rpms
/
papi
7
0
Fork 0
Code Issues Pull Requests Releases Activity
papi/papi-no-iozone.patch

34629 lines
1010 KiB
Diff
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

From 08608fb6887b53e3bbd71dde8eeaf8f5f2ad6e29 Mon Sep 17 00:00:00 2001
From: William Cohen <wcohen@redhat.com>
Date: Mon, 30 Nov 2020 12:19:54 -0500
Subject: [PATCH 1/2] Remove bundled iozone due to incompatible license.
A review of the PAPI sources found some iozone code bundled in papi
(rhbz1901077 - papi bundles non-free iozone code ). The upstream
license for iozone does not give permission to modify the source.
There are some minor changes in the PAPI version of the iozone files.
---
src/components/appio/tests/Makefile | 10 +-
src/components/appio/tests/iozone/Changes.txt | 2409 --
.../appio/tests/iozone/Generate_Graphs | 32 -
src/components/appio/tests/iozone/Gnuplot.txt | 23 -
src/components/appio/tests/iozone/client_list | 36 -
src/components/appio/tests/iozone/fileop.c | 1389 -
.../appio/tests/iozone/gengnuplot.sh | 57 -
src/components/appio/tests/iozone/gnu3d.dem | 146 -
src/components/appio/tests/iozone/gnuplot.dem | 60 -
.../appio/tests/iozone/gnuplotps.dem | 63 -
src/components/appio/tests/iozone/iozone.c | 25297 ----------------
.../appio/tests/iozone/iozone_visualizer.pl | 262 -
src/components/appio/tests/iozone/libasync.c | 1604 -
src/components/appio/tests/iozone/libbif.c | 452 -
src/components/appio/tests/iozone/makefile | 1461 -
.../appio/tests/iozone/pit_server.c | 831 -
.../appio/tests/iozone/read_telemetry | 29 -
src/components/appio/tests/iozone/report.pl | 150 -
src/components/appio/tests/iozone/spec.in | 107 -
.../appio/tests/iozone/write_telemetry | 29 -
20 files changed, 1 insertion(+), 34446 deletions(-)
delete mode 100644 src/components/appio/tests/iozone/Changes.txt
delete mode 100755 src/components/appio/tests/iozone/Generate_Graphs
delete mode 100644 src/components/appio/tests/iozone/Gnuplot.txt
delete mode 100644 src/components/appio/tests/iozone/client_list
delete mode 100644 src/components/appio/tests/iozone/fileop.c
delete mode 100755 src/components/appio/tests/iozone/gengnuplot.sh
delete mode 100644 src/components/appio/tests/iozone/gnu3d.dem
delete mode 100644 src/components/appio/tests/iozone/gnuplot.dem
delete mode 100644 src/components/appio/tests/iozone/gnuplotps.dem
delete mode 100644 src/components/appio/tests/iozone/iozone.c
delete mode 100755 src/components/appio/tests/iozone/iozone_visualizer.pl
delete mode 100644 src/components/appio/tests/iozone/libasync.c
delete mode 100644 src/components/appio/tests/iozone/libbif.c
delete mode 100644 src/components/appio/tests/iozone/makefile
delete mode 100644 src/components/appio/tests/iozone/pit_server.c
delete mode 100644 src/components/appio/tests/iozone/read_telemetry
delete mode 100755 src/components/appio/tests/iozone/report.pl
delete mode 100644 src/components/appio/tests/iozone/spec.in
delete mode 100644 src/components/appio/tests/iozone/write_telemetry
diff --git a/src/components/appio/tests/Makefile b/src/components/appio/tests/Makefile
index 26fc5f3c5..4a3005df5 100644
--- a/src/components/appio/tests/Makefile
+++ b/src/components/appio/tests/Makefile
@@ -55,17 +55,9 @@ appio_test_fread_fwrite: appio_test_fread_fwrite.o $(UTILOBJS) $(PAPILIB)
appio_test_pthreads: appio_test_pthreads.o $(UTILOBJS) $(PAPILIB)
$(CC) $(CFLAGS) $(INCLUDE) -o $@ appio_test_pthreads.o $(UTILOBJS) $(PAPILIB) $(LDFLAGS) -lpthread
-iozone/iozone_linux$(ARCH_SUFFIX).o iozone/libasync.o iozone/libbif.o:
- $(MAKE) -C iozone iozone_linux$(ARCH_SUFFIX).o libasync.o libbif.o
-
init_fini.o: init_fini.c
$(CC) $(CFLAGS) $(INCLUDE) -o $@ -c $^
-# to test, try:
-# ./appio_test_iozone -s 100m -r 64 -i 0 -i 1 -t 1
-appio_test_iozone: iozone/iozone_linux$(ARCH_SUFFIX).o iozone/libasync.o iozone/libbif.o init_fini.o $(UTILOBJS) $(PAPILIB)
- $(CC) -g -O2 -o $@ $(LDFLAGS) $^ -lpthread -lrt
-
clean:
- rm -f $(ALL_TESTS) appio_test_iozone *.o
+ rm -f $(ALL_TESTS) *.o
diff --git a/src/components/appio/tests/iozone/Changes.txt b/src/components/appio/tests/iozone/Changes.txt
deleted file mode 100644
index a619f8bba..000000000
--- a/src/components/appio/tests/iozone/Changes.txt
+++ /dev/null
@@ -1,2409 +0,0 @@
-V1.0 (capps):
-Capps:
- Beginning of the code base.
-Isom:
- Added reread
- Added rewrite
- Added read backwards
- Added lseek+read
- Added lseek+reread
-
-Capps:
- Added more accurate time collection method.
- Added alignment in the on chip Cache code.
- Added change step when passing 16 Meg size file.
-
-Capps:
- Added auto+ to purge on chip cache.
-
-kcollins:
- replaced the lseek+read &reread test with random reads and writes
-
-Capps:
- Replaced reverse re-read with record rewrite. This gives
- both source and destination on chip cache hits.
-
-Capps:
- added auto+multi
- Support for multiple buffers in the iozone.
-
-Capps:
- Removed the recursion through main().
- Cleaned up the printout when not in auto mode.
- Added support for stride-read. ( Manual mode only )
-
-Capps:
- Cleanup so it will build for bsd4_2 ( C series machines )
-
-Capps:
- Cleanup on frontend. Now uses getopt() and has a real parser.
- Cleanup on error handling.
- Added throughput tests.
- Eliminated page faults in the throughput tests.
-
-Capps:
- Made all perf tests table driven.
- Add back Bill's Copyright.
- ansify, prototypes, scope limitations.
-
-V2.1 (kcollins):
- Simplified auto mode logic. auto test now runs from
- MEGABYTES_START to MEGABYTES_END and from RECLEN_START
- to RECLEN_END with values multiplied by MULTIPLIER
- each iteration. Range set to (4K...16M) for RECLEN
- and (1M...512M) for MEGABYTES. (the physical I/O
- tests for RECLEN <4K take several hours on a 1200).
-
- Enlarged MAXBUFFERSIZE to 16MB for large record tests.
-
- Added error checking for mallocs (!-).
-
- Changed multibuffer code to use all of MAXBUFFERSIZE
- as a circular buffer, with the number of buffers
- varying as MAXBUFFERSIZE/reclen. This corrects
- problems where MAXBUFFERSIZE*MAXBUFFERS was very large.
- Also modified auto mode so that tests where
- reclen>filesize are skipped.
-
- Modified preadv code to vary the number of buffers as
- necessary such that they will fit in min(MAXBUFFERSIZE,filesize).
- This fixes problems where the number of buffers in
- the i/o vector exceeded the size of mainbuffer.
-
- Added bzero for buffer when it is first malloc'd. This
- ensures that it is initialized before use.
-
- Created a script (profile.fs) that runs a series of tests
- to generate a "box" around common application variables
- such as filesize, buffer size, buffer encachement, and
- number of concurrent processes. This is intended to serve
- as the "standard" filesystem profile.
-
- buffer reset to mainbuffer before each test loop
-
-V2.3 (kcollins):
-
- added -F option to write to specify pathnames for throughput
- tests (allowing throughput tests to multiple filesystems).
-
-V2.4 (capps):
- Changed preadv/pwritev to use a non-sequential access pattern.
- Changed the version number.
- Moved all user interface values to KB. This simplifies
- the user interface. (consistant scaling) and it also
- allows one to start with 512kb file. This is very important
- since the first indirect block causes a significant
- slowdown in the initial write cases.
-
-V2.5 (capps):
- Re-structure and cleanup.
-
-V2.6 (kcollins)
- Bug fix for the throughput tests.
-
-V2.7 (capps):
- Added -o flag. This makes all file opens for writes
- have the O_SYNC flag set. This makes all writes go
- to disk before competion. This is useful for seeing
- what the media can do without the buffer cache helping.
-
-V2.8 (capps):
- Added -V flag. This turns on pattern verification. If
- the user were to type:
- -V 165
- Then bit pattern 0xa5 would be placed in every byte in the
- buffer and when read back from buffer cache, or disk,
- it will be verified to be correct. If it fails then
- the error handler will specify the byte location of the
- miscompare.
-
-V2.9 (capps):
- Added fread/re-fread, fwrite/re-fwrite to list of tests.
- Added -E to allow the user to run pread and friends as an option.
-
-V2.10 (capps):
- Added -R. This will generate Excel compatible files that
- can then be imported into Excel and graphed.
- Added support for 5 targets to the makefile.
- Added -M This prints out the uname -a stuff about a machine.
- Added -O This gives all results in operations/sec instead of KB/sec.
- More code cleanup. Update comments.
-
-V2.11 (kcollins)
- added -A. Auto mode with no crossover and read/write tests only
- changed default record size to 64KB (from 512 bytes)
-
-V2.12 (capps)
- Added shared memory barrier sync for throughput mode. This
- provides much finer control over the actual timeing
- of the children.
- Added mmap() for BSD (Convex) machines that do not
- have System V shared memory.
- Added two ways of showing throughput results. The second
- method takes into consideration children that lag behind
- due to slow devices, and gives results that are more accurate.
- Cleanup of some tab problems in throughput results.
- Cleanup of floating point output taking to much space.
- Added -d to allow a variable delay comming out of the barrier
- in the throughput tests.
-V2.12 (kcollins)
- added declaration for create_list to make ansi c compiles work
- several fixes to some of the SPPUX 5.x make targets
- added date run to banner (hope this doesn't break your scripts $-)
-
-V2.13 (capps)
- Added "stone walling". During throughput tests, if one process
- finishes then all others are sent a signal to tell them
- to stop. (The parallel region has finished). This provides
- better numbers for throughput.
- Only bzero or fill min(reclen,CACHE_SIZE) this saves a bunch
- of paging on workstations with small memory systems.
- Fixed broken target in the makefile.
- Note: use of -d is not advised. It makes the children not run
- in parallel.
-V2.14 (capps)
- Bug fix to avoid anomaly in SPP-UX. In SPP-UX the filesystem
- code preallocates meta-data to improve initial file writes.
- The first indirect block allocation was causing a block
- of zeros to be written syncronously. In SPP-UX the filesytem
- code preallocates zero filled blocks when the first writer
- touches a filesystem after a sync. A pool of on disk zero'd
- blocks are created asynchronously and handed out to writers
- when they cross the boundry into the first level indirect
- and would have had to stop and wait for the zero filled
- block to be written. Iozone's testing methodology was not
- allowing the OS to have any time to complete the async
- pre-allocation and was not showing the speed up that real
- applications would see.
-
-V2.15 (capps)
- Improve throughput testing mode.
-
-V2.16 (capps)
- Added -U option. This allows the filesystem to be unmounted
- and remounted between tests. This guarentees that the buffer
- cache is cold.
-
-V2.17 (capps)
- Added -T option. This makes the throughput tests use
- threads instead of processes. Currently using pthread_create(),
- pthread_self(), and pthread_exit().
- Cleaned up file cleanup mechanism. Control C will now cause
- all temp files to be deleted. Removed all signals used to
- control sub-processes.
-
-V2.18 (capps)
- Cleanup. Added read stride, read backwards to the throughput
- tests. Various bug fixes
-
-V2.19 (capps)
- Removed all calls to malloc() and all use of system V shared
- memory. mmap() is much easier to deal with. As for malloc()
- HP programs are very limited on the ammount of malloc() space
- and not nearly so constrained on mmap() memory. It was necessary
- to move to mmap() since multiple threads all need buffers in
- the processes address space.
- Removed dependency on first thread being number 2. Iozone now
- probes to find out what the thread library will return for
- the first thread. This makes the switching thread libraries
- much easier.
-
-V2.20 (capps)
- Children now set stop_flag and shutdown all other children.There
- is no further need to tell the parent to distribute the stop_flag.
- verify, purge, and osync are now supported in the throughput
- tests. Fixed bug where pthreads stack size was causing
- segmentation violation when purgeit() was called for buffer
- that were greater than 256kb.
-
-V2.21 (capps)
- Enhanced throughput reporting. Now provides:
- Child throughput, Parent throughput, Minimum throughput for
- any child in the group, Maximum throughput for any child in the
- group, and Minimum transfer count. Due to stone walling
- not all children write the full requested size. This
- minimum transfer count provides the user with knowledge of
- how much work was performed by the slowest child.
- Added -C flag. This allows the user to see all of the transfer
- counts for each child. Had to add system 5 shared memory back.
- Linux does not support mmap(MAP_ANONYMOUS|MAP_SHARED). So it
- must use SYSV shared memory get get sharing working.
-
-V2.22 (capps)
- Made changes to make iozone work correctly on Linux on a
- PC. Changes are just scaling down the test to fit on a
- pc, and scaling down shared segments to < 16 Meg so it
- can run on an Intel 386 class machine.
- Added: -L # Set the processor cache line size in bytes.
- Added: -S # Set the processor cache size in kbytes.
- Removed spin wait in parent waiting for threads to
- finish each throughput test. Code not uses thread_join().
- Fixed -O (operations/sec) mode to work in throughput tests.
-
-V2.23 (capps)
- Close small timing hole where thread/process has set stop flag
- and others are in a system call. The hole allowed threads/processes
- to continue to increment work done after one had finished and
- told the others to stop. The result was that the children would
- report slightly high numbers as they were not truely parallel
- at the finish line. Added random read throughput test.
- Fixes for VxFS small extents being created by prime_zb() functions.
- Provides more details about the throughput run.
-
-V2.24 (capps)
- Added support for -R (Excell chart generation) to the throughput
- tests. Also added support for the -O (ops/sec) to the throughput
- Excell chart.
-
-V2.25 (capps)
- Added support for selecting which test to run. -i #
- -i 0 -i 3
- will run write and read-backwards tests only. For a list
- of the test numbers type iozone -h.
-V2.26 (capps)
- Added support for LARGE_FILES for the hpux-11.0 target.
-
-
-V2.27 (capps)
- All tests now verify one long word of data from each page
- written/read to/from the file. This is to level the
- playing field with systems that do not move data
- when "read" or "write" is called, but instead just
- map the file and perform the I/O when the address space
- is touched. Benchmarks that do not validate the data
- ,at least touch each page, do not measure the read/write
- times just the map times.
- Note: The -V option still verifies each byte of the buffer,
- the default is now to verify one long from each page.
-
-V2.28 (capps)
- Added support for benchmarking mmap() files.
- Added more command line options. -B -G -D
- B = Use mmap() files for the benchmark.
- G = Use msync(MS_SYNC) for mmap files.
- D = Use msync(MS_ASYNC) for mmap files.
-
-V2.29 (capps)
- Bug fixes for:
- Combination of running individual tests and mmap() files support.
- Stride read bug that caused only portions of the total file to be
- examined.
-
-V2.30 (capps)
- Fixups for build under SPP-UX
-
-V2.31 (capps)
- Fixups for build under Linux.
- Added -j ### to support user setting the stride size for the
- stride read benchmark.
-
-V2.32 (capps)
- Add support for IRIX and IRIX64.
-
-V2.33 (capps)
- Add support for POSIX async I/O benchmarking. Uses a library
- to interface to POSIX async I/O model. The library provides
- and extended async_read() interface. It takes the standard
- calling options of read() but also allows the application to
- perform read-ahead with a stride. (positive or negative)
- and allows the user to specify how much read ahead to
- perform.
- Tested on HP-UX 11.0, Linux, SGI Origin.
-
-V2.34 (capps)
- Added -k. This allows POSIX async I/O to utilize the buffer
- specified and not to perform any bcopys. Fixes to make
- multi-threadedness work on SGI Origin.
-
-V2.34 (capps)
- Added [-k #]. This allows POSIX async I/O to utilize the buffer
- specified and not to perform any bcopys. Fixes to make
- multi-threadedness work on SGI Origin.
-
-V2.36 (capps)
- Iozone is now a 64 bit application. It may be compiled for either
- 64 bit or 32 bit machines. The makefile supports 64 and 32 bit
- targets for machines that support 32 & 64 bit targets.
- All version numbers are now automatically generated by
- RCS. This is the last time we have to bump the version
- number by hand.
-
-
------------------------------------------------------------------------------------
-Changed over to RCS source control here:
-Version Numbers are reset at this point back to Version 1.1.
------------------------------------------------------------------------------------
-
-
-RCS file: iozone.c,v; Working file: iozone.c
-head: 1.94
-locks: ; strict
-access list:
-symbolic names:
-comment leader: " * "
-total revisions: 94; selected revisions: 94
-description:
-Initial rcs version of Iozone
-----------------------------
-Revision 1.94
-date: 99/01/18 13:02:57; author: capps; state: Exp; lines added/del: 7/2
-Call msync if writer wants sync in timing and terminates early in multi thread test case.
-----------------------------
-Revision 1.93
-date: 99/01/18 11:46:11; author: capps; state: Exp; lines added/del: 309/126
-Cleanup for include_flush and include_close for single and multi threaded operations.
-----------------------------
-Revision 1.92
-date: 99/01/15 10:53:58; author: capps; state: Exp; lines added/del: 40/11
-Add include_close support for throughput testing
-----------------------------
-Revision 1.91
-date: 98/12/07 09:26:22; author: capps; state: Exp; lines added/del: 43/24
-For Windows: Use the high resolution timers instead of timeofday();
-Fix a few casting problems.
-----------------------------
-Revision 1.90
-date: 98/11/30 14:49:46; author: capps; state: Exp; lines added/del: 24/17
-Update the copyright and names and places
-----------------------------
-Revision 1.89
-date: 98/10/30 09:04:51; author: capps; state: Exp; lines added/del: 1/2
-An extra close(fd) causes HP-UX to fail future unmounts...
-----------------------------
-Revision 1.88
-date: 98/10/29 09:47:25; author: capps; state: Exp; lines added/del: 17/17
-Cleanup the help screen
-----------------------------
-Revision 1.87
-date: 98/10/28 23:31:11; author: capps; state: Exp; lines added/del: 7/6
-Spelling error fix.
-----------------------------
-Revision 1.86
-date: 98/10/14 11:21:50; author: capps; state: Exp; lines added/del: 23/68
-Unified the time method to only have 2 ways to get time.
-----------------------------
-Revision 1.85
-date: 98/10/14 09:22:09; author: capps; state: Exp; lines added/del: 91/91
-Added code to remove the latency of gettimeofday() from the file performance measurements.
-----------------------------
-Revision 1.84
-date: 98/10/12 11:44:50; author: capps; state: Exp; lines added/del: 107/8
-Add time resolution output, and fix the divide by zero when the time in
-a system call turns out to be Zero. This will introduce distortion for machines
-that have very fast system calls and very poor time resolution. Windows
-has a 50 Milli second resolution on gettimeofday(). So... to fix it
-all calls that take less than 50 Milli seconds will be rounded up to
-cost 50 milliseconds.
-----------------------------
-Revision 1.83
-date: 98/10/06 09:58:16; author: capps; state: Exp; lines added/del: 46/2
-Add support for Windows build
-----------------------------
-Revision 1.82
-date: 98/09/23 09:48:02; author: capps; state: Exp; lines added/del: 2/2
-Fix bug where -i # was leaving tmp files after throughput test.
-----------------------------
-Revision 1.81
-date: 98/09/23 09:41:12; author: capps; state: Exp; lines added/del: 1/3
-Remove debug printf
-----------------------------
-Revision 1.80
-date: 98/09/23 09:29:01; author: capps; state: Exp; lines added/del: 23/1
-Add my_nap(). This allows the threads to switch processors to their
-new bound processor before performing any work.
-----------------------------
-Revision 1.79
-date: 98/09/22 11:57:20; author: capps; state: Exp; lines added/del: 8/8
-Change xx back into an int so the modulo will work better.
-----------------------------
-Revision 1.78
-date: 98/09/18 16:27:05; author: capps; state: Exp; lines added/del: 18/15
-Remove create in rewrite path.
-----------------------------
-Revision 1.77
-date: 98/08/17 16:44:06; author: capps; state: Exp; lines added/del: 23/1
-Fixes for Solaris and the new processor bind feature.
-----------------------------
-Revision 1.76
-date: 98/08/17 16:17:45; author: capps; state: Exp; lines added/del: 1/2
-Remove debug code.
-----------------------------
-Revision 1.75
-date: 98/08/17 16:16:15; author: capps; state: Exp; lines added/del: 92/5
-Add support for binding procs/threads to cpus.
-----------------------------
-Revision 1.74
-date: 98/08/07 16:51:41; author: capps; state: Exp; lines added/del: 4/3
-Add fsync to the fwrite test case when the user specifies -e
-----------------------------
-Revision 1.73
-date: 98/08/07 16:47:38; author: capps; state: Exp; lines added/del: 178/208
-Add -c and -e to allow closes and fsyncs to be inside the timing calculations.
-----------------------------
-Revision 1.72
-date: 98/08/06 22:40:15; author: capps; state: Exp; lines added/del: 9/1
-Add setvbuf to fwrite and fread tests so that the internal fwrite and fread
-buffer size is the same as the record size. This is what a well tuned application
-would do.
-----------------------------
-Revision 1.71
-date: 98/08/06 09:03:06; author: capps; state: Exp; lines added/del: 2/3
-Fix fsync filename problem in fwrite_perf_test
-----------------------------
-Revision 1.70
-date: 98/08/05 18:06:41; author: capps; state: Exp; lines added/del: 6/2
-Add fsync after fwrite test case so the fread will start with a
-clean buffer cache and no writes in progress.
-----------------------------
-Revision 1.69
-date: 98/08/03 10:45:49; author: capps; state: Exp; lines added/del: 3/3
-Bug fix for -V option not filling the entire buffer.
-----------------------------
-Revision 1.68
-date: 98/07/30 22:11:11; author: capps; state: Exp; lines added/del: 2/3
-Fix for solaris
-----------------------------
-Revision 1.67
-date: 98/07/30 22:08:19; author: capps; state: Exp; lines added/del: 2/2
-Fix for solaris
-----------------------------
-Revision 1.66
-date: 98/07/30 22:05:02; author: capps; state: Exp; lines added/del: 43/15
-Add support for Solaris
-----------------------------
-Revision 1.65
-date: 98/07/01 14:19:19; author: capps; state: Exp; lines added/del: 80/82
-Move end_async inside the timing loops as in async I/O it counts.
-----------------------------
-Revision 1.64
-date: 98/06/16 17:04:36; author: capps; state: Exp; lines added/del: 13/2
-Correct problem where user specifies pread tests on hpux... which does not
-support these operations. The test now prints an error message and exits.
-----------------------------
-Revision 1.63
-date: 98/06/16 16:54:22; author: capps; state: Exp; lines added/del: 1/2
-Remove exit from auto_test. This allows the message "iozone test complete" to
-be printed when in auto test mode.
-----------------------------
-Revision 1.62
-date: 98/06/10 10:54:28; author: capps; state: Exp; lines added/del: 175/173
-All exit()s now have a unique exit value.
-----------------------------
-Revision 1.61
-date: 98/05/18 13:34:03; author: capps; state: Exp; lines added/del: 17/18
-Move .dat file descriptors to global data. Needed to prevent re-opens.
-----------------------------
-Revision 1.60
-date: 98/05/18 13:24:22; author: capps; state: Exp; lines added/del: 6/3
-Bug fix. Prevents re-opending .dat files when in auto mode.
-----------------------------
-Revision 1.59
-date: 98/05/08 13:03:02; author: capps; state: Exp; lines added/del: 21/3
-Enhance throughput tests to follow the -i test number to run options.
-----------------------------
-Revision 1.58
-date: 98/05/07 14:15:49; author: capps; state: Exp; lines added/del: 109/39
-Make VXFS a define in the make command. This makes moving to other targets
-easier. It removes the binding of HPUX and VXFS.
-Also, Added -Q to support offset/latency file generation for later use
-as inputs to plot program.
-----------------------------
-Revision 1.57
-date: 98/05/06 15:09:43; author: capps; state: Exp; lines added/del: 100/27
-Add -N to provide results in microseconds per operation.
-----------------------------
-Revision 1.56
-date: 98/05/05 13:23:29; author: capps; state: Exp; lines added/del: 3/10
-If the user specifies -i 0 then run both write and rewrite tests.
-----------------------------
-Revision 1.55
-date: 98/04/30 15:19:02; author: capps; state: Exp; lines added/del: 1/1
-No change
-----------------------------
-Revision 1.54
-date: 98/04/30 15:09:58; author: capps; state: Exp; lines added/del: 2/2
-Unlink the vxfstest when the test fails.
-----------------------------
-Revision 1.53
-date: 98/04/30 13:07:21; author: capps; state: Exp; lines added/del: 7/5
-Cleanup help output.
-----------------------------
-Revision 1.52
-date: 98/04/30 12:58:29; author: capps; state: Exp; lines added/del: 21/4
-Add async I/O with no bcopy to throughput tests.
-----------------------------
-Revision 1.51
-date: 98/04/29 15:29:29; author: capps; state: Exp; lines added/del: 5/1
-Fixes so it will compile on the SGI Origin.
-----------------------------
-Revision 1.50
-date: 98/04/29 11:57:58; author: capps; state: Exp; lines added/del: 5/1
-Do not need to limit async ops. Fix is in libasync.c
-----------------------------
-Revision 1.49
-date: 98/04/29 10:45:19; author: capps; state: Exp; lines added/del: 61/3
-Add async I/O to throughput testing for writes
-----------------------------
-Revision 1.48
-date: 98/04/28 11:57:13; author: capps; state: Exp; lines added/del: 5/1
-Limit max async operations to 60. Beyond this there be dragons.
-----------------------------
-Revision 1.47
-date: 98/04/28 10:16:09; author: capps; state: Exp; lines added/del: 108/21
-Completed support for no_bcopy POSIX async I/O in the async_write_no_copy path.
-This allows write tests to perform async I/O with buffers released when
-the write is completed.
-----------------------------
-Revision 1.46
-date: 98/04/27 16:58:38; author: capps; state: Exp; lines added/del: 43/10
-Add aio_write() to the write and re-write tests. This provides
-POSIX async I/O for the those tests.
-----------------------------
-Revision 1.45
-date: 98/04/25 09:53:39; author: capps; state: Exp; lines added/del: 3/2
-direct_flag is an int. Was a char in one place and
-an int in another.
-----------------------------
-Revision 1.44
-date: 98/04/25 09:17:42; author: capps; state: Exp; lines added/del: 27/15
-More support for vx_direct support in the write path
-----------------------------
-Revision 1.43
-date: 98/04/24 16:33:44; author: capps; state: Exp; lines added/del: 115/77
-Move VX_DIRECT to libasync. But keep the VX_DIRECT support also
-in iozone. So one can use VX_DIRECT with and without async I/O
-----------------------------
-Revision 1.42
-date: 98/04/24 16:20:34; author: capps; state: Exp; lines added/del: 127/60
-Move VX_DIRECT to the libasync module.
-----------------------------
-Revision 1.41
-date: 98/04/24 15:50:54; author: capps; state: Exp; lines added/del: 190/7
-Add support for VxFS VX_DIRECT
-Idea is to use VX_DIRECT and POSIX async I/O together
-----------------------------
-Revision 1.40
-date: 98/04/22 16:38:25; author: capps; state: Exp; lines added/del: 5/5
-Sppux wants ail_gettimeofday variables to be unsigned int.
-----------------------------
-Revision 1.39
-date: 98/04/22 16:19:50; author: capps; state: Exp; lines added/del: 7/3
-Fix -M option not printing cleanly
-Fix -R in 32 bit mode printing garbage.
-----------------------------
-Revision 1.38
-date: 98/04/22 15:56:02; author: capps; state: Exp; lines added/del: 1/1
-Change to only disply revision not full header.
-----------------------------
-Revision 1.37
-date: 98/04/22 15:52:19; author: capps; state: Exp; lines added/del: 1/1
-Add RCS Header to support versioning.
-----------------------------
-Revision 1.36
-date: 98/04/22 15:38:26; author: capps; state: Exp; lines added/del: 1/1
-fix to bcopy() third arg needs to be size_t for 32 bit mode.
-----------------------------
-Revision 1.35
-date: 98/04/22 09:09:24; author: capps; state: Exp; lines added/del: 17/17
-Bug fixes for 64 bit mode on IRIX, and addition
-on the internal inuse queue to insure that the
-internal struct_cache_ent structures are not released
-too early when doing direct I/O (async_read_no_copy).
-----------------------------
-Revision 1.34
-date: 98/04/21 09:31:02; author: capps; state: Exp; lines added/del: 4/0
-Fix to eliminate hidden (dot) files that iozone was creating
-in throughput mode. All files are now visible with ls.
-----------------------------
-Revision 1.33
-date: 98/04/21 08:30:35; author: capps; state: Exp; lines added/del: 7/1
-Have Iozone print the compile model used.
-----------------------------
-Revision 1.32
-date: 98/04/20 18:46:02; author: capps; state: Exp; lines added/del: 49/20
-Fixes for 32 bit mode.
-----------------------------
-Revision 1.31
-date: 98/04/20 16:57:29; author: capps; state: Exp; lines added/del: 8/8
-make sure malloc is called with (size_t) parameter.
-----------------------------
-Revision 1.30
-date: 98/04/20 16:05:08; author: capps; state: Exp; lines added/del: 933/757
-Iozone now 64 bit application
-----------------------------
-Revision 1.29
-date: 98/04/20 12:32:25; author: capps; state: Exp; lines added/del: 4/4
-Move msync to before munmap so file gets written.
-----------------------------
-Revision 1.28
-date: 98/04/20 10:21:30; author: capps; state: Exp; lines added/del: 2/2
-Minor fix for -O flag and -B not working smoothly together.
-----------------------------
-Revision 1.27
-date: 98/04/20 10:17:19; author: capps; state: Exp; lines added/del: 0/0
-No change
-
-----------------------------
-Revision 1.26
-date: 98/04/19 15:11:07; author: capps; state: Exp; lines added/del: 5/5
-Remove prime_zbfill. It causes problems with mmap files.
-----------------------------
-Revision 1.25
-date: 98/04/16 15:24:50; author: capps; state: Exp; lines added/del: 228/70
--H is Nastran async I/O with bcopy
--k is async I/O without any bcopys
-----------------------------
-Revision 1.24
-date: 98/04/15 16:48:30; author: capps; state: Exp; lines added/del: 22/4
-fix to make build on 9.05 and 10.1
-----------------------------
-Revision 1.23
-date: 98/04/15 15:36:55; author: capps; state: Exp; lines added/del: 9/9
-Cleanup some compiler warnings about un-initialized variables. They
-are not really un-initialized and used but it does generate
-compiler warnings on some machines.
-----------------------------
-Revision 1.22
-date: 98/04/15 15:32:56; author: capps; state: Exp; lines added/del: 7/7
-Need to free the dummyname space a bit later.
-----------------------------
-Revision 1.21
-date: 98/04/15 14:37:05; author: capps; state: Exp; lines added/del: 27/13
-Fix to use smaller stack size in thread_ routines. It was causing
-the SGI to drop core in throughput tests.
-----------------------------
-Revision 1.20
-date: 98/04/14 17:01:19; author: capps; state: Exp; lines added/del: 27/16
-Fix a memory leak. In multi_throughput testing shmalloc was getting called
-for each iteration. This is not needed and causes much to much
-shm to be allocated. Not broken but definately a pig.
-----------------------------
-Revision 1.19
-date: 98/04/14 15:19:15; author: capps; state: Exp; lines added/del: 2/0
-When -k is specified alone this will turn on the POSIX async I/O and
-set depth to 0.
-----------------------------
-Revision 1.18
-date: 98/04/14 15:00:18; author: capps; state: Exp; lines added/del: 21/20
-Fixes to make multi-threaded version run on the SGI Origin.
-----------------------------
-Revision 1.17
-date: 98/04/14 11:55:44; author: capps; state: Exp; lines added/del: 17/11
-Add support for -k. When using POSIX async I/O use the
-buffer specified and do not perform any bcopys.
-----------------------------
-Revision 1.16
-date: 98/04/13 10:22:18; author: capps; state: Exp; lines added/del: 27/380
-Add libasync library support
-----------------------------
-Revision 1.15
-date: 98/04/11 12:09:25; author: capps; state: Exp; lines added/del: 1/0
-Fix memory leak. Now calls del_cache when ever any calls to async_end happen.
-This will ensure that there are no outstanding I/Os on the cache that
-ha ve not been canceled .
-----------------------------
-Revision 1.14
-date: 98/04/11 11:57:10; author: capps; state: Exp; lines added/del: 632/47
-Add support for POSIX async I/O testing
-----------------------------
-Revision 1.13
-date: 98/03/31 14:30:15; author: capps; state: Exp; lines added/del: 44/6
-Fix support for bsd4_2 and ConvexOS
-----------------------------
-Revision 1.12
-date: 98/03/31 11:26:34; author: capps; state: Exp; lines added/del: 2/2
-Bump version number to 2.32
-----------------------------
-Revision 1.11
-date: 98/03/31 11:20:51; author: capps; state: Exp; lines added/del: 70/6
-Add support for SGI IRIX and SGI IRIX64
-----------------------------
-Revision 1.10
-date: 98/03/27 14:00:47; author: capps; state: Exp; lines added/del: 15/20
-Put the bcopy back. It is more represenative
-of what the real application will do.
-----------------------------
-Revision 1.9
-date: 98/03/27 13:25:02; author: capps; state: Exp; lines added/del: 40/14
-Improved mmap file support. Now only have 1 long word from
-each page touched. This eliminates the overhead of bcopy
-dominating the results. It also is performing the same
-work that the non-mmap version does with verify().
-----------------------------
-Revision 1.8
-date: 98/03/27 10:41:13; author: capps; state: Exp; lines added/del: 10/4
-Bug fix. Frewrite was truncating the file. This fix
-ensures that the Frewrite test opens without trunc.
-----------------------------
-Revision 1.7
-date: 98/03/27 10:16:41; author: capps; state: Exp; lines added/del: 3/3
-Fix report to specify stride size as a function of reclen.
-It did not make sense to output kbytes as the value changes
-when in auto mode to match the current record length.
-----------------------------
-Revision 1.6
-date: 98/03/26 15:28:15; author: capps; state: Exp; lines added/del: 16/8
-Add support for -j option. This
-allows the user to specify the stride size for
-the strided file access benchmark.
-----------------------------
-Revision 1.5
-date: 98/03/25 15:27:01; author: capps; state: Exp; lines added/del: 1/1
-Fixup help screen to reflect new options
-----------------------------
-Revision 1.4
-date: 98/03/25 15:21:23; author: capps; state: Exp; lines added/del: 1/1
-Change the revision number
-----------------------------
-Revision 1.3
-date: 98/03/25 15:20:28; author: capps; state: Exp; lines added/del: 16/1
-Fixup support for Linux
-----------------------------
-Revision 1.2
-date: 98/03/25 13:58:05; author: capps; state: Exp; lines added/del: 16/3
-Bug fixes for SPP-UX
-----------------------------
-Revision 1.1
-date: 98/03/25 10:43:45; author: capps; state: Exp;
-Initial revision
-=============================================================================
-
-RCS file: libasync.c,v; Working file: libasync.c
-head: 1.39
-locks: ; strict
-access list:
-symbolic names:
-comment leader: " * "
-total revisions: 39; selected revisions: 39
-description:
-Initial version of POSIX async I/O library interface.
-----------------------------
-Revision 1.39
-date: 98/07/30 22:05:21; author: capps; state: Exp; lines added/del: 3/1
-Add support for Solaris
-----------------------------
-Revision 1.38
-date: 98/07/07 13:00:39; author: capps; state: Exp; lines added/del: 1/11
-Remove extra bcopy in the async_write_no_bcopy path.
-----------------------------
-Revision 1.37
-date: 98/06/11 09:47:58; author: capps; state: Exp; lines added/del: 3/3
-Fix syntax error for IRIX
-----------------------------
-Revision 1.36
-date: 98/06/10 10:56:55; author: capps; state: Exp; lines added/del: 10/10
-All exit()s now have a unique exit value.
-----------------------------
-Revision 1.35
-date: 98/05/07 14:17:20; author: capps; state: Exp; lines added/del: 2/2
-Make VXFS a define in the make command. This makes moving to other targets
-easier. It removes the binding of HPUX and VXFS.
-Also, Added -Q to support offset/latency file generation for later use
-as inputs to plot program.
-----------------------------
-Revision 1.34
-date: 98/04/30 15:19:54; author: capps; state: Exp; lines added/del: 1/3
-Remove debug code that breaks 64 bit mode compiled code.
-----------------------------
-Revision 1.33
-date: 98/04/30 13:09:13; author: capps; state: Exp; lines added/del: 2/2
-Make retval an int so it can be checked for less than zero.
-----------------------------
-Revision 1.32
-date: 98/04/29 16:49:34; author: capps; state: Exp; lines added/del: 5/11
-If overshooting on number of asyncs then terminate the loop and
-let the next time through pick up the I/O.
-----------------------------
-Revision 1.31
-date: 98/04/29 16:37:49; author: capps; state: Exp; lines added/del: 3/3
-Remove debug code
-----------------------------
-Revision 1.30
-date: 98/04/29 15:29:48; author: capps; state: Exp; lines added/del: 3/1
-Fixes so it will compile on the SGI Origin.
-----------------------------
-Revision 1.29
-date: 98/04/29 11:56:27; author: capps; state: Exp; lines added/del: 36/10
-Work around for bug in POSIX async I/O library
-----------------------------
-Revision 1.28
-date: 98/04/29 11:04:26; author: capps; state: Exp; lines added/del: 1/2
-Remove debug code
-----------------------------
-Revision 1.27
-date: 98/04/29 11:02:54; author: capps; state: Exp; lines added/del: 54/27
-Added resource shortage paths.
-----------------------------
-Revision 1.26
-date: 98/04/28 18:12:51; author: capps; state: Exp; lines added/del: 1/3
-Add async I/O to the throughput tests
-----------------------------
-Revision 1.25
-date: 98/04/28 17:12:40; author: capps; state: Exp; lines added/del: 3/1
-fix wait_for_ routine to reset w_tail if item being removed is also the tail.
-----------------------------
-Revision 1.24
-date: 98/04/28 16:14:06; author: capps; state: Exp; lines added/del: 1/3
-bug fix. 2 calls to malloc for aligned memory.
-----------------------------
-Revision 1.23
-date: 98/04/28 11:57:39; author: capps; state: Exp; lines added/del: 37/13
-Limit max async operations to 60. Beyond this there be dragons.
-----------------------------
-Revision 1.22
-date: 98/04/28 10:17:22; author: capps; state: Exp; lines added/del: 127/42
-Completed support for no_bcopy POSIX async I/O in the async_write_no_copy path.
-This allows write tests to perform async I/O with buffers released when
-the write is completed.
-----------------------------
-Revision 1.21
-date: 98/04/27 16:59:14; author: capps; state: Exp; lines added/del: 246/9
-Add aio_write() to the write and re-write tests. This provides
-POSIX async I/O for the those tests.
-----------------------------
-Revision 1.20
-date: 98/04/24 16:20:55; author: capps; state: Exp; lines added/del: 15/3
-Move VX_DIRECT to the libasync module.
-----------------------------
-Revision 1.19
-date: 98/04/24 15:50:13; author: capps; state: Exp; lines added/del: 42/11
-Add support for VxFS VX_DIRECT
-Idea is to use VX_DIRECT and POSIX async I/O together
-----------------------------
-Revision 1.18
-date: 98/04/24 12:36:42; author: capps; state: Exp; lines added/del: 13/5
-Fix some error printfs to match the size of the off_t.
-----------------------------
-Revision 1.17
-date: 98/04/24 12:18:11; author: capps; state: Exp; lines added/del: 7/7
-Fixes for LP64 mode. off_t changed to off64_t
-----------------------------
-Revision 1.16
-date: 98/04/24 09:33:32; author: capps; state: Exp; lines added/del: 275/35
-Add comments and fix for LP64 model on hpux.
-----------------------------
-Revision 1.15
-date: 98/04/23 16:58:06; author: capps; state: Exp; lines added/del: 167/13
-Make libasync large file aware.
-----------------------------
-Revision 1.14
-date: 98/04/22 15:58:45; author: capps; state: Exp; lines added/del: 1/1
-Change version to only display rcs version id.
-----------------------------
-Revision 1.13
-date: 98/04/22 15:52:54; author: capps; state: Exp; lines added/del: 1/2
-Add RCS version support
-----------------------------
-Revision 1.12
-date: 98/04/22 11:39:35; author: capps; state: Exp; lines added/del: 52/8
-Add firewall to prevent in flight changes to the aiocb structure.
-----------------------------
-Revision 1.11
-date: 98/04/22 09:10:36; author: capps; state: Exp; lines added/del: 57/19
-Bug fixes for 64 bit mode on IRIX, and addition
-on the internal inuse queue to insure that the
-internal struct_cache_ent structures are not released
-too early when doing direct I/O (async_read_no_copy).
-----------------------------
-Revision 1.10
-date: 98/04/21 09:34:14; author: capps; state: Exp; lines added/del: 18/10
-Improve error messages.
-----------------------------
-Revision 1.9
-date: 98/04/20 16:06:21; author: capps; state: Exp; lines added/del: 53/50
-Iozone now 64 bit application
-----------------------------
-Revision 1.8
-date: 98/04/20 10:17:59; author: capps; state: Exp; lines added/del: 0/0
-no change
-----------------------------
-Revision 1.7
-date: 98/04/17 08:49:16; author: capps; state: Exp; lines added/del: 15/2
-Optimization on async operations. Just add one to the end
-of the list if the list already has more than one item.
-----------------------------
-Revision 1.6
-date: 98/04/17 00:00:30; author: capps; state: Exp; lines added/del: 10/2
-Make cancel keep trying until it succeeds. Otherwise transfers after the buffer
-is freed can occur.
-----------------------------
-Revision 1.5
-date: 98/04/16 16:49:28; author: capps; state: Exp; lines added/del: 49/4
-Improve error handling when running machine out of memory.
-----------------------------
-Revision 1.4
-date: 98/04/16 15:26:41; author: capps; state: Exp; lines added/del: 118/28
-added async_read_no_copy(). This allows the application to let the
-library specify the destination buffer and perform the async I/O
-without unwanted bcopys.
-----------------------------
-Revision 1.3
-date: 98/04/14 11:56:23; author: capps; state: Exp; lines added/del: 36/10
-Add supporf for -k. When using POSIX async I/O use
-the buffer specified and do not perform any bcopys.
-----------------------------
-Revision 1.2
-date: 98/04/13 10:35:20; author: capps; state: Exp; lines added/del: 5/7
-Fixup for error path to propagate any small transfers.
-----------------------------
-Revision 1.1
-date: 98/04/13 10:21:23; author: capps; state: Exp;
-Initial revision
-=============================================================================
-
-RCS file: makefile,v; Working file: makefile
-head: 1.20
-locks: ; strict
-access list:
-symbolic names:
-comment leader: "# "
-total revisions: 20; selected revisions: 20
-description:
-Initial version of makefile
-----------------------------
-Revision 1.20
-date: 98/10/06 10:36:22; author: capps; state: Exp; lines added/del: 87/28
-Add comments to describe each targets capabilities.
-----------------------------
-Revision 1.19
-date: 98/10/06 09:59:18; author: capps; state: Exp; lines added/del: 3/3
-Fix spelling error
-----------------------------
-Revision 1.18
-date: 98/10/06 09:58:29; author: capps; state: Exp; lines added/del: 18/3
-Add support for Windows build
-----------------------------
-Revision 1.17
-date: 98/08/17 16:44:56; author: capps; state: Exp; lines added/del: 2/2
-Fixes for Solaris
-----------------------------
-Revision 1.16
-date: 98/07/30 22:05:33; author: capps; state: Exp; lines added/del: 20/1
-Add support for Solaris
-----------------------------
-Revision 1.15
-date: 98/05/07 14:17:26; author: capps; state: Exp; lines added/del: 13/13
-Make VXFS a define in the make command. This makes moving to other targets
-easier. It removes the binding of HPUX and VXFS.
-Also, Added -Q to support offset/latency file generation for later use
-as inputs to plot program.
-----------------------------
-Revision 1.14
-date: 98/04/22 16:02:42; author: capps; state: Exp; lines added/del: 2/0
-Add RCS version ids.
-----------------------------
-Revision 1.13
-date: 98/04/22 13:58:54; author: capps; state: Exp; lines added/del: 6/6
-For now only build the SGI targets in 32 bit mode.
-There is some problem with POSIX async I/O and 64 bit apps.
-----------------------------
-Revision 1.12
-date: 98/04/22 12:08:25; author: capps; state: Exp; lines added/del: 3/3
-Let the IRIX64 target default to its default compile mode.
-----------------------------
-Revision 1.11
-date: 98/04/22 09:10:54; author: capps; state: Exp; lines added/del: 3/3
-Bug fixes for 64 bit mode on IRIX, and addition
-on the internal inuse queue to insure that the
-internal struct_cache_ent structures are not released
-too early when doing direct I/O (async_read_no_copy).
-----------------------------
-Revision 1.10
-date: 98/04/21 09:29:57; author: capps; state: Exp; lines added/del: 17/17
-Improve dependencies
-----------------------------
-Revision 1.9
-date: 98/04/20 16:05:48; author: capps; state: Exp; lines added/del: 58/29
-Iozone now 64 bit application
-----------------------------
-Revision 1.8
-date: 98/04/20 10:17:44; author: capps; state: Exp; lines added/del: 0/0
-*** empty log message ***
-----------------------------
-Revision 1.7
-date: 98/04/16 16:50:11; author: capps; state: Exp; lines added/del: 6/6
-Have the SGI build 32 bit app too.
-----------------------------
-Revision 1.6
-date: 98/04/15 16:48:09; author: capps; state: Exp; lines added/del: 5/5
-Fix to make build on 9.05 and 10.1
-----------------------------
-Revision 1.5
-date: 98/04/13 10:22:34; author: capps; state: Exp; lines added/del: 14/6
-Add support for libasync library.
-----------------------------
-Revision 1.4
-date: 98/04/11 11:57:34; author: capps; state: Exp; lines added/del: 10/10
-AAdd support for POSIX async I/O testing
-----------------------------
-Revision 1.3
-date: 98/03/31 11:21:34; author: capps; state: Exp; lines added/del: 24/0
-Add support for SGI IRIX and SGI IRIX64
-----------------------------
-Revision 1.2
-date: 98/03/25 13:59:18; author: capps; state: Exp; lines added/del: 21/9
-Fixes for SPP-UX
-----------------------------
-Revision 1.1
-date: 98/03/25 10:48:21; author: capps; state: Exp;
-Initial revision
-=============================================================================
-Added support for BIFF file output. Iozone can now write Excel spreadsheet
-format. This allows one to directly access the Excel spreadsheet without
-needing to import with tab and space delimited method.
-
-Added support for large files and threads for Solaris.
-
-Add support for FreeBSD
-
-Change default stride value to avoid nodalization with various spindle counts.
-=============================================================================
-Version 3.3:
-Changed name of processor_bind to ioz_processor_bind to avoid collision
-with SVR5.4.MP shared library.
-Removed leading tab on an #ifdef that caused some compilers to get sick.
-=============================================================================
-Version 3.4:
-Add support for OpenBSD
-=============================================================================
-Version 3.6:
-Lots of code cleanup.
-Added support for OSF1 on the DEC Alpha.
-=============================================================================
-Version 3.7:
-Add support for OSF Version 4.
-Add timer resolution problem detection.
-
-=============================================================================
-Add support for OSF Version 5.
-=============================================================================
-Version 3.13:
-Add support for Linux to use pthreads.
-
-=============================================================================
-Version 3.16:
-=============================================================================
-Add support for Netbsd
-Add support for Largefiles and Async I/O to Linux target
-=============================================================================
-Version 3.17:
-=============================================================================
-Removed small model for Linux. In the past Iozone was forced to
-use a small model for testing Linux as the normal load caused
-Redhat to panic. Redhat users have told me that the system now
-works fine with the normal load. They have tested Redhat 6.1 and
-it no longer panics.
-=============================================================================
-Version 3.18:
-=============================================================================
-Add support for BSDI. Base, largefiles, pthread. No async I/O
-=============================================================================
-Revision 3.19
-=============================================================================
-date: 2000/03/08 14:47:21; author: capps; state: Exp; lines added/del: 4/1
-Add support for getpagesize. This is used when available.
-=============================================================================
-Revision 3.20
-=============================================================================
-date: 00/04/01 11:04:59; author: capps; state: Exp; lines added/del: 2/2
-Fix for multiple filenames and range of threads being used.
-=============================================================================
-Revision 3.21
-=============================================================================
-date: 00/04/01 11:10:54; author: capps; state: Exp; lines added/del: 3/1
-SPPUX does not have getpagesize...
-=============================================================================
-Revision 3.22
-=============================================================================
-Add support for Linux-ia64
-Add support for mmap & normal file I/O mixing.
-=============================================================================
-Revision 3.23
-Fixups for IBM AIX.
-=============================================================================
-Revision 3.24
-Fixups for BSD 2.7 (New release of BSD that supports O_SYNC)
-=============================================================================
-Revision 3.27
-Fixups for Cygnus compiler changes. (Windows targets). With this
-change Iozone will compile with at least 2 versions of the Cygnus
-compilers.
-=============================================================================
-Revision 3.28
-=============================================================================
-Add support for reading and writing while holding lockf() on the file.
-This turns out to be important aspect of NFS benchmarking.
-=============================================================================
-Revision 3.29
-=============================================================================
-Change calls to lockf() to calls to fcntl(). This is more portable.
-=============================================================================
-Revision 3.30
-=============================================================================
-Add support for variable compute cycle time before each I/O
-operation. This allows one to more accuratly represent
-a specific application that is doing compute/read/compute/read
-style operations.
-=============================================================================
-Revision 3.30 through 3.37
-=============================================================================
-Add support for read and write telemetry files.
-=============================================================================
-Revision 3.40
-=============================================================================
-Code cleanup for popen() usage in -M path.
-=============================================================================
-Revision 3.41
-=============================================================================
-Bug fix for ops/sec in rewrite throughput testing.
-Added average throughput to output in throughput mode.
-=============================================================================
-Revision 3.42
-=============================================================================
-Bug fix for read and re-read. Usage of un-initialized variable that
-caused results to be wrong.
-=============================================================================
-Revision 3.43
-=============================================================================
-Add support for latency plot data for throughput testing.
-Each child thread/process gets its own data file.
-=============================================================================
-Revision 3.44
-=============================================================================
-Enhance compatibility of multi-thread/proc latency offsets with
-telemetry file support.
-=============================================================================
-Revision 3.45 through 3.48
-=============================================================================
-Added latency/offset plot data files for all throughput tests.
-=============================================================================
-Revision 3.49
-=============================================================================
-Fixed compile warning for Linux off64_t redefinition.
-Add Solaris2.6 target with simple build.
-=============================================================================
-Revision 3.50
-=============================================================================
-Added support for openbsd-threads
-Cleanup for page size foo.
-=============================================================================
-Revision 3.51, 3.52, 3.53
-=============================================================================
-Cleanup for new random write testing in throughput mode.
-Improve perror handling.
-=============================================================================
-Revision 3.54
-=============================================================================
-Add -g maxfilesize so people will not have to edit the source to
-test files bigger than 512 Mbytes.
-=============================================================================
-Revision 3.55
-=============================================================================
-Supports -n and -g to set the min and max file sizes to be used for
-an auto mode run.
-=============================================================================
-Revision 3.56
-=============================================================================
-Added support for SCO Unixware SVR5 with gcc compiler
-=============================================================================
-Revision 3.57
-=============================================================================
-Fixed bug where file locking was not being used when
-_LARGE_FILE64_SOURCE was defined in read_perf_test.
-=============================================================================
-Revision 3.58
-=============================================================================
-Added -z option. This is to be used with the -a option. It
-provides more complete testing for small record sizes
-when the file sizes are very large.
-Fixed -a so that the cross-over mechanism works correctly.
-=============================================================================
-Revision 3.59
-=============================================================================
-Fix a bug where the user specified -R -s but did not specify
--a or -r. This caused the Excel report to print a bunch
-of zeros.
-=============================================================================
-Revision 3.60
-=============================================================================
-Fix headers in the Excel output when cross over kicks in.
-=============================================================================
-Revision 3.61
-=============================================================================
-Added -y and -q to set record size range
-Added command line to output
-=============================================================================
-Revision 3.62
-=============================================================================
-Put auto cross over back to 16 Meg
-=============================================================================
-Revision 3.63
-=============================================================================
-Minor code cleanups for error messages
-=============================================================================
-Revision 3.64
-=============================================================================
-Re-organize the help listing.
-=============================================================================
-Revision 3.65
-=============================================================================
-Add labels to the latency/offset output files.
-=============================================================================
-Revision 3.66
-=============================================================================
-Added Randy Dunlap to the list of contributors. Thanks Randy !!
-=============================================================================
-Revision 3.67
-=============================================================================
-Fix labels when using -R and -i options together.
-=============================================================================
-Revision 3.68
-=============================================================================
-Code cleanup. No functionality changes.
-=============================================================================
-Revision 3.69
-=============================================================================
-Prevent mixed modes. Auto and throughput.
-Added support for the Plus extended options.
-=============================================================================
-Revision 3.70
-=============================================================================
-Added support for -+u option. Cpu utilization.
-=============================================================================
-Revision 3.71
-=============================================================================
-Added comment for the support for -+u option. Cpu utilization.
-=============================================================================
-Revision 3.72
-=============================================================================
-Added network testing mode. -+m (Experimental) Tested: Linux, HP-UX
-=============================================================================
-Revision 3.73
-=============================================================================
-Added -xflag support for distributed mode.
-Handle interrupts when in distributed mode.
-=============================================================================
-Revision 3.74
-=============================================================================
-Add default for REMOTE_SHELL
-=============================================================================
-Revision 3.75
-=============================================================================
-Code cleanup.
-=============================================================================
-Revision 3.76
-=============================================================================
-Portability change for shmat().
-Added and example of client_list file to the distribution.
-=============================================================================
-Revision 3.77
-=============================================================================
-Disable CPU utilization in distributed mode.
-Bug fix for CPU utilization in normal mode.
-=============================================================================
-Revision 3.78
-=============================================================================
-Fix compatibility with AIX for shmat()
-=============================================================================
-Revision 3.79
-=============================================================================
-Fix throughput labels when user is selecting specific tests with -i option.
-=============================================================================
-Revision 3.80
-=============================================================================
-Remove dependency on min() and max(). They are not portable.
-=============================================================================
-Revision 3.81
-=============================================================================
-Changes for 64bit architectures. Brad Smith. OpenBSD.
-=============================================================================
-Revision 3.83
-=============================================================================
-Add -+m cluster option to the help list and the list of options.
-=============================================================================
-Revision 3.84 -> 3.88
-=============================================================================
-Fix file descriptor leak in cluster mode.
-=============================================================================
-Revision 3.89 -> 3.91
-=============================================================================
-Support for heterogeneous clusters, bug fix for -C
-=============================================================================
-Revision 3.92
-=============================================================================
-Add a small sleep in the client so the master's terminate message
-can arrive before the client exits and closes the channel.
-=============================================================================
-Revision 3.93
-=============================================================================
-Add support for UWIN (Unix for Windows)
-=============================================================================
-Revision 3.94
-=============================================================================
-Bug fix for client's working dir in cluster mode.
-=============================================================================
-Revision 3.95
-=============================================================================
-Enable more options in Cluster mode.
-=============================================================================
-Revision 3.96
-=============================================================================
-Add support for Solaris 8 in 64-bit mode.
-=============================================================================
-Revision 3.97
-=============================================================================
-Linux demands a function proto for functions that take floats as args.
-=============================================================================
-Revision 3.98
-=============================================================================
-Changes for Solaris to make their silly compiler eat reasonable
-function prototypes. (yech !!)
-=============================================================================
-Revision 3.99
-=============================================================================
-Add protocol version checking for distributed messages.
-Add support for AIX 5.2
-=============================================================================
-Revision 3.100
-=============================================================================
-Fixes for socket ports. Needed to be in network format.
-=============================================================================
-Revision 3.101
-=============================================================================
-Add support for RSH environment override.
-=============================================================================
-Revision 3.102
-=============================================================================
-Improve O_DIRECT and VX_DIRECT so that testing is done
-on the correct file on the correct client.
-=============================================================================
-Revision 3.103
-=============================================================================
-Code cleanup.
-=============================================================================
-Revision 3.104
-=============================================================================
-Code cleanup. Bug fix for O_DIRECT in read_perf_test.
-=============================================================================
-Revision 3.105
-=============================================================================
-Bug fix for TRU64 and OSF where reclen was not getting displayed.
-=============================================================================
-Revision 3.106
-=============================================================================
-Add -+d file I/O diagnostic mode.
-=============================================================================
-Revision 3.107
-=============================================================================
-Fixes for the awesome Diagnostics mode.
-=============================================================================
-Revision 3.108
-=============================================================================
-turn off cdebug
-Switch child comm to SOCK_STREAM. Avoid UDP fragment problems.
-=============================================================================
-Revision 3.109
-=============================================================================
-Fix for "disrupt" and Direct I/O. Needs to be page size and aligned.
-=============================================================================
-Revision 3.110
-=============================================================================
-Cleanup for -Wall to all source files.
-=============================================================================
-Revision 3.111
-=============================================================================
-Fixes for UWIN compile warnings.
-=============================================================================
-Revision 3.112
-=============================================================================
-Fixes for Windows compile warnings. do_compute() proto.
-=============================================================================
-Revision 3.113
-=============================================================================
-Add definition char *dumb for Solaris to alloc_mem()
-=============================================================================
-Revision 3.114
-=============================================================================
-Code cleanup for AIX. No async support caused warnings.
-=============================================================================
-Revision 3.115
-=============================================================================
-Fix for Solaris returning short reads() from socket to child_listen.
-=============================================================================
-Revision 3.116
-=============================================================================
-Add support for Mac OS X
-=============================================================================
-Revision 3.117
-=============================================================================
-Add code to set the socket buffer window size. Solaris needs this.
-=============================================================================
-Revision 3.118
-=============================================================================
-Add O_Direct for AIX
-=============================================================================
-Revision 3.119-> 3.120
-=============================================================================
-Fix some compiler warnings and implement the -+x option for
-setting the multiplier used for file and record size incrementing.
-=============================================================================
-Revision 3.121
-=============================================================================
-Add changes from Debian. Add powerpc and sparc.
-Add changes to fix warning on Irix and Irix64
-=============================================================================
-Revision 3.122
-=============================================================================
-Bug fix for cluster mode. Need to bzero buffers before sprintf or sscanf
-=============================================================================
-Revision 3.123
-=============================================================================
-Bug fix for handling all chars that are transported over messaging.
-=============================================================================
-Revision 3.124
-=============================================================================
-Simplify the child's debug output mechanism.
-=============================================================================
-Revision 3.125
-=============================================================================
-Fix for stonewall in cluster mode.
-=============================================================================
-Revision 3.126
-=============================================================================
-Shrink the client_neutral_command structure so it fits in a single
-UDP packet.
-=============================================================================
-Revision 3.127
-=============================================================================
-Improve debug code for cluster mode.
-=============================================================================
-Revision 3.128
-=============================================================================
-Reduce the message traffic due to master's distribution of STOP. Only
-one STOP distribution is needed. More can lead to socket buffer overflows.
-=============================================================================
-Revision 3.129
-=============================================================================
-Bzero structures on the stack before using. No problem seen but it
-is a possible hole.
-=============================================================================
-Revision 3.130
-=============================================================================
-Add error checking for the client file contents.
-=============================================================================
-Revision 3.131
-=============================================================================
-Use prealloc() for HP-UX to create file for use with mmap.
-=============================================================================
-Revision 3.132
-=============================================================================
-Add random mix mode.
-=============================================================================
-Revision 3.133
-=============================================================================
-Make a better 32 bit random offset from calling rand()<<16||rand()
-=============================================================================
-Revision 3.134
-=============================================================================
-Add -+p percentage read option.
-=============================================================================
-Revision 3.135
-=============================================================================
-Improve the mixed mode distribution algorithm.
-=============================================================================
-Revision 3.136
-=============================================================================
-Fix auto bug introduced by mixed mode testing.
-Introduce -+r for O_RSYNC.
-=============================================================================
-Revision 3.137
-=============================================================================
-Code cleanup for some warnings on IA-64 systems.
-=============================================================================
-Revision 3.138
-=============================================================================
-Fixes for FreeBSD
-=============================================================================
-Revision 3.139
-=============================================================================
-Add support for multiple -r and -s options.
-=============================================================================
-Revision 3.140
-=============================================================================
-Code cleanup for non-ansi builds
-Add target build to output.
-=============================================================================
-Revision 3.141
-=============================================================================
-Add speed check code.
-=============================================================================
-Revision 3.142
-=============================================================================
-Increase maximum threads/procs to 256
-=============================================================================
-Revision 3.143
-=============================================================================
-Add contribs and -+t to help splash screen.
-=============================================================================
-Revision 3.144
-=============================================================================
-Bug fix for Redhat.
-=============================================================================
-Revision 3.145
-=============================================================================
-Bug fix for when user used -l but failed to use -u too.
-=============================================================================
-Revision 3.146
-=============================================================================
-Add void to speed_main() for non-ansi compiles.
-=============================================================================
-Revision 3.147
-=============================================================================
-Add "Test running" So users will know the test is running
-and not to hit control 'c' too soon.
-Bug fix in libbif.c do_float()
-=============================================================================
-Revision 3.148
-=============================================================================
-Turn off some child debug code.
-=============================================================================
-Revision 3.149
-=============================================================================
-Disable fread and fwrite testing if mmap or async is in use.
-=============================================================================
-Revision 3.150
-=============================================================================
-Add pread/pwrite to Linux
-=============================================================================
-Revision 3.151
-=============================================================================
-Handle -EB
-=============================================================================
-Revision 3.152
-=============================================================================
-Add pread/pwrite throughput testing
-=============================================================================
-Revision 3.153
-=============================================================================
-Changed second parameter to mmap() to be size_t. AIX needs this.
-=============================================================================
-Revision 3.154
-=============================================================================
-Add support for madvise().
-=============================================================================
-Revision 3.155
-=============================================================================
-Code cleanup.
-=============================================================================
-Revision 3.156
-=============================================================================
-Fixes for -w -t -R from Veritas
-=============================================================================
-Revision 3.157
-=============================================================================
-Make madvise() go away for windows.
-=============================================================================
-Revision 3.158
-=============================================================================
-Permit smaller values for -n and -g
-=============================================================================
-Revision 3.159
-=============================================================================
-Make initial write in initfile() a page size request.
-=============================================================================
-Revision 3.160
-=============================================================================
-Stop test if file can not be written.
-=============================================================================
-Revision 3.161
-=============================================================================
-Special handling for mmap of a file that is opened (O_DIRECT)
-=============================================================================
-Revision 3.162
-=============================================================================
-Fixup for systems that do not have O_DIRECT.
-=============================================================================
-Revision 3.163
-=============================================================================
-Simplify the prototype for do_compute()
-=============================================================================
-Revision 3.164
-=============================================================================
-Zero compute_val inside of loops.
-=============================================================================
-Revision 3.165
-=============================================================================
-Add support for O_DIRECT for IRIX and IRIX64
-=============================================================================
-Revision 3.166
-=============================================================================
-Improve macros and add prototypes.
-=============================================================================
-Revision 3.167
-=============================================================================
-Improve resolution of get_resolution().
-=============================================================================
-Revision 3.168
-=============================================================================
-Changes to support RedHat 9.0.
-=============================================================================
-Revision 3.169
-=============================================================================
-Special handling of NAME for broken frontend in Cygwin/Windows env.
-=============================================================================
-Revision 3.170
-=============================================================================
-Add support for the CrayX1
-=============================================================================
-Revision 3.171
-=============================================================================
-Remove reference to PAGE_SIZE for linux. This causes problems
-with SuSe 8.
-=============================================================================
-Revision 3.172
-=============================================================================
-Fixup for SCO build.
-=============================================================================
-Revision 3.173
-=============================================================================
-Add -DHAVE_PREAD for Solaris8-64 target.
-=============================================================================
-Revision 3.174
-=============================================================================
-Code cleanup for Linux
-=============================================================================
-Revision 3.177
-=============================================================================
-Improve -+d so that each byte is more unique.
-Improve byte level validation.
-=============================================================================
-Revision 3.178
-=============================================================================
-Provide byte level error detection with Found char and Expecting Char in
- -+d mode.
-=============================================================================
-Revision 3.179
-=============================================================================
-Improve speed of -+d without losing uniqueness of bytes.
-=============================================================================
-Revision 3.180
-=============================================================================
-Fix so that Windows can use multiple processes. Needed mmap like SCO.
-=============================================================================
-Revision 3.181
-=============================================================================
-Use malloc() instead of mmap() for threads memory, instead of mmap.
-=============================================================================
-Revision 3.182
-=============================================================================
-Make CPU utilization use doubles everywhere.
-=============================================================================
-Revision 3.183
-=============================================================================
-Add support for CPU utilization while in distributed mode.
-=============================================================================
-Revision 3.184
-=============================================================================
-Make all times relative so multi node can do CPU usage.
-=============================================================================
-Revision 3.185
-=============================================================================
-Remove unused variables.
-=============================================================================
-Revision 3.186
-=============================================================================
-Add -+n option to disable re-testing.
-=============================================================================
-Revision 3.187
-=============================================================================
-Fixup -+n for throughput mode.
-=============================================================================
-Revision 3.188
-=============================================================================
-Fix Excel output when -+n is used.
-=============================================================================
-Revision 3.189
-=============================================================================
-Add support for the IBM S390 running Linux.
-=============================================================================
-Revision 3.190
-=============================================================================
-Cleanup naming conventions for the S390 and fixup a #define.
-=============================================================================
-Revision 3.191
-=============================================================================
-Add 64 bit compiles for s390x
-Move BIG_ENDIAN to ZBIG_ENDIAN to avoid header conflicts.
-=============================================================================
-Revision 3.192
-=============================================================================
-Make random offsets always based on 48 bit random values.
-=============================================================================
-Revision 3.193
-=============================================================================
-Addition for make random offsets always based on 48 bit random values.
-=============================================================================
-Revision 3.194
-=============================================================================
-Make rands long longs.
-=============================================================================
-Revision 3.195
-=============================================================================
-Bug fix for 48 bit rands in bsd4_2 and Windows.
-=============================================================================
-Revision 3.196
-=============================================================================
-Make big_rand a long long.
-=============================================================================
-Revision 3.197
-=============================================================================
-Inject Erik's changes for Multi-client Windows.
-=============================================================================
-Revision 3.198
-=============================================================================
-Change proto version due to changes in Windows -+m support.
-Add Eric to the contributors list.
-=============================================================================
-Revision 3.199
-=============================================================================
-Add more Windows support.
-=============================================================================
-Revision 3.200
-=============================================================================
-Spelling error.
-=============================================================================
-Revision 3.201
-=============================================================================
-Bug fixes from Erik H.
-=============================================================================
-Revision 3.202
-=============================================================================
-Reduce usage of shared memory.
-=============================================================================
-Revision 3.203
-=============================================================================
-Eliminate STUPID warning from the silly compiler.
-=============================================================================
-Revision 3.204
-=============================================================================
-Changes to remove warnings on BSD. Thanks to Christian Weisgerber
-=============================================================================
-Revision 3.205
-=============================================================================
-Support for the AMD64
-=============================================================================
-Revision 3.206
-=============================================================================
-Add -+k for constant aggregate data set size in throughput mode.
-=============================================================================
-Revision 3.207
-=============================================================================
-Add pread support for the TRU64 target. Department of Defense in Canada.
-Add -+q for delay in seconds between tests.
-=============================================================================
-Revision 3.208
-=============================================================================
-Move variable up, GCC on Solaris was getting a bogus parse error
-=============================================================================
-Revision 3.209
-=============================================================================
-Add support for -+D (O_DSYNC) mode testing.
-=============================================================================
-Revision 3.210
-=============================================================================
-Make O_DSYNC conditional.
-=============================================================================
-Revision 3.211
-=============================================================================
-Add telemetry support for pread/pwrite
-=============================================================================
-Revision 3.212
-=============================================================================
-Add record locking
-Add single file, file sharing.
-=============================================================================
-Revision 3.213
-=============================================================================
-Enhance fill/verify (diag mode) for shared file.
-=============================================================================
-Revision 3.214
-=============================================================================
-Remove warnings.
-=============================================================================
-Revision 3.215
-=============================================================================
-Add prototype for mylockr()
-=============================================================================
-Revision 3.216
-=============================================================================
-Fix prototype for mylockr
-=============================================================================
-Revision 3.217
-=============================================================================
-Enable options for Windows systems.
-=============================================================================
-Revision 3.218
-=============================================================================
-Add label to Excel spreadsheet that describes the rows and columns.
-Add support for Solaris64 with VxFS.
-Add support for Linux-arm
-=============================================================================
-Revision 3.219
-=============================================================================
-Add sleep to permit child to get connection up before master does connect.
-=============================================================================
-Revision 3.220
-=============================================================================
-Improve master connect to child, without delays.
-=============================================================================
-Revision 3.221
-=============================================================================
-Add -+B Mixed sequential testing. BlueArc request.
-=============================================================================
-Revision 3.222
-=============================================================================
-Workaround for bug in Cygwin's sscanf
-=============================================================================
-Revision 3.223
-=============================================================================
-Add transfer size to the output from -Q
-=============================================================================
-Revision 3.224
-=============================================================================
-Work around for TCP_WAIT in Windows.
-=============================================================================
-Revision 3.225
-=============================================================================
-Fix for broken rsh on Windows.
-=============================================================================
-Revision 3.226
-=============================================================================
-Workaround for gcc 3.4. From the folks at Gentoo.org.
-=============================================================================
-Revision 3.227
-=============================================================================
-Enable -+m and telemetry files.
-=============================================================================
-Revision 3.228
-=============================================================================
-Make more unique file names for mmap files.
-=============================================================================
-Revision 3.229
-=============================================================================
-Add -+T time stamps.
-=============================================================================
-Revision 3.230
-=============================================================================
-Bug fix for -m and validation code.
-=============================================================================
-Revision 3.231
-=============================================================================
-Add a space to the throughput output dump.
-=============================================================================
-Revision 3.232
-=============================================================================
-Add another space to the throughput output dump.
-=============================================================================
-Revision 3.233
-=============================================================================
-Enable shared file with no locking
-=============================================================================
-Revision 3.234
-=============================================================================
-Add sanity check to validate that open(name, O_CREAT | O_WRONLY | O_TRUNC, 0)
-does work correctly. This is an NFS client test that
-detects if the NFS server's local filesystem is broken and
-fails to support the sequence above correctly.
-=============================================================================
-Revision 3.235
-=============================================================================
-add a close(fd) to the sanity test.
-=============================================================================
-Revision 3.237
-=============================================================================
-Transport the -o flag to remote clients.
-=============================================================================
-Revision 3.238
-=============================================================================
-Fix hang when using HP-UX master, Linux client, ssh buildup.
-=============================================================================
-Revision 3.239
-=============================================================================
-Add -+h hostname. Permits one to manually set the hostname. For systems
-with multiple names/NICs.
-=============================================================================
-Revision 3.241
-=============================================================================
-Add -+h, set hostname, and fix Solaris hang.
-=============================================================================
-Revision 3.242
-=============================================================================
-Remove the side effect of no-rereads when using -w. Now use -+n for
-consistancy.
-=============================================================================
-Revision 3.243
-=============================================================================
-Bug fix for -+k option.
-=============================================================================
-Revision 3.246
-=============================================================================
-Add the -+U for WIN32 API calls .. Unbuffered I/O. Sony studios.
-=============================================================================
-Revision 3.247
-=============================================================================
-Add support for -+U with -K (WIN32API calls + Jitter)
-=============================================================================
-Revision 3.248
-=============================================================================
-Bug fix. -J with -+m not passing compute delay correctly.
-=============================================================================
-Revision 3.249
-=============================================================================
-Add support for -i 8 when used with -+B (sequential mix)
-=============================================================================
-Revision 3.250
-=============================================================================
-Change the default pattern. Samba is trying to cheat by
-special casing IOZONE.tmp, and the pattern of 0xA5.
-=============================================================================
-Revision 3.251
-=============================================================================
-Make the default pattern random, and based on Iozone version.
-This is to prevent the hack from Richard Sharpe (in Samba)
-from special casing Iozone, and lying to the user.
-=============================================================================
-Revision 3.252
-=============================================================================
-bug fix in pattern gen.
-=============================================================================
-Revision 3.253
-=============================================================================
-Add -+Z old data set mode.
-Add -+X constant data for short circuit testing only.
-=============================================================================
-Revision 3.254
-=============================================================================
- Multi-node changes for new options. (-+Z and -+X)
-=============================================================================
-Revision 3.255
-=============================================================================
-Add -+K flag for Sony.
-=============================================================================
-Revision 3.256
-=============================================================================
-Move -+K outside of Windows only.
-=============================================================================
-Revision 3.257
-=============================================================================
-Simplify percentage calculation
-=============================================================================
-Revision 3.258
-=============================================================================
-Add error checking for -f and -F in the wrong modes.
-=============================================================================
-Revision 3.259
-=============================================================================
-Bug fix for pbuffer allocation on remote clients.
-=============================================================================
-Revision 3.260
-=============================================================================
-Check for max_rec_size when using ranges. -r -r -r
-=============================================================================
-Revision 3.261
-=============================================================================
-Fix for Debian user bug. -r 1m -n 1m -g 2m gave bogus error.
-=============================================================================
-Revision 3.262
-=============================================================================
-Bug fix for -k used in conjunction with -t and content validation.
-=============================================================================
-Revision 3.263
-=============================================================================
-Bug fix for -k used in conjunction with -t and content validation.
-=============================================================================
-Revision 3.264
-=============================================================================
-Add DragonFly target.
-=============================================================================
-Revision 3.265
-=============================================================================
-Put PER_VECTOR_OFFSET in for HP-UX
-=============================================================================
-Revision 3.266
-=============================================================================
-Fix compiler warning messages
-=============================================================================
-Revision 3.267
-=============================================================================
-Enforce minimum file size of page_size
-=============================================================================
-Revision 3.268
-=============================================================================
-Minor fixes.
-=============================================================================
-Revision 3.269
-=============================================================================
-Check fsync and close for errors.
-=============================================================================
-Revision 3.270
-=============================================================================
-Adding support for testing block devices. Will be done is phases. This is
-phase 1. (Single threaded mode only)
-=============================================================================
-Revision 3.271
-=============================================================================
-Adding 4 token support to client_list. Each entry may now contain 4 tokens
-and the new one is the absolute path to the temp file for testing.
-=============================================================================
-Revision 3.272
-Editorial change.
-=============================================================================
-Revision 3.273
-Add support for external monitor start & stop for throughput tests.
-IMON_START and IMON_STOP environmental variables used.
-=============================================================================
-Revision 3.274
-=============================================================================
-minor change.
-=============================================================================
-Revision 3.275
-Bug fix for systems without O_DIRECT. Fall through in switch statement.
-=============================================================================
-Revision 3.276
-Fix for -c -t over NFS and initial writer close() when told by another to stop
-=============================================================================
-Revision 3.277
-Add Benny Halevy to contributors list.
-=============================================================================
-Revision 3.278
-Fix for Cygwin environment.
-=============================================================================
-Revision 3.279
-Code cleanup, and add arg to external trigger.
-=============================================================================
-Revision 3.280
-Code fixes for macosx
-=============================================================================
-=============================================================================
-Revision 3.281
-Add support for building with Sun's Studio 11 compiler
-=============================================================================
-Revision 3.283
-Bug fix for fread/fwrite with > 2Gig files.
-=============================================================================
-Revision 3.287
-Add O_DIRECT for Windows
-=============================================================================
-Revision 3.288
-Add -+w dedup testing mode.
-=============================================================================
-Revision 3.289
-Make remaining non-dedup data unique.
-=============================================================================
-Revision 3.290
-Make non-dedupable more unique.
-=============================================================================
-Revision 3.291
-Bug fix for non-dedup.
-=============================================================================
-Revision 3.292
-Make random offsets unique, using Knuth shuffle.
-=============================================================================
-Revision 3.292
-free memory used for random offset uniqueness.
-=============================================================================
-Revision 3.294
-Make unique/random offsets 64bits.
-=============================================================================
-Revision 3.295
-Add fallback for random/unique.
-=============================================================================
-Revision 3.296
-Make non-dedup region more unique
-=============================================================================
-Revision 3.297
-Add -+y ## to set percentage of interior dedup.
-=============================================================================
-Revision 3.298
-Add -+y ## to set percentage of interior dedup.
-=============================================================================
-Revision 3.299
-Bug fixes for -+w and -+y
-=============================================================================
-Revision 3.300
-Minor fix for dedup
-=============================================================================
-Revision 3.302
-Adding -+C to set percent of dedupable within a file.
-=============================================================================
-Revision 3.303
-bug fix
-=============================================================================
-Revision 3.304
-Add solaris to read sync O_RSYNC
-=============================================================================
-Revision 3.305
-Add space to avoid field output touching each other.
-=============================================================================
-Revision 3.306
-Add check for config file exceeding MAXSTREAMS.
-=============================================================================
-Revision 3.307
-Add new contributor's name.
-=============================================================================
-Revision 3.308
-Fix type-oh
-=============================================================================
-Revision 3.309
-Bug fix. rewrite_rec needed to fill entire buffer, or later stride read will
-fail.
-=============================================================================
-Revision 3.310
-=============================================================================
-Add ability for remote clients to return errors to the master and
-have the master display on output.
-=============================================================================
-Revision 3.311
-=============================================================================
-fix double reporting of client errors
-=============================================================================
-Revision 3.312
-=============================================================================
-Eliminate extra file descriptor in fwrite test.
-=============================================================================
-Revision 3.312
-=============================================================================
-bug fix for barray allocation in -T mode
-=============================================================================
-Revision 3.313
-Revision 3.314
-Revision 3.315
-=============================================================================
-Changes from Debian: Retry umount, add fileop for linux-sparc, and
-fix column width in fileop for faster boxes.
-=============================================================================
-Revision 3.316
-Add O_DIRECT support to FreeBSD
-=============================================================================
-Revision 3.317
-Fix for defines in FreeBSD
-=============================================================================
-Revision 3.318
-Add IMON_SYNC to enable monitor scripts to be run sync.
-=============================================================================
-Revision 3.319
-Add directio() for Solaris
-=============================================================================
-Revision 3.320
-Add fixes for unresolved references in directio() for Solaris
-=============================================================================
-Revision 3.321
-Fix type oh.
-=============================================================================
-Revision 3.322
-Fix c++ style comment back to 'C' style comment.
-=============================================================================
-Revision 3.323
-Bug fix for check_filenames and large files
-=============================================================================
-Revision 3.324
-Replace tripple rand() calls with 64 bit Mersene twister.
-=============================================================================
-Revision 3.325
-Add read-only, external file, with no-verify. -+E
-=============================================================================
-Revision 3.325
-Permit -+E on dedup files.
-=============================================================================
-Revision 3.327
-Permit -+E on random read only testing, on existing file.
-=============================================================================
-Revision 3.328
-Add passing master listener's port to remote children if it is not
-HOST_LIST_PORT
-=============================================================================
-Revision 3.329
-Adding Dave Boone's notruncate option -+N
-=============================================================================
-Revision 3.330
-Bug fix for Dave's code.
-=============================================================================
-Revision 3.331
-Add multi -t ops. Fabrice
-=============================================================================
-Revision 3.332
-Added Li Qin's multi dedup set support. -+S #
-=============================================================================
-Revision 3.333
-Bug fix for -+S dedup_mseed needs to be an integer
-=============================================================================
-Revision 3.334
-Make -+S generate more uniqueness
-=============================================================================
-Revision 3.335
-Make -+S generate more uniqueness
-=============================================================================
-Revision 3.336
-Make -+S generate more uniqueness
-=============================================================================
-Revision 3.337
-Bug fix for -+S
-=============================================================================
-Revision 3.338
-Make umount/remount more robust, in the face of server errors.
-=============================================================================
-Revision 3.339
-Improve the help string for the -+S option.
-=============================================================================
-Revision 3.340
-Add new contributor name.
-=============================================================================
-Revision 3.342
-Add support for the programmable interdimensional timer.
-=============================================================================
-Revision 3.343
-Bug fix for PIT on remote clients.
-=============================================================================
-Revision 3.344
-Bug fix for PIT on remote clients.
-=============================================================================
-Revision 3.345
-Have children re-acquire get_resolution.
-=============================================================================
-Revision 3.346
-Bug fix for t_range addition.
-=============================================================================
-Revision 3.347
-Get rid of a warning. ( An invalid warning, but none the less )
-=============================================================================
-Revision 3.348
-Add more words to the usage warnings and license
-=============================================================================
-Revision 3.349
-Remove Ascii dependency for IBM's Z/OS that speaks EBCDIC.
-=============================================================================
-Revision 3.353
-Add support for SUA
-=============================================================================
-Revision 3.354
-Remove Sanity check so that SMB on Windows, under SUA, works
-=============================================================================
-Revision 3.355
-Cache the getaddrinfo call.
-=============================================================================
-Revision 3.356
-delete optimization.. bad...Cache the getaddrinfo call.
-=============================================================================
-Revision 3.358
-Change pit to use unsigned long longs
-=============================================================================
-Revision 3.359
-Add Linux processor affinity
-=============================================================================
-Revision 3.360
-Remove UDP usage
-=============================================================================
-Revision 3.361
-Increment protocol_version to catch incompat versions.
-=============================================================================
-Revision 3.362
-Fixup for new include needed by Solaris10
-=============================================================================
-Revision 3.363
-Patch for Mac errno
-=============================================================================
-Revision 3.364
-Patch for Mac printf's
-=============================================================================
-Revision 3.365
-Fix Josh's introduction of new Linux warnings.
-=============================================================================
-Revision 3.366
-Take sleep(1) out put path, deal with it in error/retry path
-=============================================================================
-Revision 3.367
-Add -+z latency histogram logging.
-=============================================================================
-Revision 3.368
-Format change for the -+z latency histogram logging.
-=============================================================================
-Revision 3.369
-Added -+O Op_rate control.
-=============================================================================
-Revision 3.370
-Close race condition with master closing socket to child async reader
-=============================================================================
-Revision 3.371
-Add "mygen" generation to the remote children protocol.
-This prevents zombies from coming back to life and killing future masters.
-=============================================================================
-Revision 3.372
-Set Listen(s,100) to Listen(s,MAXSTREAMS)
-=============================================================================
-Revision 3.373
-Move lable "again" to outside of cdebug.
-=============================================================================
-Revision 3.374
-More fixes for busted crap in Solaris !!!
-=============================================================================
-Revision 3.376
-AIX update. They now have errno.h
-=============================================================================
-Revision 3.377
-Need errno.h for FreeBSD
-=============================================================================
-Revision 3.379
-Need to include errno.h for Cygwin
-=============================================================================
-Revision 3.381
-Add SO_LINGER for master_listen and child_listen, so that wind-blows
-will work like all other systems on the planet.
-=============================================================================
-Revision 3.382
-Fix for linger addition
-=============================================================================
-Revision 3.383
-Fix for linger addition
-=============================================================================
-Revision 3.384
-Fix for linger addition
-=============================================================================
-Revision 3.385
-Make linger for all
-=============================================================================
-Revision 3.387
-Change sleep() calls, that help connect() to nanosleep() calls.
-=============================================================================
-Revision 3.388
-Fixup remainder for nanosleep()
-=============================================================================
-Revision 3.389
-Fixup remainder for nanosleep()
-=============================================================================
-Revision 3.390
-Add code for pread/pwrite from Ben England (Redhat)
-=============================================================================
-Revision 3.391
-Add code for MDEBUG and CDEBUG from Bob England (Redhat)
-=============================================================================
-Revision 3.392
-Add code for building HPUX. Errno.h
-=============================================================================
-Revision 3.393
-Fixes for Windows (nanosleep doesn't always work )
-=============================================================================
-Revision 3.394
-Fixes for preadv and pwritev from RedHat (Ben Englanc)
-=============================================================================
-Revision 3.395
-Add warnings for default switch cases, and exit with value for unknowns.
-=============================================================================
-Revision 3.396
-Fix warnings from RedHat patches
-=============================================================================
-Revision 3.397
-Bug fix for getopt default case, with bad parameter handed in.
-=============================================================================
-Revision 3.398
-Adding thread_read_test and thread_write_test.
-=============================================================================
diff --git a/src/components/appio/tests/iozone/Generate_Graphs b/src/components/appio/tests/iozone/Generate_Graphs
deleted file mode 100755
index 7c14a9a14..000000000
--- a/src/components/appio/tests/iozone/Generate_Graphs
+++ /dev/null
@@ -1,32 +0,0 @@
-#
-# This script will create the Iozone graphs using
-# gnuplot.
-#
-#
-#
-# ------------------------------------------------
-# YOU MUST PROVIDE A FILE NAME FOR IT TO PROCESS.
-# This filename is the name of the file where you
-# sent Iozone's output.
-# ------------------------------------------------
-
-# Generate data base for all of the operation types.
-
-./gengnuplot.sh $1 write
-./gengnuplot.sh $1 rewrite
-./gengnuplot.sh $1 read
-./gengnuplot.sh $1 reread
-./gengnuplot.sh $1 randread
-./gengnuplot.sh $1 randwrite
-./gengnuplot.sh $1 bkwdread
-./gengnuplot.sh $1 recrewrite
-./gengnuplot.sh $1 strideread
-./gengnuplot.sh $1 fwrite
-./gengnuplot.sh $1 frewrite
-./gengnuplot.sh $1 fread
-./gengnuplot.sh $1 freread
-
-# Produce graphs and postscript results.
-gnuplot gnu3d.dem
-
-
diff --git a/src/components/appio/tests/iozone/Gnuplot.txt b/src/components/appio/tests/iozone/Gnuplot.txt
deleted file mode 100644
index c62e08e86..000000000
--- a/src/components/appio/tests/iozone/Gnuplot.txt
+++ /dev/null
@@ -1,23 +0,0 @@
-The script Generate_Graphs will create the 3D surface plots
-and display them. It will also produce postscript outputs
-for each test and leave them in their respective sub-directory.
-
-It processes the output from an Iozone run. The output from
-Iozone that it is expecting is the text output from
-the iozone default behavior. (iozone -a, or iozone -az)
-
-How to produce graphs:
-
- Generate_Graphs iozone.out
-
-The gen_graphs script will:
-1. Create the databases for each type of operation
- and then processes them with Gnuplot.
-2. It will display each result on the X11 screen, and
- also save a copy in postscript in the test sub-directory.
-
-
-Thanks to Yves Rougy for providing the nifty scripts to help
-with the plots.
-
-
diff --git a/src/components/appio/tests/iozone/client_list b/src/components/appio/tests/iozone/client_list
deleted file mode 100644
index c3f043bec..000000000
--- a/src/components/appio/tests/iozone/client_list
+++ /dev/null
@@ -1,36 +0,0 @@
-#
-# Lines that start with # in column 0 are comments.
-#
-# There are now two formats supported.
-# Format: 3 fields, space delimited.
-# Format: 4 fields, space delimited.
-#
-# Format: 3 fields, space delimited.
-# client_name working_dir_on_client path_to_iozone_on_client
-# Format: 4 fields, space delimited.
-# client_name working_dir_on_client path_to_iozone_on_client path_to_testfile
-#
-# Example: With two clients (format 3 fields)
-#
-# client1 /home/user/tmp /home/user/tmp/iozone
-# client2 /home/user/tmp /home/user/tmp/iozone
-#
-#
-# Example: With two copies of Iozone on each of the two clients
-# (format 3 fields)
-#
-# client1 /home/user/tmp /home/user/tmp/iozone
-# client1 /home/user/tmp /home/user/tmp/iozone
-# client2 /home/user/tmp /home/user/tmp/iozone
-# client2 /home/user/tmp /home/user/tmp/iozone
-#
-# Example: With two clients (format 4 fields)
-# client1 /home/user/tmp /home/user/tmp/iozone /tmp/foo1
-# client2 /home/user/tmp /home/user/tmp/iozone /tmp/foo2
-#
-# Example: With two copies of Iozone on each of the two clients
-# (format 4 fields)
-# client1 /home/user/tmp /home/user/tmp/iozone /tmp/foo1
-# client1 /home/user/tmp /home/user/tmp/iozone /tmp/foo2
-# client2 /home/user/tmp /home/user/tmp/iozone /tmp/foo3
-# client2 /home/user/tmp /home/user/tmp/iozone /tmp/foo4
diff --git a/src/components/appio/tests/iozone/fileop.c b/src/components/appio/tests/iozone/fileop.c
deleted file mode 100644
index 588a2d279..000000000
--- a/src/components/appio/tests/iozone/fileop.c
+++ /dev/null
@@ -1,1389 +0,0 @@
-/*
- * Author: Don Capps
- * 3/13/2006
- *
- * Author: Don Capps (capps@iozone.org)
- * 7417 Crenshaw
- * Plano, TX 75025
- *
- * Copyright 2006, 2007, 2008, 2009 Don Capps.
- *
- * License to freely use and distribute this software is hereby granted
- * by the author, subject to the condition that this copyright notice
- * remains intact. The author retains the exclusive right to publish
- * derivative works based on this work, including, but not limited to,
- * revised versions of this work",
- *
- *
- fileop [-f X ]|[-l # -u #] [-s Y] [-e] [-b] [-w] [-d <dir>] [-t] [-v] [-h]
- -f # Force factor. X^3 files will be created and removed.
- -l # Lower limit on the value of the Force factor.
- -u # Upper limit on the value of the Force factor.
- -s # Optional. Sets filesize for the create/write. May use suffix 'K' or 'M'.
- -e Excel importable format.
- -b Output best case.
- -w Output worst case.
- -d <dir> Specify starting directory.
- -U <dir> Mount point to remount between tests.
- -t Verbose output option.
- -v Version information.
- -h Help text.
- *
- * X is a force factor. The total number of files will
- * be X * X * X ( X ^ 3 )
- * The structure of the file tree is:
- * X number of Level 1 directories, with X number of
- * level 2 directories, with X number of files in each
- * of the level 2 directories.
- *
- * Example: fileop 2
- *
- * dir_1 dir_2
- * / \ / \
- * sdir_1 sdir_2 sdir_1 sdir_2
- * / \ / \ / \ / \
- * file_1 file_2 file_1 file_2 file_1 file_2 file_1 file_2
- *
- * Each file will be created, and then 1 byte is written to the file.
- *
- */
-
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <sys/time.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <signal.h>
-#include <unistd.h>
-#include <dirent.h>
-#include <string.h>
-
-#include <limits.h>
-
-#if defined(Windows)
-#include <Windows.h>
-#endif
-#if !defined(PATH_MAX)
-#define PATH_MAX 255
-#endif
-
-#if defined(_SUA_)
-extern char *optarg;
-extern char *opterr;
-int fsync();
-int getopt();
-#endif
-int junk, *junkp;
-int x,excel;
-int verbose = 0;
-int sz = 1;
-char *mbuffer;
-int incr = 1;
-#define _STAT_CREATE 0
-#define _STAT_WRITE 1
-#define _STAT_CLOSE 2
-#define _STAT_LINK 3
-#define _STAT_UNLINK 4
-#define _STAT_DELETE 5
-#define _STAT_STAT 6
-#define _STAT_ACCESS 7
-#define _STAT_CHMOD 8
-#define _STAT_READDIR 9
-#define _STAT_DIR_CREATE 10
-#define _STAT_DIR_DELETE 11
-#define _STAT_READ 12
-#define _STAT_OPEN 13
-#define _STAT_DIR_TRAVERSE 14
-#define _NUM_STATS 15
-struct stat_struct {
- double starttime;
- double endtime;
- double speed;
- double best;
- double worst;
- double dummy;
- double total_time;
- double dummy1;
- long long counter;
-} volatile stats[_NUM_STATS];
-
-
-static double time_so_far(void);
-void dir_create(int);
-void dir_traverse(int);
-void dir_delete(int);
-void file_create(int);
-void file_stat(int);
-void file_access(int);
-void file_chmod(int);
-void file_readdir(int);
-void file_delete(int);
-void file_link(int);
-void file_unlink(int);
-void file_read(int);
-void splash(void);
-void usage(void);
-void bzero();
-void clear_stats();
-int validate(char *, int , char );
-
-#define THISVERSION " $Revision$"
-/*#define NULL 0*/
-
-char version[]=THISVERSION;
-char thedir[PATH_MAX]="."; /* Default is to use the current directory */
-const char *mountname=NULL; /* Default is not to unmount anything between the tests */
-
-int cret;
-int lower, upper,range;
-int i;
-int best, worst;
-int dirlen;
-
-/************************************************************************/
-/* Routine to purge the buffer cache by unmounting drive. */
-/************************************************************************/
-void purge_buffer_cache()
-{
- if (!mountname)
- return;
-
- char cwd[PATH_MAX];
- char command[1024];
- int ret,i;
-
- junkp=(int *)getcwd(cwd, sizeof(cwd));
- junk=chdir("/");
- strcpy(command,"umount ");
- strcat(command, mountname);
- /*
- umount might fail if the device is still busy, so
- retry unmounting several times with increasing delays
- */
- for (i = 1; i < 10; ++i) {
- ret = system(command);
- if (ret == 0)
- break;
- sleep(i); /* seconds */
- }
- strcpy(command,"mount ");
- strcat(command, mountname);
- junk=system(command);
- junk=chdir(cwd);
-}
-
-int main(int argc, char **argv)
-{
- if(argc == 1)
- {
- usage();
- exit(1);
- }
- while((cret = getopt(argc,argv,"hbwetvf:s:l:u:d:U:i: ")) != EOF){
- switch(cret){
- case 'h':
- usage();
- exit(0);
- break;
- case 'd' :
- dirlen=strlen(optarg);
- if (optarg[dirlen-1]=='/')
- --dirlen;
- strncpy(thedir, optarg, dirlen);
- thedir[dirlen] = 0;
- break;
- case 'U':
- mountname = optarg;
- break;
- case 'i': /* Increment force by */
- incr=atoi(optarg);
- if(incr < 0)
- incr=1;
- break;
- case 'f': /* Force factor */
- x=atoi(optarg);
- if(x < 0)
- x=1;
- break;
- case 's': /* Size of files */
- sz=atoi(optarg);
- if(optarg[strlen(optarg)-1]=='k' ||
- optarg[strlen(optarg)-1]=='K'){
- sz = (1024 * atoi(optarg));
- }
- if(optarg[strlen(optarg)-1]=='m' ||
- optarg[strlen(optarg)-1]=='M'){
- sz = (1024 * 1024 * atoi(optarg));
- }
- if(sz < 0)
- sz=1;
- break;
- case 'l': /* lower force value */
- lower=atoi(optarg);
- range=1;
- if(lower < 0)
- lower=1;
- break;
- case 'v': /* version */
- splash();
- exit(0);
- break;
- case 'u': /* upper force value */
- upper=atoi(optarg);
- range=1;
- if(upper < 0)
- upper=1;
- break;
- case 't': /* verbose */
- verbose=1;
- break;
- case 'e': /* Excel */
- excel=1;
- break;
- case 'b': /* Best */
- best=1;
- break;
- case 'w': /* Worst */
- worst=1;
- break;
- }
- }
- mbuffer=(char *)malloc(sz);
- memset(mbuffer,'a',sz);
- if(!excel)
- printf("\nFileop: Working in %s, File size is %d, Output is in Ops/sec. (A=Avg, B=Best, W=Worst)\n", thedir, sz);
- if(!verbose)
- {
-#ifdef Windows
- printf(" . %7s %7s %7s %7s %7s %7s %7s %7s %7s %7s %7s %7s %7s %10s\n",
- "mkdir","chdir","rmdir","create","open","read","write","close","stat",
- "access","chmod","readdir","delete"," Total_files");
-#else
-
- printf(" . %7s %7s %7s %7s %7s %7s %7s %7s %7s %7s %7s %7s %7s %7s %7s %10s\n",
- "mkdir","chdir","rmdir","create","open", "read","write","close","stat",
- "access","chmod","readdir","link ","unlink","delete",
- " Total_files");
-#endif
- }
- junk=chdir(thedir); /* change starting point */
- if(x==0)
- x=1;
- if(range==0)
- lower=upper=x;
- for(i=lower;i<=upper;i+=incr)
- {
- clear_stats();
- x=i;
- /*
- * Dir Create test
- */
- purge_buffer_cache();
- dir_create(x);
-
- if(verbose)
- {
- printf("mkdir: Dirs = %9lld ",stats[_STAT_DIR_CREATE].counter);
- printf("Total Time = %12.9f seconds\n", stats[_STAT_DIR_CREATE].total_time);
- printf(" Avg mkdir(s)/sec = %12.2f (%12.9f seconds/op)\n",
- stats[_STAT_DIR_CREATE].counter/stats[_STAT_DIR_CREATE].total_time,
- stats[_STAT_DIR_CREATE].total_time/stats[_STAT_DIR_CREATE].counter);
- printf(" Best mkdir(s)/sec = %12.2f (%12.9f seconds/op)\n",1/stats[_STAT_DIR_CREATE].best,stats[_STAT_DIR_CREATE].best);
- printf(" Worst mkdir(s)/sec = %12.2f (%12.9f seconds/op)\n\n",1/stats[_STAT_DIR_CREATE].worst,stats[_STAT_DIR_CREATE].worst);
- }
-
- /*
- * Dir Traverse test
- */
- purge_buffer_cache();
- dir_traverse(x);
-
- if(verbose)
- {
- printf("chdir: Dirs = %9lld ",stats[_STAT_DIR_TRAVERSE].counter);
- printf("Total Time = %12.9f seconds\n", stats[_STAT_DIR_TRAVERSE].total_time);
- printf(" Avg chdir(s)/sec = %12.2f (%12.9f seconds/op)\n",
- stats[_STAT_DIR_TRAVERSE].counter/stats[_STAT_DIR_TRAVERSE].total_time,
- stats[_STAT_DIR_TRAVERSE].total_time/stats[_STAT_DIR_TRAVERSE].counter);
- printf(" Best chdir(s)/sec = %12.2f (%12.9f seconds/op)\n",1/stats[_STAT_DIR_TRAVERSE].best,stats[_STAT_DIR_TRAVERSE].best);
- printf(" Worst chdir(s)/sec = %12.2f (%12.9f seconds/op)\n\n",1/stats[_STAT_DIR_TRAVERSE].worst,stats[_STAT_DIR_TRAVERSE].worst);
- }
-
- /*
- * Dir delete test
- */
- purge_buffer_cache();
- dir_delete(x);
-
- if(verbose)
- {
- printf("rmdir: Dirs = %9lld ",stats[_STAT_DIR_DELETE].counter);
- printf("Total Time = %12.9f seconds\n",stats[_STAT_DIR_DELETE].total_time);
- printf(" Avg rmdir(s)/sec = %12.2f (%12.9f seconds/op)\n",
- stats[_STAT_DIR_DELETE].counter/stats[_STAT_DIR_DELETE].total_time,
- stats[_STAT_DIR_DELETE].total_time/stats[_STAT_DIR_DELETE].counter);
- printf(" Best rmdir(s)/sec = %12.2f (%12.9f seconds/op)\n",1/stats[_STAT_DIR_DELETE].best,stats[_STAT_DIR_DELETE].best);
- printf(" Worst rmdir(s)/sec = %12.2f (%12.9f seconds/op)\n\n",1/stats[_STAT_DIR_DELETE].worst,stats[_STAT_DIR_DELETE].worst);
- }
-
- /*
- * Create test
- */
- purge_buffer_cache();
- file_create(x);
- if(verbose)
- {
- printf("create: Files = %9lld ",stats[_STAT_CREATE].counter);
- printf("Total Time = %12.9f seconds\n", stats[_STAT_CREATE].total_time);
- printf(" Avg create(s)/sec = %12.2f (%12.9f seconds/op)\n",
- stats[_STAT_CREATE].counter/stats[_STAT_CREATE].total_time,
- stats[_STAT_CREATE].total_time/stats[_STAT_CREATE].counter);
- printf(" Best create(s)/sec = %12.2f (%12.9f seconds/op)\n",
- 1/stats[_STAT_CREATE].best,stats[_STAT_CREATE].best);
- printf(" Worst create(s)/sec = %12.2f (%12.9f seconds/op)\n\n",
- 1/stats[_STAT_CREATE].worst,stats[_STAT_CREATE].worst);
- printf("write: Files = %9lld ",stats[_STAT_WRITE].counter);
- printf("Total Time = %12.9f seconds\n", stats[_STAT_WRITE].total_time);
- printf(" Avg write(s)/sec = %12.2f (%12.9f seconds/op)\n",
- stats[_STAT_WRITE].counter/stats[_STAT_WRITE].total_time,
- stats[_STAT_WRITE].total_time/stats[_STAT_WRITE].counter);
- printf(" Best write(s)/sec = %12.2f (%12.9f seconds/op)\n",
- 1/stats[_STAT_WRITE].best,stats[_STAT_WRITE].best);
- printf(" Worst write(s)/sec = %12.2f (%12.9f seconds/op)\n\n",
- 1/stats[_STAT_WRITE].worst,stats[_STAT_WRITE].worst);
- printf("close: Files = %9lld ",stats[_STAT_CLOSE].counter);
- printf("Total Time = %12.9f seconds\n", stats[_STAT_CLOSE].total_time);
- printf(" Avg close(s)/sec = %12.2f (%12.9f seconds/op)\n",
- stats[_STAT_CLOSE].counter/stats[_STAT_CLOSE].total_time,
- stats[_STAT_CLOSE].total_time/stats[_STAT_CLOSE].counter);
- printf(" Best close(s)/sec = %12.2f (%12.9f seconds/op)\n",
- 1/stats[_STAT_CLOSE].best,stats[_STAT_CLOSE].best);
- printf(" Worst close(s)/sec = %12.2f (%12.9f seconds/op)\n\n",
- 1/stats[_STAT_CLOSE].worst,stats[_STAT_CLOSE].worst);
- }
-
- /*
- * Stat test
- */
- purge_buffer_cache();
- file_stat(x);
-
- if(verbose)
- {
- printf("stat: Files = %9lld ",stats[_STAT_STAT].counter);
- printf("Total Time = %12.9f seconds\n", stats[_STAT_STAT].total_time);
- printf(" Avg stat(s)/sec = %12.2f (%12.9f seconds/op)\n",
- stats[_STAT_STAT].counter/stats[_STAT_STAT].total_time,
- stats[_STAT_STAT].total_time/stats[_STAT_STAT].counter);
- printf(" Best stat(s)/sec = %12.2f (%12.9f seconds/op)\n",
- 1/stats[_STAT_STAT].best,stats[_STAT_STAT].best);
- printf(" Worst stat(s)/sec = %12.2f (%12.9f seconds/op)\n\n",
- 1/stats[_STAT_STAT].worst,stats[_STAT_STAT].worst);
- }
- /*
- * Read test
- */
- purge_buffer_cache();
- file_read(x);
-
- if(verbose)
- {
- printf("open: Files = %9lld ",stats[_STAT_OPEN].counter);
- printf("Total Time = %12.9f seconds\n", stats[_STAT_OPEN].total_time);
- printf(" Avg open(s)/sec = %12.2f (%12.9f seconds/op)\n",
- stats[_STAT_OPEN].counter/stats[_STAT_OPEN].total_time,
- stats[_STAT_OPEN].total_time/stats[_STAT_OPEN].counter);
- printf(" Best open(s)/sec = %12.2f (%12.9f seconds/op)\n",
- 1/stats[_STAT_OPEN].best,stats[_STAT_OPEN].best);
- printf(" Worst open(s)/sec = %12.2f (%12.9f seconds/op)\n\n",
- 1/stats[_STAT_OPEN].worst,stats[_STAT_OPEN].worst);
-
- printf("read: Files = %9lld ",stats[_STAT_READ].counter);
- printf("Total Time = %12.9f seconds\n", stats[_STAT_READ].total_time);
- printf(" Avg read(s)/sec = %12.2f (%12.9f seconds/op)\n",
- stats[_STAT_READ].counter/stats[_STAT_READ].total_time,
- stats[_STAT_READ].total_time/stats[_STAT_READ].counter);
- printf(" Best read(s)/sec = %12.2f (%12.9f seconds/op)\n",
- 1/stats[_STAT_READ].best,stats[_STAT_READ].best);
- printf(" Worst read(s)/sec = %12.2f (%12.9f seconds/op)\n\n",
- 1/stats[_STAT_READ].worst,stats[_STAT_READ].worst);
- }
-
- /*
- * Access test
- */
- purge_buffer_cache();
- file_access(x);
- if(verbose)
- {
- printf("access: Files = %9lld ",stats[_STAT_ACCESS].counter);
- printf("Total Time = %12.9f seconds\n", stats[_STAT_ACCESS].total_time);
- printf(" Avg access(s)/sec = %12.2f (%12.9f seconds/op)\n",
- stats[_STAT_ACCESS].counter/stats[_STAT_ACCESS].total_time,
- stats[_STAT_ACCESS].total_time/stats[_STAT_ACCESS].counter);
- printf(" Best access(s)/sec = %12.2f (%12.9f seconds/op)\n",
- 1/stats[_STAT_ACCESS].best,stats[_STAT_ACCESS].best);
- printf(" Worst access(s)/sec = %12.2f (%12.9f seconds/op)\n\n",
- 1/stats[_STAT_ACCESS].worst,stats[_STAT_ACCESS].worst);
- }
- /*
- * Chmod test
- */
- purge_buffer_cache();
- file_chmod(x);
-
- if(verbose)
- {
- printf("chmod: Files = %9lld ",stats[_STAT_CHMOD].counter);
- printf("Total Time = %12.9f seconds\n", stats[_STAT_CHMOD].total_time);
- printf(" Avg chmod(s)/sec = %12.2f (%12.9f seconds/op)\n",
- stats[_STAT_CHMOD].counter/stats[_STAT_CHMOD].total_time,
- stats[_STAT_CHMOD].total_time/stats[_STAT_CHMOD].counter);
- printf(" Best chmod(s)/sec = %12.2f (%12.9f seconds/op)\n",
- 1/stats[_STAT_CHMOD].best,stats[_STAT_CHMOD].best);
- printf(" Worst chmod(s)/sec = %12.2f (%12.9f seconds/op)\n\n",
- 1/stats[_STAT_CHMOD].worst,stats[_STAT_CHMOD].worst);
- }
- /*
- * readdir test
- */
- purge_buffer_cache();
- file_readdir(x);
-
- if(verbose)
- {
- printf("readdir: Files = %9lld ",stats[_STAT_READDIR].counter);
- printf("Total Time = %12.9f seconds\n", stats[_STAT_READDIR].total_time);
- printf(" Avg readdir(s)/sec = %12.2f (%12.9f seconds/op)\n",
- stats[_STAT_READDIR].counter/stats[_STAT_READDIR].total_time,
- stats[_STAT_READDIR].total_time/stats[_STAT_READDIR].counter);
- printf(" Best readdir(s)/sec = %12.2f (%12.9f seconds/op)\n",
- 1/stats[_STAT_READDIR].best,stats[_STAT_READDIR].best);
- printf(" Worst readdir(s)/sec = %12.2f (%12.9f seconds/op)\n\n",
- 1/stats[_STAT_READDIR].worst,stats[_STAT_READDIR].worst);
- }
-#if !defined(Windows)
- /*
- * link test
- */
- purge_buffer_cache();
- file_link(x);
- if(verbose)
- {
- printf("link: Files = %9lld ",stats[_STAT_LINK].counter);
- printf("Total Time = %12.9f seconds\n",stats[_STAT_LINK].total_time);
- printf(" Avg link(s)/sec = %12.2f (%12.9f seconds/op)\n",
- stats[_STAT_LINK].counter/stats[_STAT_LINK].total_time,
- stats[_STAT_LINK].total_time/stats[_STAT_LINK].counter);
- printf(" Best link(s)/sec = %12.2f (%12.9f seconds/op)\n",
- 1/stats[_STAT_LINK].best,stats[_STAT_LINK].best);
- printf(" Worst link(s)/sec = %12.2f (%12.9f seconds/op)\n\n",
- 1/stats[_STAT_LINK].worst,stats[_STAT_LINK].worst);
- }
- /*
- * unlink test
- */
- purge_buffer_cache();
- file_unlink(x);
- if(verbose)
- {
- printf("unlink: Files = %9lld ",stats[_STAT_UNLINK].counter);
- printf("Total Time = %12.9f seconds\n", stats[_STAT_UNLINK].total_time);
- printf(" Avg unlink(s)/sec = %12.2f (%12.9f seconds/op)\n",
- stats[_STAT_UNLINK].counter/stats[_STAT_UNLINK].total_time,
- stats[_STAT_UNLINK].total_time/stats[_STAT_UNLINK].counter);
- printf(" Best unlink(s)/sec = %12.2f (%12.9f seconds/op)\n",
- 1/stats[_STAT_UNLINK].best,stats[_STAT_UNLINK].best);
- printf(" Worst unlink(s)/sec = %12.2f (%12.9f seconds/op)\n\n",
- 1/stats[_STAT_UNLINK].worst,stats[_STAT_UNLINK].worst);
- }
-#endif
- /*
- * Delete test
- */
- purge_buffer_cache();
- file_delete(x);
- if(verbose)
- {
- printf("delete: Files = %9lld ",stats[_STAT_DELETE].counter);
- printf("Total Time = %12.9f seconds\n", stats[_STAT_DELETE].total_time);
- printf(" Avg delete(s)/sec = %12.2f (%12.9f seconds/op)\n",
- stats[_STAT_DELETE].counter/stats[_STAT_DELETE].total_time,
- stats[_STAT_DELETE].total_time/stats[_STAT_DELETE].counter);
- printf(" Best delete(s)/sec = %12.2f (%12.9f seconds/op)\n",
- 1/stats[_STAT_DELETE].best,stats[_STAT_DELETE].best);
- printf(" Worst delete(s)/sec = %12.2f (%12.9f seconds/op)\n\n",
- 1/stats[_STAT_DELETE].worst,stats[_STAT_DELETE].worst);
- }
- if(!verbose)
- {
- printf("%c %4d %7.0f ",'A',x,stats[_STAT_DIR_CREATE].counter/stats[_STAT_DIR_CREATE].total_time);
- printf("%7.0f ",stats[_STAT_DIR_TRAVERSE].counter/stats[_STAT_DIR_TRAVERSE].total_time);
- printf("%7.0f ",stats[_STAT_DIR_DELETE].counter/stats[_STAT_DIR_DELETE].total_time);
- printf("%7.0f ",stats[_STAT_CREATE].counter/stats[_STAT_CREATE].total_time);
- printf("%7.0f ",stats[_STAT_OPEN].counter/stats[_STAT_OPEN].total_time);
- printf("%7.0f ",stats[_STAT_READ].counter/stats[_STAT_READ].total_time);
- printf("%7.0f ",stats[_STAT_WRITE].counter/stats[_STAT_WRITE].total_time);
- printf("%7.0f ",stats[_STAT_CLOSE].counter/stats[_STAT_CLOSE].total_time);
- printf("%7.0f ",stats[_STAT_STAT].counter/stats[_STAT_STAT].total_time);
- printf("%7.0f ",stats[_STAT_ACCESS].counter/stats[_STAT_ACCESS].total_time);
- printf("%7.0f ",stats[_STAT_CHMOD].counter/stats[_STAT_CHMOD].total_time);
- printf("%7.0f ",stats[_STAT_READDIR].counter/stats[_STAT_READDIR].total_time);
-#ifndef Windows
- printf("%7.0f ",stats[_STAT_LINK].counter/stats[_STAT_LINK].total_time);
- printf("%7.0f ",stats[_STAT_UNLINK].counter/stats[_STAT_UNLINK].total_time);
-#endif
- printf("%7.0f ",stats[_STAT_DELETE].counter/stats[_STAT_DELETE].total_time);
- printf("%10d ",x*x*x);
- printf("\n");
- fflush(stdout);
-
- if(best)
- {
- printf("%c %4d %7.0f ",'B',x, 1/stats[_STAT_DIR_CREATE].best);
- printf("%7.0f ",1/stats[_STAT_DIR_TRAVERSE].best);
- printf("%7.0f ",1/stats[_STAT_DIR_DELETE].best);
- printf("%7.0f ",1/stats[_STAT_CREATE].best);
- printf("%7.0f ",1/stats[_STAT_OPEN].best);
- printf("%7.0f ",1/stats[_STAT_READ].best);
- printf("%7.0f ",1/stats[_STAT_WRITE].best);
- printf("%7.0f ",1/stats[_STAT_CLOSE].best);
- printf("%7.0f ",1/stats[_STAT_STAT].best);
- printf("%7.0f ",1/stats[_STAT_ACCESS].best);
- printf("%7.0f ",1/stats[_STAT_CHMOD].best);
- printf("%7.0f ",1/stats[_STAT_READDIR].best);
-#ifndef Windows
- printf("%7.0f ",1/stats[_STAT_LINK].best);
- printf("%7.0f ",1/stats[_STAT_UNLINK].best);
-#endif
- printf("%7.0f ",1/stats[_STAT_DELETE].best);
- printf("%10d ",x*x*x);
- printf("\n");
- fflush(stdout);
- }
- if(worst)
- {
- printf("%c %4d %7.0f ",'W',x, 1/stats[_STAT_DIR_CREATE].worst);
- printf("%7.0f ",1/stats[_STAT_DIR_TRAVERSE].worst);
- printf("%7.0f ",1/stats[_STAT_DIR_DELETE].worst);
- printf("%7.0f ",1/stats[_STAT_CREATE].worst);
- printf("%7.0f ",1/stats[_STAT_OPEN].worst);
- printf("%7.0f ",1/stats[_STAT_READ].worst);
- printf("%7.0f ",1/stats[_STAT_WRITE].worst);
- printf("%7.0f ",1/stats[_STAT_CLOSE].worst);
- printf("%7.0f ",1/stats[_STAT_STAT].worst);
- printf("%7.0f ",1/stats[_STAT_ACCESS].worst);
- printf("%7.0f ",1/stats[_STAT_CHMOD].worst);
- printf("%7.0f ",1/stats[_STAT_READDIR].worst);
-#ifndef Windows
- printf("%7.0f ",1/stats[_STAT_LINK].worst);
- printf("%7.0f ",1/stats[_STAT_UNLINK].worst);
-#endif
- printf("%7.0f ",1/stats[_STAT_DELETE].worst);
- printf("%10d ",x*x*x);
- printf("\n");
- fflush(stdout);
- }
- }
- }
- return(0);
-}
-
-void
-dir_create(int x)
-{
- int i,j,k;
- int ret;
- char buf[100];
- stats[_STAT_DIR_CREATE].best=(double)99999.9;
- stats[_STAT_DIR_CREATE].worst=(double)0.00000000;
- for(i=0;i<x;i++)
- {
- sprintf(buf,"fileop_L1_%d",i);
- stats[_STAT_DIR_CREATE].starttime=time_so_far();
- ret=mkdir(buf,0777);
- if(ret < 0)
- {
- printf("Mkdir failed\n");
- exit(1);
- }
- stats[_STAT_DIR_CREATE].endtime=time_so_far();
- stats[_STAT_DIR_CREATE].speed=stats[_STAT_DIR_CREATE].endtime-stats[_STAT_DIR_CREATE].starttime;
- if(stats[_STAT_DIR_CREATE].speed < (double)0.0)
- stats[_STAT_DIR_CREATE].speed=(double)0.0;
- stats[_STAT_DIR_CREATE].total_time+=stats[_STAT_DIR_CREATE].speed;
- stats[_STAT_DIR_CREATE].counter++;
- if(stats[_STAT_DIR_CREATE].speed < stats[_STAT_DIR_CREATE].best)
- stats[_STAT_DIR_CREATE].best=stats[_STAT_DIR_CREATE].speed;
- if(stats[_STAT_DIR_CREATE].speed > stats[_STAT_DIR_CREATE].worst)
- stats[_STAT_DIR_CREATE].worst=stats[_STAT_DIR_CREATE].speed;
- junk=chdir(buf);
- for(j=0;j<x;j++)
- {
- sprintf(buf,"fileop_L1_%d_L2_%d",i,j);
- stats[_STAT_DIR_CREATE].starttime=time_so_far();
- ret=mkdir(buf,0777);
- if(ret < 0)
- {
- printf("Mkdir failed\n");
- exit(1);
- }
- stats[_STAT_DIR_CREATE].endtime=time_so_far();
- stats[_STAT_DIR_CREATE].speed=stats[_STAT_DIR_CREATE].endtime-stats[_STAT_DIR_CREATE].starttime;
- if(stats[_STAT_DIR_CREATE].speed < (double)0.0)
- stats[_STAT_DIR_CREATE].speed=(double) 0.0;
- stats[_STAT_DIR_CREATE].total_time+=stats[_STAT_DIR_CREATE].speed;
- stats[_STAT_DIR_CREATE].counter++;
- if(stats[_STAT_DIR_CREATE].speed < stats[_STAT_DIR_CREATE].best)
- stats[_STAT_DIR_CREATE].best=stats[_STAT_DIR_CREATE].speed;
- if(stats[_STAT_DIR_CREATE].speed > stats[_STAT_DIR_CREATE].worst)
- stats[_STAT_DIR_CREATE].worst=stats[_STAT_DIR_CREATE].speed;
- junk=chdir(buf);
- for(k=0;k<x;k++)
- {
- sprintf(buf,"fileop_dir_%d_%d_%d",i,j,k);
- stats[_STAT_DIR_CREATE].starttime=time_so_far();
- ret=mkdir(buf,0777);
- if(ret < 0)
- {
- printf("Mkdir failed\n");
- exit(1);
- }
- stats[_STAT_DIR_CREATE].endtime=time_so_far();
- stats[_STAT_DIR_CREATE].speed=stats[_STAT_DIR_CREATE].endtime-stats[_STAT_DIR_CREATE].starttime;
- if(stats[_STAT_DIR_CREATE].speed < (double)0.0)
- stats[_STAT_DIR_CREATE].speed=(double) 0.0;
- stats[_STAT_DIR_CREATE].total_time+=stats[_STAT_DIR_CREATE].speed;
- stats[_STAT_DIR_CREATE].counter++;
- if(stats[_STAT_DIR_CREATE].speed < stats[_STAT_DIR_CREATE].best)
- stats[_STAT_DIR_CREATE].best=stats[_STAT_DIR_CREATE].speed;
- if(stats[_STAT_DIR_CREATE].speed > stats[_STAT_DIR_CREATE].worst)
- stats[_STAT_DIR_CREATE].worst=stats[_STAT_DIR_CREATE].speed;
- junk=chdir(buf);
- junk=chdir("..");
- }
- junk=chdir("..");
- }
- junk=chdir("..");
- }
-}
-
-void
-dir_traverse(int x)
-{
- int i,j,k;
- char buf[100];
- double time1, time2;
- stats[_STAT_DIR_TRAVERSE].best=(double)99999.9;
- stats[_STAT_DIR_TRAVERSE].worst=(double)0.00000000;
- for(i=0;i<x;i++)
- {
- sprintf(buf,"fileop_L1_%d",i);
- stats[_STAT_DIR_TRAVERSE].starttime=time_so_far();
- junk=chdir(buf);
- stats[_STAT_DIR_TRAVERSE].endtime=time_so_far();
- time1=stats[_STAT_DIR_TRAVERSE].endtime-stats[_STAT_DIR_TRAVERSE].starttime;
- for(j=0;j<x;j++)
- {
- sprintf(buf,"fileop_L1_%d_L2_%d",i,j);
- stats[_STAT_DIR_TRAVERSE].starttime=time_so_far();
- junk=chdir(buf);
- stats[_STAT_DIR_TRAVERSE].endtime=time_so_far();
- time2=stats[_STAT_DIR_TRAVERSE].endtime-stats[_STAT_DIR_TRAVERSE].starttime;
- for(k=0;k<x;k++)
- {
- sprintf(buf,"fileop_dir_%d_%d_%d",i,j,k);
- stats[_STAT_DIR_TRAVERSE].starttime=time_so_far();
- junk=chdir(buf);
- junk=chdir("..");
- stats[_STAT_DIR_TRAVERSE].endtime=time_so_far();
- stats[_STAT_DIR_TRAVERSE].speed=stats[_STAT_DIR_TRAVERSE].endtime-stats[_STAT_DIR_TRAVERSE].starttime;
- if(stats[_STAT_DIR_TRAVERSE].speed < (double)0.0)
- stats[_STAT_DIR_TRAVERSE].speed=(double) 0.0;
- stats[_STAT_DIR_TRAVERSE].total_time+=stats[_STAT_DIR_TRAVERSE].speed;
- stats[_STAT_DIR_TRAVERSE].counter++;
- if(stats[_STAT_DIR_TRAVERSE].speed < stats[_STAT_DIR_TRAVERSE].best)
- stats[_STAT_DIR_TRAVERSE].best=stats[_STAT_DIR_TRAVERSE].speed;
- if(stats[_STAT_DIR_TRAVERSE].speed > stats[_STAT_DIR_TRAVERSE].worst)
- stats[_STAT_DIR_TRAVERSE].worst=stats[_STAT_DIR_TRAVERSE].speed;
- }
- stats[_STAT_DIR_TRAVERSE].starttime=time_so_far();
- junk=chdir("..");
- stats[_STAT_DIR_TRAVERSE].endtime=time_so_far();
- stats[_STAT_DIR_TRAVERSE].speed=time2+stats[_STAT_DIR_TRAVERSE].endtime-stats[_STAT_DIR_TRAVERSE].starttime;
- if(stats[_STAT_DIR_TRAVERSE].speed < (double)0.0)
- stats[_STAT_DIR_TRAVERSE].speed=(double) 0.0;
- stats[_STAT_DIR_TRAVERSE].total_time+=stats[_STAT_DIR_TRAVERSE].speed;
- stats[_STAT_DIR_TRAVERSE].counter++;
- if(stats[_STAT_DIR_TRAVERSE].speed < stats[_STAT_DIR_TRAVERSE].best)
- stats[_STAT_DIR_TRAVERSE].best=stats[_STAT_DIR_TRAVERSE].speed;
- if(stats[_STAT_DIR_TRAVERSE].speed > stats[_STAT_DIR_TRAVERSE].worst)
- stats[_STAT_DIR_TRAVERSE].worst=stats[_STAT_DIR_TRAVERSE].speed;
- }
- stats[_STAT_DIR_TRAVERSE].starttime=time_so_far();
- junk=chdir("..");
- stats[_STAT_DIR_TRAVERSE].endtime=time_so_far();
- stats[_STAT_DIR_TRAVERSE].speed=time1+stats[_STAT_DIR_TRAVERSE].endtime-stats[_STAT_DIR_TRAVERSE].starttime;
- if(stats[_STAT_DIR_TRAVERSE].speed < (double)0.0)
- stats[_STAT_DIR_TRAVERSE].speed=(double)0.0;
- stats[_STAT_DIR_TRAVERSE].total_time+=stats[_STAT_DIR_TRAVERSE].speed;
- stats[_STAT_DIR_TRAVERSE].counter++;
- if(stats[_STAT_DIR_TRAVERSE].speed < stats[_STAT_DIR_TRAVERSE].best)
- stats[_STAT_DIR_TRAVERSE].best=stats[_STAT_DIR_TRAVERSE].speed;
- if(stats[_STAT_DIR_TRAVERSE].speed > stats[_STAT_DIR_TRAVERSE].worst)
- stats[_STAT_DIR_TRAVERSE].worst=stats[_STAT_DIR_TRAVERSE].speed;
- }
-}
-
-void
-file_create(int x)
-{
- int i,j,k;
- int fd;
- int ret;
- char buf[100];
- char value;
- stats[_STAT_CREATE].best=(double)999999.9;
- stats[_STAT_CREATE].worst=(double)0.0;
- stats[_STAT_WRITE].best=(double)999999.9;
- stats[_STAT_WRITE].worst=(double)0.0;
- stats[_STAT_CLOSE].best=(double)999999.9;
- stats[_STAT_CLOSE].worst=(double)0.0;
- for(i=0;i<x;i++)
- {
- sprintf(buf,"fileop_L1_%d",i);
- ret=mkdir(buf,0777);
- if(ret < 0)
- {
- printf("Mkdir failed\n");
- exit(1);
- }
- junk=chdir(buf);
- for(j=0;j<x;j++)
- {
- sprintf(buf,"fileop_L1_%d_L2_%d",i,j);
- ret=mkdir(buf,0777);
- if(ret < 0)
- {
- printf("Mkdir failed\n");
- exit(1);
- }
- junk=chdir(buf);
- for(k=0;k<x;k++)
- {
- sprintf(buf,"fileop_file_%d_%d_%d",i,j,k);
- value=(char) ((i^j^k) & 0xff);
- memset(mbuffer,value,sz);
- stats[_STAT_CREATE].starttime=time_so_far();
- fd=creat(buf,O_RDWR|0600);
- if(fd < 0)
- {
- printf("Create failed\n");
- exit(1);
- }
- stats[_STAT_CREATE].endtime=time_so_far();
- stats[_STAT_CREATE].speed=stats[_STAT_CREATE].endtime-stats[_STAT_CREATE].starttime;
- if(stats[_STAT_CREATE].speed < (double)0.0)
- stats[_STAT_CREATE].speed=(double)0.0;
- stats[_STAT_CREATE].total_time+=stats[_STAT_CREATE].speed;
- stats[_STAT_CREATE].counter++;
- if(stats[_STAT_CREATE].speed < stats[_STAT_CREATE].best)
- stats[_STAT_CREATE].best=stats[_STAT_CREATE].speed;
- if(stats[_STAT_CREATE].speed > stats[_STAT_CREATE].worst)
- stats[_STAT_CREATE].worst=stats[_STAT_CREATE].speed;
-
- stats[_STAT_WRITE].starttime=time_so_far();
- junk=write(fd,mbuffer,sz);
- stats[_STAT_WRITE].endtime=time_so_far();
- stats[_STAT_WRITE].counter++;
- stats[_STAT_WRITE].speed=stats[_STAT_WRITE].endtime-stats[_STAT_WRITE].starttime;
- if(stats[_STAT_WRITE].speed < (double)0.0)
- stats[_STAT_WRITE].speed=(double)0.0;
- stats[_STAT_WRITE].total_time+=stats[_STAT_WRITE].speed;
- if(stats[_STAT_WRITE].speed < stats[_STAT_WRITE].best)
- stats[_STAT_WRITE].best=stats[_STAT_WRITE].speed;
- if(stats[_STAT_WRITE].speed > stats[_STAT_WRITE].worst)
- stats[_STAT_WRITE].worst=stats[_STAT_WRITE].speed;
-
- fsync(fd);
- stats[_STAT_CLOSE].starttime=time_so_far();
- close(fd);
- stats[_STAT_CLOSE].endtime=time_so_far();
- stats[_STAT_CLOSE].speed=stats[_STAT_CLOSE].endtime-stats[_STAT_CLOSE].starttime;
- if(stats[_STAT_CLOSE].speed < (double)0.0)
- stats[_STAT_CLOSE].speed=(double)0.0;
- stats[_STAT_CLOSE].total_time+=stats[_STAT_CLOSE].speed;
- stats[_STAT_CLOSE].counter++;
- if(stats[_STAT_CLOSE].speed < stats[_STAT_CLOSE].best)
- stats[_STAT_CLOSE].best=stats[_STAT_CLOSE].speed;
- if(stats[_STAT_CLOSE].speed > stats[_STAT_CLOSE].worst)
- stats[_STAT_CLOSE].worst=stats[_STAT_CLOSE].speed;
- }
- junk=chdir("..");
- }
- junk=chdir("..");
- }
-}
-
-void
-file_stat(int x)
-{
- int i,j,k,y;
- char buf[100];
- struct stat mystat;
- stats[_STAT_STAT].best=(double)99999.9;
- stats[_STAT_STAT].worst=(double)0.00000000;
- for(i=0;i<x;i++)
- {
- sprintf(buf,"fileop_L1_%d",i);
- junk=chdir(buf);
- for(j=0;j<x;j++)
- {
- sprintf(buf,"fileop_L1_%d_L2_%d",i,j);
- junk=chdir(buf);
- for(k=0;k<x;k++)
- {
- sprintf(buf,"fileop_file_%d_%d_%d",i,j,k);
- stats[_STAT_STAT].starttime=time_so_far();
- y=stat(buf,&mystat);
- if(y < 0)
- {
- printf("Stat failed\n");
- exit(1);
- }
- stats[_STAT_STAT].endtime=time_so_far();
- stats[_STAT_STAT].speed=stats[_STAT_STAT].endtime-stats[_STAT_STAT].starttime;
- if(stats[_STAT_STAT].speed < (double)0.0)
- stats[_STAT_STAT].speed=(double)0.0;
- stats[_STAT_STAT].total_time+=stats[_STAT_STAT].speed;
- stats[_STAT_STAT].counter++;
- if(stats[_STAT_STAT].speed < stats[_STAT_STAT].best)
- stats[_STAT_STAT].best=stats[_STAT_STAT].speed;
- if(stats[_STAT_STAT].speed > stats[_STAT_STAT].worst)
- stats[_STAT_STAT].worst=stats[_STAT_STAT].speed;
- }
- junk=chdir("..");
- }
- junk=chdir("..");
- }
-}
-
-void
-file_access(int x)
-{
- int i,j,k,y;
- char buf[100];
- stats[_STAT_ACCESS].best=(double)999999.9;
- stats[_STAT_ACCESS].worst=(double)0.0;
- for(i=0;i<x;i++)
- {
- sprintf(buf,"fileop_L1_%d",i);
- junk=chdir(buf);
- for(j=0;j<x;j++)
- {
- sprintf(buf,"fileop_L1_%d_L2_%d",i,j);
- junk=chdir(buf);
- for(k=0;k<x;k++)
- {
- sprintf(buf,"fileop_file_%d_%d_%d",i,j,k);
- stats[_STAT_ACCESS].starttime=time_so_far();
- y=access(buf,W_OK|F_OK);
- if(y < 0)
- {
- printf("access failed\n");
- perror("what");
- exit(1);
- }
- stats[_STAT_ACCESS].endtime=time_so_far();
- stats[_STAT_ACCESS].speed=stats[_STAT_ACCESS].endtime-stats[_STAT_ACCESS].starttime;
- if(stats[_STAT_ACCESS].speed < (double)0.0)
- stats[_STAT_ACCESS].speed=(double)0.0;
- stats[_STAT_ACCESS].total_time+=stats[_STAT_ACCESS].speed;
- stats[_STAT_ACCESS].counter++;
- if(stats[_STAT_ACCESS].speed < stats[_STAT_ACCESS].best)
- stats[_STAT_ACCESS].best=stats[_STAT_ACCESS].speed;
- if(stats[_STAT_ACCESS].speed > stats[_STAT_ACCESS].worst)
- stats[_STAT_ACCESS].worst=stats[_STAT_ACCESS].speed;
- }
- junk=chdir("..");
- }
- junk=chdir("..");
- }
-}
-
-void
-file_chmod(int x)
-{
- int i,j,k,y;
- char buf[100];
- stats[_STAT_CHMOD].best=(double)999999.9;
- stats[_STAT_CHMOD].worst=(double)0.0;
- for(i=0;i<x;i++)
- {
- sprintf(buf,"fileop_L1_%d",i);
- junk=chdir(buf);
- for(j=0;j<x;j++)
- {
- sprintf(buf,"fileop_L1_%d_L2_%d",i,j);
- junk=chdir(buf);
- for(k=0;k<x;k++)
- {
- sprintf(buf,"fileop_file_%d_%d_%d",i,j,k);
- stats[_STAT_CHMOD].starttime=time_so_far();
- y=chmod(buf,0666);
- if(y < 0)
- {
- printf("chmod failed\n");
- perror("what");
- exit(1);
- }
- stats[_STAT_CHMOD].endtime=time_so_far();
- stats[_STAT_CHMOD].speed=stats[_STAT_CHMOD].endtime-stats[_STAT_CHMOD].starttime;
- if(stats[_STAT_CHMOD].speed < (double)0.0)
- stats[_STAT_CHMOD].speed=(double)0.0;
- stats[_STAT_CHMOD].total_time+=stats[_STAT_CHMOD].speed;
- stats[_STAT_CHMOD].counter++;
- if(stats[_STAT_CHMOD].speed < stats[_STAT_CHMOD].best)
- stats[_STAT_CHMOD].best=stats[_STAT_CHMOD].speed;
- if(stats[_STAT_CHMOD].speed > stats[_STAT_CHMOD].worst)
- stats[_STAT_CHMOD].worst=stats[_STAT_CHMOD].speed;
- }
- junk=chdir("..");
- }
- junk=chdir("..");
- }
-}
-
-void
-file_readdir(int x)
-{
- int i,j,ret1;
- char buf[100];
- DIR *dirbuf;
- struct dirent *y;
- stats[_STAT_READDIR].best=(double)999999.9;
- stats[_STAT_READDIR].worst=(double)0.0;
- for(i=0;i<x;i++)
- {
- sprintf(buf,"fileop_L1_%d",i);
- junk=chdir(buf);
- for(j=0;j<x;j++)
- {
- sprintf(buf,"fileop_L1_%d_L2_%d",i,j);
- junk=chdir(buf);
- dirbuf=opendir(".");
- if(dirbuf==0)
- {
- printf("opendir failed\n");
- exit(1);
- }
- stats[_STAT_READDIR].starttime=time_so_far();
- y=readdir(dirbuf);
- if(y == 0)
- {
- printf("readdir failed\n");
- exit(1);
- }
- stats[_STAT_READDIR].endtime=time_so_far();
- stats[_STAT_READDIR].speed=stats[_STAT_READDIR].endtime-stats[_STAT_READDIR].starttime;
- if(stats[_STAT_READDIR].speed < (double)0.0)
- stats[_STAT_READDIR].speed=(double)0.0;
- stats[_STAT_READDIR].total_time+=stats[_STAT_READDIR].speed;
- stats[_STAT_READDIR].counter++;
- if(stats[_STAT_READDIR].speed < stats[_STAT_READDIR].best)
- stats[_STAT_READDIR].best=stats[_STAT_READDIR].speed;
- if(stats[_STAT_READDIR].speed > stats[_STAT_READDIR].worst)
- stats[_STAT_READDIR].worst=stats[_STAT_READDIR].speed;
- ret1=closedir(dirbuf);
- if(ret1 < 0)
- {
- printf("closedir failed\n");
- exit(1);
- }
- junk=chdir("..");
- }
- junk=chdir("..");
- }
-}
-
-void
-file_link(int x)
-{
- int i,j,k,y;
- char buf[100];
- char bufn[100];
- stats[_STAT_LINK].best=(double)999999.9;
- stats[_STAT_LINK].worst=(double)0.0;
- for(i=0;i<x;i++)
- {
- sprintf(buf,"fileop_L1_%d",i);
- junk=chdir(buf);
- for(j=0;j<x;j++)
- {
- sprintf(buf,"fileop_L1_%d_L2_%d",i,j);
- junk=chdir(buf);
- for(k=0;k<x;k++)
- {
- sprintf(buf,"fileop_file_%d_%d_%d",i,j,k);
- sprintf(bufn,"fileop_file_%d_%d_%dL",i,j,k);
- stats[_STAT_LINK].starttime=time_so_far();
- y=link(buf,bufn);
- if(y < 0)
- {
- printf("Link failed\n");
- exit(1);
- }
- stats[_STAT_LINK].endtime=time_so_far();
- stats[_STAT_LINK].speed=stats[_STAT_LINK].endtime-stats[_STAT_LINK].starttime;
- if(stats[_STAT_LINK].speed < (double)0.0)
- stats[_STAT_LINK].speed=(double)0.0;
- stats[_STAT_LINK].total_time+=stats[_STAT_LINK].speed;
- stats[_STAT_LINK].counter++;
- if(stats[_STAT_LINK].speed < stats[_STAT_LINK].best)
- stats[_STAT_LINK].best=stats[_STAT_LINK].speed;
- if(stats[_STAT_LINK].speed > stats[_STAT_LINK].worst)
- stats[_STAT_LINK].worst=stats[_STAT_LINK].speed;
- }
- junk=chdir("..");
- }
- junk=chdir("..");
- }
-}
-
-void
-file_unlink(int x)
-{
- int i,j,k,y;
- char buf[100];
- char bufn[100];
- stats[_STAT_UNLINK].best=(double)999999.9;
- stats[_STAT_UNLINK].worst=(double)0.0;
- for(i=0;i<x;i++)
- {
- sprintf(buf,"fileop_L1_%d",i);
- junk=chdir(buf);
- for(j=0;j<x;j++)
- {
- sprintf(buf,"fileop_L1_%d_L2_%d",i,j);
- junk=chdir(buf);
- for(k=0;k<x;k++)
- {
- sprintf(buf,"fileop_file_%d_%d_%d",i,j,k);
- sprintf(bufn,"fileop_file_%d_%d_%dL",i,j,k);
- stats[_STAT_UNLINK].starttime=time_so_far();
- y=unlink(bufn);
- if(y < 0)
- {
- printf("Unlink failed\n");
- exit(1);
- }
- stats[_STAT_UNLINK].endtime=time_so_far();
- stats[_STAT_UNLINK].speed=stats[_STAT_UNLINK].endtime-stats[_STAT_UNLINK].starttime;
- if(stats[_STAT_UNLINK].speed < (double)0.0)
- stats[_STAT_UNLINK].speed=(double)0.0;
- stats[_STAT_UNLINK].total_time+=stats[_STAT_UNLINK].speed;
- stats[_STAT_UNLINK].counter++;
- if(stats[_STAT_UNLINK].speed < stats[_STAT_UNLINK].best)
- stats[_STAT_UNLINK].best=stats[_STAT_UNLINK].speed;
- if(stats[_STAT_UNLINK].speed > stats[_STAT_UNLINK].worst)
- stats[_STAT_UNLINK].worst=stats[_STAT_UNLINK].speed;
- }
- junk=chdir("..");
- }
- junk=chdir("..");
- }
-}
-
-void
-dir_delete(int x)
-{
- int i,j,k;
- char buf[100];
- stats[_STAT_DIR_DELETE].best=(double)99999.9;
- stats[_STAT_DIR_DELETE].worst=(double)0.00000000;
- for(i=0;i<x;i++)
- {
- sprintf(buf,"fileop_L1_%d",i);
- junk=chdir(buf);
- for(j=0;j<x;j++)
- {
- sprintf(buf,"fileop_L1_%d_L2_%d",i,j);
- junk=chdir(buf);
- for(k=0;k<x;k++)
- {
- sprintf(buf,"fileop_dir_%d_%d_%d",i,j,k);
- junk=chdir(buf);
- junk=chdir("..");
- stats[_STAT_DIR_DELETE].starttime=time_so_far();
- rmdir(buf);
- stats[_STAT_DIR_DELETE].endtime=time_so_far();
- stats[_STAT_DIR_DELETE].speed=stats[_STAT_DIR_DELETE].endtime-stats[_STAT_DIR_DELETE].starttime;
- if(stats[_STAT_DIR_DELETE].speed < (double)0.0)
- stats[_STAT_DIR_DELETE].speed=(double)0.0;
- stats[_STAT_DIR_DELETE].total_time+=stats[_STAT_DIR_DELETE].speed;
- stats[_STAT_DIR_DELETE].counter++;
- if(stats[_STAT_DIR_DELETE].speed < stats[_STAT_DIR_DELETE].best)
- stats[_STAT_DIR_DELETE].best=stats[_STAT_DIR_DELETE].speed;
- if(stats[_STAT_DIR_DELETE].speed > stats[_STAT_DIR_DELETE].worst)
- stats[_STAT_DIR_DELETE].worst=stats[_STAT_DIR_DELETE].speed;
- }
- junk=chdir("..");
- sprintf(buf,"fileop_L1_%d_L2_%d",i,j);
- stats[_STAT_DIR_DELETE].starttime=time_so_far();
- rmdir(buf);
- stats[_STAT_DIR_DELETE].endtime=time_so_far();
- stats[_STAT_DIR_DELETE].speed=stats[_STAT_DIR_DELETE].endtime-stats[_STAT_DIR_DELETE].starttime;
- if(stats[_STAT_DIR_DELETE].speed < (double)0.0)
- stats[_STAT_DIR_DELETE].speed=(double)0.0;
- stats[_STAT_DIR_DELETE].total_time+=stats[_STAT_DIR_DELETE].speed;
- stats[_STAT_DIR_DELETE].counter++;
- if(stats[_STAT_DIR_DELETE].speed < stats[_STAT_DIR_DELETE].best)
- stats[_STAT_DIR_DELETE].best=stats[_STAT_DIR_DELETE].speed;
- if(stats[_STAT_DIR_DELETE].speed > stats[_STAT_DIR_DELETE].worst)
- stats[_STAT_DIR_DELETE].worst=stats[_STAT_DIR_DELETE].speed;
- }
- junk=chdir("..");
- sprintf(buf,"fileop_L1_%d",i);
- stats[_STAT_DIR_DELETE].starttime=time_so_far();
- rmdir(buf);
- stats[_STAT_DIR_DELETE].endtime=time_so_far();
- stats[_STAT_DIR_DELETE].speed=stats[_STAT_DIR_DELETE].endtime-stats[_STAT_DIR_DELETE].starttime;
- if(stats[_STAT_DIR_DELETE].speed < (double)0.0)
- stats[_STAT_DIR_DELETE].speed=(double)0.0;
- stats[_STAT_DIR_DELETE].total_time+=stats[_STAT_DIR_DELETE].speed;
- stats[_STAT_DIR_DELETE].counter++;
- if(stats[_STAT_DIR_DELETE].speed < stats[_STAT_DIR_DELETE].best)
- stats[_STAT_DIR_DELETE].best=stats[_STAT_DIR_DELETE].speed;
- if(stats[_STAT_DIR_DELETE].speed > stats[_STAT_DIR_DELETE].worst)
- stats[_STAT_DIR_DELETE].worst=stats[_STAT_DIR_DELETE].speed;
- }
-}
-
-void
-file_delete(int x)
-{
- int i,j,k;
- char buf[100];
- stats[_STAT_DELETE].best=(double)999999.9;
- stats[_STAT_DELETE].worst=(double)0.0;
- for(i=0;i<x;i++)
- {
- sprintf(buf,"fileop_L1_%d",i);
- junk=chdir(buf);
- for(j=0;j<x;j++)
- {
- sprintf(buf,"fileop_L1_%d_L2_%d",i,j);
- junk=chdir(buf);
- for(k=0;k<x;k++)
- {
- sprintf(buf,"fileop_file_%d_%d_%d",i,j,k);
- stats[_STAT_DELETE].starttime=time_so_far();
- unlink(buf);
- stats[_STAT_DELETE].endtime=time_so_far();
- stats[_STAT_DELETE].speed=stats[_STAT_DELETE].endtime-stats[_STAT_DELETE].starttime;
- if(stats[_STAT_DELETE].speed < (double)0.0)
- stats[_STAT_DELETE].speed=(double)0.0;
- stats[_STAT_DELETE].total_time+=stats[_STAT_DELETE].speed;
- stats[_STAT_DELETE].counter++;
- if(stats[_STAT_DELETE].speed < stats[_STAT_DELETE].best)
- stats[_STAT_DELETE].best=stats[_STAT_DELETE].speed;
- if(stats[_STAT_DELETE].speed > stats[_STAT_DELETE].worst)
- stats[_STAT_DELETE].worst=stats[_STAT_DELETE].speed;
- }
- junk=chdir("..");
- sprintf(buf,"fileop_L1_%d_L2_%d",i,j);
- rmdir(buf);
- }
- junk=chdir("..");
- sprintf(buf,"fileop_L1_%d",i);
- rmdir(buf);
- }
-}
-void
-file_read(int x)
-{
- int i,j,k,y,fd;
- char buf[100];
- char value;
- stats[_STAT_READ].best=(double)99999.9;
- stats[_STAT_READ].worst=(double)0.00000000;
- stats[_STAT_OPEN].best=(double)99999.9;
- stats[_STAT_OPEN].worst=(double)0.00000000;
- for(i=0;i<x;i++)
- {
- sprintf(buf,"fileop_L1_%d",i);
- junk=chdir(buf);
- for(j=0;j<x;j++)
- {
- sprintf(buf,"fileop_L1_%d_L2_%d",i,j);
- junk=chdir(buf);
- for(k=0;k<x;k++)
- {
- sprintf(buf,"fileop_file_%d_%d_%d",i,j,k);
- value=(char)((i^j^k) &0xff);
- stats[_STAT_OPEN].starttime=time_so_far();
- fd=open(buf,O_RDONLY);
- if(fd < 0)
- {
- printf("Open failed\n");
- exit(1);
- }
- stats[_STAT_OPEN].endtime=time_so_far();
- stats[_STAT_OPEN].speed=stats[_STAT_OPEN].endtime-stats[_STAT_OPEN].starttime;
- if(stats[_STAT_OPEN].speed < (double)0.0)
- stats[_STAT_OPEN].speed=(double)0.0;
- stats[_STAT_OPEN].total_time+=stats[_STAT_OPEN].speed;
- stats[_STAT_OPEN].counter++;
- if(stats[_STAT_OPEN].speed < stats[_STAT_OPEN].best)
- stats[_STAT_OPEN].best=stats[_STAT_OPEN].speed;
- if(stats[_STAT_OPEN].speed > stats[_STAT_OPEN].worst)
- stats[_STAT_OPEN].worst=stats[_STAT_OPEN].speed;
-
- stats[_STAT_READ].starttime=time_so_far();
- y=read(fd,mbuffer,sz);
- if(y < 0)
- {
- printf("Read failed\n");
- exit(1);
- }
- if(validate(mbuffer,sz, value) !=0)
- printf("Error: Data Mis-compare\n");;
- stats[_STAT_READ].endtime=time_so_far();
- close(fd);
- stats[_STAT_READ].speed=stats[_STAT_READ].endtime-stats[_STAT_READ].starttime;
- if(stats[_STAT_READ].speed < (double)0.0)
- stats[_STAT_READ].speed=(double)0.0;
- stats[_STAT_READ].total_time+=stats[_STAT_READ].speed;
- stats[_STAT_READ].counter++;
- if(stats[_STAT_READ].speed < stats[_STAT_READ].best)
- stats[_STAT_READ].best=stats[_STAT_READ].speed;
- if(stats[_STAT_READ].speed > stats[_STAT_READ].worst)
- stats[_STAT_READ].worst=stats[_STAT_READ].speed;
- }
- junk=chdir("..");
- }
- junk=chdir("..");
- }
-}
-
-/************************************************************************/
-/* Time measurement routines. Thanks to Iozone :-) */
-/************************************************************************/
-
-#ifdef HAVE_ANSIC_C
-static double
-time_so_far(void)
-#else
-static double
-time_so_far()
-#endif
-{
-#ifdef Windows
- LARGE_INTEGER freq,counter;
- double wintime,bigcounter;
- /* For Windows the time_of_day() is useless. It increments in 55 milli second */
- /* increments. By using the Win32api one can get access to the high performance */
- /* measurement interfaces. With this one can get back into the 8 to 9 */
- /* microsecond resolution. */
- QueryPerformanceFrequency(&freq);
- QueryPerformanceCounter(&counter);
- bigcounter=(double)counter.HighPart *(double)0xffffffff +
- (double)counter.LowPart;
- wintime = (double)(bigcounter/(double)freq.LowPart);
- return((double)wintime);
-#else
-#if defined (OSFV4) || defined(OSFV3) || defined(OSFV5)
- struct timespec gp;
-
- if (getclock(TIMEOFDAY, (struct timespec *) &gp) == -1)
- perror("getclock");
- return (( (double) (gp.tv_sec)) +
- ( ((float)(gp.tv_nsec)) * 0.000000001 ));
-#else
- struct timeval tp;
-
- if (gettimeofday(&tp, (struct timezone *) NULL) == -1)
- perror("gettimeofday");
- return ((double) (tp.tv_sec)) +
- (((double) tp.tv_usec) * 0.000001 );
-#endif
-#endif
-}
-
-void
-splash(void)
-{
- printf("\n");
- printf(" --------------------------------------\n");
- printf(" | Fileop | \n");
- printf(" | %s | \n",version);
- printf(" | | \n");
- printf(" | by |\n");
- printf(" | | \n");
- printf(" | Don Capps |\n");
- printf(" --------------------------------------\n");
- printf("\n");
-}
-
-void
-usage(void)
-{
- splash();
- printf(" fileop [-f X ]|[-l # -u #] [-s Y] [-e] [-b] [-w] [-d <dir>] [-t] [-v] [-h]\n");
- printf("\n");
- printf(" -f # Force factor. X^3 files will be created and removed.\n");
- printf(" -l # Lower limit on the value of the Force factor.\n");
- printf(" -u # Upper limit on the value of the Force factor.\n");
- printf(" -s # Optional. Sets filesize for the create/write. May use suffix 'K' or 'M'.\n");
- printf(" -e Excel importable format.\n");
- printf(" -b Output best case results.\n");
- printf(" -i # Increment force factor by this increment.\n");
- printf(" -w Output worst case results.\n");
- printf(" -d <dir> Specify starting directory.\n");
- printf(" -U <dir> Mount point to remount between tests.\n");
- printf(" -t Verbose output option.\n");
- printf(" -v Version information.\n");
- printf(" -h Help text.\n");
- printf("\n");
- printf(" The structure of the file tree is:\n");
- printf(" X number of Level 1 directories, with X number of\n");
- printf(" level 2 directories, with X number of files in each\n");
- printf(" of the level 2 directories.\n");
- printf("\n");
- printf(" Example: fileop 2\n");
- printf("\n");
- printf(" dir_1 dir_2\n");
- printf(" / \\ / \\ \n");
- printf(" sdir_1 sdir_2 sdir_1 sdir_2\n");
- printf(" / \\ / \\ / \\ / \\ \n");
- printf(" file_1 file_2 file_1 file_2 file_1 file_2 file_1 file_2\n");
- printf("\n");
- printf(" Each file will be created, and then Y bytes is written to the file.\n");
- printf("\n");
-}
-void
-clear_stats()
-{
- int i;
- for(i=0;i<_NUM_STATS;i++)
- bzero((char *)&stats[i],sizeof(struct stat_struct));
-}
-int
-validate(char *buffer, int size, char value)
-{
- register int i;
- register char *cp;
- register int size1;
- register char v1;
- v1=value;
- cp = buffer;
- size1=size;
- for(i=0;i<size;i++)
- {
- if(*cp++ != v1)
- return(1);
- }
- return(0);
-}
-
diff --git a/src/components/appio/tests/iozone/gengnuplot.sh b/src/components/appio/tests/iozone/gengnuplot.sh
deleted file mode 100755
index ec1d3eead..000000000
--- a/src/components/appio/tests/iozone/gengnuplot.sh
+++ /dev/null
@@ -1,57 +0,0 @@
-#!/bin/sh
-#
-# Copyright (c) 2001 Yves Rougy Yves@Rougy.net
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-
-
-
-cp $1 iozone_gen_out
-file_name=iozone_gen_out
-#set -x
-
-write_gnuplot_file() {
- echo \#test : $query
- case $query in
- (write) awk '$1 ~ /^[0-9]+/ { print $1 " " $2 " " $3 }' < $file_name ;;
- (rewrite) awk '$1 ~ /^[0-9]+/ { print $1 " " $2 " " $4 }' < $file_name ;;
- (read) awk '$1 ~ /^[0-9]+/ { print $1 " " $2 " " $5 }' < $file_name ;;
- (reread) awk '$1 ~ /^[0-9]+/ { print $1 " " $2 " " $6 }' < $file_name ;;
- (randread) awk '$1 ~ /^[0-9]+/ { print $1 " " $2 " " $7 }' < $file_name ;;
- (randwrite) awk '$1 ~ /^[0-9]+/ { print $1 " " $2 " " $8 }' < $file_name ;;
- (bkwdread) awk '$1 ~ /^[0-9]+/ { print $1 " " $2 " " $9 }' < $file_name ;;
- (recrewrite) awk '$1 ~ /^[0-9]+/ { print $1 " " $2 " " $10 }' < $file_name ;;
- (strideread) awk '$1 ~ /^[0-9]+/ { print $1 " " $2 " " $11 }' < $file_name ;;
- (fwrite) awk '$1 ~ /^[0-9]+/ { print $1 " " $2 " " $12 }' < $file_name ;;
- (frewrite) awk '$1 ~ /^[0-9]+/ { print $1 " " $2 " " $13 }' < $file_name ;;
- (fread) awk '$1 ~ /^[0-9]+/ { print $1 " " $2 " " $14 }' < $file_name ;;
- (freread) awk '$1 ~ /^[0-9]+/ { print $1 " " $2 " " $15 }' < $file_name ;;
- (*) echo "Usage : gengnuplot.sh <filename> <test>" >> /dev/stderr ;
- echo "filename is the output of iozone -a" >> /dev/stderr ;
- echo "test is one of write rewrite read reread randread randwrite bkwdread recrewrite strideread fwrite frewrite fread freread" >> /dev/stderr ;;
- esac }
-
-#filename=$1
-filename=iozone_gen_out
-query=$2
-if (! [ -e $query ] ) ; then mkdir $query; fi
-if ( [ $# -eq 2 ] ) ;
- then
- write_gnuplot_file > $query/`basename $file_name.gnuplot`
- else
- echo "Usage : gengnuplot.sh <filename> <test>" 2>&1
- echo "filename is the output of iozone -a" 2>&1
- echo "test is one of write rewrite read reread randread randwrite bkwdread recrewrite strideread fwrite frewrite fread freread" 2>&1
-fi
diff --git a/src/components/appio/tests/iozone/gnu3d.dem b/src/components/appio/tests/iozone/gnu3d.dem
deleted file mode 100644
index df14ef1f0..000000000
--- a/src/components/appio/tests/iozone/gnu3d.dem
+++ /dev/null
@@ -1,146 +0,0 @@
-#
-# $Id: 3D plot of performance
-#
-# Processes files that were created by Generate_Graphs
-# and displays the results. Also, saves a postscript copy.
-#
-# Don Capps
-
-dirs = "write rewrite read reread randread randwrite bkwdread recrewrite strideread fwrite frewrite fread freread"
-titles = "Write ReWrite Read Reread Random_read Random_write Read_Backwards Record_rewrite Stride_read Fwrite Frewrite Fread Freread"
-
-file(n) = sprintf("%s/iozone_gen_out.gnuplot", word(dirs,n))
-outfile(n) = sprintf("%s/%s.ps", word(dirs,n), word(dirs,n))
-title(n) = word(titles,n)
-
-set title "Iozone performance"
-set grid lt 2 lw 1
-set surface
-set parametric
-set xtics
-set ytics
-set logscale x 2
-set logscale y 2
-set xlabel "File size in 2^n KBytes"
-set ylabel "Record size in 2^n Kbytes"
-set zlabel "Kbytes/sec"
-set style data lines
-set dgrid3d 80,80,3
-
-i = 1
-set terminal x11
-set output
-splot file(i) title title(i)
-pause -1 "Hit return to continue"
-set terminal postscript color
-set output outfile(i)
-replot
-
-i = 2
-set terminal x11
-set output
-replot
-pause -1 "Hit return to continue"
-set terminal postscript color
-set output outfile(i)
-replot
-
-i = 3
-set terminal x11
-set output
-replot
-pause -1 "Hit return to continue"
-set terminal postscript color
-set output outfile(i)
-replot
-
-i = 4
-set terminal x11
-set output
-replot
-pause -1 "Hit return to continue"
-set terminal postscript color
-set output outfile(i)
-replot
-
-i = 5
-set terminal x11
-set output
-replot
-pause -1 "Hit return to continue"
-set terminal postscript color
-set output outfile(i)
-replot
-
-i = 6
-set terminal x11
-set output
-replot
-pause -1 "Hit return to continue"
-set terminal postscript color
-set output outfile(i)
-replot
-
-i = 7
-set terminal x11
-set output
-replot
-pause -1 "Hit return to continue"
-set terminal postscript color
-set output outfile(i)
-replot
-
-i = 8
-set terminal x11
-set output
-replot
-pause -1 "Hit return to continue"
-set terminal postscript color
-set output outfile(i)
-replot
-
-i = 9
-set terminal x11
-set output
-replot
-pause -1 "Hit return to continue"
-set terminal postscript color
-set output outfile(i)
-replot
-
-i = 10
-set terminal x11
-set output
-replot
-pause -1 "Hit return to continue"
-set terminal postscript color
-set output outfile(i)
-replot
-
-i = 11
-set terminal x11
-set output
-replot
-pause -1 "Hit return to continue"
-set terminal postscript color
-set output outfile(i)
-replot
-
-i = 12
-set terminal x11
-set output
-replot
-pause -1 "Hit return to continue"
-set terminal postscript color
-set output outfile(i)
-replot
-
-i = 13
-set terminal x11
-set output
-replot
-pause -1 "Hit return to continue"
-set terminal postscript color
-set output outfile(i)
-replot
-
diff --git a/src/components/appio/tests/iozone/gnuplot.dem b/src/components/appio/tests/iozone/gnuplot.dem
deleted file mode 100644
index d1abdf500..000000000
--- a/src/components/appio/tests/iozone/gnuplot.dem
+++ /dev/null
@@ -1,60 +0,0 @@
-#
-# $Id: Plot of latency versus offset in a file
-#
-# Requires data file "wol.dat" from this directory,
-# so change current working directory to this directory before running.
-#
-
-set title "File system write latency "
-set autoscale x
-set xtics
-set xlabel "Offset in file (KB)"
-set ylabel "Latency in Microseconds"
-plot 'wol.dat' using 1:2 title "Latency Plot" with lines
-pause -1 "Hit return to continue"
-
-#
-# $Id: Plot of latency versus offset in a file
-#
-# Requires data file "rwol.dat" from this directory,
-# so change current working directory to this directory before running.
-#
-
-set title "File system re-write latency "
-set autoscale x
-set xtics
-set xlabel "Offset in file (KB)"
-set ylabel "Latency in Microseconds"
-plot 'rwol.dat' using 1:2 title "Latency Plot" with lines
-pause -1 "Hit return to continue"
-
-#
-# $Id: Plot of latency versus offset in a file
-#
-# Requires data file "rol.dat" from this directory,
-# so change current working directory to this directory before running.
-#
-
-set title "File system read latency "
-set autoscale x
-set xtics
-set xlabel "Offset in file (KB)"
-set ylabel "Latency in Microseconds"
-plot 'rol.dat' using 1:2 title "Latency Plot" with lines
-pause -1 "Hit return to continue"
-
-#
-# $Id: Plot of latency versus offset in a file
-#
-# Requires data file "rrol.dat" from this directory,
-# so change current working directory to this directory before running.
-#
-
-set title "File system re-read latency "
-set autoscale x
-set xtics
-set xlabel "Offset in file (KB)"
-set ylabel "Latency in Microseconds"
-plot 'rrol.dat' using 1:2 title "Latency Plot" with lines
-pause -1 "Hit return to continue"
-
diff --git a/src/components/appio/tests/iozone/gnuplotps.dem b/src/components/appio/tests/iozone/gnuplotps.dem
deleted file mode 100644
index 39e1c71af..000000000
--- a/src/components/appio/tests/iozone/gnuplotps.dem
+++ /dev/null
@@ -1,63 +0,0 @@
-#
-# $Id: Plot of latency versus offset in a file
-#
-# Requires data file "wol.dat" from this directory,
-# so change current working directory to this directory before running.
-#
-
-set title "File system write latency "
-set terminal postscript
-set output "gnu_wol.ps"
-set autoscale x
-set xtics
-set xlabel "Offset in file (KB)"
-set ylabel "Latency in Microseconds"
-plot 'wol.dat' using 1:2 title "Latency Plot" with lines
-#
-# $Id: Plot of latency versus offset in a file
-#
-# Requires data file "rwol.dat" from this directory,
-# so change current working directory to this directory before running.
-#
-
-set title "File system re-write latency "
-set terminal postscript
-set output "gnu_rwol.ps"
-set autoscale x
-set xtics
-set xlabel "Offset in file (KB)"
-set ylabel "Latency in Microseconds"
-plot 'rwol.dat' using 1:2 title "Latency Plot" with lines
-
-#
-# $Id: Plot of latency versus offset in a file
-#
-# Requires data file "rol.dat" from this directory,
-# so change current working directory to this directory before running.
-#
-
-set title "File system read latency "
-set autoscale x
-set xtics
-set xlabel "Offset in file (KB)"
-set ylabel "Latency in Microseconds"
-set terminal postscript
-set output "gnu_rol.ps"
-plot 'rol.dat' using 1:2 title "Latency Plot" with lines
-
-#
-# $Id: Plot of latency versus offset in a file
-#
-# Requires data file "rrol.dat" from this directory,
-# so change current working directory to this directory before running.
-#
-
-set title "File system re-read latency "
-set terminal postscript
-set output "gnu_rrol.ps"
-set autoscale x
-set xtics
-set xlabel "Offset in file (KB)"
-set ylabel "Latency in Microseconds"
-plot 'rrol.dat' using 1:2 title "Latency Plot" with lines
-
diff --git a/src/components/appio/tests/iozone/iozone.c b/src/components/appio/tests/iozone/iozone.c
deleted file mode 100644
index 7708cd76c..000000000
--- a/src/components/appio/tests/iozone/iozone.c
+++ /dev/null
@@ -1,25297 +0,0 @@
-/************************************************************************/
-/* Original Author: */
-/* William Norcott (wnorcott@us.oracle.com) */
-/* 4 Dunlap Drive */
-/* Nashua, NH 03060 */
-/* */
-/************************************************************************/
-/* Enhancements by: */
-/* Don Capps (capps@iozone.org) */
-/* 7417 Crenshaw */
-/* Plano, TX 75025 */
-/* */
-/************************************************************************/
-/* Copyright 1991, 1992, 1994, 1998, 2000, 2001 William D. Norcott */
-/************************************************************************/
-/* */
-/* Iozone is based on the original work done by William Norrcot. It has */
-/* been enhanced so that it provides a more complete filesystem */
-/* characterization. */
-/* Its purpose is to provide automated filesystem characterization. */
-/* Enhancements have been made by: */
-/* */
-/* Don Capps capps@iozone.org */
-/* */
-/* Iozone can perform single stream and multi stream I/O */
-/* also it now performs read, write, re-read, re-write, */
-/* read backwards, read/write random, re-read record, */
-/* pread, re-pread, re-pwrite, preadv, re-preadv, pwritev, */
-/* stride read, and re-pwritev,mmap, POSIX async I/O, NFS */
-/* cluster testing and much more. */
-/* */
-/* The frontend now uses getopt() and the user can control many more */
-/* of the actions. */
-/* */
-/* */
-/************************************************************************/
-/* THIS SOFTWARE IS PROVIDED BY DON CAPPS AND THE IOZONE CREW "AS IS */
-/* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED */
-/* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A */
-/* PARTICULAR PURPOSE ARE DISCLAIMED. */
-/* */
-/* IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY */
-/* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL */
-/* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE */
-/* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS */
-/* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER */
-/* IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR */
-/* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE. */
-/************************************************************************/
-
-/************************************************************************/
-/* For the beginner... */
-/* */
-/* 1. make linux (linux, hpux, convex, hpux_no_ansi) */
-/* 2. type ./iozone -Ra */
-/* */
-/* Hint: Type make (it will give you a list of valid targets) */
-/* */
-/************************************************************************/
-
-
-/* The version number */
-#define THISVERSION " Version $Revision$"
-
-#if defined(linux)
- #define _GNU_SOURCE
-#endif
-/* Include for Cygnus development environment for Windows */
-#if defined (Windows)
-#include <windows.h>
-#include <errno.h>
-#else
-#if defined(linux) || defined(solaris) || defined(macosx) || defined(__AIX__) || defined(FreeBSD) || defined(_HPUX_SOURCE)
-#include <errno.h>
-#else
-extern int errno; /* imported for errors */
-extern int h_errno; /* imported for errors */
-#endif
-#endif
-
-
-#include <sys/types.h>
-#include <sys/stat.h>
-#if defined (__LP64__) || defined(OSF_64) || defined(__alpha__) || defined(__arch64__) || defined(_LP64) || defined(__s390x__) || defined(__AMD64__)
-#define MODE "\tCompiled for 64 bit mode."
-#define _64BIT_ARCH_
-#else
-#define MODE "\tCompiled for 32 bit mode."
-#endif
-
-#ifndef NO_THREADS
-#include <pthread.h>
-#endif
-
-#if defined(HAVE_ANSIC_C) && defined(linux)
-#include <stdlib.h>
-#include <sys/wait.h>
-#endif
-
-#ifdef HAVE_PROTO
-#include "proto.h"
-#else
-int atoi();
-int close();
-int unlink();
-int main();
-void record_command_line();
-#if !defined(linux)
-int wait();
-#endif
-int fsync();
-void srand48();
-long lrand48();
-void create_list();
-void Poll();
-void print_header();
-void Kill();
-long long l_min();
-long long l_max();
-long long mythread_create();
-int gen_new_buf();
-void touch_dedup();
-void init_by_array64(unsigned long long *, unsigned long long );
-unsigned long long genrand64_int64(void);
-#endif
-
-#include <fcntl.h>
-
-char *help[] = {
-" Usage: iozone [-s filesize_Kb] [-r record_size_Kb] [-f [path]filename] [-h]",
-" [-i test] [-E] [-p] [-a] [-A] [-z] [-Z] [-m] [-M] [-t children]",
-" [-l min_number_procs] [-u max_number_procs] [-v] [-R] [-x] [-o]",
-" [-d microseconds] [-F path1 path2...] [-V pattern] [-j stride]",
-" [-T] [-C] [-B] [-D] [-G] [-I] [-H depth] [-k depth] [-U mount_point]",
-" [-S cache_size] [-O] [-L cacheline_size] [-K] [-g maxfilesize_Kb]",
-" [-n minfilesize_Kb] [-N] [-Q] [-P start_cpu] [-e] [-c] [-b Excel.xls]",
-" [-J milliseconds] [-X write_telemetry_filename] [-w] [-W]",
-" [-Y read_telemetry_filename] [-y minrecsize_Kb] [-q maxrecsize_Kb]",
-" [-+u] [-+m cluster_filename] [-+d] [-+x multiplier] [-+p # ]",
-" [-+r] [-+t] [-+X] [-+Z] [-+w percent dedupable] [-+y percent_interior_dedup]",
-" [-+C percent_dedup_within]",
-" ",
-" -a Auto mode",
-" -A Auto2 mode",
-" -b Filename Create Excel worksheet file",
-" -B Use mmap() files",
-" -c Include close in the timing calculations",
-" -C Show bytes transferred by each child in throughput testing",
-" -d # Microsecond delay out of barrier",
-" -D Use msync(MS_ASYNC) on mmap files",
-" -e Include flush (fsync,fflush) in the timing calculations",
-" -E Run extension tests",
-" -f filename to use",
-" -F filenames for each process/thread in throughput test",
-" -g # Set maximum file size (in Kbytes) for auto mode (or #m or #g)",
-" -G Use msync(MS_SYNC) on mmap files",
-" -h help",
-" -H # Use POSIX async I/O with # async operations",
-" -i # Test to run (0=write/rewrite, 1=read/re-read, 2=random-read/write",
-" 3=Read-backwards, 4=Re-write-record, 5=stride-read, 6=fwrite/re-fwrite",
-" 7=fread/Re-fread, 8=random_mix, 9=pwrite/Re-pwrite, 10=pread/Re-pread",
-" 11=pwritev/Re-pwritev, 12=preadv/Re-preadv)",
-" -I Use VxFS VX_DIRECT, O_DIRECT,or O_DIRECTIO for all file operations",
-" -j # Set stride of file accesses to (# * record size)",
-" -J # milliseconds of compute cycle before each I/O operation",
-" -k # Use POSIX async I/O (no bcopy) with # async operations",
-" -K Create jitter in the access pattern for readers",
-" -l # Lower limit on number of processes to run",
-" -L # Set processor cache line size to value (in bytes)",
-" -m Use multiple buffers",
-" -M Report uname -a output",
-" -n # Set minimum file size (in Kbytes) for auto mode (or #m or #g)",
-" -N Report results in microseconds per operation",
-" -o Writes are synch (O_SYNC)",
-" -O Give results in ops/sec.",
-" -p Purge on",
-" -P # Bind processes/threads to processors, starting with this cpu",
-" -q # Set maximum record size (in Kbytes) for auto mode (or #m or #g)",
-" -Q Create offset/latency files",
-" -r # record size in Kb",
-" or -r #k .. size in Kb",
-" or -r #m .. size in Mb",
-" or -r #g .. size in Gb",
-" -R Generate Excel report",
-" -s # file size in Kb",
-" or -s #k .. size in Kb",
-" or -s #m .. size in Mb",
-" or -s #g .. size in Gb",
-" -S # Set processor cache size to value (in Kbytes)",
-" -t # Number of threads or processes to use in throughput test",
-" -T Use POSIX pthreads for throughput tests",
-" -u # Upper limit on number of processes to run",
-" -U Mount point to remount between tests",
-" -v version information",
-" -V # Verify data pattern write/read",
-" -w Do not unlink temporary file",
-" -W Lock file when reading or writing",
-" -x Turn off stone-walling",
-" -X filename Write telemetry file. Contains lines with (offset reclen compute_time) in ascii",
-" -y # Set minimum record size (in Kbytes) for auto mode (or #m or #g)",
-" -Y filename Read telemetry file. Contains lines with (offset reclen compute_time) in ascii",
-" -z Used in conjunction with -a to test all possible record sizes",
-" -Z Enable mixing of mmap I/O and file I/O",
-" -+E Use existing non-Iozone file for read-only testing",
-" -+K Sony special. Manual control of test 8.",
-" -+m Cluster_filename Enable Cluster testing",
-" -+d File I/O diagnostic mode. (To troubleshoot a broken file I/O subsystem)",
-" -+u Enable CPU utilization output (Experimental)",
-" -+x # Multiplier to use for incrementing file and record sizes",
-" -+p # Percentage of mix to be reads",
-" -+r Enable O_RSYNC|O_SYNC for all testing.",
-" -+t Enable network performance test. Requires -+m ",
-" -+n No retests selected.",
-" -+k Use constant aggregate data set size.",
-" -+q Delay in seconds between tests.",
-" -+l Enable record locking mode.",
-" -+L Enable record locking mode, with shared file.",
-" -+B Sequential mixed workload.",
-#if defined(O_DSYNC)
-" -+D Enable O_DSYNC mode.",
-#endif
-#ifndef NO_MADVISE
-" -+A # Enable madvise. 0 = normal, 1=random, 2=sequential",
-" 3=dontneed, 4=willneed",
-#endif
-" -+N Do not truncate existing files on sequential writes.",
-" -+S # Dedup-able data is limited to sharing within each numerically",
-" identified file set",
-" -+V Enable shared file. No locking.",
-#if defined(Windows)
-" -+U Windows Unbufferd I/O API (Very Experimental)",
-#endif
-" -+X Enable short circuit mode for filesystem testing ONLY",
-" ALL Results are NOT valid in this mode.",
-" -+Z Enable old data set compatibility mode. WARNING.. Published",
-" hacks may invalidate these results and generate bogus, high",
-" values for results.",
-" -+w ## Percent of dedup-able data in buffers.",
-" -+y ## Percent of dedup-able within & across files in buffers.",
-" -+C ## Percent of dedup-able within & not across files in buffers.",
-" -+H Hostname Hostname of the PIT server.",
-" -+P Service Service of the PIT server.",
-" -+z Enable latency histogram logging.",
-"" };
-
-char *head1[] = {
- " 'Iozone' Filesystem Benchmark Program",
- " ",
-THISVERSION,
- MODE,
- " ",
- " Original Author: William Norcott (wnorcott@us.oracle.com)",
- " 4 Dunlap Drive",
- " Nashua, NH 03060",
- " ",
- " Enhancements: Don Capps (capps@iozone.org)",
- " 7417 Crenshaw",
- " Plano, TX 75025",
- " ",
- " Copyright 1991, 1992, 1994, 1998, 1999, 2002 William D. Norcott",
- " ",
- " License to freely use and distribute this software is hereby granted ",
- " by the author, subject to the condition that this copyright notice ",
- " remains intact. The author retains the exclusive right to publish ",
- " derivative works based on this work, including, but not limited to, ",
- " revised versions of this work",
- " ",
- " Other contributors:",
- " ",
- " Don Capps (Network Appliance) capps@iozone.org",
- " ",
- ""};
-
-/******************************************************************
-
- INCLUDE FILES (system-dependent)
-
-******************************************************************/
-#include <sys/mman.h>
-#include <stdio.h>
-#include <signal.h>
-#include <unistd.h>
-
-#include <fcntl.h>
-#if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__APPLE__) && !defined(__DragonFly__)
-#include <malloc.h>
-#endif
-#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__APPLE__) || defined(__DragonFly__)
-#include <stdlib.h>
-#include <string.h>
-#endif
-
-#if defined (__FreeBSD__) || defined(__OpenBSD__) || defined(__bsdi__) || defined(__APPLE__) || defined(__DragonFly__)
-#ifndef O_SYNC
-#define O_SYNC O_FSYNC
-#endif
-#endif
-
-#if defined (__FreeBSD__)
-#ifndef O_RSYNC
-#define O_RSYNC O_FSYNC
-#endif
-#endif
-
-#if ((defined(solaris) && defined(__LP64__)) || defined(__s390x__))
-/* If we are building for 64-bit Solaris, all functions that return pointers
- * must be declared before they are used; otherwise the compiler will assume
- * that they return ints and the top 32 bits of the pointer will be lost,
- * causing segmentation faults. The following includes take care of this.
- * It should be safe to add these for all other OSs too, but we're only
- * doing it for Solaris now in case another OS turns out to be a special case.
- */
-#include <strings.h>
-#include <stdlib.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-
-#endif
-#if ( defined(solaris) && defined(studio11) )
-#include <strings.h>
-#include <stdlib.h>
-#endif
-
-#if defined(OSFV5) || defined(linux)
-#include <string.h>
-#endif
-
-#if defined(linux)
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#endif
-
-#ifndef MAP_FAILED
-#define MAP_FAILED -1
-#endif
-
-#ifdef generic
-typedef long long off64_t;
-#endif
-
-#if defined(__DragonFly__)
-#define __off64_t_defined
-typedef off_t off64_t;
-#endif
-
-
-#ifndef solaris
-#ifndef off64_t
-#ifndef _OFF64_T
-#ifndef __AIX__
-#ifndef __off64_t_defined
-#ifndef SCO_Unixware_gcc
-#ifndef UWIN
-#ifndef __DragonFly__
-typedef long long off64_t;
-#endif
-#endif
-#endif
-#endif
-#endif
-#endif
-#endif
-#endif
-
-#ifdef __AIX__
-#include <fcntl.h>
-#endif
-
-#ifdef VXFS
-#include <sys/fs/vx_ioctl.h>
-#endif
-
-#ifdef unix
-#if defined (__APPLE__) || defined(__FreeBSD__) || defined(__DragonFly__) \
- || defined(_SUA_)
-#include <sys/time.h>
-#endif
-#include <sys/times.h>
-#include <sys/file.h>
-#include <sys/resource.h>
-#ifndef NULL
-#define NULL 0
-#endif
-
-#ifndef nolimits
-#include <limits.h>
-#endif
-#endif
-
-#ifdef HAVE_ANSIC_C
-#define VOLATILE volatile
-#else
-#define VOLATILE
-#endif
-
-#include <sys/time.h>
-
-#ifdef SHARED_MEM
-#include <sys/shm.h>
-#endif
-
-#if defined(bsd4_2) && !defined(MS_SYNC)
-#define MS_SYNC 0
-#define MS_ASYNC 0
-#endif
-
-#if defined(bsd4_4) || defined(__DragonFly__)
-#define MAP_ANONYMOUS MAP_ANON
-#endif
-
-#if defined(SCO_Unixware_gcc) || defined(solaris) || defined(UWIN) || defined(SCO)
-#define MAP_FILE (0)
-#endif
-
-#if defined(IRIX) || defined(IRIX64) || defined(Windows) || defined(bsd4_2) || defined(bsd4_4) || defined(SCO) || defined(Solaris) || defined(SCO_Unixware_gcc)
-long long page_size = 4096;
-#define GOT_PAGESIZE 1
-#elif defined(NBPG)
-long long page_size = NBPG;
-#define GOT_PAGESIZE 1
-#elif defined(old_linux)
-#include <asm/page.h>
-long long page_size = PAGE_SIZE;
-#define GOT_PAGESIZE 1
-#elif !defined(GOT_PAGESIZE)
-long long page_size = 4096; /* Used when all else fails */
-#endif
-
-#ifdef HAVE_PREAD
-#ifdef HAVE_PREADV
-#define PVECMAX 16
-
-#ifdef _HPUX_SOURCE
-#define PER_VECTOR_OFFSET
-#include <sys/puio.h>
-struct piovec piov[PVECMAX];
-#else
-#include <sys/uio.h>
-struct iovec piov[PVECMAX];
-#define piov_base iov_base
-#define piov_len iov_len
-#endif
-
-#endif
-#endif
-
-#define DEDUPSEED 0x2719362
-
-
-/*
- * In multi thread/process throughput mode each child keeps track of
- * statistics and communicates them through various flavors of
- * shared memory, and via messages.
- */
-struct child_stats {
- long long flag; /* control space */
- long long flag1; /* pad */
- float walltime; /* child elapsed time */
- float cputime; /* child CPU time */
- float throughput; /* Throughput in either kb/sec or ops/sec */
- float actual; /* Either actual kb read or # of ops performed */
-} VOLATILE *child_stat;
-
-/*
- * Used for cpu time statistics.
- */
-struct runtime {
- float walltime;
- float cputime;
- float cpuutil;
-};
-
-#ifdef __convex_spp
-#include <sys/cnx_ail.h>
-#endif
-
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <netdb.h>
-
-
-/*
- * Messages the controlling process sends to children.
- * Internal representation that is arch specific.
- * This is used when using the network distributed mode.
- */
-struct client_command {
- char c_host_name[100];
- char c_pit_hostname[40];
- char c_pit_service[8];
- char c_client_name[100];
- char c_working_dir[200];
- char c_file_name[200];
- char c_path_dir[200];
- char c_execute_name[200];
- char c_write_traj_filename[200];
- char c_read_traj_filename[200];
- int c_oflag;
- int c_mfflag;
- int c_unbuffered;
- int c_noretest;
- int c_notruncate;
- int c_read_sync;
- int c_jflag;
- int c_async_flag;
- int c_k_flag;
- int c_h_flag;
- int c_mflag;
- int c_pflag;
- int c_stride_flag;
- int c_verify;
- int c_sverify;
- int c_odsync;
- int c_diag_v;
- int c_dedup;
- int c_dedup_interior;
- int c_dedup_compress;
- int c_dedup_mseed;
- int c_hist_summary;
- int c_op_rate;
- int c_op_rate_flag;
- int c_Q_flag;
- int c_L_flag;
- int c_OPS_flag;
- int c_mmapflag;
- int c_mmapasflag;
- int c_mmapnsflag;
- int c_mmapssflag;
- int c_no_copy_flag;
- int c_include_close;
- int c_include_flush;
- int c_disrupt_flag;
- int c_compute_flag;
- int c_xflag;
- int c_MS_flag;
- int c_mmap_mix;
- int c_Kplus_flag;
- int c_stop_flag;
- int c_w_traj_flag;
- int c_r_traj_flag;
- int c_direct_flag;
- int c_cpuutilflag;
- int c_seq_mix;
- int c_client_number;
- int c_command;
- int c_testnum;
- int c_no_unlink;
- int c_no_write;
- int c_file_lock;
- int c_rec_lock;
- int c_Kplus_readers;
- int c_multiplier;
- int c_share_file;
- int c_pattern;
- int c_version;
- int c_base_time;
- int c_num_child;
- int c_pct_read;
- int c_advise_op;
- int c_advise_flag;
- int c_restf;
- int c_mygen;
- long long c_stride;
- long long c_rest_val;
- long long c_delay;
- long long c_purge;
- long long c_fetchon;
- long long c_numrecs64;
- long long c_reclen;
- long long c_child_flag;
- long long c_delay_start;
- long long c_depth;
- float c_compute_time;
-};
-
-/*
- * All data in this is in string format for portability in a
- * hetrogeneous environment.
- *
- * Messages that the master will send to the clients
- * over the socket. This provides neutral format
- * so that heterogeneous clusters will work.
- * This is used when using the network distributed mode.
- * WARNING !!! This data structure MUST not be bigger
- * than 1448 bytes or fragmentation will kick your butt.
- */
-struct client_neutral_command {
- char c_host_name[100];
- char c_pit_hostname[40];
- char c_pit_service[8];
- char c_client_name[100];
- char c_working_dir[200];
- char c_file_name[200];
- char c_path_dir[200];
- char c_execute_name[200];
- char c_write_traj_filename[200];
- char c_read_traj_filename[200];
- char c_oflag[2];
- char c_mfflag[2];
- char c_unbuffered[2];
- char c_noretest[2];
- char c_notruncate[2];
- char c_read_sync[2];
- char c_jflag[2];
- char c_async_flag[2];
- char c_k_flag[2];
- char c_h_flag[2];
- char c_mflag[2];
- char c_pflag[2];
- char c_stride_flag[2];
- char c_verify[2];
- char c_sverify[2];
- char c_odsync[2];
- char c_diag_v[2];
- char c_dedup[4];
- char c_dedup_interior[4];
- char c_dedup_compress[4];
- char c_dedup_mseed[4];
- char c_hist_summary[4];
- char c_op_rate[4];
- char c_op_rate_flag[2];
- char c_Q_flag[2];
- char c_L_flag[2];
- char c_OPS_flag[2];
- char c_mmapflag[2];
- char c_mmapasflag[2];
- char c_mmapnsflag[2];
- char c_mmapssflag[2];
- char c_no_copy_flag[2];
- char c_include_close[2];
- char c_include_flush[2];
- char c_disrupt_flag[2];
- char c_compute_flag[2];
- char c_stop_flag[2];
- char c_xflag[2];
- char c_MS_flag[2];
- char c_mmap_mix[2];
- char c_Kplus_flag[2];
- char c_w_traj_flag[2]; /* small int */
- char c_r_traj_flag[2]; /* small int */
- char c_direct_flag[2]; /* small int */
- char c_cpuutilflag[2]; /* small int */
- char c_seq_mix[2]; /* small int */
- char c_stride[10]; /* small long long */
- char c_rest_val[10]; /* small long long */
- char c_purge[10]; /* very small long long */
- char c_fetchon[10]; /* very small long long */
- char c_multiplier[10]; /* small int */
- char c_share_file[10]; /* small int */
- char c_file_lock[10]; /* small int */
- char c_rec_lock[10]; /* small int */
- char c_Kplus_readers[10]; /* small int */
- char c_client_number[20]; /* int */
- char c_command[20]; /* int */
- char c_testnum[20]; /* int */
- char c_no_unlink[4]; /* int */
- char c_no_write[4]; /* int */
- char c_pattern[20]; /* int */
- char c_version[20]; /* int */
- char c_base_time[20]; /* int */
- char c_num_child[20]; /* int */
- char c_pct_read[6]; /* small int */
- char c_advise_op[4]; /* small int */
- char c_advise_flag[4]; /* small int */
- char c_restf[4]; /* small int */
- char c_mygen[20]; /* long */
- char c_depth[20]; /* small long long */
- char c_child_flag[40]; /* small long long */
- char c_delay[80]; /* long long */
- char c_numrecs64[80]; /* long long */
- char c_reclen[80]; /* long long */
- char c_delay_start[80]; /* long long */
- char c_compute_time[80]; /* float */
-};
-
-/*
- * Messages the clients will send to the master.
- * Internal representation on each client and the master.
- * This is used when using the network distributed mode.
- */
-struct master_command {
- char m_host_name[100];
- char m_client_name[100];
- char m_stop_flag;
- int m_client_number;
- int m_client_error;
- int m_child_port;
- int m_child_async_port;
- int m_command;
- int m_testnum;
- int m_version;
- int m_mygen;
- float m_throughput;
- float m_cputime;
- float m_walltime;
- float m_actual;
- long long m_child_flag;
-};
-
-/*
- * Messages that the clients will send to the master
- * over the socket. This provides neutral format
- * so that heterogeneous clusters will work.
- * This is used when using the network distributed mode.
- */
-struct master_neutral_command {
- char m_host_name[100];
- char m_client_name[100];
- char m_client_number[20]; /* int */
- char m_client_error[20]; /* int */
- char m_stop_flag[4]; /* char +space */
- char m_child_port[20]; /* int */
- char m_child_async_port[20]; /* int */
- char m_command[20]; /* int */
- char m_testnum[20]; /* int */
- char m_version[20]; /* int */
- char m_mygen[20]; /* int */
- char m_throughput[80]; /* float */
- char m_cputime[80]; /* float */
- char m_walltime[80]; /* float */
- char m_actual[80]; /* float */
- char m_child_flag[80]; /* long long */
-};
-
-
-/*
- * Possible values for the commands sent to the master
- */
-#define R_CHILD_JOIN 1
-#define R_STAT_DATA 2
-#define R_FLAG_DATA 3
-
-/*
- * Possible values for the master's commands sent to a client
- *
- * The R_FLAG_DATA is also used by the master to tell the
- * client to update its flags.
- */
-#define R_JOIN_ACK 4
-#define R_STOP_FLAG 5
-#define R_TERMINATE 6
-#define R_DEATH 7
-
-
-/* These are the defaults for the processor. They can be
- * over written by the command line options.
- */
-#define CACHE_LINE_SIZE 32
-#define CACHE_SIZE ( 1024 * 1024 )
-
-
-#define MEG (1024 * 1024)
-
-/*
- * For stride testing use a prime number to avoid stripe
- * wrap hitting the same spindle.
- */
-#define STRIDE 17
-
-
-
-/************************************************************************/
-/* */
-/* DEFINED CONSTANTS */
-/* */
-/* Never add a comment to the end of a #define. Some compilers will */
-/* choke and fail the compile. */
-/************************************************************************/
-
-/*
- * Size of buffer for capturing the machine's name.
- */
-#define IBUFSIZE 100
-/*
- * How many I/Os before a non-uniform access.
- */
-#define DISRUPT 100
-
-/*
- * Set the crossover size. This is where the small transfers
- * are skipped to save time. There is an option to
- * disable the skipping.
- */
-#define LARGE_REC 65536
-
-/* Default number of kilobytes in file */
-#define KILOBYTES 512
-
-/* Default number of bytes in a record */
-#define RECLEN 1024
-
-/* Default size of file in bytes*/
-#define FILESIZE (KILOBYTES*1024)
-
-/* Default number of records */
-#define NUMRECS FILESIZE/RECLEN
-
-#ifdef __bsdi__
-/* At 8 Meg switch to large records */
-#define CROSSOVER (8*1024)
-/*maximum buffer size*/
-#define MAXBUFFERSIZE (8*1024*1024)
-#else
-/* At 16 Meg switch to large records */
-#define CROSSOVER (16*1024)
-/* Maximum buffer size*/
-#define MAXBUFFERSIZE (16*1024*1024)
-#endif
-
-/* Maximum number of children. Threads/procs/clients */
-#define MAXSTREAMS 256
-
-/* Minimum buffer size */
-#define MINBUFFERSIZE 128
-/* If things ran way too fast */
-#define TOOFAST 10
-/* Set the maximum number of types of tests */
-#define MAXTESTS 12
-/* Default fill pattern for verification */
-#define PATTERN get_pattern();
-#define PATTERN1 0xBB
-/* Used for Excel internal tables */
-#define MAX_X 100
-/* Used for Excel internal tables */
-#define MAX_Y 512
-
-#define USAGE "\tUsage: For usage information type iozone -h \n\n"
-
-
-/* Maximum number of characters in filename */
-#define MAXNAMESIZE 1000
-
-/*
- * Define the typical output that the user will see on their
- * screen.
- */
-#ifdef NO_PRINT_LLD
-#ifdef HAVE_PREAD
-#include <sys/times.h>
-#if defined(HAVE_PREAD) && defined(HAVE_PREADV)
-#define CONTROL_STRING1 "%16ld%8ld%8ld%8ld%8ld%8ld%8ld%8ld%8ld %8ld %8ld%8ld%8ld%9ld%9ld%8ld%10ld%9ld%10ld%9ld%10ld%10ld%9ld\n"
-#define CONTROL_STRING2 "%16s%8s%8s%8s%8s%10s%8s%8s%8s %8s %8s%9s%9s%8s%9s%8s%9s%7s%10s%10s%10s%9s%9s\n"
-#define CONTROL_STRING3 "%16s%8s%8s%8s%8s%10s%8s%8s%8s %8s %8s%9s%9s%8s%9s\n"
-#define CONTROL_STRING4 "%16s%8s%8s%8s%8s%10s\n"
-#else
-#define CONTROL_STRING1 "%16ld%8ld%8ld%8ld%8ld%8ld%8ld%8ld%8ld %8ld %8ld%8ld%8ld%9ld%9ld%8ld%10ld%9ld%10ld\n"
-#define CONTROL_STRING2 "%16s%8s%8s%8s%8s%10s%8s%8s%8s %8s %8s%9s%9s%8s%9s%8s%9s%7s%10s\n"
-#define CONTROL_STRING3 "%16s%8s%8s%8s%8s%10s%8s%8s%8s %8s %8s\n"
-#define CONTROL_STRING4 "%16s%8s%8s%8s%8s%10s\n"
-#endif
-#else
-#define CONTROL_STRING1 "%16ld%8ld%8ld%8ld%8ld%8ld%8ld%8ld%8ld %8ld %8ld%8ld%8ld%9ld%9ld\n"
-#define CONTROL_STRING2 "%16s%8s%8s%8s%8s%10s%8s%8s%8s %8s %8s%9s%9s%8s%9s\n"
-#define CONTROL_STRING3 "%16s%8s%8s%8s%8s%10s%8s%8s%8s %8s %8s%9s%9s%8s%9s\n"
-#define CONTROL_STRING4 "%16s%8s%8s%8s%8s%10s\n"
-#endif
-#endif
-
-#ifndef NO_PRINT_LLD
-#ifdef HAVE_PREAD
-#include <sys/times.h>
-#if defined(HAVE_PREAD) && defined(HAVE_PREADV)
-#define CONTROL_STRING1 "%16lld%8ld%8ld%8ld%8ld%8ld%8ld%8ld%8ld %8ld %8ld%8ld%8ld%9ld%9ld%8ld%10ld%9ld%10ld%9ld%10ld%10ld%9ld\n"
-#define CONTROL_STRING2 "%16s%8s%8s%8s%8s%10s%8s%8s%8s %8s %8s%9s%9s%8s%9s%8s%9s%7s%10s%10s%10s%9s%9s\n"
-#define CONTROL_STRING3 "%16s%8s%8s%8s%8s%10s%8s%8s%8s %8s %8s%9s%9s%8s%9s\n"
-#define CONTROL_STRING4 "%16s%8s%8s%8s%8s%10s\n"
-#else
-#define CONTROL_STRING1 "%16lld%8ld%8ld%8ld%8ld%8ld%8ld%8ld%8ld %8ld %8ld%8ld%8ld%9ld%9ld%8ld%10ld%9ld%10ld\n"
-#define CONTROL_STRING2 "%16s%8s%8s%8s%8s%10s%8s%8s%8s %8s %8s%9s%9s%8s%9s%8s%9s%7s%10s\n"
-#define CONTROL_STRING3 "%16s%8s%8s%8s%8s%10s%8s%8s%8s %8s %8s%9s%9s%8s%9s\n"
-#define CONTROL_STRING4 "%16s%8s%8s%8s%8s%10s\n"
-#endif
-#else
-#define CONTROL_STRING1 "%16lld%8ld%8ld%8ld%8ld%8ld%8ld%8ld %8ld %8ld%8ld%8ld%8ld%9ld%9ld\n"
-#define CONTROL_STRING2 "%16s%8s%8s%8s%8s%10s%8s%8s%8s %8s %8s%9s%9s%8s%9s\n"
-#define CONTROL_STRING3 "%16s%8s%8s%8s%8s%10s%8s%8s%8s %8s %8s%9s%9s%8s%9s\n"
-#define CONTROL_STRING4 "%16s%8s%8s%8s%8s%10s\n"
-#endif
-#endif
-
-/*
- For 'auto mode', these defines determine the number of iterations
- to perform for both the file size and the record length.
-*/
-
-/* Start with 64 kbyte minimum file size by default */
-#define KILOBYTES_START 64
-/* Default maximum file size. This is 512 Mbytes */
-#define KILOBYTES_END (1024*512)
-/* Default starting record size */
-#define RECLEN_START 4096
-/* Default maximum record size */
-#define RECLEN_END (MAXBUFFERSIZE)
-/* Multiplier for each itteration on file and record size */
-#define MULTIPLIER 2
-
-/*
- * Assign numeric values to each of the tests.
- */
-#define WRITER_TEST 0
-#define READER_TEST 1
-#define RANDOM_RW_TEST 2
-#define REVERSE_TEST 3
-#define REWRITE_REC_TEST 4
-#define STRIDE_READ_TEST 5
-#define FWRITER_TEST 6
-#define FREADER_TEST 7
-#define RANDOM_MIX_TEST 8
-#ifdef HAVE_PREAD
-#define PWRITER_TEST 9
-#define PREADER_TEST 10
-#endif /* HAVE_PREAD */
-#ifdef HAVE_PREADV
-#define PWRITEV_TEST 11
-#define PREADV_TEST 12
-#endif /* HAVE_PREADV */
-
-#define WRITER_MASK (1 << WRITER_TEST)
-#define READER_MASK (1 << READER_TEST)
-#define RANDOM_RW_MASK (1 << RANDOM_RW_TEST)
-#define RANDOM_MIX_MASK (1 << RANDOM_MIX_TEST)
-#define REVERSE_MASK (1 << REVERSE_TEST)
-#define REWRITE_REC_MASK (1 << REWRITE_REC_TEST)
-#define STRIDE_READ_MASK (1 << STRIDE_READ_TEST)
-#define FWRITER_MASK (1 << FWRITER_TEST)
-#define FREADER_MASK (1 << FREADER_TEST)
-#ifdef HAVE_PREAD
-#define PWRITER_MASK (1 << PWRITER_TEST)
-#define PREADER_MASK (1 << PREADER_TEST)
-#endif /* HAVE_PREAD */
-#ifdef HAVE_PREADV
-#define PWRITEV_MASK (1 << PWRITEV_TEST)
-#define PREADV_MASK (1 << PREADV_TEST)
-#endif /* HAVE_PREADV */
-
-/*
- * child_stat->flag values and transitions
- */
-/* Parent initializes children to HOLD */
-#define CHILD_STATE_HOLD 0
-/* Child tells master when it's READY */
-#define CHILD_STATE_READY 1
-/* Parent tells child to BEGIN */
-#define CHILD_STATE_BEGIN 2
-/* Child tells parent that it's DONE */
-#define CHILD_STATE_DONE 3
-
-#define MERSENNE
-
-/******************************************************************/
-/* */
-/* FUNCTION DECLARATIONS */
-/* */
-/******************************************************************/
-char *initfile();
-/*int pit_gettimeofday( struct timeval *, struct timezone *, char *, char *);*/
-int pit_gettimeofday( );
-static int openSckt( const char *, const char *, unsigned int );
-static void pit( int, struct timeval *);
-void mmap_end();
-void alloc_pbuf();
-void auto_test(); /* perform automatic test series */
-void show_help(); /* show development help */
-static double time_so_far(); /* time since start of program */
-#ifdef unix
-static double utime_so_far(); /* user time */
-static double stime_so_far(); /* system time */
-static double clk_tck(); /* Get clocks/tick */
-static double cputime_so_far();
-#else
-#define cputime_so_far() time_so_far()
-#endif
-static double time_so_far1(); /* time since start of program */
-void get_resolution();
-void get_rusage_resolution();
-void signal_handler(); /* clean up if user interrupts us */
-void begin(); /* The main worker in the app */
-void fetchit(); /* Prime on chip cache */
-void purgeit(); /* Purge on chip cache */
-void throughput_test(); /* Multi process throughput */
-void multi_throughput_test(); /* Multi process throughput */
-void prepage(); /* Pre-fault user buffer */
-void get_date();
-int get_pattern(); /* Set pattern based on version */
-#ifdef HAVE_ANSIC_C
-float do_compute(float); /* compute cycle simulation */
-#else
-float do_compute(); /* compute cycle simulation */
-#endif
-void write_perf_test(); /* write/rewrite test */
-void fwrite_perf_test(); /* fwrite/refwrite test */
-void fread_perf_test(); /* fread/refread test */
-void read_perf_test(); /* read/reread test */
-void mix_perf_test(); /* read/reread test */
-void random_perf_test(); /* random read/write test */
-void reverse_perf_test(); /* reverse read test */
-void rewriterec_perf_test(); /* rewrite record test */
-void read_stride_perf_test(); /* read with stride test */
-#ifdef HAVE_PREAD
-void pread_perf_test(); /* pread/re-pread test */
-void pwrite_perf_test(); /* pwrite/re-pwrite test */
-#endif /* HAVE_PREAD */
-#ifdef HAVE_PREADV
-void preadv_perf_test(); /* preadv/re-preadv test */
-void pwritev_perf_test(); /* pwritev/re-pwritev test */
-#endif /* HAVE_PREADV */
-void store_dvalue(); /* Store doubles array */
-void dump_excel();
-void dump_throughput();
-int sp_start_child_send();
-int sp_start_master_listen();
-#ifdef HAVE_ANSIC_C
-#if defined (HAVE_PREAD) && defined(_LARGEFILE64_SOURCE)
-ssize_t pwrite64();
-ssize_t pread64();
-#endif
-#if !defined(linux)
-char *getenv();
-char *inet_ntoa();
-int system();
-#endif
-void my_nap();
-void my_unap();
-int thread_exit();
-#ifdef ASYNC_IO
-size_t async_write();
-void async_release();
-int async_read();
-int async_read_no_copy();
-size_t async_write_no_copy();
-void end_async();
-void async_init();
-#else
-size_t async_write();
-size_t async_write_no_copy();
-void async_release();
-#endif
-void do_float();
-int create_xls();
-void close_xls();
-void do_label();
-int mylockf(int, int, int);
-int mylockr(int,int, int, off64_t, off64_t);
-int rand(void);
-void srand(unsigned int);
-int get_client_info(void);
-void exit(int);
-void find_remote_shell(char *);
-void find_external_mon(char *,char *);
-void start_monitor(char *);
-void stop_monitor(char *);
-void takeoff_cache();
-void del_cache();
-void fill_area(long long *, long long *, long long);
-void fill_buffer(char *,long long ,long long ,char, long long );
-void store_value(off64_t);
-void store_times(double, double);
-static double cpu_util(double, double);
-void dump_cputimes(void);
-void purge_buffer_cache(void);
-char *alloc_mem(long long,int);
-void *(thread_rwrite_test)(void *);
-void *(thread_write_test)(void *);
-void *(thread_fwrite_test)(void *);
-void *(thread_fread_test)(void *);
-void *(thread_read_test)(void*);
-#ifdef HAVE_PREAD
-void *(thread_pread_test)(void*);
-void *(thread_pwrite_test)(void*);
-#endif
-void *(thread_cleanup_test)(void*);
-void *(thread_cleanup_quick)(void*);
-void *(thread_ranread_test)(void *);
-void *(thread_mix_test)(void *);
-void *(thread_ranwrite_test)(void *);
-void *(thread_rread_test)(void *);
-void *(thread_reverse_read_test)(void *);
-void *(thread_stride_read_test)(void *);
-void *(thread_set_base)(void *);
-void *(thread_join)(long long, void *);
-void disrupt(int);
-#if defined(Windows)
-void disruptw(HANDLE);
-#endif
-long long get_traj(FILE *, long long *, float *, long);
-void create_temp(off64_t, long long );
-FILE *open_w_traj(void);
-FILE *open_r_traj(void);
-void traj_vers(void);
-void r_traj_size(void);
-long long w_traj_size(void);
-void init_file_sizes();
-off64_t get_next_file_size(off64_t);
-void add_file_size(off64_t);
-void init_file_sizes( off64_t, off64_t);
-off64_t get_next_record_size(off64_t);
-void add_record_size(off64_t);
-void init_record_sizes( off64_t, off64_t);
-void del_record_sizes( void );
-void hist_insert(double );
-void dump_hist(char *,int );
-void do_speed_check(int);
-#else
-void do_speed_check();
-#if !defined(linux)
-char *getenv();
-char *inet_ntoa();
-int system();
-#endif
-void my_nap();
-void my_unap();
-int thread_exit();
-void close_xls();
-void do_label();
-int create_xls();
-void do_float();
-#ifdef ASYNC_IO
-void async_release();
-size_t async_write();
-size_t async_write_no_copy();
-int async_read();
-int async_read_no_copy();
-#endif
-int mylockf();
-int mylockr();
-int rand();
-void srand();
-int get_client_info();
-void exit();
-void find_remote_shell();
-void traj_vers();
-void r_traj_size();
-long long w_traj_size();
-FILE *open_w_traj();
-FILE *open_r_traj();
-void create_temp();
-void fill_buffer();
-char *alloc_mem();
-void *(thread_rwrite_test)();
-void *(thread_write_test)();
-void *(thread_fwrite_test)();
-void *(thread_fread_test)();
-void *(thread_read_test)();
-void *(thread_cleanup_test)();
-void *(thread_ranread_test)();
-void *(thread_mix_test)();
-void *(thread_ranwrite_test)();
-void *(thread_rread_test)();
-void *(thread_reverse_read_test)();
-void *(thread_stride_read_test)();
-void *(thread_set_base)();
-void *(thread_join)();
-void disrupt();
-long long get_traj();
-void init_file_sizes();
-off64_t get_next_file_size();
-void add_file_size();
-void init_record_sizes();
-off64_t get_next_record_size();
-void add_record_size();
-void dump_cputimes();
-static double cpu_util();
-void del_record_sizes();
-void hist_insert();
-void dump_hist();
-#endif
-
-#ifdef _LARGEFILE64_SOURCE
-#define I_LSEEK(x,y,z) lseek64(x,(off64_t)(y),z)
-#define I_OPEN(x,y,z) open64(x,(int)(y),(int)(z))
-#define I_CREAT(x,y) creat64(x,(int)(y))
-#define I_FOPEN(x,y) fopen64(x,y)
-#define I_STAT(x,y) stat64(x,y)
-#ifdef HAVE_PREAD
-#define I_PREAD(a,b,c,d) pread64(a,b,(size_t)(c),(off64_t)(d))
-#define I_PWRITE(a,b,c,d) pwrite64(a,b,(size_t)(c),(off64_t)(d))
-#endif
-#define I_MMAP(a,b,c,d,e,f) mmap64((void *)(a),(size_t)(b),(int)(c),(int)(d),(int)(e),(off64_t)(f))
-#else
-#define I_LSEEK(x,y,z) lseek(x,(off_t)(y),z)
-#define I_OPEN(x,y,z) open(x,(int)(y),(int)(z))
-#define I_CREAT(x,y) creat(x,(int)(y))
-#define I_FOPEN(x,y) fopen(x,y)
-#define I_STAT(x,y) stat(x,y)
-#ifdef HAVE_PREAD
-#define I_PREAD(a,b,c,d) pread(a,b,(size_t)(c),(off_t)(d))
-#define I_PWRITE(a,b,c,d) pwrite(a,b,(size_t)(c),(off_t)(d))
-#endif
-#define I_MMAP(a,b,c,d,e,f) mmap((void *)(a),(size_t)(b),(int)(c),(int)(d),(int)(e),(off_t)(f))
-#endif
-
-
-/************************************************************************/
-/* The list of tests to be called. */
-/************************************************************************/
-void (*func[])() = {
- write_perf_test,
- read_perf_test,
- random_perf_test,
- reverse_perf_test,
- rewriterec_perf_test,
- read_stride_perf_test,
- fwrite_perf_test,
- fread_perf_test,
- mix_perf_test
-#ifdef HAVE_PREAD
- ,
- pwrite_perf_test,
- pread_perf_test
-#ifdef HAVE_PREADV
- ,
- pwritev_perf_test,
- preadv_perf_test
-#endif /* HAVE_PREADV */
-#endif /* HAVE_PREAD */
- };
-
-/*
-char *test_output[] = {" ",
- " ",
- " ",
- " ",
- " ",
- " ",
- " ",
- " ",
- " ",
- " ",
- " ",
- " \n" };
-*/
-char *test_output[] = {" ",
- " ",
- " ",
- " ",
- " ",
- " ",
- " ",
- " ",
- "",
- " ",
- " ",
- " ",
- " ",
- " ",
- " ",
- " \n" };
-long long test_soutput[] = {2,2,2,1,1,1,2,2,2,2,2,2,2,2};
-
-
-/******************************************************************/
-/* */
-/* GLOBAL VARIABLES */
-/* */
-/*******************************************************************/
-
-/*
- * Set the size of the shared memory segment for the children
- * to put their results.
- */
-#define SHMSIZE ((( sizeof(struct child_stats) * MAXSTREAMS) )+4096 )
-/*
- * Pointer to the shared memory segment.
- */
-VOLATILE struct child_stats *shmaddr;
-double totaltime,total_time, temp_time ,total_kilos;
-off64_t report_array[MAX_X][MAX_Y];
-double report_darray[MAX_X][MAXSTREAMS];
-double time_res,cputime_res;
-long long throughput_array[MAX_X]; /* Filesize & record size are constants */
-short current_x, current_y;
-long long orig_size;
-long long max_x, max_y;
-unsigned long long goodkilos;
-off64_t kilobytes64 = (off64_t)KILOBYTES;
-long long goodrecl;
-off64_t offset = 0; /*offset for random I/O */
-off64_t offset64 = 0; /*offset for random I/O */
-off64_t filebytes64;
-off64_t r_range[100];
-off64_t s_range[100];
-int t_range[100];
-int t_count = 0;
-int r_count,s_count;
-char *barray[MAXSTREAMS];
-char *haveshm;
-extern int optind;
-long long onetime, auto_mode, sfd, multi_buffer;
-int fd;
-int sp_msfd,sp_mrfd,sp_csfd,sp_crfd;
-int begin_proc,num_processors,ioz_processor_bind;
-long long res_prob,rec_prob;
-char silent,read_sync;
-char master_iozone, client_iozone,distributed;
-int bif_fd,s_count;
-int bif_row,bif_column;
-int dedup_mseed = 1;
-int hist_summary;
-int op_rate;
-int op_rate_flag;
-char aflag, Eflag, hflag, Rflag, rflag, sflag;
-char diag_v,sent_stop,dedup,dedup_interior,dedup_compress;
-char *dedup_ibuf;
-char *dedup_temp;
-char bif_flag;
-int rlocking;
-int share_file;
-int ecount;
-char gflag,nflag;
-char yflag,qflag;
-#ifdef Windows
-char *build_name = "Windows";
-#else
-char *build_name = NAME;
-#endif
-char imon_start[256],imon_stop[256];
-char imon_sync;
-char trflag;
-char cpuutilflag;
-char seq_mix;
-long base_time;
-long long mint, maxt;
-long long w_traj_ops, r_traj_ops, w_traj_fsize,r_traj_fsize;
-long long r_traj_ops_completed,r_traj_bytes_completed;
-long long w_traj_ops_completed,w_traj_bytes_completed;
-int w_traj_items, r_traj_items;
-char fflag, Uflag,uflag,lflag,include_tflag;
-struct runtime runtimes [MAX_X] [MAX_Y]; /* in parallel with report_array[][] */
-long long include_test[50];
-long long include_mask;
-char RWONLYflag, NOCROSSflag; /*auto mode 2 - kcollins 8-21-96*/
-char mfflag;
-long long status, x, y, childids[MAXSTREAMS+1], myid, num_child;
-int pct_read,speed_code;
-#ifndef NO_THREADS
-pthread_t p_childids[MAXSTREAMS+1];
-#endif
-off64_t next64;
-char wol_opened, rol_opened;
-FILE *wqfd,*rwqfd,*rqfd,*rrqfd;
-
-extern char *optarg;
-#ifndef __AIX__
-long long ret;
-#else
-short ret;
-#endif
-struct size_entry {
- struct size_entry *next;
- off64_t size;
-};
-struct size_entry *size_list=0;
-struct size_entry *rec_size_list=0;
-off64_t maximum_file_size;
-off64_t minimum_file_size;
-
-char bif_filename [MAXNAMESIZE]; /* name of biff file */
-char filename [MAXNAMESIZE]; /* name of temporary file */
-char mountname [MAXNAMESIZE]; /* name of device */
-char dummyfile [MAXSTREAMS][MAXNAMESIZE]; /* name of dummy file */
-char dummyfile1 [MAXNAMESIZE]; /* name of dummy file */
-char *filearray[MAXSTREAMS]; /* array of file names */
-char tfile[] = "iozone";
-char *buffer,*buffer1, *mbuffer,*mainbuffer;
-FILE *pi,*r_traj_fd,*w_traj_fd;
-VOLATILE char *pbuffer;
-char *default_filename="iozone.tmp"; /*default name of temporary file*/
-VOLATILE char stoptime;
-char Cflag;
-char use_thread = 0;
-long long debug1=0;
-long long debug=0;
-unsigned long cache_size=CACHE_SIZE;
-unsigned long cache_line_size=CACHE_LINE_SIZE;
-long long *pstatus;
-off64_t min_file_size = KILOBYTES_START;
-off64_t max_file_size = KILOBYTES_END;
-long long min_rec_size = RECLEN_START;
-long long max_rec_size = RECLEN_END;
-long long orig_min_rec_size = RECLEN_START;
-long long orig_max_rec_size = RECLEN_END;
-long long xover = CROSSOVER;
-char *throughput_tests[] = {"Initial write","Rewrite","Read","Re-read",
- "Reverse Read","Stride read","Random read","Mixed workload","Random write","Pwrite","Pread","Fwrite","Fread"};
-char command_line[1024] = "\0";
-#ifdef unix
-double sc_clk_tck;
-#endif
-
-int argcsave;
-char **argvsave;
-char splash[80][80];
-int splash_line;
-char client_filename[256];
-char remote_shell[256];
-int client_error;
-
-char pit_hostname[40];
-char pit_service[8];
-int junk;
-
-/*
- * Host ports used to listen, and handle errors.
- */
-#define HOST_LIST_PORT 20000
-#define HOST_ESEND_PORT (HOST_LIST_PORT+MAXSTREAMS)
-#define HOST_ASEND_PORT (HOST_ESEND_PORT+MAXSTREAMS)
-int controlling_host_port = HOST_LIST_PORT;
-
-/*
- * Childs ports used to listen, and handle errors.
- */
-#define CHILD_ESEND_PORT (HOST_ASEND_PORT+MAXSTREAMS)
-#define CHILD_LIST_PORT (CHILD_ESEND_PORT+MAXSTREAMS)
-
-/* Childs async message port. Used for stop flag and terminate */
-#define CHILD_ALIST_PORT (CHILD_LIST_PORT+MAXSTREAMS)
-
-/* Ports for the network speed code */
-#define SP_CHILD_LISTEN_PORT 31000
-#define SP_CHILD_ESEND_PORT (SP_CHILD_LISTEN_PORT+10)
-#define SP_MASTER_LISTEN_PORT (SP_CHILD_ESEND_PORT+10)
-#define SP_MASTER_ESEND_PORT (SP_MASTER_LISTEN_PORT+10)
-#define SP_MASTER_RESULTS_PORT (SP_MASTER_ESEND_PORT+10)
-
-
-#define THREAD_WRITE_TEST 1
-#define THREAD_REWRITE_TEST 2
-#define THREAD_READ_TEST 3
-#define THREAD_REREAD_TEST 4
-#define THREAD_STRIDE_TEST 5
-#define THREAD_RANDOM_READ_TEST 6
-#define THREAD_RANDOM_WRITE_TEST 7
-#define THREAD_REVERSE_READ_TEST 8
-#define THREAD_RANDOM_MIX_TEST 9
-#define THREAD_PWRITE_TEST 10
-#define THREAD_PREAD_TEST 11
-#define THREAD_FWRITE_TEST 12
-#define THREAD_FREAD_TEST 13
-#define THREAD_CLEANUP_TEST 14
-
-/*
- * Child states that the master is tracking.
- * The master uses these to determine how to shutdown
- * the clients when some fool hits control-C.
- */
-#define C_STATE_ZERO 1
-#define C_STATE_WAIT_WHO 2
-#define C_STATE_WAIT_BARRIER 3
-
-
-int c_port,a_port; /* port number */
-int child_port; /* Virtualized due to fork */
-int child_async_port; /* Virtualized due to fork */
-int client_listen_pid; /* Virtualized due to fork */
-int master_join_count; /* How many children have joined */
-int l_sock,l_async_sock; /* Sockets for listening */
-char master_rcv_buf[4096]; /* Master's receive buffer */
-int master_listen_pid; /* Pid of the master's async listener proc */
-char master_send_buf[4096]; /* Master's send buffer */
-char child_rcv_buf[4096]; /* Child's receive buffer */
-char child_async_rcv_buf[4096]; /* Child's async recieve buffer */
-char child_send_buf[4096]; /* Child's send buffer */
-int child_send_socket; /* Child's send socket */
-int child_listen_socket; /* Child's listener socket */
-int child_listen_socket_async; /* Child's async listener socket */
-int master_send_socket; /* Needs to be an array. One for each child*/
-int master_send_sockets[MAXSTREAMS]; /* Needs to be an array. One for each child*/
-int master_send_async_sockets[MAXSTREAMS]; /* Needs to be an array. One for each child*/
-int master_listen_port; /* Master's listener port number */
-int master_listen_socket; /* Master's listener socket */
-int clients_found; /* Number of clients found in the client file */
-FILE *newstdin, *newstdout, *newstderr; /* used for debug in cluster mode.*/
-char toutput[20][20]; /* Used to help format the output */
-int toutputindex; /* Index to the current output line */
-int cdebug = 0; /* Use to turn on child/client debugging in cluster mode. */
-int mdebug = 0; /* Use to turn on master debug in cluster mode */
-int aggflag; /* Used to indicate constant aggregate data set size */
-struct sockaddr_in child_sync_sock, child_async_sock;
-
-/*
- * Change this whenever you change the message format of master or client.
- */
-int proto_version = 25;
-
-/******************************************************************************/
-/* Tele-port zone. These variables are updated on the clients when one is */
-/* using cluster mode. (-+m) */
-/* Do not touch these unless you have become one with the universe !! */
-/******************************************************************************/
-char controlling_host_name[100];
-struct child_ident {
- char child_name[100];
- char workdir[200];
- char execute_path[200];
- char file_name[200];
- int state;
- int child_number;
- int child_port;
- int child_async_port;
- int master_socket_num;
- int master_async_socket_num;
-}child_idents[MAXSTREAMS];
-int Kplus_readers;
-char write_traj_filename [MAXNAMESIZE]; /* name of write telemetry file */
-char read_traj_filename [MAXNAMESIZE]; /* name of read telemetry file */
-char oflag,jflag,k_flag,h_flag,mflag,pflag,unbuffered,Kplus_flag;
-char noretest;
-char notruncate; /* turn off truncation of files */
-char async_flag,stride_flag,mmapflag,mmapasflag,mmapssflag,mmapnsflag,mmap_mix;
-char verify = 1;
-int restf;
-char sverify = 1;
-char odsync = 0;
-char Q_flag,OPS_flag;
-char L_flag=0;
-char no_copy_flag,include_close,include_flush;
-char disrupt_flag,compute_flag,xflag,Z_flag, X_flag;
-int no_unlink = 0;
-int no_write = 0;
-int r_traj_flag,w_traj_flag;
-int mygen;
-char MS_flag;
-int advise_op,advise_flag;
-int direct_flag;
-int current_client_number;
-long long chid;
-int file_lock;
-unsigned int pattern;
-long long stride = STRIDE;
-long long delay,purge,fetchon;
-off64_t numrecs64 = (off64_t)NUMRECS;
-long long reclen = RECLEN;
-long long delay_start,depth;
-VOLATILE char *stop_flag; /* Used to stop all children */
-float compute_time;
-int multiplier = MULTIPLIER;
-long long rest_val;
-#if defined(Windows)
- HANDLE hand;
-#endif
-
-/******************************************************************************/
-/* End of Tele-port zone. */
-/******************************************************************************/
-
-
-/*
- * Prototypes
- * Sort of... Full prototypes break non-ansi C compilers. No protos is
- * a bit sloppy, so the compromise is this.
- */
-void child_send();
-int start_child_listen();
-int start_child_listen_async();
-void start_child_listen_loop();
-void child_listen();
-void child_listen_async();
-void stop_child_send();
-void stop_child_listen();
-void cleanup_comm();
-void master_send();
-int start_master_send();
-int start_master_listen();
-int check_filename();
-void master_listen();
-void stop_master_send();
-void stop_master_listen();
-long long start_child_proc();
-int parse_client_line();
-void wait_dist_join();
-void tell_children_begin();
-void start_master_listen_loop();
-void wait_for_master_go();
-void tell_master_ready();
-void stop_master_listen_loop();
-void tell_master_stats();
-void become_client();
-int pick_client();
-long long start_child_proc();
-int start_master_send();
-void child_listen();
-int start_child_listen();
-void stop_master_send();
-void stop_master_listen();
-void stop_child_send();
-void stop_child_listen();
-void master_send();
-void child_send();
-void master_listen();
-int start_master_listen();
-void child_remove_files();
-void terminate_child_async();
-void distribute_stop();
-void send_stop();
-void cleanup_children();
-
-
-/****************************************************************/
-/* */
-/* MAIN () */
-/* */
-/****************************************************************/
-
-int
-main(argc,argv)
-int argc;
-char **argv;
-{
-
- long long fileindx,i,tval;
- long long ind;
- int ret;
- FILE *pi;
- char reply[IBUFSIZE];
- unsigned char inp_pat;
- time_t time_run;
- char *port,*m,*subarg;
- int num_child1;
- int cret;
- int anwser,bind_cpu;
- char *evalue;
-
-
- anwser=bind_cpu=0;
- /* Used to make fread/fwrite do something better than their defaults */
- setvbuf( stdout, NULL, _IONBF, (size_t) NULL );
- setvbuf( stderr, NULL, _IONBF, (size_t) NULL );
-
- /* Save the master's name */
- gethostname(controlling_host_name,100);
-
- /* Let user activate mdebug or cdebug via environmental variables */
- evalue = (char *)NULL;
- evalue=(char *)getenv("CDEBUG");
- if(evalue)
- cdebug=atoi(evalue);
- evalue = (char *)NULL;
- evalue=(char *)getenv("MDEBUG");
- if(evalue)
- mdebug=atoi(evalue);
-
- srand(time(0));
- mygen=rand(); /* Pick a random generation number */
-
- /* Try to find the actual VM page size, if possible */
-#if defined (solaris) || defined (_HPUX_SOURCE) || defined (linux) || defined(IRIX) || defined (IRIX64)
-#ifndef __convex_spp
- page_size=getpagesize();
-#endif
-#endif
- /* Try to find the actual number of ticks per second */
-#ifdef unix
- sc_clk_tck = clk_tck();
-#endif
- for(ind=0;ind<MAXSTREAMS;ind++)
- filearray[ind]=(char *)tfile;
-
- /* base_time=(long)time_so_far(); */
- myid=(long long)getpid(); /* save the master's PID */
- /* get_resolution(); Get clock resolution */
- time_run = time(0); /* Start a timer */
- (void)find_external_mon(imon_start, imon_stop);
-
- /*
- * Save the splash screen for later display. When in distributed network
- * mode this output does not get displayed on the clients.
- */
- sprintf(splash[splash_line++],"\tIozone: Performance Test of File I/O\n");
- sprintf(splash[splash_line++],"\t%s\n\t%s\n", THISVERSION,MODE);
- sprintf(splash[splash_line++],"\t\tBuild: %s \n\n",build_name);
- sprintf(splash[splash_line++],"\tContributors:William Norcott, Don Capps, Isom Crawford, Kirby Collins\n");
- sprintf(splash[splash_line++],"\t Al Slater, Scott Rhine, Mike Wisner, Ken Goss\n");
- sprintf(splash[splash_line++],"\t Steve Landherr, Brad Smith, Mark Kelly, Dr. Alain CYR,\n");
- sprintf(splash[splash_line++],"\t Randy Dunlap, Mark Montague, Dan Million, Gavin Brebner,\n");
- sprintf(splash[splash_line++],"\t Jean-Marc Zucconi, Jeff Blomberg, Benny Halevy, Dave Boone,\n");
- sprintf(splash[splash_line++],"\t Erik Habbinga, Kris Strecker, Walter Wong, Joshua Root,\n");
- sprintf(splash[splash_line++],"\t Fabrice Bacchella, Zhenghua Xue, Qin Li, Darren Sawyer.\n");
- sprintf(splash[splash_line++],"\t Ben England.\n\n");
- sprintf(splash[splash_line++],"\tRun began: %s\n",ctime(&time_run));
- argcsave=argc;
- argvsave=argv;
-
- signal(SIGINT, signal_handler); /* handle user interrupt */
- signal(SIGTERM, signal_handler); /* handle kill from shell */
-
- /********************************************************/
- /* Allocate and align buffer with beginning of the */
- /* on chip data cache. */
- /********************************************************/
-
- buffer = (char *) alloc_mem((long long)(MAXBUFFERSIZE + (2 * cache_size)),(int)0);
- if(buffer == 0) {
- perror("Memory allocation failed:");
- exit(1);
- }
-
-#ifdef _64BIT_ARCH_
- buffer = (char *) ((long long )(buffer + cache_size ) &
- ~(cache_size-1));
-#else
- buffer = (char *) ((long)(buffer + cache_size ) &
- ~((long)cache_size-1));
-#endif
- mainbuffer = buffer;
-
- /* de-dup input buf */
- buffer1 = (char *) alloc_mem((long long)(MAXBUFFERSIZE + (2 * cache_size)),(int)0);
- if(buffer1 == 0) {
- perror("Memory allocation failed:");
- exit(1);
- }
-
-#ifdef _64BIT_ARCH_
- buffer1 = (char *) ((long long )(buffer1 + cache_size ) &
- ~(cache_size-1));
-#else
- buffer1 = (char *) ((long)(buffer1 + cache_size ) &
- ~((long)cache_size-1));
-#endif
- dedup_ibuf = buffer1;
- touch_dedup(buffer1, MAXBUFFERSIZE);
-
-#ifdef FOOB
- /* de-dup temp buf */
- buffer1 = (char *) alloc_mem((long long)(MAXBUFFERSIZE + (2 * cache_size)),(int)0);
- if(buffer1 == 0) {
- perror("Memory allocation failed:");
- exit(1);
- }
-
-#ifdef _64BIT_ARCH_
- buffer1 = (char *) ((long long )(buffer1 + cache_size ) &
- ~(cache_size-1));
-#else
- buffer1 = (char *) ((long)(buffer1 + cache_size ) &
- ~((long)cache_size-1));
-#endif
-#endif
- dedup_temp = mainbuffer;
-
- fetchon++; /* By default, prefetch the CPU cache lines associated with the buffer */
- strcpy(filename,default_filename); /* Init default filename */
- sprintf(dummyfile[0],"%s.DUMMY",default_filename);
- if(argc <=1){
- printf(USAGE);
- exit(255);
- }
- auto_mode = 0; /* Default is to disable auto mode */
- inp_pat = PATTERN; /* Init default pattern for verification */
- /* Fill the entire pattern variable with the same character */
- pattern = ((inp_pat << 24) | (inp_pat << 16) | (inp_pat << 8) | inp_pat);
-
- /*
- * Parse all of the options that the user specified.
- */
- while((cret = getopt(argc,argv,"ZQNIBDGCTOMREWovAxamwphcezKJ:j:k:V:r:t:s:f:F:d:l:u:U:S:L:H:+:P:i:b:X:Y:g:n:y:q: ")) != EOF){
- switch(cret){
- case 'k': /* Async I/O with no bcopys */
- depth = (long long)(atoi(optarg));
- if(depth <0)
- depth=0;
- /*
- if(depth > 60)
- depth=60;
- */
-#ifdef NO_PRINT_LLD
- sprintf(splash[splash_line++],"\tPOSIX Async I/O (no bcopy). Depth %ld \n",depth);
-#else
- sprintf(splash[splash_line++],"\tPOSIX Async I/O (no bcopy). Depth %lld \n",depth);
-#endif
- no_copy_flag=1;
- async_flag++;
- k_flag++;
- break;
- case 'T': /* Switch to POSIX thread based */
-#ifndef NO_THREADS
- use_thread++;
-#else
- printf("\tThreads not supported in this version\n");
- exit(2);
-#endif
- break;
- case 'H': /* Use POSIX async_io */
- h_flag++;
- depth = (long long)(atoi(optarg));
- if(depth <0)
- depth=0;
- /*
- * Hmmm. many systems fail is strange ways when the maximum
- * number of async I/Os per user or proc is exceeded.
- */
- /*
- if(depth > 60)
- depth=60;
- */
-#ifdef NO_PRINT_LLD
- sprintf(splash[splash_line++],"\tPOSIX async I/O (with bcopy). Depth %ld\n",depth);
-#else
- sprintf(splash[splash_line++],"\tPOSIX async I/O (with bcopy). Depth %lld\n",depth);
-#endif
- async_flag++;
- break;
- case 'I': /* Use VXFS direct advisory or O_DIRECT from Linux or AIX , or O_DIRECTIO for TRU64 or Solaris directio */
-#ifdef VXFS
- direct_flag++;
- sprintf(splash[splash_line++],"\tVxFS advanced feature SET_CACHE, VX_DIRECT enabled\n");
- break;
-#endif
-#if ! defined(DONT_HAVE_O_DIRECT)
-#if defined(linux) || defined(__AIX__) || defined(IRIX) || defined(IRIX64) || defined(Windows) || defined(__FreeBSD__) || defined(solaris)
- direct_flag++;
- sprintf(splash[splash_line++],"\tO_DIRECT feature enabled\n");
- break;
-#endif
-#if defined(TRU64)
- direct_flag++;
- sprintf(splash[splash_line++],"\tO_DIRECTIO feature enabled\n");
- break;
-#endif
-#else
- break;
-#endif
-#if defined(Windows)
- sprintf(splash[splash_line++],"\tO_DIRECTIO feature not available in Windows version.\n");
- break;
-#endif
- case 'B': /* Use mmap file for test file */
- sprintf(splash[splash_line++],"\tUsing mmap files\n");
- mmapflag++;
- mmapnsflag++;
- break;
- case 'D': /* Use async msync mmap file */
- sprintf(splash[splash_line++],"\tUsing msync(MS_ASYNC) on mmap files\n");
- mmapflag++;
- mmapasflag++;
- mmapnsflag=0;
- break;
- case 'G': /* Use msync sync for mmap file */
- sprintf(splash[splash_line++],"\tUsing msync(MS_SYNC) on mmap files\n");
- mmapssflag++;
- mmapnsflag=0;
- break;
- case 'C': /* show children xfer counts */
- Cflag++;
- break;
- case 'Q': /* Enable output offset/latency files */
- sprintf(splash[splash_line++],"\tOffset/latency files enabled.\n");
- Q_flag++;
- break;
- case 'x': /* Disable stone_wall */
- sprintf(splash[splash_line++],"\tStonewall disabled\n");
- xflag++;
- break;
-
- case 'a': /* auto mode */
- fetchon=1;
- purge=0;
- multi_buffer=0;
- auto_mode = 1;
- aflag++;
- sprintf(splash[splash_line++],"\tAuto Mode\n");
- break;
- case 'c': /* Include close in timing */
- include_close++;
- sprintf(splash[splash_line++],"\tInclude close in write timing\n");
- break;
- case 'e': /* Include fsync in timing */
- include_flush++;
- sprintf(splash[splash_line++],"\tInclude fsync in write timing\n");
- break;
- case 'A': /* auto2 mode. Soon to go away. Please use -az */
- fetchon=1;
- purge=0;
- multi_buffer=0;
- auto_mode = 1;
- aflag++;
- sprintf(splash[splash_line++],"\tAuto Mode 2. This option is obsolete. Use -az -i0 -i1 \n");
- RWONLYflag++;
- NOCROSSflag++;
- include_tflag++; /* automatically set WRITER_TEST and READER_TEST */
- include_test[WRITER_TEST]++;
- include_test[READER_TEST]++;
- break;
- case 's': /* Set file size */
-#ifdef NO_PRINT_LLD
- sscanf(optarg,"%ld",&kilobytes64);
-#else
- sscanf(optarg,"%lld",&kilobytes64);
-#endif
- if(optarg[strlen(optarg)-1]=='k' ||
- optarg[strlen(optarg)-1]=='K'){
- ;
- }
- if(optarg[strlen(optarg)-1]=='m' ||
- optarg[strlen(optarg)-1]=='M'){
- kilobytes64 = kilobytes64 * 1024;
- }
- if(optarg[strlen(optarg)-1]=='g' ||
- optarg[strlen(optarg)-1]=='G'){
- kilobytes64 = kilobytes64 *1024 * 1024;
- }
- if(kilobytes64 <= 0)
- kilobytes64=512;
-
- s_range[s_count++]=kilobytes64;
- max_file_size = (off64_t)s_range[s_count-1]; /* Make visable globally */
- min_file_size = (off64_t)s_range[0]; /* Make visable globally */
-
-#ifdef NO_PRINT_LLD
- sprintf(splash[splash_line++],"\tFile size set to %ld KB\n",kilobytes64);
-#else
- sprintf(splash[splash_line++],"\tFile size set to %lld KB\n",kilobytes64);
-#endif
- sflag++;
- break;
- case 'l': /* Set lower thread/proc limit */
- mint = (long long)(atoi(optarg));
- if(mint <= 0)
- {
- mint=1;
- num_child=1;
- }else
- num_child=mint;
- if(mint > (unsigned long long)MAXSTREAMS){
- printf("Invalid options: maximum streams for ");
- printf("throughput is MAXSTREAMS\n");
- exit(4);
- }
- lflag++;
- trflag++;
- if(Uflag)
- {
- printf("Can not run throughput tests with unmount & remounts.\n");
- exit(5);
- }
- break;
- case 'u': /* Set upper thread/proc limit */
- maxt = (long long)(atoi(optarg));
- if(maxt <= 0)
- maxt=1;
- if(maxt > MAXSTREAMS){
- printf("Invalid options: maximum streams for ");
- printf("throughput is MAXSTREAMS\n");
- exit(6);
- }
- uflag++;
- trflag++;
- if(Uflag)
- {
- printf("Can not run throughput tests with unmount & remounts.\n");
- exit(7);
- }
- break;
- case 'm': /* Use multiple buffers */
- fetchon=0;
- multi_buffer=1;
- mflag++;
- mbuffer = (char *) alloc_mem((long long)MAXBUFFERSIZE,(int)0);
- if(mbuffer == 0) {
- perror("Memory allocation failed:");
- exit(8);
- }
- sprintf(splash[splash_line++],"\tMulti_buffer. Work area %d bytes\n",
- MAXBUFFERSIZE);
- break;
- case 'M': /* Report machine name and OS */
- bzero(reply,sizeof(reply));
- pi=popen("uname -a", "r");
- if(pi == (FILE *)0)
- {
- sprintf(splash[splash_line++],"\n\tError using popen() on uname\n");
- sprintf(splash[splash_line++],"\t-M option suppressed.\n");
- }
- else
- {
- junk=fread(reply,IBUFSIZE-1,1,pi);
- pclose(pi);
- m=reply;
- while(*m) /* Strip new line */
- {
- if(*m=='\n')
- *m=0;
- else
- m++;
- }
- sprintf(splash[splash_line++],"\n\tMachine = %s\n",reply);
- }
- break;
-
- case 'P': /* Set beginning processor for binding. */
-#ifndef NO_THREADS
-#if defined(_HPUX_SOURCE) || defined(linux)
-#if defined(_HPUX_SOURCE)
- num_processors= pthread_num_processors_np();
-#else
- num_processors = sysconf(_SC_NPROCESSORS_ONLN);
-#endif
- begin_proc = atoi(optarg);
- if(begin_proc < 0)
- begin_proc=0;
- if(begin_proc > num_processors)
- begin_proc=0;
- sprintf(splash[splash_line++],"\tBinding of processors beginning with %d \n",begin_proc);
- ioz_processor_bind++;
-#else
- sprintf(splash[splash_line++],"\tProcessor binding not available in this version\n");
-#endif
-#endif
- break;
- case 'p': /* purge the processor cache */
- sprintf(splash[splash_line++],"\tPurge Mode On\n");
- fetchon=0;
- pflag++;
- purge=1;
- break;
- case 'h': /* show help */
- hflag++;
- show_help();
- exit(0);
- break;
- case 'E': /* Extended testing for pread/pwrite... */
- Eflag++;
- break;
- case 'R': /* Generate Excel compatible Report */
- Rflag++;
- sprintf(splash[splash_line++],"\tExcel chart generation enabled\n");
- break;
- case 'o': /* Open OSYNC */
- sprintf(splash[splash_line++],"\tSYNC Mode. \n");
- oflag++;
- break;
- case 'O': /* Report in Ops/sec instead of KB/sec */
- sprintf(splash[splash_line++],"\tOPS Mode. Output is in operations per second.\n");
- OPS_flag++;
- break;
- case 'N': /* Report in usec/op */
- sprintf(splash[splash_line++],"\tMicroseconds/op Mode. Output is in microseconds per operation.\n");
- MS_flag++;
- break;
- case 'V': /* Turn on Verify every byte */
- sverify=0;
- inp_pat = (char)(atoi(optarg));
- if(inp_pat == 0)
- inp_pat = PATTERN;
- pattern = ((inp_pat << 24) | (inp_pat << 16) | (inp_pat << 8)
- | inp_pat);
- verify=1;
- sprintf(splash[splash_line++],"\tVerify Mode. Pattern %x\n",pattern);
- sprintf(splash[splash_line++],"\tPerformance measurements are invalid in this mode.\n");
- break;
- case 'S': /* Set the processor cache size */
- cache_size = (long)(atoi(optarg)*1024);
- if(cache_size == 0)
- cache_size = CACHE_SIZE;
- break;
- case 'L': /* Set processor cache line size */
- cache_line_size = (long)(atoi(optarg));
- if(cache_line_size == 0)
- cache_line_size = CACHE_LINE_SIZE;
- break;
- case 'f': /* Specify the file name */
- if(mfflag) {
- printf("invalid options: -f and -F are mutually exclusive\n");
- exit(10);
- }
- fflag++;
- strcpy(filename,optarg);
- sprintf(dummyfile[0],"%s.DUMMY",optarg);
- break;
- case 'b': /* Specify the biff file name */
- Rflag++;
- bif_flag++;
- strcpy(bif_filename,optarg);
- break;
- case 'F': /* Specify multiple file names for -t */
- mfflag++;
- if(fflag) {
- printf("invalid options: -f and -F are mutually exclusive\n");
- exit(11);
- }
- if(!trflag) {
- printf("invalid options: must specify -t N before -F\n");
- exit(12);
- }
- optind--;
- for(fileindx=0;fileindx<maxt;fileindx++) {
- filearray[fileindx]=argv[optind++];
- if(optind > argc) {
-#ifdef NO_PRINT_LLD
- printf("invalid options: not enough filenames for %ld streams\n",num_child);
-#else
- printf("invalid options: not enough filenames for %lld streams\n",num_child);
-#endif
- exit(13);
- }
- }
- break;
- case 'r': /* Specify the record size to use */
- rflag++;
- reclen = ((long long)(atoi(optarg))*1024);
- if(optarg[strlen(optarg)-1]=='k' ||
- optarg[strlen(optarg)-1]=='K'){
- reclen = (long long)(1024 * atoi(optarg));
- }
- if(optarg[strlen(optarg)-1]=='m' ||
- optarg[strlen(optarg)-1]=='M'){
- reclen = (long long)(1024 * 1024 * atoi(optarg));
- }
- if(optarg[strlen(optarg)-1]=='g' ||
- optarg[strlen(optarg)-1]=='G'){
- reclen = (long long)(1024 * 1024 * 1024 *(long long)atoi(optarg));
- }
- if(reclen <= 0)
- reclen=(long long)4096;
-
- r_range[r_count++]=reclen;
- max_rec_size = (off64_t)r_range[r_count-1]; /* Make visable globally */
- min_rec_size = (off64_t)r_range[0]; /* Make visable globally */
-#ifdef NO_PRINT_LLD
- sprintf(splash[splash_line++],"\tRecord Size %ld KB\n",reclen/1024);
-#else
- sprintf(splash[splash_line++],"\tRecord Size %lld KB\n",reclen/1024);
-#endif
- if(max_rec_size > MAXBUFFERSIZE) {
-#ifdef NO_PRINT_LLD
- printf("Error: maximum record size %ld KB is greater than maximum buffer size %ld KB\n ",
- max_rec_size/1024, MAXBUFFERSIZE/1024);
-#else
- printf("Error: maximum record size %lld KB is greater than maximum buffer size %lld KB\n ",
- (long long)(max_rec_size/1024LL), (long long)MAXBUFFERSIZE/1024LL);
-#endif
- exit(23);
- }
- break;
- case 'J': /* Specify the compute time in millisecs */
- compute_time = (float)(atoi(optarg));
- compute_time=compute_time/1000;
- if(compute_time < (float)0)
- compute_time=(float)0;
- else
- compute_flag=1;
- jflag++;
- break;
- case 'j': /* Specify the stride in records */
- stride = (long long)(atoi(optarg));
- if(stride < 0)
- stride=0;
- stride_flag=1;
- break;
- case 't': /* Specify the number of children to run */
- num_child1=(atoi(optarg));
- num_child = (long long)num_child1;
- if(num_child > (long long)MAXSTREAMS) {
- printf("invalid options: maximum streams for throughput is MAXSTREAMS\n");
-#ifdef NO_PRINT_LLD
- printf("Numchild %ld %s\n",num_child,optarg);
-#else
- printf("Numchild %lld %s\n",num_child,optarg);
-#endif
- exit(14);
- }
- if(num_child <= 0)
- num_child = 8;
- if(num_child == 0)
- num_child=1;
- t_range[t_count++]=num_child;
- maxt = (maxt>num_child?maxt:num_child);
- trflag++;
- if(Uflag)
- {
- printf("Can not run throughput tests with unmount & remounts.\n");
- exit(15);
- }
- break;
- case 'd': /* Specify the delay of children to run */
- delay_start = (long long)(atoi(optarg));
- if(delay_start < 0)
- delay_start=0;
- break;
- case 'i': /* Specify specific tests */
- tval=(long long)(atoi(optarg));
- if(tval < 0) tval=0;
-#ifndef HAVE_PREAD
- if(tval > RANDOM_MIX_TEST)
- {
- printf("\tPread tests not available on this operating system.\n");
- exit(183);
- }
-#endif
- if(tval > sizeof(func)/sizeof(char *))
- {
- tval=0;
- sprintf(splash[splash_line++],"\tSelected test not available on the version.\n");
- }
- include_test[tval]++;
- include_tflag++;
- break;
- case 'v': /* Show version information */
- for(ind=0; strlen(head1[ind]); ind++)
- {
- printf("%s\n", head1[ind]);
- }
- exit(0);
- break;
- case 'U': /* Specify the dev name for umount/mount*/
- Uflag++;
- strcpy(mountname,optarg);
- if(trflag)
- {
- printf("Can not run throughput tests with unmount & remounts.\n");
- exit(16);
- }
- break;
- case 'w': /* Do not unlink files */
- sprintf(splash[splash_line++],"\tSetting no_unlink\n");
- no_unlink = 1;
- break;
- case 'Z': /* Turn on the mmap and file I/O mixing */
- sprintf(splash[splash_line++],"\tEnable mmap & file I/O mixing.\n");
- mmap_mix = 1;
- break;
- case 'W': /* Read/Write with file locked */
- file_lock=1;
- sprintf(splash[splash_line++],"\tLock file when reading/writing.\n");
- break;
- case 'K': /* Cause disrupted read pattern */
- disrupt_flag=1;
- sprintf(splash[splash_line++],"\tDisrupted read patterns selected.\n");
- break;
- case 'X': /* Open write telemetry file */
- compute_flag=1;
- sverify=2; /* touch lightly */
- w_traj_flag=1;
- strcpy(write_traj_filename,optarg);
- traj_vers();
- w_traj_size();
- sprintf(splash[splash_line++],"\tUsing write telemetry file \"%s\"\n",
- write_traj_filename);
- w_traj_fd=open_w_traj();
- if(w_traj_fd == (FILE *)0)
- exit(200);
- break;
- case 'Y': /* Open Read telemetry file */
- compute_flag=1;
- sverify=2; /* touch lightly */
- r_traj_flag=1;
- strcpy(read_traj_filename,optarg);
- sprintf(splash[splash_line++],"\tUsing read telemetry file \"%s\"\n",
- read_traj_filename);
- traj_vers();
- r_traj_size();
- r_traj_fd=open_r_traj();
- if(r_traj_fd == (FILE*) 0)
- exit(200);
- break;
- case 'n': /* Set min file size for auto mode */
- nflag=1;
- minimum_file_size = (off64_t)atoi(optarg);
- if(optarg[strlen(optarg)-1]=='k' ||
- optarg[strlen(optarg)-1]=='K'){
- ;
- }
- if(optarg[strlen(optarg)-1]=='m' ||
- optarg[strlen(optarg)-1]=='M'){
- minimum_file_size = (long long)(1024 * atoi(optarg));
- }
- if(optarg[strlen(optarg)-1]=='g' ||
- optarg[strlen(optarg)-1]=='G'){
- minimum_file_size = (long long)(1024 * 1024 * (long long)atoi(optarg));
- }
- if(minimum_file_size < RECLEN_START/1024)
- minimum_file_size=(off64_t)(RECLEN_START/1024);
- if(minimum_file_size < page_size/1024)
- minimum_file_size=(off64_t)(page_size/1024);
-#ifdef NO_PRINT_LLD
- sprintf(splash[splash_line++],"\tUsing minimum file size of %ld kilobytes.\n",minimum_file_size);
-#else
- sprintf(splash[splash_line++],"\tUsing minimum file size of %lld kilobytes.\n",minimum_file_size);
-#endif
- break;
- case 'g': /* Set maximum file size for auto mode */
- gflag=1;
- maximum_file_size = (off64_t)atoi(optarg);
- if(optarg[strlen(optarg)-1]=='k' ||
- optarg[strlen(optarg)-1]=='K'){
- ;
- }
- if(optarg[strlen(optarg)-1]=='m' ||
- optarg[strlen(optarg)-1]=='M'){
- maximum_file_size = (long long)(1024 * atoi(optarg));
- }
- if(optarg[strlen(optarg)-1]=='g' ||
- optarg[strlen(optarg)-1]=='G'){
- maximum_file_size = (long long)(1024 * 1024 * (long long)atoi(optarg));
- }
- if(maximum_file_size < RECLEN_START/1024)
- maximum_file_size=(off64_t)(RECLEN_START/1024);
-#ifdef NO_PRINT_LLD
- sprintf(splash[splash_line++],"\tUsing maximum file size of %ld kilobytes.\n",maximum_file_size);
-#else
- sprintf(splash[splash_line++],"\tUsing maximum file size of %lld kilobytes.\n",maximum_file_size);
-#endif
- break;
- case 'z': /* Set no cross over */
- sprintf(splash[splash_line++],"\tCross over of record size disabled.\n");
- NOCROSSflag=1;
- break;
- case 'y': /* Set min record size for auto mode */
- yflag=1;
- min_rec_size = ((long long)(atoi(optarg))*1024);
- if(optarg[strlen(optarg)-1]=='k' ||
- optarg[strlen(optarg)-1]=='K'){
- min_rec_size = (long long)(1024 * atoi(optarg));
- }
- if(optarg[strlen(optarg)-1]=='m' ||
- optarg[strlen(optarg)-1]=='M'){
- min_rec_size = (long long)(1024 * 1024 * atoi(optarg));
- }
- if(optarg[strlen(optarg)-1]=='g' ||
- optarg[strlen(optarg)-1]=='G'){
- min_rec_size = (long long)(1024 * 1024 * 1024 *(long long)atoi(optarg));
- }
- if(min_rec_size <= 0)
- min_rec_size=(long long)RECLEN_START;
-#ifdef NO_PRINT_LLD
- sprintf(splash[splash_line++],"\tUsing Minimum Record Size %ld KB\n", min_rec_size/1024);
-#else
- sprintf(splash[splash_line++],"\tUsing Minimum Record Size %lld KB\n", min_rec_size/1024);
-#endif
- break;
- case 'q': /* Set max record size for auto mode */
- qflag=1;
- max_rec_size = ((long long)(atoi(optarg))*1024);
- if(optarg[strlen(optarg)-1]=='k' ||
- optarg[strlen(optarg)-1]=='K'){
- max_rec_size = (long long)(1024 * atoi(optarg));
- }
- if(optarg[strlen(optarg)-1]=='m' ||
- optarg[strlen(optarg)-1]=='M'){
- max_rec_size = (long long)(1024 * 1024 * atoi(optarg));
- }
- if(optarg[strlen(optarg)-1]=='g' ||
- optarg[strlen(optarg)-1]=='G'){
- max_rec_size = (long long)(1024 * 1024 * 1024 *(long long)atoi(optarg));
- }
- if(max_rec_size <= 0)
- min_rec_size=(long long)RECLEN_END;
- if(max_rec_size > MAXBUFFERSIZE) {
-#ifdef NO_PRINT_LLD
- printf("Error: maximum record size %ld KB is greater than maximum buffer size %ld KB\n ",
- max_rec_size/1024, MAXBUFFERSIZE/1024);
-#else
- printf("Error: maximum record size %lld KB is greater than maximum buffer size %lld KB\n ",
- (long long)(max_rec_size/1024LL), (long long)MAXBUFFERSIZE/1024LL);
-#endif
- exit(23);
- }
-#ifdef NO_PRINT_LLD
- sprintf(splash[splash_line++],"\tUsing Maximum Record Size %ld KB\n", max_rec_size/1024);
-#else
- sprintf(splash[splash_line++],"\tUsing Maximum Record Size %lld KB\n", max_rec_size/1024);
-#endif
- break;
-
- /*
- * The + operator is for the new extended options mechanism
- * Syntax is -+ followed by option leter, and if the optino
- * takes an operand then it is implemented below. An example
- * -+a arg is shown below. This is a sub option with an argument.
- * -+b is shown below. This is a sub option with no argument.
- */
- case '+':
- /* printf("Plus option = >%s<\n",optarg);*/
- switch (*((char *)optarg))
- {
- case 'a': /* Example: Has argument */
- subarg=argv[optind++];
- /* if(subarg!=(char *)0) Error checking. */
- /* printf("Plus option argument = >%s<\n",subarg);*/
- break;
- case 'b': /* Example: Does not have an argument */
- break;
- case 'c': /* Argument is the controlling host name */
- /* I am a client for distributed Iozone */
- subarg=argv[optind++];
- if(subarg==(char *)0)
- {
- printf("-+c takes an operand !!\n");
- exit(200);
- }
- strcpy(controlling_host_name,subarg);
- distributed=1;
- client_iozone=1;
- master_iozone=0;
- break;
- case 'h': /* Argument is the controlling host name */
- subarg=argv[optind++];
- if(subarg==(char *)0)
- {
- printf("-+h takes an operand !!\n");
- exit(200);
- }
- strcpy(controlling_host_name,subarg);
- sprintf(splash[splash_line++],"\tHostname = %s\n",controlling_host_name);
- break;
- case 'm': /* I am the controlling process for distributed Iozone */
- /* Does not have an argument */
- subarg=argv[optind++];
- if(subarg==(char *)0)
- {
- printf("-+m takes an operand. ( filename )\n");
- exit(201);
- }
- strcpy(client_filename,subarg);
- ret=get_client_info();
- if(ret <= 0)
- {
- printf("Error reading client file\n");
- exit(178);
- }
- clients_found=ret;
- distributed=1;
- master_iozone=1;
- client_iozone=0;
- sprintf(splash[splash_line++],"\tNetwork distribution mode enabled.\n");
- break;
- case 'N': /* turn off truncating the file before write test */
- notruncate = 1;
- break;
- case 'u': /* Set CPU utilization output flag */
- cpuutilflag = 1; /* only used if R(eport) flag is also set */
- get_rusage_resolution();
- sprintf(splash[splash_line++],"\tCPU utilization Resolution = %5.3f seconds.\n",cputime_res);
- sprintf(splash[splash_line++],"\tCPU utilization Excel chart enabled\n");
- break;
- case 's': /* Clients operate in silent mode. */
- /* Does not have an argument */
- silent=1;
- break;
- case 'd': /* Diagnostics mode */
- sprintf(splash[splash_line++],"\t>>> I/O Diagnostic mode enabled. <<<\n");
- sprintf(splash[splash_line++],"\tPerformance measurements are invalid in this mode.\n");
- diag_v=1;
- sverify=0;
- break;
- case 'x': /* Argument is the multiplier for rec size and file size */
- subarg=argv[optind++];
- if(subarg==(char *)0)
- {
- printf("-+c takes an operand !!\n");
- exit(200);
- }
- multiplier = atoi(subarg);
- if(multiplier <=1)
- multiplier = 2;
- break;
- case 'i': /* Argument is the host port */
- subarg=argv[optind++];
- if(subarg==(char *)0)
- {
- printf("-+i takes an operand !!\n");
- exit(200);
- }
- controlling_host_port = atoi(subarg);
- break;
- case 'p': /* Argument is the percentage read */
- subarg=argv[optind++];
- if(subarg==(char *)0)
- {
- printf("-+p takes an operand !!\n");
- exit(200);
- }
- pct_read = atoi(subarg);
- if(pct_read < 1)
- pct_read = 1;
- if(pct_read >=100)
- pct_read = 100;
- sprintf(splash[splash_line++],"\tPercent read in mix test is %d\n",pct_read);
- break;
- case 't': /* Speed code activated */
- speed_code=1;
- break;
-#if defined(_HPUX_SOURCE) || defined(linux) || defined(solaris)
- case 'r': /* Read sync too */
- read_sync=1;
- sprintf(splash[splash_line++],"\tRead & Write sync mode active.\n");
- break;
-#endif
-#ifndef NO_MADVISE
- case 'A': /* Argument is madvise selector */
- subarg=argv[optind++];
- if(subarg==(char *)0)
- {
- printf("-+A take an operand !!\n");
- exit(200);
- }
- advise_flag=1;
- advise_op=atoi(subarg);
- sprintf(splash[splash_line++],"\tMadvise enabled: %d\n",advise_op);
- break;
-#endif
- case 'n': /* Set no-retest */
- noretest = 1;
- sprintf(splash[splash_line++],"\tNo retest option selected\n");
- break;
- case 'k': /* Constant aggregate data set size */
- aggflag=1;
- break;
- case 'q': /* Argument is the rest time between tests in seconds */
- subarg=argv[optind++];
- if(subarg==(char *)0)
- {
- printf("-+q takes an operand !!\n");
- exit(200);
- }
- rest_val = (long long)atoi(subarg);
- if(rest_val <=0)
- rest_val = 0;
- restf=1;
- sprintf(splash[splash_line++],"\tDelay %d seconds between tests enabled.\n",atoi(subarg));
- break;
-#if defined(O_DSYNC)
- case 'D': /* O_DSYNC mode */
- sprintf(splash[splash_line++],"\t>>> O_DSYNC mode enabled. <<<\n");
- odsync=1;
- break;
-#endif
- case 'l': /* Record locking mode */
- sprintf(splash[splash_line++],"\t>>> Record locking mode enabled. <<<\n");
- rlocking=1;
- break;
- case 'L': /* Record locking mode shared files*/
- sprintf(splash[splash_line++],"\t>>> Record locking, shared file mode enabled. <<<\n");
- share_file=1;
- rlocking=1;
- break;
- case 'V': /* No Record locking shared files*/
- sprintf(splash[splash_line++],"\t>>> Shared file mode enabled. <<<\n");
- share_file=1;
- break;
- case 'B': /* Sequential mix */
- sprintf(splash[splash_line++],"\t>>> Sequential Mixed workload. <<<\n");
- seq_mix=1;
- break;
- /* Use an existing user file, that does
- not contain Iozone's pattern. Use file
- for testing, but read only, and no
- delete at the end of the test. Also,
- no pattern verification, but do touch
- the pages. */
- case 'E':
- sprintf(splash[splash_line++],"\t>>> No Verify mode. <<<\n");
- sverify=2;
- no_unlink=1;
- no_write=1;
- break;
- case 'T': /* Time stamps on */
- L_flag=1;
- break;
- case 'X': /* Short circuit test mode */
- X_flag = 1;
- sverify=1;
- verify=1;
- inp_pat = 0xBB;
- pattern = ((inp_pat << 24) |
- (inp_pat << 16) | (inp_pat << 8) |
- inp_pat);
- sprintf(splash[splash_line++],"\tShort circuit mode. For\n");
- sprintf(splash[splash_line++],"\t filesystem development testing ONLY !\n");
- break;
- case 'Z': /* Compatibility mode for 0xA5 */
- Z_flag = 1;
- sverify=1;
- verify=1;
- inp_pat = 0xA5;
- pattern = ((inp_pat << 24) |
- (inp_pat << 16) | (inp_pat << 8) |
- inp_pat);
- sprintf(splash[splash_line++],"\tUsing old data sets.\n");
- sprintf(splash[splash_line++],"\t Performance measurements may be invalid in this\n");
- sprintf(splash[splash_line++],"\t mode due to published hack.\n");
- break;
-#if defined(Windows)
- case 'U': /* Windows only Unbufferd I/O */
- unbuffered=1;
- sprintf(splash[splash_line++],"\tUnbuffered Windows API usage. >>> Very Experimental <<<\n");
- break;
-#endif
- case 'K': /* Sony special for manual control of test 8 */
- subarg=argv[optind++];
- if(subarg==(char *)0)
- {
- printf("-+K takes an operand !!\n");
- exit(204);
- }
- Kplus_readers = (int)atoi(subarg);
- if(Kplus_readers <=0)
- Kplus_readers = 1;
- Kplus_flag=1;
- sprintf(splash[splash_line++],"\tManual control of test 8. >>> Very Experimental. Sony special <<<\n");
- break;
- case 'w': /* Argument is the percent of dedup */
- /* Sets size of dedup region across files */
- subarg=argv[optind++];
- if(subarg==(char *)0)
- {
- printf("-+w takes an operand !!\n");
- exit(200);
- }
- dedup = atoi(subarg);
- if(dedup <=0)
- dedup = 0;
- if(dedup >100)
- dedup = 100;
- sprintf(splash[splash_line++],"\tDedup activated %d percent.\n",dedup);
- break;
- case 'y': /* Argument is the percent of interior dedup */
- /* Sets size of dedup region within and across files */
- subarg=argv[optind++];
- if(subarg==(char *)0)
- {
- printf("-+y takes an operand !!\n");
- exit(200);
- }
- dedup_interior = atoi(subarg);
- if(dedup_interior <0)
- dedup_interior = 0;
- if(dedup_interior >100)
- dedup_interior = 100;
- sprintf(splash[splash_line++],"\tDedupe within & across %d percent.\n",dedup_interior);
- break;
- case 'C': /* Argument is the percent of dedupe within & !across */
- /* Sets size of dedup region within and !across files */
- subarg=argv[optind++];
- if(subarg==(char *)0)
- {
- printf("-+C takes an operand !!\n");
- exit(200);
- }
- dedup_compress = atoi(subarg);
- if(dedup_compress <0)
- dedup_compress = 0;
- if(dedup_compress >100)
- dedup_compress = 100;
- sprintf(splash[splash_line++],"\tDedupe within %d percent.\n",dedup_compress);
- break;
- case 'S': /* Argument is the seed for dedup */
- subarg=argv[optind++];
- if(subarg==(char *)0)
- {
- printf("-+S takes an operand !!\n");
- exit(200);
- }
- dedup_mseed = atoi(subarg);
- if(dedup_mseed ==0)
- dedup_mseed = 1;
- sprintf(splash[splash_line++],"\tDedup manual seed %d .\n",dedup_mseed);
- break;
- case 'H': /* Argument is hostname of the PIT */
- subarg=argv[optind++];
- if(subarg==(char *)0)
- {
- printf("-+H takes operand !!\n");
- exit(200);
- }
- strcpy(pit_hostname,subarg);
- sprintf(splash[splash_line++],"\tPIT_host %s\n",pit_hostname);
-
- break;
- case 'P': /* Argument is port of the PIT */
- subarg=argv[optind++];
- if(subarg==(char *)0)
- {
- printf("-+P takes operand !!\n");
- exit(200);
- }
- strcpy(pit_service,subarg);
- sprintf(splash[splash_line++],"\tPIT_port %s\n",pit_service);
- break;
- case 'z': /* Enable hist summary*/
- hist_summary=1;
- sprintf(splash[splash_line++],"\tHistogram summary enabled.\n");
- break;
- case 'O': /* Argument is the Op rate */
- subarg=argv[optind++];
- if(subarg==(char *)0)
- {
- printf("-+O takes an operand !!\n");
- exit(200);
- }
- op_rate = atoi(subarg);
- if(op_rate <= 0)
- op_rate = 1;
- op_rate_flag = 1;
- sprintf(splash[splash_line++],"\tRate control active %d Ops/sec .\n",op_rate);
- break;
- default:
- printf("Unsupported Plus option -> %s <-\n",optarg);
- exit(255);
- break;
- }
- break;
- default:
- printf("Unsupported option -> %s <-\n",optarg);
- exit(255);
- }
- }
- base_time=(long)time_so_far();
- get_resolution(); /* Get clock resolution */
- if(speed_code)
- {
- do_speed_check(client_iozone);
- exit(0);
- }
- if(r_count > 1)
- {
- aflag=1;
- rflag=0;
- NOCROSSflag=1;
- }
- if(s_count > 1)
- {
- aflag=1;
- sflag=0;
- NOCROSSflag=1;
- }
- /*
- * If not in silent mode then display the splash screen.
- */
- for(i=0;i<splash_line;i++)
- if(!silent) printf("%s",splash[i]);
- /*
- * Save the command line for later
- */
- record_command_line(argcsave, argvsave);
-
- if(pflag) /* Allocate after cache_size is set */
- {
- alloc_pbuf();
- }
- if(distributed && master_iozone)
- {
- if(maxt > clients_found)
- {
- printf("You can not specify more threads/processes than you have in the client file list\n");
- exit(202);
- }
- }
-
- if(!OPS_flag && !MS_flag)
- {
- if(!silent) printf("\tOutput is in Kbytes/sec\n");
- }
- if (min_rec_size > max_rec_size) {
-#ifdef NO_PRINT_LLD
- printf("Error: minimum record size %ld KB is greater than maximum record size %ld KB\n ",
- min_rec_size/1024, max_rec_size/1024);
-#else
- printf("Error: minimum record size %lld KB is greater than maximum record size %lld KB\n ",
- min_rec_size/1024, max_rec_size/1024);
-#endif
- exit(23);
- }
- orig_min_rec_size=min_rec_size;
- orig_max_rec_size=max_rec_size;
- /*
- * No telemetry files... just option selected
- */
- if(compute_flag && jflag && !(r_traj_flag || w_traj_flag))
- if(!silent) printf("\tCompute time %f seconds for reads and writes.\n",compute_time);
- /*
- * Read telemetry file and option selected
- */
- if(compute_flag && r_traj_flag && !w_traj_flag)
- {
- if(r_traj_items==3)
- {
- if(!silent) printf("\tCompute time from telemetry files for reads.\n");
- }
- else
- {
- if(jflag)
- if(!silent) printf("\tCompute time %f seconds for reads.\n",compute_time);
- }
- if(jflag)
- if(!silent) printf("\tCompute time %f seconds for writes.\n",compute_time);
- }
- /*
- * Write telemetry file and option selected
- */
- if(compute_flag && !r_traj_flag && w_traj_flag)
- {
- if(w_traj_items==3)
- {
- if(!silent) printf("\tCompute time from telemetry files for writes.\n");
- }
- else
- {
- if(jflag)
- if(!silent) printf("\tCompute time %f seconds for writes.\n",compute_time);
- }
- if(jflag)
- if(!silent) printf("\tCompute time %f seconds for reads.\n",compute_time);
- }
- if(compute_flag && r_traj_flag && w_traj_flag && jflag)
- {
- if(r_traj_items==3)
- {
- if(!silent) printf("\tCompute time from telemetry files for reads.\n");
- }
- else
- {
- if(!silent) printf("\tCompute time %f seconds for reads.\n",compute_time);
- }
- if(w_traj_items==3)
- {
- if(!silent) printf("\tCompute time from telemetry files for writes.\n");
- }
- else
- {
- if(!silent) printf("\tCompute time %f seconds for writes.\n",compute_time);
- }
- }
- if(compute_flag && r_traj_flag && w_traj_flag && !jflag)
- {
- if(r_traj_items==3)
- {
- if(!silent) printf("\tCompute time from telemetry files for reads.\n");
- }
- else
- {
- if(!silent) printf("\tNo compute time for reads.\n");
- }
-
- if(w_traj_items==3)
- {
- if(!silent) printf("\tCompute time from telemetry files for writes.\n");
- }
- else
- {
- if(!silent) printf("\tNo compute time for writes.\n");
- }
- }
-
- /* Enforce only write,rewrite,read,reread */
- if(w_traj_flag || r_traj_flag)
- {
- for(i=2;i<sizeof(func)/sizeof(char *);i++)
- {
- if(seq_mix && (i==8))
- ;
- else
- include_test[i] = 0;
- }
- }
-
- if(r_traj_flag)
- {
- if(include_test[READER_TEST] == 0)
- {
- include_test[WRITER_TEST]=1;
- include_test[READER_TEST]=1;
- include_tflag=1;
- }
- }
- if(w_traj_flag)
- {
- if(include_test[WRITER_TEST] == 0)
- {
- include_test[WRITER_TEST]=1;
- include_tflag=1;
- }
- }
- if(w_traj_flag && w_traj_fsize != 0)
- kilobytes64=w_traj_fsize/1024;
- if(r_traj_flag && r_traj_fsize != 0)
- kilobytes64=r_traj_fsize/1024;
-
- if( sverify==0 && (w_traj_flag || r_traj_flag))
- {
- printf("\n\tFull verification not supported in telemetry mode.\n\n");
- exit(17);
- }
- ;
- if(disrupt_flag &&(w_traj_flag || r_traj_flag) )
- {
- printf("\n\tDisrupt not supported in telemetry mode.\n\n");
- exit(17);
- }
- if(aflag &&(w_traj_flag || r_traj_flag) )
- {
- printf("\n\tAuto mode not supported in telemetry mode.\n");
- printf("\tTry: -i 0 -i 1 \n\n");
- exit(17);
- }
- if(sflag && w_traj_flag )
- {
- printf("\n\tSize of file is determined by telemetry file.\n\n");
- exit(17);
- }
- if(rflag && w_traj_flag )
- {
- printf("\n\tRecord size of file is determined by telemetry file.\n\n");
- exit(17);
- }
- if(stride_flag && (w_traj_flag || r_traj_flag))
- {
- printf("\n\tStride size is determined by telemetry file.\n\n");
- exit(17);
- }
- if(trflag && MS_flag)
- {
- printf("\n\tMicrosecond mode not supported in throughput mode.\n\n");
- exit(17);
- }
- if (trflag /* throughput mode, don't allow auto-mode options: */
- && (auto_mode || aflag || yflag || qflag || nflag || gflag))
- {
- printf("\n\tCan not mix throughput mode and auto-mode flags.\n\n");
- exit(17);
- }
- if(fflag && trflag)
- {
- printf("\n\tYou must use -F when using multiple threads or processes.\n\n");
- exit(17);
- }
- if(aflag && mfflag)
- {
- printf("\n\tYou must use -f when using auto mode.\n\n");
- exit(17);
- }
- if(async_flag && mmapflag)
- {
- printf("\n\tSorry ... Only mmap or async but not both\n\n");
- exit(18);
- }
-#ifndef ASYNC_IO
- if(async_flag)
- {
- printf("\n\tSorry ... This version does not support async I/O\n\n");
- exit(19);
- }
-#endif
- if(no_write)
- {
- if(!include_tflag)
- {
- printf("You must specify which tests ( -i # ) when using -+E\n");
- exit(19);
- }
- }
- if(include_tflag)
- {
- for(i=0;i<sizeof(func)/sizeof(char *);i++)
- if(include_test[i])
- include_mask|=(long long)(1<<i);
- /* printf(">> %llx",include_mask); HERE */
- }
- if(no_write) /* Disable if any writer would disturbe existing file */
- {
- if(include_test[0] || include_test[4] ||
- include_test[6] || include_test[8] || include_test[9] ||
- include_test[11])
- {
- printf("You must disable any test that writes when using -+E\n");
- exit(20);
- }
- }
- if(no_write) /* User must specify the existing file name */
- {
- if(!(fflag | mfflag))
- {
- printf("You must use -f or -F when using -+E\n");
- exit(20);
- }
- }
- if(h_flag && k_flag)
- {
- printf("\n\tCan not do both -H and -k\n");
- exit(20);
- }
- if((dedup | dedup_interior) && diag_v)
- {
- printf("\n\tCan not do both -+d and -+w\n");
- exit(20);
- }
-
- if(!aflag && !rflag)
- max_rec_size=min_rec_size;
-
- init_record_sizes(min_rec_size,max_rec_size);
- if(!silent) printf("\tTime Resolution = %1.6f seconds.\n",time_res);
-#ifdef NO_PRINT_LLD
- if(!silent) printf("\tProcessor cache size set to %ld Kbytes.\n",cache_size/1024);
- if(!silent) printf("\tProcessor cache line size set to %ld bytes.\n",cache_line_size);
- if(!silent) printf("\tFile stride size set to %ld * record size.\n",stride);
-#else
- if(!silent) printf("\tProcessor cache size set to %ld Kbytes.\n",cache_size/1024);
- if(!silent) printf("\tProcessor cache line size set to %ld bytes.\n",cache_line_size);
- if(!silent) printf("\tFile stride size set to %lld * record size.\n",stride);
-#endif
- if(!rflag)
- reclen=(long long)4096;
-
- if(uflag && !lflag)
- num_child=mint = 1;
- if(lflag && !uflag)
- maxt = mint;
- if(use_thread)
- port="thread";
- else
- port="process";
- if(lflag || uflag){
-#ifdef NO_PRINT_LLD
- if(!silent) printf("\tMin %s = %ld \n",port,mint);
- if(!silent) printf("\tMax %s = %ld \n",port,maxt);
-#else
- if(!silent) printf("\tMin %s = %lld \n",port,mint);
- if(!silent) printf("\tMax %s = %lld \n",port,maxt);
-#endif
- }
- if(trflag)
- {
- if(num_child > 1)
- {
- if(use_thread)
- {
- port="threads";
- }
- else
- {
- port="processes";
- }
- }
-
-#ifdef NO_PRINT_LLD
- if(!silent) printf("\tThroughput test with %ld %s\n", num_child,port);
-#else
- if(!silent) printf("\tThroughput test with %lld %s\n", num_child,port);
-#endif
- }
- numrecs64 = (long long)(kilobytes64*1024)/reclen;
- if (reclen > (long long)MAXBUFFERSIZE) {
-#ifdef NO_PRINT_LLD
- printf("Error: Maximum record length is %ld bytes\n",
- MAXBUFFERSIZE);
-#else
- printf("Error: Maximum record length is %lld bytes\n",
- (long long)MAXBUFFERSIZE);
-#endif
- exit(21);
- }
- if (reclen < (long long)MINBUFFERSIZE) {
-#ifdef NO_PRINT_LLD
- printf("Error: Minimum record length is %ld bytes\n",
- MINBUFFERSIZE);
-#else
- printf("Error: Minimum record length is %lld bytes\n",
- (long long)MINBUFFERSIZE);
-#endif
- exit(22);
- }
- /* Only bzero or fill that which you will use. The buffer is very large */
- if(verify )
- {
- fill_buffer((char *)buffer,l_min(reclen,(long long)cache_size),(long long)pattern,(char)sverify,(long long)0);
- if(pflag)
- fill_buffer((char *)pbuffer,l_min(reclen,(long long)cache_size),(long long)pattern,(char)sverify,(long long)0);
- if(mflag)
- fill_buffer((char *)mbuffer,l_min(reclen,(long long)cache_size),(long long)pattern,(char)sverify,(long long)0);
- }
- else
- {
- bzero(buffer,(size_t)l_min(reclen,(long long)cache_size));
- }
-
-#ifndef NO_THREADS
-#if defined( _HPUX_SOURCE ) || defined ( linux )
- if(ioz_processor_bind)
- {
- bind_cpu=begin_proc;
-#if defined( _HPUX_SOURCE )
- pthread_processor_bind_np(PTHREAD_BIND_FORCED_NP,
- (pthread_spu_t *)&anwser, (pthread_spu_t)bind_cpu, pthread_self());
-#else
- cpu_set_t cpuset;
- CPU_ZERO(&cpuset);
- CPU_SET(bind_cpu, &cpuset);
-
- pthread_setaffinity_np(pthread_self(), sizeof(cpuset),&cpuset);
-#endif
- my_nap(40); /* Switch to new cpu */
- }
-#endif
-#endif
- orig_size=kilobytes64;
- if(trflag){
- (void)multi_throughput_test(mint,maxt);
- goto out;
- }
- if(trflag && (mint == maxt)){
- auto_mode=0;
- throughput_test();
- goto out;
- }
- if (aflag) {
- print_header();
- auto_test();
- goto out;
- }
- print_header();
- (void) begin(kilobytes64,reclen);
-out:
- if(r_traj_flag)
- fclose(r_traj_fd);
- if(w_traj_flag)
- fclose(w_traj_fd);
- if (!no_unlink)
- {
- if(check_filename(dummyfile[0]))
- unlink(dummyfile[0]); /* delete the file */
- }
- if(!silent) printf("\niozone test complete.\n");
- if(res_prob)
- {
- printf("Timer resolution is poor. Some small transfers may have \n");
- printf("reported inaccurate results. Sizes %ld Kbytes and below.\n",
- (long)(rec_prob/(long long)1024));
- }
-
- if(Rflag && !trflag){
- dump_excel();
- }
- return(0);
-}
-
-#ifdef HAVE_ANSIC_C
-void
-record_command_line(int argc, char **argv)
-#else
-void
-record_command_line(argc, argv)
-int argc;
-char **argv;
-#endif
-{
- int ix, len = 0;
-
- /* print and save the entire command line */
- if(!silent) printf("\tCommand line used:");
- for (ix=0; ix < argc; ix++) {
- if(!silent) printf(" %s", argv[ix]);
- if ((len + strlen(argv[ix])) < sizeof(command_line)) {
- strcat (command_line, argv[ix]);
- strcat (command_line, " ");
- len += strlen(argv[ix]) + 1;
- }
- else {
- printf ("Command line too long to save completely.\n");
- break;
- }
- }
- if(!silent) printf("\n");
-}
-
-/*************************************************************************/
-/* BEGIN() */
-/* This is the main work horse. It is called from main and from */
-/* auto_test. The caller provides the size of file and the record length.*/
-/*************************************************************************/
-#ifdef HAVE_ANSIC_C
-void
-begin(off64_t kilos64,long long reclength)
-#else
-void
-begin(kilos64,reclength)
-off64_t kilos64;
-long long reclength;
-#endif
-{
- long long num_tests,test_num,i,j;
- long long data1[MAXTESTS], data2[MAXTESTS];
- num_tests = sizeof(func)/sizeof(char *);
-#if defined(HAVE_PREAD)
- if(!Eflag)
- {
-#if defined(HAVE_PREAD) && defined(HAVE_PREADV)
- num_tests -= 4;
-#else
- num_tests -= 2;
-#endif
- if(mmapflag || async_flag)
- {
- num_tests -= 2;
- }
- }
- else
- {
- if(mmapflag || async_flag)
-#if defined(HAVE_PREAD) && defined(HAVE_PREADV)
- num_tests -= 6;
-#else
- num_tests -= 4;
-#endif
- }
-#else
- if(mmapflag || async_flag)
- {
- num_tests -= 2;
- }
-#endif
-
- if(RWONLYflag) num_tests = 2; /* kcollins 8-21-96*/
- sync(); /* just in case there were some dirty */
- sync();
- kilobytes64=kilos64;
- reclen=reclength;
- numrecs64 = (kilobytes64*1024)/reclen;
- store_value(kilobytes64);
- if(r_traj_flag || w_traj_flag)
- store_value((off64_t)0);
- else
- store_value((off64_t)(reclen/1024));
-
-#ifdef NO_PRINT_LLD
- if(!silent) printf("%16ld",kilobytes64);
- if(r_traj_flag || w_traj_flag)
- {
- if(!silent) printf("%8ld",0);
- }
- else
- {
- if(!silent) printf("%8ld",reclen/1024);
- }
-#else
- if(!silent) printf("%16lld",kilobytes64);
- if(r_traj_flag || w_traj_flag)
- {
- if(!silent) printf("%8lld",(long long )0);
- }
- else
- {
- if(!silent) printf("%8lld",reclen/1024);
- }
-#endif
- if(include_tflag)
- {
- for(i=0;i<num_tests;i++)
- {
- if(include_mask & (long long)(1<<i))
- func[i](kilobytes64,reclen,&data1[i],&data2[i]);
- else
- {
- if(!silent) printf("%s",test_output[i]);
- fflush(stdout);
- for(j=0;j<test_soutput[i];j++)
- store_value((off64_t)0);
- }
- }
- }
- else
- {
- for(test_num=0;test_num < num_tests;test_num++)
- {
- func[test_num](kilobytes64,reclen,&data1[test_num],&data2[test_num]);
- };
- }
- if(!silent) printf("\n");
- if(!OPS_flag && !include_tflag){ /* Report in ops/sec ? */
- if(data1[1]!=0 && data2[1] != 0)
- {
- totaltime = data1[1] + data1[0];
- if (totaltime < TOOFAST)
- {
- goodkilos = (TOOFAST/totaltime)*2*kilobytes64;
- printf("\nThe test completed too quickly to give a good result\n");
- printf("You will get a more precise measure of this machine's\n");
- printf("performance by re-running iozone using the command:\n");
-#ifdef NO_PRINT_LLD
- printf("\n\tiozone %ld ", goodkilos);
- printf("\t(i.e., file size = %ld kilobytes64)\n", goodkilos);
-#else
- printf("\n\tiozone %lld ", goodkilos);
- printf("\t(i.e., file size = %lld kilobytes64)\n", goodkilos);
-#endif
- }
- } else {
- goodrecl = reclen/2;
- printf("\nI/O error during read. Try again with the command:\n");
-#ifdef NO_PRINT_LLD
- printf("\n\tiozone %ld %ld ", kilobytes64, goodrecl);
- printf("\t(i.e. record size = %ld bytes)\n", goodrecl);
-#else
- printf("\n\tiozone %lld %lld ", kilobytes64, goodrecl);
- printf("\t(i.e. record size = %lld bytes)\n", goodrecl);
-#endif
- }
- }
- if (!no_unlink)
- {
- if(check_filename(filename))
- unlink(filename); /* delete the file */
- }
- /*stop timer*/
- return ;
-}
-/******************************************************************
-
- SHOW_HELP -- show development help of this program
-
-******************************************************************/
-#ifdef HAVE_ANSIC_C
-void show_help(void)
-#else
-void show_help()
-#endif
-{
- long long i;
- if(!silent) printf("iozone: help mode\n\n");
- for(i=0; strlen(help[i]); i++)
- {
- if(!silent) printf("%s\n", help[i]);
- }
-}
-/******************************************************************
-
- SIGNAL_HANDLER -- clean up if user interrupts the program
-
-******************************************************************/
-#ifdef HAVE_ANSIC_C
-void signal_handler(void)
-#else
-void signal_handler()
-#endif
-{
- long long i;
- if(distributed)
- {
- if(master_iozone)
- cleanup_children();
- }
- if((long long)getpid()==myid)
- {
- if(!silent) printf("\niozone: interrupted\n\n");
-#ifndef VMS
- if (!no_unlink)
- {
- if(check_filename(filename))
- unlink(filename); /* delete the file */
- }
- for(i=1;i<num_child;i++)
- {
- if(check_filename(dummyfile[i]))
- unlink(dummyfile[i]); /* delete the file */
- }
- if (!no_unlink)
- {
- if(check_filename(dummyfile[0]))
- unlink(dummyfile[0]); /* delete the file */
- }
-
-#endif
- if(Rflag && !trflag){
- dump_excel();
- }
- if(Rflag && trflag){
- dump_throughput();
- }
-
- if(!silent) printf("exiting iozone\n\n");
- if(res_prob)
- {
- printf("Timer resolution is poor. Some small transfers may have \n");
- printf("reported inaccurate results. Sizes %ld Kbytes and below.\n",
- (long)rec_prob/1024);
- }
- if(trflag && !use_thread)
- for(i=0;i<num_child;i++)
- kill((pid_t)childids[i],SIGTERM);
- if(r_traj_flag)
- fclose(r_traj_fd);
- if(w_traj_flag)
- fclose(w_traj_fd);
- }
- if(sp_msfd)
- close(sp_msfd);
- if(sp_mrfd)
- close(sp_mrfd);
- exit(0);
-}
-
-/****************************************************************/
-/* */
-/* AUTO_TEST -- perform series of tests and tabulate results */
-/* */
-/****************************************************************/
-#ifdef HAVE_ANSIC_C
-void
-auto_test(void)
-#else
-void auto_test()
-#endif
-{
- off64_t kilosi;
- long long recszi,count1;
- long long mult;
- long long xx;
-
- /****************************************************************/
- /* Start with file size of 1 megabyte and repeat the test */
- /* KILOBYTES_ITER_LIMIT */
- /* times. Each time we run, the file size is doubled */
- /****************************************************************/
-/*
- if(sflag) {
- min_file_size = kilobytes64;
- max_file_size = kilobytes64;
- }
- if(rflag) {
- min_rec_size = reclen;
- max_rec_size = reclen;
- }
-*/
- if(gflag)
- max_file_size = maximum_file_size;
- if(nflag)
- min_file_size = minimum_file_size;
-
- if (min_rec_size > (long long)(min_file_size*1024)) {
-#ifdef NO_PRINT_LLD
- printf("Error: record length %ld is greater than filesize %ld KB\n ",
- min_rec_size,min_file_size);
-#else
- printf("Error: record length %lld is greater than filesize %lld KB\n ",
- min_rec_size,min_file_size);
-#endif
- exit(23);
- }
-
- if(NOCROSSflag) xover = max_file_size;
-
- init_file_sizes(min_file_size, max_file_size);
- del_record_sizes();
- orig_min_rec_size=min_rec_size;
- orig_max_rec_size=max_rec_size;
- init_record_sizes(min_rec_size, max_rec_size);
-
- for(kilosi=get_next_file_size((off64_t)0); kilosi>0; kilosi=get_next_file_size(kilosi))
- {
- /****************************************************************/
- /* Start with record size of min_rec_size bytes and repeat the */
- /* test, multiplying the record size by MULTIPLIER each time, */
- /* until we reach max_rec_size. At the CROSSOVER we stop doing */
- /* small buffers as it takes forever and becomes very */
- /* un-interesting. */
- /****************************************************************/
- if(!rflag && !sflag && !yflag && !qflag)
- if(kilosi > xover){
- min_rec_size = LARGE_REC;
- mult = orig_min_rec_size/1024;
- del_record_sizes();
- init_record_sizes(min_rec_size, max_rec_size);
- /************************************/
- /* Generate dummy entries in the */
- /* Excel buffer for skipped */
- /* record sizes */
- /************************************/
- for(count1=min_rec_size;
- (count1 != orig_min_rec_size) && (
- mult <= (kilosi*1024)) ;
- count1=(count1>>1))
- {
- current_x=0;
- store_value((off64_t)kilosi);
- store_value((off64_t)mult);
- for(xx=0;xx<20;xx++)
- store_value((off64_t)0);
- mult=mult*2;
- current_y++;
- if(current_y>max_y)
- max_y=current_y;
- current_x=0;
- }
- }
-
- for (recszi=get_next_record_size((off64_t)0);recszi!=0;recszi=get_next_record_size(recszi))
- {
- if(recszi > (kilosi*1024))
- break;
- begin(kilosi, recszi );
- current_x=0;
- current_y++;
- }
- }
-}
-
-
-/****************************************************************/
-/* */
-/* THROUGHPUT_TEST () Multi process throughput test */
-/* */
-/* Note: States for share memory barrier are: */
-/* 0 = Child not running or has finished. */
-/* 1 = Child is ready to begin. */
-/* 2 = Child is told to begin. */
-/****************************************************************/
-/* Data in shared memory format is: */
-/* */
-/* struct child_stats { */
-/* long long flag; Used to barrier */
-/* double walltime; Child's elapsed time */
-/* double cputime; Child's CPU time */
-/* double throughput; Child's throughput */
-/* double actual; Child's actual read/written */
-/* } */
-/* */
-/* There is an array of child_stat structures layed out in */
-/* shared memory. */
-/* */
-/****************************************************************/
-
-#ifdef HAVE_ANSIC_C
-void
-throughput_test(void)
-#else
-void
-throughput_test()
-#endif
-{
- char *unit;
- double starttime1 = 0;
- double jstarttime = 0;
- double jtime = 0;
- double walltime = 0;
- double cputime = 0;
- char *port;
- char getout;
- long long throughsize = KILOBYTES;
- long long xx,xy,i;
- long long xyz;
- double ptotal;
- off64_t written_so_far, read_so_far, re_written_so_far,re_read_so_far;
- VOLATILE char *temp;
- double min_throughput = 0;
- double max_throughput = 0;
- double avg_throughput = 0;
- double min_xfer = 0;
-
-
- toutputindex=0;
- strcpy(&toutput[0][0],throughput_tests[0]);
- ptotal=written_so_far=read_so_far=re_written_so_far=re_read_so_far=0 ;
-
- if(OPS_flag)
- unit="ops";
- else
- unit="KB";
-
- if(!haveshm)
- {
- shmaddr=(struct child_stats *)alloc_mem((long long)SHMSIZE,(int)1);
-#ifdef _64BIT_ARCH_
- if((long long)shmaddr==(long long)-1)
-#else
- if((long )shmaddr==(long)-1)
-#endif
- {
- printf("\nShared memory not working\n");
- exit(24);
- }
- haveshm=(char*)shmaddr;
- }
- else
- shmaddr=(struct child_stats *)haveshm;
-
- if(use_thread)
- stop_flag = &stoptime;
- else
- {
- temp = (char *)&shmaddr[0];
- stop_flag = (char *)&temp[(long long)SHMSIZE]-4;
- }
- for(xyz=0;xyz<num_child;xyz++){ /* all children to state 0 (HOLD) */
- child_stat = (struct child_stats *)&shmaddr[xyz];
- child_stat->flag=CHILD_STATE_HOLD;
- child_stat->actual=0;
- child_stat->throughput=0;
- child_stat->cputime=0;
- child_stat->walltime=0;
- }
- *stop_flag = 0;
- if(!sflag)
- kilobytes64=throughsize;
- if(!rflag)
- reclen=(long long)4096;
- if(aggflag)
- kilobytes64=orig_size/num_child;
- numrecs64 = (long long)(kilobytes64*1024)/reclen;
- buffer=mainbuffer;
- if(use_thread)
- port="thread";
- else
- port="process";
- if(w_traj_flag)
- {
-#ifdef NO_PRINT_LLD
- if(!silent) printf("\tEach %s writes a %ld Kbyte file in telemetry controlled records\n",
- port,kilobytes64);
-#else
- if(!silent) printf("\tEach %s writes a %lld Kbyte file in telemetry controlled records\n",
- port,kilobytes64);
-#endif
- }
- else
- {
-#ifdef NO_PRINT_LLD
- if(!silent) printf("\tEach %s writes a %ld Kbyte file in %ld Kbyte records\n",
- port,kilobytes64,reclen/1024);
-#else
- if(!silent) printf("\tEach %s writes a %lld Kbyte file in %lld Kbyte records\n",
- port,kilobytes64,reclen/1024);
-#endif
- }
-
- if(fflag) /* Each child has a file name to write */
- for(xx=0;xx<num_child;xx++)
- filearray[xx] = filename;
- myid = (long long)getpid();
-
- /* rags: skip writer test */
- if(include_tflag)
- if(!(include_mask & (long long)WRITER_MASK))
- {
- store_dvalue( (double)0);
- store_dvalue( (double)0);
- toutputindex++;
- goto next0;
- }
-
- if((!distributed) || (distributed && master_iozone))
- start_monitor("Write");
- /* Hooks to start the distributed Iozone client/server code */
- if(distributed)
- {
- use_thread=0; /* Turn of any Posix threads */
- if(master_iozone)
- master_listen_socket = start_master_listen();
- else
- become_client();
- }
- if(!use_thread)
- {
- for(xx = 0; xx< num_child ; xx++){ /* Create the children */
- chid=xx;
- childids[xx] = start_child_proc(THREAD_WRITE_TEST,numrecs64,reclen);
- if(childids[xx]==-1){
- printf("\nFork failed\n");
- for(xy = 0; xy< xx ; xy++){
- if(!use_thread)
- kill((pid_t)childids[xy],SIGTERM);
- }
- exit(25);
- }
- if(childids[xx]!=0 && debug1)
-#ifdef NO_PRINT_LLD
- printf("Parent starting slot %ld\n",xx);
-#else
- printf("Parent starting slot %lld\n",xx);
-#endif
- if( childids[xx] == 0 ){
-#ifdef _64BIT_ARCH_
- thread_write_test((void *)xx);
-#else
- thread_write_test((void *)(long)xx);
-#endif
- }else {
-#ifdef NO_PRINT_LLD
- sprintf(dummyfile[xx],"%s.DUMMY.%ld",filearray[xx], xx);
-#else
- sprintf(dummyfile[xx],"%s.DUMMY.%lld",filearray[xx], xx);
-#endif
- }
- }
- }
-#ifndef NO_THREADS
- else
- {
- for(xx = 0; xx< num_child ; xx++){ /* Create the children */
-
-#ifdef NO_PRINT_LLD
- sprintf(dummyfile[xx],"%s.DUMMY.%ld",filearray[xx], xx);
-#else
- sprintf(dummyfile[xx],"%s.DUMMY.%lld",filearray[xx], xx);
-#endif
- if(!barray[xx])
- {
- barray[xx]=(char *) alloc_mem((long long)(MAXBUFFERSIZE+cache_size),(int)0);
- if(barray[xx] == 0) {
- perror("Memory allocation failed:");
- exit(26);
- }
- barray[xx] =(char *)(((long)barray[xx] + cache_size ) &
- ~(cache_size-1));
- }
-
-#ifdef _64BIT_ARCH_
- childids[xx] = mythread_create(thread_write_test,(void*)xx);
-#else
- childids[xx] = mythread_create(thread_write_test,(void*)(long)xx);
-#endif
- if(childids[xx]==-1){
- printf("Thread create failed\n");
- for(xy = 0; xy< xx ; xy++){
- kill((pid_t)myid,SIGTERM);
- }
- exit(27);
- }
- }
- }
-#endif
- if((long long)getpid() == myid)
- {
- prepage(buffer,reclen); /* Force copy on write */
- /* wait for children to start */
- if(distributed && master_iozone)
- {
- start_master_listen_loop((int) num_child);
- }
- for(i=0;i<num_child; i++){
- child_stat = (struct child_stats *)&shmaddr[i];
- while(child_stat->flag==CHILD_STATE_HOLD)
- Poll((long long)1);
- }
- for(i=0;i<num_child; i++) /* Start all children going */
- {
- if(delay_start!=0)
- Poll((long long)delay_start);
- /* State "go" */
- child_stat = (struct child_stats *)&shmaddr[i];
- child_stat->flag=CHILD_STATE_BEGIN;
- if(distributed && master_iozone)
- tell_children_begin(i);
- }
- starttime1 = time_so_far(); /* Start parents timer */
- goto waitout;
- }
-
-waitout:
- getout=0;
- if((long long)getpid() == myid) { /* Parent only */
- starttime1 = time_so_far(); /* Wait for all children */
- for( i = 0; i < num_child; i++){
- child_stat = (struct child_stats *) &shmaddr[i];
- if(distributed && master_iozone)
- {
- printf("\n\tTest running:");
- wait_dist_join();
- break;
- }
- else
- {
- if(use_thread)
- {
- thread_join(childids[i],(void *)&pstatus);
- }
- else
- {
- wait(0);
- }
- }
- if(!jstarttime)
- jstarttime = time_so_far();
- }
- jtime = (time_so_far()-jstarttime)-time_res;
- if(jtime < (double).000001)
- {
- jtime=time_res;
- }
- }
- total_time = (time_so_far() - starttime1)-time_res; /* get parents total time */
- if(total_time < (double).000001)
- {
- total_time=time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-#ifdef JTIME
- total_time=total_time-jtime;/* Remove the join time */
- if(!silent) printf("\nJoin time %10.2f\n",jtime);
-#endif
-
- total_kilos=0;
- ptotal=0;
- walltime = 0.0;
- cputime = 0.0;
- if(!silent) printf("\n");
- for(xyz=0;xyz<num_child;xyz++){
- child_stat = (struct child_stats *) &shmaddr[xyz];
- total_kilos += child_stat->throughput; /* add up the children */
- ptotal += child_stat->actual;
- if(!min_xfer)
- min_xfer=child_stat->actual;
- if(child_stat->actual < min_xfer)
- min_xfer=child_stat->actual;
- if(!min_throughput)
- min_throughput=child_stat->throughput;
- if(child_stat->throughput < min_throughput)
- min_throughput=child_stat->throughput;
- if(child_stat->throughput > max_throughput)
- max_throughput=child_stat->throughput;
- /* Add up the cpu times of all children */
- cputime += child_stat->cputime;
-
- /* and find the child with the longest wall time */
- /* Get the earliest start time and latest fini time to calc. elapsed time. */
- if (child_stat->walltime < child_stat->cputime)
- child_stat->walltime = child_stat->cputime;
- if (child_stat->walltime > walltime)
- walltime = child_stat->walltime;
- }
- avg_throughput=total_kilos/num_child;
- if(cpuutilflag)
- {
- if (cputime < cputime_res)
- cputime = 0.0;
- }
-
- for(xyz=0;xyz<num_child;xyz++){
- child_stat = (struct child_stats *) &shmaddr[xyz];
- child_stat->flag = CHILD_STATE_HOLD; /* Start children at state 0 (HOLD) */
- }
- if(cpuutilflag)
- store_times (walltime, cputime); /* Must be Before store_dvalue(). */
- store_dvalue(total_kilos);
-#ifdef NO_PRINT_LLD
- if(!silent) printf("\tChildren see throughput for %2ld initial writers \t= %10.2f %s/sec\n", num_child, total_kilos,unit);
- if(!silent && !distributed) printf("\tParent sees throughput for %2ld initial writers \t= %10.2f %s/sec\n",num_child,((double)(ptotal)/total_time),unit);
-#else
- if(!silent) printf("\tChildren see throughput for %2lld initial writers \t= %10.2f %s/sec\n", num_child, total_kilos,unit);
- if(!silent && !distributed) printf("\tParent sees throughput for %2lld initial writers \t= %10.2f %s/sec\n",num_child,((double)(ptotal)/total_time),unit);
-#endif
- if(!silent) printf("\tMin throughput per %s \t\t\t= %10.2f %s/sec \n", port,min_throughput,unit);
- if(!silent) printf("\tMax throughput per %s \t\t\t= %10.2f %s/sec\n", port,max_throughput,unit);
- if(!silent) printf("\tAvg throughput per %s \t\t\t= %10.2f %s/sec\n", port,avg_throughput,unit);
- if(!silent) printf("\tMin xfer \t\t\t\t\t= %10.2f %s\n", min_xfer,unit);
- /* CPU% can be > 100.0 for multiple CPUs */
- if(cpuutilflag)
- {
- if(walltime == 0.0)
- {
- if(!silent) printf("\tCPU utilization: Wall time %8.3f CPU time %8.3f CPU utilization %6.2f %%\n\n",
- walltime, cputime, 0.0);
- }
- else
- {
- if(!silent) printf("\tCPU Utilization: Wall time %8.3f CPU time %8.3f CPU utilization %6.2f %%\n\n",
- walltime, cputime, 100.0 * cputime / walltime);
- }
- }
- if(Cflag)
- {
- for(xyz=0;xyz<num_child;xyz++)
- {
- child_stat = (struct child_stats *) &shmaddr[xyz];
- if(cpuutilflag)
- {
- if(!silent)
- printf("\tChild[%ld] xfer count = %10.2f %s, Throughput = %10.2f %s/sec, wall=%6.3f, cpu=%6.3f, %%=%6.2f\n",
- (long)xyz, child_stat->actual, unit, child_stat->throughput, unit, child_stat->walltime,
- child_stat->cputime, cpu_util(child_stat->cputime, child_stat->walltime));
- }
- else
- {
- if(!silent) printf("\tChild[%ld] xfer count = %10.2f %s, Throughput = %10.2f %s/sec\n",
- (long)xyz, child_stat->actual, unit, child_stat->throughput, unit);
- }
- }
- }
- if((!distributed) || (distributed && master_iozone))
- stop_monitor("Write");
- /**********************************************************/
- /*************** End of intitial writer *******************/
- /**********************************************************/
- sync();
- sleep(2);
- if(restf)
- sleep((int)rest_val);
- *stop_flag=0;
- if(distributed && master_iozone)
- {
- stop_master_listen(master_listen_socket);
- cleanup_comm();
- }
-
- /**********************************************************/
- /* Re-write throughput performance test. ******************/
- /**********************************************************/
- walltime = 0.0;
- cputime = 0.0;
- jstarttime=0;
- total_kilos=0;
- toutputindex=1;
- strcpy(&toutput[1][0],throughput_tests[1]);
- if(noretest)
- {
- store_dvalue( (double)0);
- goto next0;
- }
- if((!distributed) || (distributed && master_iozone))
- start_monitor("Rewrite");
- /* Hooks to start the distributed Iozone client/server code */
- if(distributed)
- {
- use_thread=0; /* Turn of any Posix threads */
- if(master_iozone)
- master_listen_socket = start_master_listen();
- else
- become_client();
- }
- if(!use_thread)
- {
- for(xx = 0; xx< num_child ; xx++){
- chid=xx;
- childids[xx] = start_child_proc(THREAD_REWRITE_TEST,numrecs64,reclen);
- if(childids[xx]==-1){
- printf("\nFork failed\n");
- for(xy = 0; xy< xx ; xy++){
- Kill((long long)childids[xy],(long long)SIGTERM);
- }
- exit(28);
- }
- if(childids[xx] == 0){
-#ifdef _64BIT_ARCH_
- thread_rwrite_test((void *)xx);
-#else
- thread_rwrite_test((void *)((long)xx));
-#endif
- }
- }
- }
-#ifndef NO_THREADS
- else
- {
- for(xx = 0; xx< num_child ; xx++){ /* Create the children */
- if(!barray[xx])
- {
- barray[xx]=(char *) alloc_mem((long long)(MAXBUFFERSIZE+cache_size),(int)0);
- if(barray[xx] == 0) {
- perror("Memory allocation failed:");
- exit(26);
- }
- barray[xx] =(char *)(((long)barray[xx] + cache_size ) &
- ~(cache_size-1));
- }
-#ifdef _64BIT_ARCH_
- childids[xx] = mythread_create( thread_rwrite_test,xx);
-#else
- childids[xx] = mythread_create( thread_rwrite_test,(void *)(long)xx);
-#endif
- if(childids[xx]==-1){
- printf("\nThread create failed\n");
- for(xy = 0; xy< xx ; xy++){
- Kill((long long)myid,(long long)SIGTERM);
- }
- exit(29);
- }
- }
- }
-#endif
- if((long long)myid == getpid())
- {
- if(distributed && master_iozone)
- {
- start_master_listen_loop((int) num_child);
- }
- for(i=0;i<num_child; i++){
- child_stat = (struct child_stats *)&shmaddr[i];
- /* wait for children to start */
- while(child_stat->flag==CHILD_STATE_HOLD)
- Poll((long long)1);
- }
- for(i=0;i<num_child; i++)
- {
- child_stat = (struct child_stats *)&shmaddr[i];
- child_stat->flag = CHILD_STATE_BEGIN; /* tell children to go */
- if(delay_start!=0)
- Poll((long long)delay_start);
- if(distributed && master_iozone)
- tell_children_begin(i);
- }
- starttime1 = time_so_far();
- goto jump3;
- }
-
-jump3:
- getout=0;
- if((long long)myid == getpid()){ /* Parent only here */
- for( i = 0; i < num_child; i++){
- child_stat=(struct child_stats *)&shmaddr[i];
- if(distributed && master_iozone)
- {
- printf("\n\tTest running:");
- wait_dist_join();
- break;
- }
- else
- {
- if(use_thread)
- {
- thread_join(childids[i],(void *)&pstatus);
- }
- else
- {
- wait(0);
- }
- }
- if(!jstarttime)
- jstarttime = time_so_far();
- }
- jtime = (time_so_far()-jstarttime)-time_res;
- if(jtime < (double).000001)
- {
- jtime=time_res;
- }
- }
- total_time = (time_so_far() - starttime1)-time_res; /* Parents total time */
- if(total_time < (double).000001)
- {
- total_time=time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-#ifdef JTIME
- total_time=total_time-jtime;/* Remove the join time */
- if(!silent) printf("\nJoin time %10.2f\n",jtime);
-#endif
-
-
- total_kilos=0;
- ptotal=0;
-
- min_throughput=max_throughput=min_xfer=0;
- if(!silent) printf("\n");
- for(xyz=0;xyz<num_child;xyz++){
- child_stat=(struct child_stats *)&shmaddr[xyz];
- total_kilos+=child_stat->throughput;
- ptotal+=child_stat->actual;
- if(!min_xfer)
- min_xfer=child_stat->actual;
- if(child_stat->actual < min_xfer)
- min_xfer=child_stat->actual;
- if(!min_throughput)
- min_throughput=child_stat->throughput;
- if(child_stat->throughput < min_throughput)
- min_throughput=child_stat->throughput;
- if(child_stat->throughput > max_throughput)
- max_throughput=child_stat->throughput;
- cputime += child_stat->cputime;
- /* Get the earliest start time and latest fini time to calc. elapsed time. */
- if (child_stat->walltime < child_stat->cputime)
- child_stat->walltime = child_stat->cputime;
- if (child_stat->walltime > walltime)
- walltime = child_stat->walltime;
- }
- avg_throughput=total_kilos/num_child;
- if(cpuutilflag)
- {
-/*
- if (walltime < cputime_res)
- walltime = 0.0;
-*/
- if (cputime < cputime_res)
- cputime = 0.0;
- }
-
- for(xyz=0;xyz<num_child;xyz++){ /* Reset state to 0 (HOLD) */
- child_stat=(struct child_stats *)&shmaddr[xyz];
- child_stat->flag = CHILD_STATE_HOLD;
- }
- if(cpuutilflag)
- store_times (walltime, cputime); /* Must be Before store_dvalue(). */
- store_dvalue(total_kilos);
-#ifdef NO_PRINT_LLD
- if(!silent) printf("\tChildren see throughput for %2ld rewriters \t= %10.2f %s/sec\n", num_child, total_kilos,unit);
- if(!silent && !distributed) printf("\tParent sees throughput for %2ld rewriters \t= %10.2f %s/sec\n", num_child, (double)(ptotal)/total_time,unit);
-#else
- if(!silent) printf("\tChildren see throughput for %2lld rewriters \t= %10.2f %s/sec\n", num_child, total_kilos,unit);
- if(!silent && !distributed) printf("\tParent sees throughput for %2lld rewriters \t= %10.2f %s/sec\n", num_child, (double)(ptotal)/total_time,unit);
-#endif
- if(!silent) printf("\tMin throughput per %s \t\t\t= %10.2f %s/sec \n", port,min_throughput,unit);
- if(!silent) printf("\tMax throughput per %s \t\t\t= %10.2f %s/sec\n", port,max_throughput,unit);
- if(!silent) printf("\tAvg throughput per %s \t\t\t= %10.2f %s/sec\n", port,avg_throughput,unit);
- if(!silent) printf("\tMin xfer \t\t\t\t\t= %10.2f %s\n", min_xfer,unit);
- /* CPU% can be > 100.0 for multiple CPUs */
- if(cpuutilflag)
- {
- if(walltime == 0.0)
- {
- if(!silent) printf("\tCPU utilization: Wall time %8.3f CPU time %8.3f CPU utilization %6.2f %%\n\n",
- walltime, cputime, 0.0);
- }
- else
- {
- if(!silent) printf("\tCPU utilization: Wall time %8.3f CPU time %8.3f CPU utilization %6.2f %%\n\n",
- walltime, cputime, 100.0 * cputime / walltime);
- }
- }
- if(Cflag)
- {
- for(xyz=0;xyz<num_child;xyz++)
- {
- child_stat = (struct child_stats *) &shmaddr[xyz];
- if(cpuutilflag)
- {
- if(!silent) printf("\tChild[%ld] xfer count = %10.2f %s, Throughput = %10.2f %s/sec, wall=%6.3f, cpu=%6.3f, %%=%6.2f\n",
- (long)xyz, child_stat->actual, unit, child_stat->throughput, unit, child_stat->walltime,
- child_stat->cputime, cpu_util(child_stat->cputime, child_stat->walltime));
- }
- else
- {
- if(!silent) printf("\tChild[%ld] xfer count = %10.2f %s, Throughput = %10.2f %s/sec\n",
- (long)xyz, child_stat->actual, unit, child_stat->throughput, unit);
- }
- }
- }
- *stop_flag=0;
- if((!distributed) || (distributed && master_iozone))
- stop_monitor("Rewrite");
- /**********************************************************/
- /*************** End of rewrite throughput ****************/
- /**********************************************************/
- sync();
- sleep(2);
- if(restf)
- sleep((int)rest_val);
- if(distributed && master_iozone)
- {
- stop_master_listen(master_listen_socket);
- cleanup_comm();
- }
-next0:
- if(include_tflag)
- if(!(include_mask & (long long)READER_MASK))
- goto next1;
- /**************************************************************/
- /*** Reader throughput tests **********************************/
- /**************************************************************/
- if((!distributed) || (distributed && master_iozone))
- start_monitor("Read");
- toutputindex++;
- strcpy(&toutput[toutputindex][0],throughput_tests[2]);
- walltime = 0.0;
- cputime = 0.0;
- jstarttime=0;
- total_kilos=0;
- if(distributed)
- {
- use_thread=0;
- if(master_iozone)
- master_listen_socket=start_master_listen();
- else
- become_client();
- }
- if(!use_thread)
- {
- for(xx = 0; xx< num_child ; xx++){
- chid=xx;
- childids[xx] = start_child_proc(THREAD_READ_TEST,numrecs64,reclen);
- if(childids[xx]==-1){
- printf("\nFork failed\n");
- for(xy = 0; xy< xx ; xy++){
- Kill((long long)childids[xy],(long long)SIGTERM);
- }
- exit(30);
- }
- if(childids[xx]==0){
-#ifdef _64BIT_ARCH_
- thread_read_test((void *)xx);
-#else
- thread_read_test((void *)((long)xx));
-#endif
- }
- }
- }
-#ifndef NO_THREADS
- else
- {
- for(xx = 0; xx< num_child ; xx++){ /* Create the children */
- if(!barray[xx])
- {
- barray[xx]=(char *) alloc_mem((long long)(MAXBUFFERSIZE+cache_size),(int)0);
- if(barray[xx] == 0) {
- perror("Memory allocation failed:");
- exit(26);
- }
- barray[xx] =(char *)(((long)barray[xx] + cache_size ) &
- ~(cache_size-1));
- }
-#ifdef _64BIT_ARCH_
- childids[xx] = mythread_create( thread_read_test,xx);
-#else
- childids[xx] = mythread_create( thread_read_test,(void *)(long)xx);
-#endif
- if(childids[xx]==-1){
- printf("\nThread create failed\n");
- for(xy = 0; xy< xx ; xy++){
- kill((pid_t)myid,(int)SIGTERM);
- }
- exit(31);
- }
- }
- }
-#endif
- if(myid == (long long)getpid()){
- if(distributed && master_iozone)
- {
- start_master_listen_loop((int) num_child);
- }
- for(i=0;i<num_child; i++){ /* wait for children to start */
- child_stat=(struct child_stats *)&shmaddr[i];
- while(child_stat->flag==CHILD_STATE_HOLD)
- Poll((long long)1);
- }
- for(i=0;i<num_child; i++)
- {
- child_stat=(struct child_stats *)&shmaddr[i];
- child_stat->flag = CHILD_STATE_BEGIN; /* tell children to go */
- if(delay_start!=0)
- Poll((long long)delay_start);
- if(distributed && master_iozone)
- tell_children_begin(i);
- }
- starttime1 = time_so_far();
- goto jumpend4;
- }
-jumpend4:
- getout=0;
- if(myid == (long long)getpid()){ /* Parent here */
- for( i = 0; i < num_child; i++){
- child_stat = (struct child_stats *)&shmaddr[i];
- if(distributed && master_iozone)
- {
- printf("\n\tTest running:");
- wait_dist_join();
- break;
- }
- else
- {
- if(use_thread)
- {
- thread_join(childids[i],(void *)&pstatus);
- }
- else
- {
- wait(0);
- }
- }
- if(!jstarttime)
- jstarttime = time_so_far();
- }
- jtime = (time_so_far()-jstarttime)-time_res;
- if(jtime < (double).000001)
- {
- jtime=time_res;
- }
- }
- total_time = (time_so_far() - starttime1)-time_res; /* Parents time */
- if(total_time < (double).000001)
- {
- total_time=time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-#ifdef JTIME
- total_time=total_time-jtime;/* Remove the join time */
- if(!silent) printf("\nJoin time %10.2f\n",jtime);
-#endif
-
- total_kilos=0;
- ptotal=0;
- min_throughput=max_throughput=min_xfer=0;
- if(!silent) printf("\n");
- for(xyz=0;xyz<num_child;xyz++){
- child_stat=(struct child_stats *)&shmaddr[xyz];
- total_kilos+=child_stat->throughput;
- ptotal+=child_stat->actual;
- if(!min_xfer)
- min_xfer=child_stat->actual;
- if(child_stat->actual < min_xfer)
- min_xfer=child_stat->actual;
- if(!min_throughput)
- min_throughput=child_stat->throughput;
- if(child_stat->throughput < min_throughput)
- min_throughput=child_stat->throughput;
- if(child_stat->throughput > max_throughput)
- max_throughput=child_stat->throughput;
- cputime += child_stat->cputime;
- /* Get the earliest start time and latest fini time to calc. elapsed time. */
- if (child_stat->walltime < child_stat->cputime)
- child_stat->walltime = child_stat->cputime;
- if (child_stat->walltime > walltime)
- walltime = child_stat->walltime;
- }
- avg_throughput=total_kilos/num_child;
- if(cpuutilflag)
- {
- if (cputime < cputime_res)
- cputime = 0.0;
- }
- if(cpuutilflag)
- store_times (walltime, cputime); /* Must be Before store_dvalue(). */
- store_dvalue(total_kilos);
-#ifdef NO_PRINT_LLD
- if(!silent) printf("\tChildren see throughput for %2ld readers \t\t= %10.2f %s/sec\n", num_child, total_kilos,unit);
- if(!silent && !distributed) printf("\tParent sees throughput for %2ld readers \t\t= %10.2f %s/sec\n", num_child, (double)(ptotal)/total_time,unit);
-#else
- if(!silent) printf("\tChildren see throughput for %2lld readers \t\t= %10.2f %s/sec\n", num_child, total_kilos,unit);
- if(!silent && !distributed) printf("\tParent sees throughput for %2lld readers \t\t= %10.2f %s/sec\n", num_child, (double)(ptotal)/total_time,unit);
-#endif
- if(!silent) printf("\tMin throughput per %s \t\t\t= %10.2f %s/sec \n", port,min_throughput,unit);
- if(!silent) printf("\tMax throughput per %s \t\t\t= %10.2f %s/sec\n", port,max_throughput,unit);
- if(!silent) printf("\tAvg throughput per %s \t\t\t= %10.2f %s/sec\n", port,avg_throughput,unit);
- if(!silent) printf("\tMin xfer \t\t\t\t\t= %10.2f %s\n", min_xfer,unit);
- /* CPU% can be > 100.0 for multiple CPUs */
- if(cpuutilflag)
- {
- if(walltime == 0.0)
- {
- if(!silent) printf("\tCPU utilization: Wall time %8.3f CPU time %8.3f CPU utilization %6.2f %%\n\n",
- walltime, cputime, 0.0);
- }
- else
- {
- if(!silent) printf("\tCPU utilization: Wall time %8.3f CPU time %8.3f CPU utilization %6.2f %%\n\n",
- walltime, cputime, 100.0 * cputime / walltime);
- }
- }
- if(Cflag)
- {
- for(xyz=0;xyz<num_child;xyz++)
- {
- child_stat = (struct child_stats *) &shmaddr[xyz];
- if(cpuutilflag)
- {
- if(!silent) printf("\tChild[%ld] xfer count = %10.2f %s, Throughput = %10.2f %s/sec, wall=%6.3f, cpu=%6.3f, %%=%6.2f\n",
- (long)xyz, child_stat->actual, unit, child_stat->throughput, unit, child_stat->walltime,
- child_stat->cputime, cpu_util(child_stat->cputime, child_stat->walltime));
- }
- else
- {
- if(!silent) printf("\tChild[%ld] xfer count = %10.2f %s, Throughput = %10.2f %s/sec\n",
- (long)xyz, child_stat->actual, unit, child_stat->throughput, unit);
- }
- }
- }
- if((!distributed) || (distributed && master_iozone))
- stop_monitor("Read");
- /**********************************************************/
- /*************** End of readers throughput ****************/
- /**********************************************************/
- sync();
- sleep(2);
- if(restf)
- sleep((int)rest_val);
- if(distributed && master_iozone)
- {
- stop_master_listen(master_listen_socket);
- cleanup_comm();
- }
-
- /**************************************************************/
- /*** ReReader throughput tests **********************************/
- /**************************************************************/
- toutputindex++;
- strcpy(&toutput[toutputindex][0],throughput_tests[3]);
- if(noretest)
- {
- store_dvalue( (double)0);
- goto next1;
- }
- if((!distributed) || (distributed && master_iozone))
- start_monitor("Reread");
- walltime = 0.0;
- cputime = 0.0;
- jstarttime=0;
- *stop_flag=0;
- total_kilos=0;
- /* Hooks to start the distributed Iozone client/server code */
- if(distributed)
- {
- use_thread=0; /* Turn of any Posix threads */
- if(master_iozone)
- master_listen_socket = start_master_listen();
- else
- become_client();
- }
- if(!use_thread)
- {
- for(xx = 0; xx< num_child ; xx++){
- chid=xx;
- childids[xx] = start_child_proc(THREAD_REREAD_TEST, numrecs64,reclen);
- if(childids[xx]==-1){
- printf("\nFork failed\n");
- for(xy = 0; xy< xx ; xy++){
- Kill((long long)childids[xy],(long long)SIGTERM);
- }
- exit(32);
- }
- if(childids[xx]==0){
-#ifdef _64BIT_ARCH_
- thread_rread_test((void *)xx);
-#else
- thread_rread_test((void *)((long)xx));
-#endif
- }
- }
- }
-#ifndef NO_THREADS
- else
- {
- for(xx = 0; xx< num_child ; xx++){ /* Create the children */
- chid=xx;
- if(!barray[xx])
- {
- barray[xx]=(char *) alloc_mem((long long)(MAXBUFFERSIZE+cache_size),(int)0);
- if(barray[xx] == 0) {
- perror("Memory allocation failed:");
- exit(26);
- }
- barray[xx] =(char *)(((long)barray[xx] + cache_size ) &
- ~(cache_size-1));
- }
-#ifdef _64BIT_ARCH_
- childids[xx] = mythread_create( thread_rread_test,xx);
-#else
- childids[xx] = mythread_create( thread_rread_test,(void *)(long)xx);
-#endif
- if(childids[xx]==-1){
- printf("\nThread create failed\n");
- for(xy = 0; xy< xx ; xy++){
- kill((pid_t)myid,(int)SIGTERM);
- }
- exit(33);
- }
- }
- }
-#endif
- if(myid == (long long)getpid()){
- if(distributed && master_iozone)
- {
- start_master_listen_loop((int) num_child);
- }
- for(i=0;i<num_child; i++){ /* wait for children to start */
- child_stat = (struct child_stats *)&shmaddr[i];
- while(child_stat->flag==CHILD_STATE_HOLD)
- Poll((long long)1);
- }
- for(i=0;i<num_child; i++){
- child_stat = (struct child_stats *)&shmaddr[i];
- child_stat->flag = CHILD_STATE_BEGIN; /* tell children to go */
- if(delay_start!=0)
- Poll((long long)delay_start);
- if(distributed && master_iozone)
- tell_children_begin(i);
- }
- starttime1 = time_so_far();
- goto jumpend2;
- }
-
-jumpend2:
- getout=0;
- if(myid == (long long)getpid()){ /* Parent here */
- for( i = 0; i < num_child; i++){ /* wait for children to stop */
- child_stat = (struct child_stats *)&shmaddr[i];
- if(distributed && master_iozone)
- {
- printf("\n\tTest running:");
- wait_dist_join();
- break;
- }
- else
- {
- if(use_thread)
- {
- thread_join(childids[i],(void *)&pstatus);
- }
- else
- {
- wait(0);
- }
- }
- if(!jstarttime)
- jstarttime = time_so_far();
- }
- jtime = (time_so_far()-jstarttime)-time_res;
- if(jtime < (double).000001)
- {
- jtime=time_res;
- }
- }
- total_time = (time_so_far() - starttime1)-time_res; /* Parents time */
- if(total_time < (double).000001)
- {
- total_time=time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-#ifdef JTIME
- total_time=total_time-jtime;/* Remove the join time */
- if(!silent) printf("\nJoin time %10.2f\n",jtime);
-#endif
- min_throughput=max_throughput=min_xfer=0;
- total_kilos=0;
- ptotal=0;
- if(!silent) printf("\n");
- for(xyz=0;xyz<num_child;xyz++){
- child_stat = (struct child_stats *)&shmaddr[xyz];
- total_kilos+=child_stat->throughput;
- ptotal+=child_stat->actual;
- if(!min_xfer)
- min_xfer=child_stat->actual;
- if(child_stat->actual < min_xfer)
- min_xfer=child_stat->actual;
- if(!min_throughput)
- min_throughput=child_stat->throughput;
- if(child_stat->throughput < min_throughput)
- min_throughput=child_stat->throughput;
- if(child_stat->throughput > max_throughput)
- max_throughput=child_stat->throughput;
- cputime += child_stat->cputime;
- /* Get the earliest start time and latest fini time to calc. elapsed time. */
- if (child_stat->walltime < child_stat->cputime)
- child_stat->walltime = child_stat->cputime;
- if (child_stat->walltime > walltime)
- walltime = child_stat->walltime;
- }
- avg_throughput=total_kilos/num_child;
- if(cpuutilflag)
- {
-/*
- if (walltime < cputime_res)
- walltime = 0.0;
-*/
- if (cputime < cputime_res)
- cputime = 0.0;
- }
- if(cpuutilflag)
- store_times (walltime, cputime); /* Must be Before store_dvalue(). */
- store_dvalue(total_kilos);
-#ifdef NO_PRINT_LLD
- if(!silent) printf("\tChildren see throughput for %ld re-readers \t= %10.2f %s/sec\n", num_child, total_kilos,unit);
- if(!silent && !distributed) printf("\tParent sees throughput for %ld re-readers \t= %10.2f %s/sec\n", num_child, (double)(ptotal)/total_time,unit);
-#else
- if(!silent) printf("\tChildren see throughput for %lld re-readers \t= %10.2f %s/sec\n", num_child, total_kilos,unit);
- if(!silent && !distributed) printf("\tParent sees throughput for %lld re-readers \t= %10.2f %s/sec\n", num_child, (double)(ptotal)/total_time,unit);
-#endif
- if(!silent) printf("\tMin throughput per %s \t\t\t= %10.2f %s/sec \n", port,min_throughput,unit);
- if(!silent) printf("\tMax throughput per %s \t\t\t= %10.2f %s/sec\n", port,max_throughput,unit);
- if(!silent) printf("\tAvg throughput per %s \t\t\t= %10.2f %s/sec\n", port,avg_throughput,unit);
- if(!silent) printf("\tMin xfer \t\t\t\t\t= %10.2f %s\n", min_xfer,unit);
- /* CPU% can be > 100.0 for multiple CPUs */
- if(cpuutilflag)
- {
- if(walltime == 0.0)
- {
- if(!silent) printf("\tCPU utilization: Wall time %8.3f CPU time %8.3f CPU utilization %6.2f %%\n\n",
- walltime, cputime, 0.0);
- }
- else
- {
- if(!silent) printf("\tCPU utilization: Wall time %8.3f CPU time %8.3f CPU utilization %6.2f %%\n\n",
- walltime, cputime, 100.0 * cputime / walltime);
- }
- }
- if(Cflag)
- {
- for(xyz=0;xyz<num_child;xyz++)
- {
- child_stat = (struct child_stats *) &shmaddr[xyz];
- if(cpuutilflag)
- {
- if(!silent) printf("\tChild[%ld] xfer count = %10.2f %s, Throughput = %10.2f %s/sec, wall=%6.3f, cpu=%6.3f, %%=%6.2f\n",
- (long)xyz, child_stat->actual, unit, child_stat->throughput, unit, child_stat->walltime,
- child_stat->cputime, cpu_util(child_stat->cputime, child_stat->walltime));
- }
- else
- {
- if(!silent) printf("\tChild[%ld] xfer count = %10.2f %s, Throughput = %10.2f %s/sec\n",
- (long)xyz, child_stat->actual, unit, child_stat->throughput, unit);
- }
- }
- }
- if((!distributed) || (distributed && master_iozone))
- stop_monitor("Reread");
- /**********************************************************/
- /*************** End of re-readers throughput ****************/
- /**********************************************************/
- sync();
- sleep(2);
- if(restf)
- sleep((int)rest_val);
- if(distributed && master_iozone)
- {
- stop_master_listen(master_listen_socket);
- cleanup_comm();
- }
-
-next1:
- if(include_tflag)
- if(!(include_mask & (long long)REVERSE_MASK))
- goto next2;
- sync();
- sleep(2);
-
- /**************************************************************/
- /*** Reverse reader throughput tests **************************/
- /**************************************************************/
- toutputindex++;
- strcpy(&toutput[toutputindex][0],throughput_tests[4]);
- if((!distributed) || (distributed && master_iozone))
- start_monitor("Revread");
- walltime = 0.0;
- cputime = 0.0;
- jstarttime=0;
- *stop_flag=0;
- total_kilos=0;
- /* Hooks to start the distributed Iozone client/server code */
- if(distributed)
- {
- use_thread=0; /* Turn of any Posix threads */
- if(master_iozone)
- master_listen_socket = start_master_listen();
- else
- become_client();
- }
- if(!use_thread)
- {
- for(xx = 0; xx< num_child ; xx++){
- chid=xx;
- childids[xx] = start_child_proc(THREAD_REVERSE_READ_TEST,numrecs64,reclen);
- if(childids[xx]==-1){
- printf("\nFork failed\n");
- for(xy = 0; xy< xx ; xy++){
- Kill((long long)childids[xy],(long long)SIGTERM);
- }
- exit(34);
- }
- if(childids[xx]==0){
-#ifdef _64BIT_ARCH_
- thread_reverse_read_test((void *)xx);
-#else
- thread_reverse_read_test((void *)((long)xx));
-#endif
- }
- }
- }
-#ifndef NO_THREADS
- else
- {
- for(xx = 0; xx< num_child ; xx++){ /* Create the children */
- chid=xx;
- if(!barray[xx])
- {
- barray[xx]=(char *) alloc_mem((long long)(MAXBUFFERSIZE+cache_size),(int)0);
- if(barray[xx] == 0) {
- perror("Memory allocation failed:");
- exit(26);
- }
- barray[xx] =(char *)(((long)barray[xx] + cache_size ) &
- ~(cache_size-1));
- }
-#ifdef _64BIT_ARCH_
- childids[xx] = mythread_create( thread_reverse_read_test,xx);
-#else
- childids[xx] = mythread_create( thread_reverse_read_test,(void *)(long)xx);
-#endif
- if(childids[xx]==-1){
- printf("\nThread create failed\n");
- for(xy = 0; xy< xx ; xy++){
- kill((pid_t)myid,(int)SIGTERM);
- }
- exit(35);
- }
- }
- }
-#endif
- if(myid == (long long)getpid()){
- if(distributed && master_iozone)
- {
- start_master_listen_loop((int) num_child);
- }
- for(i=0;i<num_child; i++){ /* wait for children to start */
- child_stat = (struct child_stats *)&shmaddr[i];
- while(child_stat->flag==CHILD_STATE_HOLD)
- Poll((long long)1);
- }
- for(i=0;i<num_child; i++){
- child_stat = (struct child_stats *)&shmaddr[i];
- child_stat->flag = CHILD_STATE_BEGIN; /* tell children to go */
- if(delay_start!=0)
- Poll((long long)delay_start);
- if(distributed && master_iozone)
- tell_children_begin(i);
- }
- starttime1 = time_so_far();
- }
-
- getout=0;
- if(myid == (long long)getpid()){ /* Parent here */
- for( i = 0; i < num_child; i++){ /* wait for children to stop */
- child_stat = (struct child_stats *)&shmaddr[i];
- if(distributed && master_iozone)
- {
- printf("\n\tTest running:");
- wait_dist_join();
- break;
- }
- else
- {
- if(use_thread)
- {
- thread_join(childids[i],(void *)&pstatus);
- }
- else
- {
- wait(0);
- }
- }
- if(!jstarttime)
- jstarttime = time_so_far();
- }
- jtime = (time_so_far()-jstarttime)-time_res;
- if(jtime < (double).000001)
- {
- jtime=time_res;
- }
- }
- total_time = (time_so_far() - starttime1)-time_res; /* Parents time */
- if(total_time < (double).000001)
- {
- total_time=time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-#ifdef JTIME
- total_time=total_time-jtime;/* Remove the join time */
- if(!silent) printf("\nJoin time %10.2f\n",jtime);
-#endif
- total_kilos=0;
- ptotal=0;
- min_throughput=max_throughput=min_xfer=0;
- if(!silent) printf("\n");
- for(xyz=0;xyz<num_child;xyz++){
- child_stat = (struct child_stats *)&shmaddr[xyz];
- total_kilos+=child_stat->throughput;
- ptotal+=child_stat->actual;
- if(!min_xfer)
- min_xfer=child_stat->actual;
- if(child_stat->actual < min_xfer)
- min_xfer=child_stat->actual;
- if(!min_throughput)
- min_throughput=child_stat->throughput;
- if(child_stat->throughput < min_throughput)
- min_throughput=child_stat->throughput;
- if(child_stat->throughput > max_throughput)
- max_throughput=child_stat->throughput;
- /* walltime += child_stat->walltime; */
- cputime += child_stat->cputime;
- /* Get the earliest start time and latest fini time to calc. elapsed time. */
- if (child_stat->walltime < child_stat->cputime)
- child_stat->walltime = child_stat->cputime;
- if (child_stat->walltime > walltime)
- walltime = child_stat->walltime;
- }
- avg_throughput=total_kilos/num_child;
- if(cpuutilflag)
- {
-/*
- if (walltime < cputime_res)
- walltime = 0.0;
-*/
- if (cputime < cputime_res)
- cputime = 0.0;
- }
- if(cpuutilflag)
- store_times (walltime, cputime); /* Must be Before store_dvalue(). */
- store_dvalue(total_kilos);
-#ifdef NO_PRINT_LLD
- if(!silent) printf("\tChildren see throughput for %ld reverse readers \t= %10.2f %s/sec\n", num_child, total_kilos,unit);
- if(!silent && !distributed) printf("\tParent sees throughput for %ld reverse readers \t= %10.2f %s/sec\n", num_child, (double)(ptotal)/total_time,unit);
-#else
- if(!silent) printf("\tChildren see throughput for %lld reverse readers \t= %10.2f %s/sec\n", num_child, total_kilos,unit);
- if(!silent && !distributed) printf("\tParent sees throughput for %lld reverse readers \t= %10.2f %s/sec\n", num_child, (double)(ptotal)/total_time,unit);
-#endif
- if(!silent) printf("\tMin throughput per %s \t\t\t= %10.2f %s/sec \n", port,min_throughput,unit);
- if(!silent) printf("\tMax throughput per %s \t\t\t= %10.2f %s/sec\n", port,max_throughput,unit);
- if(!silent) printf("\tAvg throughput per %s \t\t\t= %10.2f %s/sec\n", port,avg_throughput,unit);
- if(!silent) printf("\tMin xfer \t\t\t\t\t= %10.2f %s\n", min_xfer,unit);
- /* CPU% can be > 100.0 for multiple CPUs */
- if(cpuutilflag)
- {
- if(walltime == 0.0)
- {
- if(!silent) printf("\tCPU utilization: Wall time %8.3f CPU time %8.3f CPU utilization %6.2f %%\n\n",
- walltime, cputime, 0.0);
- }
- else
- {
- if(!silent) printf("\tCPU utilization: Wall time %8.3f CPU time %8.3f CPU utilization %6.2f %%\n\n",
- walltime, cputime, 100.0 * cputime / walltime);
- }
- }
- if(Cflag)
- {
- for(xyz=0;xyz<num_child;xyz++)
- {
- child_stat = (struct child_stats *) &shmaddr[xyz];
- if(cpuutilflag)
- {
- if(!silent) printf("\tChild[%ld] xfer count = %10.2f %s, Throughput = %10.2f %s/sec, wall=%6.3f, cpu=%6.3f, %%=%6.2f\n",
- (long)xyz, child_stat->actual, unit, child_stat->throughput, unit, child_stat->walltime,
- child_stat->cputime, cpu_util(child_stat->cputime, child_stat->walltime));
- }
- else
- {
- if(!silent) printf("\tChild[%ld] xfer count = %10.2f %s, Throughput = %10.2f %s/sec\n",
- (long)xyz, child_stat->actual, unit, child_stat->throughput, unit);
- }
- }
- }
- if((!distributed) || (distributed && master_iozone))
- stop_monitor("Revread");
- sync();
- sleep(2);
- if(restf)
- sleep((int)rest_val);
- if(distributed && master_iozone)
- {
- stop_master_listen(master_listen_socket);
- cleanup_comm();
- }
-next2:
- if(include_tflag)
- if(!(include_mask & (long long)STRIDE_READ_MASK))
- goto next3;
- /**************************************************************/
- /*** stride reader throughput tests **************************/
- /**************************************************************/
- toutputindex++;
- strcpy(&toutput[toutputindex][0],throughput_tests[5]);
- if((!distributed) || (distributed && master_iozone))
- start_monitor("Strideread");
- walltime = 0.0;
- cputime = 0.0;
- jstarttime=0;
- sync();
- sleep(2);
- *stop_flag=0;
- total_kilos=0;
- /* Hooks to start the distributed Iozone client/server code */
- if(distributed)
- {
- use_thread=0; /* Turn of any Posix threads */
- if(master_iozone)
- master_listen_socket = start_master_listen();
- else
- become_client();
- }
- if(!use_thread)
- {
- for(xx = 0; xx< num_child ; xx++){
- chid=xx;
- childids[xx] = start_child_proc(THREAD_STRIDE_TEST,numrecs64,reclen);
- if(childids[xx]==-1){
- printf("\nFork failed\n");
- for(xy = 0; xy< xx ; xy++){
- Kill((long long)childids[xy],(long long)SIGTERM);
- }
- exit(36);
- }
- if(childids[xx]==0){
-#ifdef _64BIT_ARCH_
- thread_stride_read_test((void *)xx);
-#else
- thread_stride_read_test((void *)((long)xx));
-#endif
- }
- }
- }
-#ifndef NO_THREADS
- else
- {
- for(xx = 0; xx< num_child ; xx++){ /* Create the children */
- chid=xx;
- if(!barray[xx])
- {
- barray[xx]=(char *) alloc_mem((long long)(MAXBUFFERSIZE+cache_size),(int)0);
- if(barray[xx] == 0) {
- perror("Memory allocation failed:");
- exit(26);
- }
- barray[xx] =(char *)(((long)barray[xx] + cache_size ) &
- ~(cache_size-1));
- }
-#ifdef _64BIT_ARCH_
- childids[xx] = mythread_create( thread_stride_read_test,xx);
-#else
- childids[xx] = mythread_create( thread_stride_read_test,(void *)(long)xx);
-#endif
- if(childids[xx]==-1){
- printf("\nThread create failed\n");
- for(xy = 0; xy< xx ; xy++){
- kill((pid_t)myid,(int)SIGTERM);
- }
- exit(37);
- }
- }
- }
-#endif
- if(myid == (long long)getpid()){
- if(distributed && master_iozone)
- {
- start_master_listen_loop((int) num_child);
- }
- for(i=0;i<num_child; i++){ /* wait for children to start */
- child_stat = (struct child_stats *)&shmaddr[i];
- while(child_stat->flag==CHILD_STATE_HOLD)
- Poll((long long)1);
- }
- for(i=0;i<num_child; i++){
- child_stat = (struct child_stats *)&shmaddr[i];
- child_stat->flag = CHILD_STATE_BEGIN; /* tell children to go */
- if(delay_start!=0)
- Poll((long long)delay_start);
- if(distributed && master_iozone)
- tell_children_begin(i);
- }
- starttime1 = time_so_far();
- }
-
- getout=0;
- if(myid == (long long)getpid()){ /* Parent here */
- for( i = 0; i < num_child; i++){ /* wait for children to stop */
- child_stat = (struct child_stats *)&shmaddr[i];
- if(distributed && master_iozone)
- {
- printf("\n\tTest running:");
- wait_dist_join();
- break;
- }
- else
- {
- if(use_thread)
- {
- thread_join(childids[i],(void *)&pstatus);
- }
- else
- {
- wait(0);
- }
- }
- if(!jstarttime)
- jstarttime = time_so_far();
- }
- jtime = (time_so_far()-jstarttime)-time_res;
- if(jtime < (double).000001)
- {
- jtime=time_res;
- }
- }
- total_time = (time_so_far() - starttime1)-time_res; /* Parents time */
- if(total_time < (double).000001)
- {
- total_time=time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-#ifdef JTIME
- total_time=total_time-jtime;/* Remove the join time */
- if(!silent) printf("\nJoin time %10.2f\n",jtime);
-#endif
- total_kilos=0;
- ptotal=0;
- min_throughput=max_throughput=min_xfer=0;
- if(!silent) printf("\n");
- for(xyz=0;xyz<num_child;xyz++){
- child_stat = (struct child_stats *)&shmaddr[xyz];
- total_kilos+=child_stat->throughput;
- ptotal+=child_stat->actual;
- if(!min_xfer)
- min_xfer=child_stat->actual;
- if(child_stat->actual < min_xfer)
- min_xfer=child_stat->actual;
- if(!min_throughput)
- min_throughput=child_stat->throughput;
- if(child_stat->throughput < min_throughput)
- min_throughput=child_stat->throughput;
- if(child_stat->throughput > max_throughput)
- max_throughput=child_stat->throughput;
- /* walltime += child_stat->walltime; */
- cputime += child_stat->cputime;
- /* Get the biggest walltime */
- if (child_stat->walltime < child_stat->cputime)
- child_stat->walltime = child_stat->cputime;
- if (child_stat->walltime > walltime)
- walltime = child_stat->walltime;
- }
- avg_throughput=total_kilos/num_child;
- if(cpuutilflag)
- {
-/*
- if (walltime < cputime_res)
- walltime = 0.0;
-*/
- if (cputime < cputime_res)
- cputime = 0.0;
- }
- if(cpuutilflag)
- store_times (walltime, cputime); /* Must be Before store_dvalue(). */
- store_dvalue(total_kilos);
-#ifdef NO_PRINT_LLD
- if(!silent) printf("\tChildren see throughput for %ld stride readers \t= %10.2f %s/sec\n", num_child, total_kilos,unit);
- if(!silent && !distributed) printf("\tParent sees throughput for %ld stride readers \t= %10.2f %s/sec\n", num_child, (double)(ptotal)/total_time,unit);
-#else
- if(!silent) printf("\tChildren see throughput for %lld stride readers \t= %10.2f %s/sec\n", num_child, total_kilos,unit);
- if(!silent && !distributed) printf("\tParent sees throughput for %lld stride readers \t= %10.2f %s/sec\n", num_child, (double)(ptotal)/total_time,unit);
-#endif
- if(!silent) printf("\tMin throughput per %s \t\t\t= %10.2f %s/sec \n", port,min_throughput,unit);
- if(!silent) printf("\tMax throughput per %s \t\t\t= %10.2f %s/sec\n", port,max_throughput,unit);
- if(!silent) printf("\tAvg throughput per %s \t\t\t= %10.2f %s/sec\n", port,avg_throughput,unit);
- if(!silent) printf("\tMin xfer \t\t\t\t\t= %10.2f %s\n", min_xfer,unit);
- /* CPU% can be > 100.0 for multiple CPUs */
- if(cpuutilflag)
- {
- if(walltime == 0.0)
- {
- if(!silent) printf("\tCPU utilization: Wall time %8.3f CPU time %8.3f CPU utilization %6.2f %%\n\n",
- walltime, cputime, 0.0);
- }
- else
- {
- if(!silent) printf("\tCPU utilization: Wall time %8.3f CPU time %8.3f CPU utilization %6.2f %%\n\n",
- walltime, cputime, 100.0 * cputime / walltime);
- }
- }
- if(Cflag)
- {
- for(xyz=0;xyz<num_child;xyz++)
- {
- child_stat = (struct child_stats *) &shmaddr[xyz];
- if(cpuutilflag)
- {
- if(!silent) printf("\tChild[%ld] xfer count = %10.2f %s, Throughput = %10.2f %s/sec, wall=%6.3f, cpu=%6.3f, %%=%6.2f\n",
- (long)xyz, child_stat->actual, unit, child_stat->throughput, unit, child_stat->walltime,
- child_stat->cputime, cpu_util(child_stat->cputime, child_stat->walltime));
- }
- else
- {
- if(!silent) printf("\tChild[%ld] xfer count = %10.2f %s, Throughput = %10.2f %s/sec\n",
- (long)xyz, child_stat->actual, unit, child_stat->throughput, unit);
- }
- }
- }
- if((!distributed) || (distributed && master_iozone))
- stop_monitor("Strideread");
- sync();
- sleep(2);
- if(restf)
- sleep((int)rest_val);
- if(distributed && master_iozone)
- {
- stop_master_listen(master_listen_socket);
- cleanup_comm();
- }
- /**************************************************************/
- /*** random reader throughput tests ***************************/
- /**************************************************************/
-next3:
- if(include_tflag)
- if(!(include_mask & (long long)RANDOM_RW_MASK))
- goto next4;
-
- toutputindex++;
- strcpy(&toutput[toutputindex][0],throughput_tests[6]);
- if((!distributed) || (distributed && master_iozone))
- start_monitor("Randread");
- walltime = 0.0;
- cputime = 0.0;
- jstarttime=0;
- sync();
- sleep(2);
- *stop_flag=0;
- total_kilos=0;
- /* Hooks to start the distributed Iozone client/server code */
- if(distributed)
- {
- use_thread=0; /* Turn of any Posix threads */
- if(master_iozone)
- master_listen_socket = start_master_listen();
- else
- become_client();
- }
- if(!use_thread)
- {
- for(xx = 0; xx< num_child ; xx++){
- chid=xx;
- childids[xx] = start_child_proc(THREAD_RANDOM_READ_TEST,numrecs64,reclen);
- if(childids[xx]==-1){
- printf("\nFork failed\n");
- for(xy = 0; xy< xx ; xy++){
- Kill((long long)childids[xy],(long long)SIGTERM);
- }
- exit(38);
- }
- if(childids[xx]==0){
-#ifdef _64BIT_ARCH_
- thread_ranread_test((void *)xx);
-#else
- thread_ranread_test((void *)((long)xx));
-#endif
- }
- }
- }
-#ifndef NO_THREADS
- else
- {
- for(xx = 0; xx< num_child ; xx++){ /* Create the children */
- chid=xx;
- if(!barray[xx])
- {
- barray[xx]=(char *) alloc_mem((long long)(MAXBUFFERSIZE+cache_size),(int)0);
- if(barray[xx] == 0) {
- perror("Memory allocation failed:");
- exit(26);
- }
- barray[xx] =(char *)(((long)barray[xx] + cache_size ) &
- ~(cache_size-1));
- }
-#ifdef _64BIT_ARCH_
- childids[xx] = mythread_create( thread_ranread_test,xx);
-#else
- childids[xx] = mythread_create( thread_ranread_test,(void *)(long)xx);
-#endif
- if(childids[xx]==-1){
- printf("\nThread create failed\n");
- for(xy = 0; xy< xx ; xy++){
- kill((pid_t)myid,(int)SIGTERM);
- }
- exit(39);
- }
- }
- }
-#endif
- if(myid == (long long)getpid()){
- if(distributed && master_iozone)
- {
- start_master_listen_loop((int) num_child);
- }
- for(i=0;i<num_child; i++){ /* wait for children to start */
- child_stat = (struct child_stats *)&shmaddr[i];
- while(child_stat->flag==CHILD_STATE_HOLD)
- Poll((long long)1);
- }
- for(i=0;i<num_child; i++){
- child_stat = (struct child_stats *)&shmaddr[i];
- child_stat->flag = CHILD_STATE_BEGIN; /* tell children to go */
- if(delay_start!=0)
- Poll((long long)delay_start);
- if(distributed && master_iozone)
- tell_children_begin(i);
- }
- starttime1 = time_so_far();
- }
-
- getout=0;
- if(myid == (long long)getpid()){ /* Parent here */
- for( i = 0; i < num_child; i++){ /* wait for children to stop */
- child_stat = (struct child_stats *)&shmaddr[i];
- if(distributed && master_iozone)
- {
- printf("\n\tTest running:");
- wait_dist_join();
- break;
- }
- else
- {
- if(use_thread)
- {
- thread_join(childids[i],(void *)&pstatus);
- }
- else
- {
- wait(0);
- }
- }
- if(!jstarttime)
- jstarttime = time_so_far();
- }
- jtime = (time_so_far()-jstarttime)-time_res;
- if(jtime < (double).000001)
- {
- jtime=time_res;
- }
- }
- total_time = (time_so_far() - starttime1)-time_res; /* Parents time */
- if(total_time < (double).000001)
- {
- total_time=time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-#ifdef JTIME
- total_time=total_time-jtime;/* Remove the join time */
- if(!silent) printf("\nJoin time %10.2f\n",jtime);
-#endif
- total_kilos=0;
- ptotal=0;
- min_throughput=max_throughput=min_xfer=0;
- if(!silent) printf("\n");
- for(xyz=0;xyz<num_child;xyz++){
- child_stat = (struct child_stats *)&shmaddr[xyz];
- total_kilos+=child_stat->throughput;
- ptotal+=child_stat->actual;
- if(!min_xfer)
- min_xfer=child_stat->actual;
- if(child_stat->actual < min_xfer)
- min_xfer=child_stat->actual;
- if(!min_throughput)
- min_throughput=child_stat->throughput;
- if(child_stat->throughput < min_throughput)
- min_throughput=child_stat->throughput;
- if(child_stat->throughput > max_throughput)
- max_throughput=child_stat->throughput;
- cputime += child_stat->cputime;
- /* Get the biggest walltime */
- if (child_stat->walltime < child_stat->cputime)
- child_stat->walltime = child_stat->cputime;
- if (child_stat->walltime > walltime)
- walltime = child_stat->walltime;
- }
- avg_throughput=total_kilos/num_child;
- if(cpuutilflag)
- {
- if (cputime < cputime_res)
- cputime = 0.0;
- }
- if(cpuutilflag)
- store_times (walltime, cputime); /* Must be Before store_dvalue(). */
- store_dvalue(total_kilos);
-#ifdef NO_PRINT_LLD
- if(!silent) printf("\tChildren see throughput for %ld random readers \t= %10.2f %s/sec\n", num_child, total_kilos,unit);
- if(!silent && !distributed) printf("\tParent sees throughput for %ld random readers \t= %10.2f %s/sec\n", num_child, (double)(ptotal)/total_time,unit);
-#else
- if(!silent) printf("\tChildren see throughput for %lld random readers \t= %10.2f %s/sec\n", num_child, total_kilos,unit);
- if(!silent && !distributed) printf("\tParent sees throughput for %lld random readers \t= %10.2f %s/sec\n", num_child, (double)(ptotal)/total_time,unit);
-#endif
- if(!silent) printf("\tMin throughput per %s \t\t\t= %10.2f %s/sec \n", port,min_throughput,unit);
- if(!silent) printf("\tMax throughput per %s \t\t\t= %10.2f %s/sec\n", port,max_throughput,unit);
- if(!silent) printf("\tAvg throughput per %s \t\t\t= %10.2f %s/sec\n", port,avg_throughput,unit);
- if(!silent) printf("\tMin xfer \t\t\t\t\t= %10.2f %s\n", min_xfer,unit);
- /* CPU% can be > 100.0 for multiple CPUs */
- if(cpuutilflag)
- {
- if(walltime == 0.0)
- {
- if(!silent) printf("\tCPU utilization: Wall time %8.3f CPU time %8.3f CPU utilization %6.2f %%\n\n",
- walltime, cputime, 0.0);
- }
- else
- {
- if(!silent) printf("\tCPU utilization: Wall time %8.3f CPU time %8.3f CPU utilization %6.2f %%\n\n",
- walltime, cputime, 100.0 * cputime / walltime);
- }
- }
- if(Cflag)
- {
- for(xyz=0;xyz<num_child;xyz++)
- {
- child_stat = (struct child_stats *) &shmaddr[xyz];
- if(cpuutilflag)
- {
- if(!silent) printf("\tChild[%ld] xfer count = %10.2f %s, Throughput = %10.2f %s/sec, wall=%6.3f, cpu=%6.3f, %%=%6.2f\n",
- (long)xyz, child_stat->actual, unit, child_stat->throughput, unit, child_stat->walltime,
- child_stat->cputime, cpu_util(child_stat->cputime, child_stat->walltime));
- }
- else
- {
- if(!silent) printf("\tChild[%ld] xfer count = %10.2f %s, Throughput = %10.2f %s/sec\n",
- (long)xyz, child_stat->actual, unit, child_stat->throughput, unit);
- }
- }
- }
- if((!distributed) || (distributed && master_iozone))
- stop_monitor("Randread");
- sync();
- sleep(2);
- if(restf)
- sleep((int)rest_val);
- if(distributed && master_iozone)
- {
- stop_master_listen(master_listen_socket);
- cleanup_comm();
- }
- /**************************************************************/
- /*** mixed workload throughput tests ***************************/
- /**************************************************************/
-next4:
- if(include_tflag)
- if(!(include_mask & (long long)RANDOM_MIX_MASK))
- goto next5;
-
- toutputindex++;
- strcpy(&toutput[toutputindex][0],throughput_tests[7]);
- if((!distributed) || (distributed && master_iozone))
- start_monitor("Mixed");
- walltime = 0.0;
- cputime = 0.0;
- jstarttime=0;
- sync();
- sleep(2);
- *stop_flag=0;
- total_kilos=0;
- /* Hooks to start the distributed Iozone client/server code */
- if(distributed)
- {
- use_thread=0; /* Turn of any Posix threads */
- if(master_iozone)
- master_listen_socket = start_master_listen();
- else
- become_client();
- }
- if(!use_thread)
- {
- for(xx = 0; xx< num_child ; xx++){
- chid=xx;
- childids[xx] = start_child_proc(THREAD_RANDOM_MIX_TEST,numrecs64,reclen);
- if(childids[xx]==-1){
- printf("\nFork failed\n");
- for(xy = 0; xy< xx ; xy++){
- Kill((long long)childids[xy],(long long)SIGTERM);
- }
- exit(38);
- }
- if(childids[xx]==0){
-#ifdef _64BIT_ARCH_
- thread_mix_test((void *)xx);
-#else
- thread_mix_test((void *)((long)xx));
-#endif
- }
- }
- }
-#ifndef NO_THREADS
- else
- {
- for(xx = 0; xx< num_child ; xx++){ /* Create the children */
- chid=xx;
- if(!barray[xx])
- {
- barray[xx]=(char *) alloc_mem((long long)(MAXBUFFERSIZE+cache_size),(int)0);
- if(barray[xx] == 0) {
- perror("Memory allocation failed:");
- exit(26);
- }
- barray[xx] =(char *)(((long)barray[xx] + cache_size ) &
- ~(cache_size-1));
- }
-#ifdef _64BIT_ARCH_
- childids[xx] = mythread_create( thread_mix_test,xx);
-#else
- childids[xx] = mythread_create( thread_mix_test,(void *)(long)xx);
-#endif
- if(childids[xx]==-1){
- printf("\nThread create failed\n");
- for(xy = 0; xy< xx ; xy++){
- kill((pid_t)myid,(int)SIGTERM);
- }
- exit(39);
- }
- }
- }
-#endif
- if(myid == (long long)getpid()){
- if(distributed && master_iozone)
- {
- start_master_listen_loop((int) num_child);
- }
- for(i=0;i<num_child; i++){ /* wait for children to start */
- child_stat = (struct child_stats *)&shmaddr[i];
- while(child_stat->flag==CHILD_STATE_HOLD)
- Poll((long long)1);
- }
- for(i=0;i<num_child; i++){
- child_stat = (struct child_stats *)&shmaddr[i];
- child_stat->flag = CHILD_STATE_BEGIN; /* tell children to go */
- if(delay_start!=0)
- Poll((long long)delay_start);
- if(distributed && master_iozone)
- tell_children_begin(i);
- }
- starttime1 = time_so_far();
- }
-
- getout=0;
- if(myid == (long long)getpid()){ /* Parent here */
- for( i = 0; i < num_child; i++){ /* wait for children to stop */
- child_stat = (struct child_stats *)&shmaddr[i];
- if(distributed && master_iozone)
- {
- printf("\n\tTest running:");
- wait_dist_join();
- break;
- }
- else
- {
- if(use_thread)
- {
- thread_join(childids[i],(void *)&pstatus);
- }
- else
- {
- wait(0);
- }
- }
- if(!jstarttime)
- jstarttime = time_so_far();
- }
- jtime = (time_so_far()-jstarttime)-time_res;
- if(jtime < (double).000001)
- {
- jtime=time_res;
- }
- }
- total_time = (time_so_far() - starttime1)-time_res; /* Parents time */
- if(total_time < (double).000001)
- {
- total_time=time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-#ifdef JTIME
- total_time=total_time-jtime;/* Remove the join time */
- if(!silent) printf("\nJoin time %10.2f\n",jtime);
-#endif
- total_kilos=0;
- ptotal=0;
- min_throughput=max_throughput=min_xfer=0;
- if(!silent) printf("\n");
- for(xyz=0;xyz<num_child;xyz++){
- child_stat = (struct child_stats *)&shmaddr[xyz];
- total_kilos+=child_stat->throughput;
- ptotal+=child_stat->actual;
- if(!min_xfer)
- min_xfer=child_stat->actual;
- if(child_stat->actual < min_xfer)
- min_xfer=child_stat->actual;
- if(!min_throughput)
- min_throughput=child_stat->throughput;
- if(child_stat->throughput < min_throughput)
- min_throughput=child_stat->throughput;
- if(child_stat->throughput > max_throughput)
- max_throughput=child_stat->throughput;
- cputime += child_stat->cputime;
- /* Get the biggest walltime */
- if (child_stat->walltime < child_stat->cputime)
- child_stat->walltime = child_stat->cputime;
- if (child_stat->walltime > walltime)
- walltime = child_stat->walltime;
- }
- avg_throughput=total_kilos/num_child;
- if(cpuutilflag)
- {
- if (cputime < cputime_res)
- cputime = 0.0;
- }
- if(cpuutilflag)
- store_times (walltime, cputime); /* Must be Before store_dvalue(). */
- store_dvalue(total_kilos);
-#ifdef NO_PRINT_LLD
- if(!silent) printf("\tChildren see throughput for %ld mixed workload \t= %10.2f %s/sec\n", num_child, total_kilos,unit);
- if(!silent && !distributed) printf("\tParent sees throughput for %ld mixed workload \t= %10.2f %s/sec\n", num_child, (double)(ptotal)/total_time,unit);
-#else
- if(!silent) printf("\tChildren see throughput for %lld mixed workload \t= %10.2f %s/sec\n", num_child, total_kilos,unit);
- if(!silent && !distributed) printf("\tParent sees throughput for %lld mixed workload \t= %10.2f %s/sec\n", num_child, (double)(ptotal)/total_time,unit);
-#endif
- if(!silent) printf("\tMin throughput per %s \t\t\t= %10.2f %s/sec \n", port,min_throughput,unit);
- if(!silent) printf("\tMax throughput per %s \t\t\t= %10.2f %s/sec\n", port,max_throughput,unit);
- if(!silent) printf("\tAvg throughput per %s \t\t\t= %10.2f %s/sec\n", port,avg_throughput,unit);
- if(!silent) printf("\tMin xfer \t\t\t\t\t= %10.2f %s\n", min_xfer,unit);
- /* CPU% can be > 100.0 for multiple CPUs */
- if(cpuutilflag)
- {
- if(walltime == 0.0)
- {
- if(!silent) printf("\tCPU utilization: Wall time %8.3f CPU time %8.3f CPU utilization %6.2f %%\n\n",
- walltime, cputime, 0.0);
- }
- else
- {
- if(!silent) printf("\tCPU utilization: Wall time %8.3f CPU time %8.3f CPU utilization %6.2f %%\n\n",
- walltime, cputime, 100.0 * cputime / walltime);
- }
- }
- if(Cflag)
- {
- for(xyz=0;xyz<num_child;xyz++)
- {
- child_stat = (struct child_stats *) &shmaddr[xyz];
- if(cpuutilflag)
- {
- if(!silent) printf("\tChild[%ld] xfer count = %10.2f %s, Throughput = %10.2f %s/sec, wall=%6.3f, cpu=%6.3f, %%=%6.2f\n",
- (long)xyz, child_stat->actual, unit, child_stat->throughput, unit, child_stat->walltime,
- child_stat->cputime, cpu_util(child_stat->cputime, child_stat->walltime));
- }
- else
- {
- if(!silent) printf("\tChild[%ld] xfer count = %10.2f %s, Throughput = %10.2f %s/sec\n",
- (long)xyz, child_stat->actual, unit, child_stat->throughput, unit);
- }
- }
- }
- if((!distributed) || (distributed && master_iozone))
- stop_monitor("Mixed");
- sync();
- sleep(2);
- if(restf)
- sleep((int)rest_val);
- if(distributed && master_iozone)
- {
- stop_master_listen(master_listen_socket);
- cleanup_comm();
- }
-next5:
- /**************************************************************/
- /*** random writer throughput tests **************************/
- /**************************************************************/
- if(include_tflag)
- if(!(include_mask & (long long)RANDOM_RW_MASK) || no_write)
- goto next6;
-
- toutputindex++;
- strcpy(&toutput[toutputindex][0],throughput_tests[8]);
- if((!distributed) || (distributed && master_iozone))
- start_monitor("Randwrite");
- walltime = 0.0;
- cputime = 0.0;
- jstarttime=0;
- sync();
- sleep(2);
- *stop_flag=0;
- total_kilos=0;
- /* Hooks to start the distributed Iozone client/server code */
- if(distributed)
- {
- use_thread=0; /* Turn of any Posix threads */
- if(master_iozone)
- master_listen_socket = start_master_listen();
- else
- become_client();
- }
- if(!use_thread)
- {
- for(xx = 0; xx< num_child ; xx++){
- chid=xx;
- childids[xx] = start_child_proc(THREAD_RANDOM_WRITE_TEST,numrecs64,reclen);
- if(childids[xx]==-1){
- printf("\nFork failed\n");
- for(xy = 0; xy< xx ; xy++){
- Kill((long long)childids[xy],(long long)SIGTERM);
- }
- exit(38);
- }
- if(childids[xx]==0){
-#ifdef _64BIT_ARCH_
- thread_ranwrite_test((void *)xx);
-#else
- thread_ranwrite_test((void *)((long)xx));
-#endif
- }
- }
- }
-#ifndef NO_THREADS
- else
- {
- for(xx = 0; xx< num_child ; xx++){ /* Create the children */
- chid=xx;
- if(!barray[xx])
- {
- barray[xx]=(char *) alloc_mem((long long)(MAXBUFFERSIZE+cache_size),(int)0);
- if(barray[xx] == 0) {
- perror("Memory allocation failed:");
- exit(26);
- }
- barray[xx] =(char *)(((long)barray[xx] + cache_size ) &
- ~(cache_size-1));
- }
-#ifdef _64BIT_ARCH_
- childids[xx] = mythread_create( thread_ranwrite_test,xx);
-#else
- childids[xx] = mythread_create( thread_ranwrite_test,(void *)(long)xx);
-#endif
- if(childids[xx]==-1){
- printf("\nThread create failed\n");
- for(xy = 0; xy< xx ; xy++){
- kill((pid_t)myid,(int)SIGTERM);
- }
- exit(39);
- }
- }
- }
-#endif
- if(myid == (long long)getpid()){
- if(distributed && master_iozone)
- {
- start_master_listen_loop((int) num_child);
- }
- for(i=0;i<num_child; i++){ /* wait for children to start */
- child_stat = (struct child_stats *)&shmaddr[i];
- while(child_stat->flag==CHILD_STATE_HOLD)
- Poll((long long)1);
- }
- for(i=0;i<num_child; i++){
- child_stat = (struct child_stats *)&shmaddr[i];
- child_stat->flag = CHILD_STATE_BEGIN; /* tell children to go */
- if(delay_start!=0)
- Poll((long long)delay_start);
- if(distributed && master_iozone)
- tell_children_begin(i);
- }
- starttime1 = time_so_far();
- }
-
- getout=0;
- if(myid == (long long)getpid()){ /* Parent here */
- for( i = 0; i < num_child; i++){ /* wait for children to stop */
- child_stat = (struct child_stats *)&shmaddr[i];
- if(distributed && master_iozone)
- {
- printf("\n\tTest running:");
- wait_dist_join();
- break;
- }
- else
- {
- if(use_thread)
- {
- thread_join(childids[i],(void *)&pstatus);
- }
- else
- {
- wait(0);
- }
- }
- if(!jstarttime)
- jstarttime = time_so_far();
- }
- jtime = (time_so_far()-jstarttime)-time_res;
- if(jtime < (double).000001)
- {
- jtime=time_res;
- }
- }
- total_time = (time_so_far() - starttime1)-time_res; /* Parents time */
- if(total_time < (double).000001)
- {
- total_time=time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-#ifdef JTIME
- total_time=total_time-jtime;/* Remove the join time */
- if(!silent) printf("\nJoin time %10.2f\n",jtime);
-#endif
- total_kilos=0;
- ptotal=0;
- min_throughput=max_throughput=min_xfer=0;
- if(!silent) printf("\n");
- for(xyz=0;xyz<num_child;xyz++){
- child_stat = (struct child_stats *)&shmaddr[xyz];
- total_kilos+=child_stat->throughput;
- ptotal+=child_stat->actual;
- if(!min_xfer)
- min_xfer=child_stat->actual;
- if(child_stat->actual < min_xfer)
- min_xfer=child_stat->actual;
- if(!min_throughput)
- min_throughput=child_stat->throughput;
- if(child_stat->throughput < min_throughput)
- min_throughput=child_stat->throughput;
- if(child_stat->throughput > max_throughput)
- max_throughput=child_stat->throughput;
- cputime += child_stat->cputime;
- /* Get the biggest walltime */
- if (child_stat->walltime < child_stat->cputime)
- child_stat->walltime = child_stat->cputime;
- if (child_stat->walltime > walltime)
- walltime = child_stat->walltime;
- }
- avg_throughput=total_kilos/num_child;
- if(cpuutilflag)
- {
- if (cputime < cputime_res)
- cputime = 0.0;
- }
- if(cpuutilflag)
- store_times (walltime, cputime); /* Must be Before store_dvalue(). */
- store_dvalue(total_kilos);
-#ifdef NO_PRINT_LLD
- if(!silent) printf("\tChildren see throughput for %ld random writers \t= %10.2f %s/sec\n", num_child, total_kilos,unit);
- if(!silent && !distributed) printf("\tParent sees throughput for %ld random writers \t= %10.2f %s/sec\n", num_child, (double)(ptotal)/total_time,unit);
-#else
- if(!silent) printf("\tChildren see throughput for %lld random writers \t= %10.2f %s/sec\n", num_child, total_kilos,unit);
- if(!silent && !distributed) printf("\tParent sees throughput for %lld random writers \t= %10.2f %s/sec\n", num_child, (double)(ptotal)/total_time,unit);
-#endif
- if(!silent) printf("\tMin throughput per %s \t\t\t= %10.2f %s/sec \n", port,min_throughput,unit);
- if(!silent) printf("\tMax throughput per %s \t\t\t= %10.2f %s/sec\n", port,max_throughput,unit);
- if(!silent) printf("\tAvg throughput per %s \t\t\t= %10.2f %s/sec\n", port,avg_throughput,unit);
- if(!silent) printf("\tMin xfer \t\t\t\t\t= %10.2f %s\n", min_xfer,unit);
- /* CPU% can be > 100.0 for multiple CPUs */
- if(cpuutilflag)
- {
- if(walltime == 0.0)
- {
- if(!silent) printf("\tCPU utilization: Wall time %8.3f CPU time %8.3f CPU utilization %6.2f %%\n\n",
- walltime, cputime, 0.0);
- }
- else
- {
- if(!silent) printf("\tCPU utilization: Wall time %8.3f CPU time %8.3f CPU utilization %6.2f %%\n\n",
- walltime, cputime, 100.0 * cputime / walltime);
- }
- }
- if(Cflag)
- {
- for(xyz=0;xyz<num_child;xyz++)
- {
- child_stat = (struct child_stats *) &shmaddr[xyz];
- if(cpuutilflag)
- {
- if(!silent) printf("\tChild[%ld] xfer count = %10.2f %s, Throughput = %10.2f %s/sec, wall=%6.3f, cpu=%6.3f, %%=%6.2f\n",
- (long)xyz, child_stat->actual, unit, child_stat->throughput, unit, child_stat->walltime,
- child_stat->cputime, cpu_util(child_stat->cputime, child_stat->walltime));
- }
- else
- {
- if(!silent) printf("\tChild[%ld] xfer count = %10.2f %s, Throughput = %10.2f %s/sec\n",
- (long)xyz, child_stat->actual, unit, child_stat->throughput, unit);
- }
- }
- }
- if((!distributed) || (distributed && master_iozone))
- stop_monitor("Randwrite");
- sync();
- sleep(2);
- if(restf)
- sleep((int)rest_val);
- if(distributed && master_iozone)
- {
- stop_master_listen(master_listen_socket);
- cleanup_comm();
- }
-next6:
- /**************************************************************/
- /*** Pwrite writer throughput tests **************************/
- /**************************************************************/
-#ifndef HAVE_PREAD
- goto next7;
-#else
- if(include_tflag)
- if(!(include_mask & (long long)PWRITER_MASK))
- goto next7;
-
- toutputindex++;
- strcpy(&toutput[toutputindex][0],throughput_tests[9]);
- if((!distributed) || (distributed && master_iozone))
- start_monitor("Pwrite");
- walltime = 0.0;
- cputime = 0.0;
- jstarttime=0;
- sync();
- sleep(2);
- *stop_flag=0;
- total_kilos=0;
- /* Hooks to start the distributed Iozone client/server code */
- if(distributed)
- {
- use_thread=0; /* Turn of any Posix threads */
- if(master_iozone)
- master_listen_socket = start_master_listen();
- else
- become_client();
- }
- if(!use_thread)
- {
- for(xx = 0; xx< num_child ; xx++){
- chid=xx;
- childids[xx] = start_child_proc(THREAD_PWRITE_TEST,numrecs64,reclen);
- if(childids[xx]==-1){
- printf("\nFork failed\n");
- for(xy = 0; xy< xx ; xy++){
- Kill((long long)childids[xy],(long long)SIGTERM);
- }
- exit(38);
- }
- if(childids[xx]==0){
-#ifdef _64BIT_ARCH_
- thread_pwrite_test((void *)xx);
-#else
- thread_pwrite_test((void *)((long)xx));
-#endif
- }
- }
- }
-#ifndef NO_THREADS
- else
- {
- for(xx = 0; xx< num_child ; xx++){ /* Create the children */
- chid=xx;
- if(!barray[xx])
- {
- barray[xx]=(char *) alloc_mem((long long)(MAXBUFFERSIZE+cache_size),(int)0);
- if(barray[xx] == 0) {
- perror("Memory allocation failed:");
- exit(26);
- }
- barray[xx] =(char *)(((long)barray[xx] + cache_size ) &
- ~(cache_size-1));
- }
-#ifdef _64BIT_ARCH_
- childids[xx] = mythread_create( thread_pwrite_test,xx);
-#else
- childids[xx] = mythread_create( thread_pwrite_test,(void *)(long)xx);
-#endif
- if(childids[xx]==-1){
- printf("\nThread create failed\n");
- for(xy = 0; xy< xx ; xy++){
- kill((pid_t)myid,(int)SIGTERM);
- }
- exit(39);
- }
- }
- }
-#endif
- if(myid == (long long)getpid()){
- if(distributed && master_iozone)
- {
- start_master_listen_loop((int) num_child);
- }
- for(i=0;i<num_child; i++){ /* wait for children to start */
- child_stat = (struct child_stats *)&shmaddr[i];
- while(child_stat->flag==CHILD_STATE_HOLD)
- Poll((long long)1);
- }
- for(i=0;i<num_child; i++){
- child_stat = (struct child_stats *)&shmaddr[i];
- child_stat->flag = CHILD_STATE_BEGIN; /* tell children to go */
- if(delay_start!=0)
- Poll((long long)delay_start);
- if(distributed && master_iozone)
- tell_children_begin(i);
- }
- starttime1 = time_so_far();
- }
-
- getout=0;
- if(myid == (long long)getpid()){ /* Parent here */
- for( i = 0; i < num_child; i++){ /* wait for children to stop */
- child_stat = (struct child_stats *)&shmaddr[i];
- if(distributed && master_iozone)
- {
- printf("\n\tTest running:");
- wait_dist_join();
- break;
- }
- else
- {
- if(use_thread)
- {
- thread_join(childids[i],(void *)&pstatus);
- }
- else
- {
- wait(0);
- }
- }
- if(!jstarttime)
- jstarttime = time_so_far();
- }
- jtime = (time_so_far()-jstarttime)-time_res;
- if(jtime < (double).000001)
- {
- jtime=time_res;
- }
- }
- total_time = (time_so_far() - starttime1)-time_res; /* Parents time */
- if(total_time < (double).000001)
- {
- total_time=time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-#ifdef JTIME
- total_time=total_time-jtime;/* Remove the join time */
- if(!silent) printf("\nJoin time %10.2f\n",jtime);
-#endif
- total_kilos=0;
- ptotal=0;
- min_throughput=max_throughput=min_xfer=0;
- if(!silent) printf("\n");
- for(xyz=0;xyz<num_child;xyz++){
- child_stat = (struct child_stats *)&shmaddr[xyz];
- total_kilos+=child_stat->throughput;
- ptotal+=child_stat->actual;
- if(!min_xfer)
- min_xfer=child_stat->actual;
- if(child_stat->actual < min_xfer)
- min_xfer=child_stat->actual;
- if(!min_throughput)
- min_throughput=child_stat->throughput;
- if(child_stat->throughput < min_throughput)
- min_throughput=child_stat->throughput;
- if(child_stat->throughput > max_throughput)
- max_throughput=child_stat->throughput;
- cputime += child_stat->cputime;
- /* Get the biggest walltime*/
- if (child_stat->walltime < child_stat->cputime)
- child_stat->walltime = child_stat->cputime;
- if (child_stat->walltime > walltime)
- walltime = child_stat->walltime;
- }
- avg_throughput=total_kilos/num_child;
- if(cpuutilflag)
- {
- if (cputime < cputime_res)
- cputime = 0.0;
- }
- if(cpuutilflag)
- store_times (walltime, cputime); /* Must be Before store_dvalue(). */
- store_dvalue(total_kilos);
-#ifdef NO_PRINT_LLD
- if(!silent) printf("\tChildren see throughput for %ld pwrite writers \t= %10.2f %s/sec\n", num_child, total_kilos,unit);
- if(!silent && !distributed) printf("\tParent sees throughput for %ld pwrite writers \t= %10.2f %s/sec\n", num_child, (double)(ptotal)/total_time,unit);
-#else
- if(!silent) printf("\tChildren see throughput for %lld pwrite writers \t= %10.2f %s/sec\n", num_child, total_kilos,unit);
- if(!silent && !distributed) printf("\tParent sees throughput for %lld pwrite writers \t= %10.2f %s/sec\n", num_child, (double)(ptotal)/total_time,unit);
-#endif
- if(!silent) printf("\tMin throughput per %s \t\t\t= %10.2f %s/sec \n", port,min_throughput,unit);
- if(!silent) printf("\tMax throughput per %s \t\t\t= %10.2f %s/sec\n", port,max_throughput,unit);
- if(!silent) printf("\tAvg throughput per %s \t\t\t= %10.2f %s/sec\n", port,avg_throughput,unit);
- if(!silent) printf("\tMin xfer \t\t\t\t\t= %10.2f %s\n", min_xfer,unit);
- /* CPU% can be > 100.0 for multiple CPUs */
- if(cpuutilflag)
- {
- if(walltime == 0.0)
- {
- if(!silent) printf("\tCPU utilization: Wall time %8.3f CPU time %8.3f CPU utilization %6.2f %%\n\n",
- walltime, cputime, 0.0);
- }
- else
- {
- if(!silent) printf("\tCPU utilization: Wall time %8.3f CPU time %8.3f CPU utilization %6.2f %%\n\n",
- walltime, cputime, 100.0 * cputime / walltime);
- }
- }
- if(Cflag)
- {
- for(xyz=0;xyz<num_child;xyz++)
- {
- child_stat = (struct child_stats *) &shmaddr[xyz];
- if(cpuutilflag)
- {
- if(!silent) printf("\tChild[%ld] xfer count = %10.2f %s, Throughput = %10.2f %s/sec, wall=%6.3f, cpu=%6.3f, %%=%6.2f\n",
- (long)xyz, child_stat->actual, unit, child_stat->throughput, unit, child_stat->walltime,
- child_stat->cputime, cpu_util(child_stat->cputime, child_stat->walltime));
- }
- else
- {
- if(!silent) printf("\tChild[%ld] xfer count = %10.2f %s, Throughput = %10.2f %s/sec\n",
- (long)xyz, child_stat->actual, unit, child_stat->throughput, unit);
- }
- }
- }
- if((!distributed) || (distributed && master_iozone))
- stop_monitor("Pwrite");
- sync();
- sleep(2);
- if(restf)
- sleep((int)rest_val);
- if(distributed && master_iozone)
- {
- stop_master_listen(master_listen_socket);
- cleanup_comm();
- }
-#endif
- /**************************************************************/
- /*** Pread reader throughput tests **************************/
- /**************************************************************/
-next7:
-
-#ifndef HAVE_PREAD
- goto next8;
-#else
- if(include_tflag)
- if(!(include_mask & (long long)PREADER_MASK))
- goto next8;
-
- toutputindex++;
- strcpy(&toutput[toutputindex][0],throughput_tests[10]);
- if((!distributed) || (distributed && master_iozone))
- start_monitor("Pread");
- walltime = 0.0;
- cputime = 0.0;
- jstarttime=0;
- sync();
- sleep(2);
- *stop_flag=0;
- total_kilos=0;
- /* Hooks to start the distributed Iozone client/server code */
- if(distributed)
- {
- use_thread=0; /* Turn of any Posix threads */
- if(master_iozone)
- master_listen_socket = start_master_listen();
- else
- become_client();
- }
- if(!use_thread)
- {
- for(xx = 0; xx< num_child ; xx++){
- chid=xx;
- childids[xx] = start_child_proc(THREAD_PREAD_TEST,numrecs64,reclen);
- if(childids[xx]==-1){
- printf("\nFork failed\n");
- for(xy = 0; xy< xx ; xy++){
- Kill((long long)childids[xy],(long long)SIGTERM);
- }
- exit(38);
- }
- if(childids[xx]==0){
-#ifdef _64BIT_ARCH_
- thread_pread_test((void *)xx);
-#else
- thread_pread_test((void *)((long)xx));
-#endif
- }
- }
- }
-#ifndef NO_THREADS
- else
- {
- for(xx = 0; xx< num_child ; xx++){ /* Create the children */
- chid=xx;
- if(!barray[xx])
- {
- barray[xx]=(char *) alloc_mem((long long)(MAXBUFFERSIZE+cache_size),(int)0);
- if(barray[xx] == 0) {
- perror("Memory allocation failed:");
- exit(26);
- }
- barray[xx] =(char *)(((long)barray[xx] + cache_size ) &
- ~(cache_size-1));
- }
-#ifdef _64BIT_ARCH_
- childids[xx] = mythread_create( thread_pread_test,xx);
-#else
- childids[xx] = mythread_create( thread_pread_test,(void *)(long)xx);
-#endif
- if(childids[xx]==-1){
- printf("\nThread create failed\n");
- for(xy = 0; xy< xx ; xy++){
- kill((pid_t)myid,(int)SIGTERM);
- }
- exit(39);
- }
- }
- }
-#endif
- if(myid == (long long)getpid()){
- if(distributed && master_iozone)
- {
- start_master_listen_loop((int) num_child);
- }
- for(i=0;i<num_child; i++){ /* wait for children to start */
- child_stat = (struct child_stats *)&shmaddr[i];
- while(child_stat->flag==CHILD_STATE_HOLD)
- Poll((long long)1);
- }
- for(i=0;i<num_child; i++){
- child_stat = (struct child_stats *)&shmaddr[i];
- child_stat->flag = CHILD_STATE_BEGIN; /* tell children to go */
- if(delay_start!=0)
- Poll((long long)delay_start);
- if(distributed && master_iozone)
- tell_children_begin(i);
- }
- starttime1 = time_so_far();
- }
-
- getout=0;
- if(myid == (long long)getpid()){ /* Parent here */
- for( i = 0; i < num_child; i++){ /* wait for children to stop */
- child_stat = (struct child_stats *)&shmaddr[i];
- if(distributed && master_iozone)
- {
- printf("\n\tTest running:");
- wait_dist_join();
- break;
- }
- else
- {
- if(use_thread)
- {
- thread_join(childids[i],(void *)&pstatus);
- }
- else
- {
- wait(0);
- }
- }
- if(!jstarttime)
- jstarttime = time_so_far();
- }
- jtime = (time_so_far()-jstarttime)-time_res;
- if(jtime < (double).000001)
- {
- jtime=time_res;
- }
- }
- total_time = (time_so_far() - starttime1)-time_res; /* Parents time */
- if(total_time < (double).000001)
- {
- total_time=time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-#ifdef JTIME
- total_time=total_time-jtime;/* Remove the join time */
- if(!silent) printf("\nJoin time %10.2f\n",jtime);
-#endif
- total_kilos=0;
- ptotal=0;
- min_throughput=max_throughput=min_xfer=0;
- if(!silent) printf("\n");
- for(xyz=0;xyz<num_child;xyz++){
- child_stat = (struct child_stats *)&shmaddr[xyz];
- total_kilos+=child_stat->throughput;
- ptotal+=child_stat->actual;
- if(!min_xfer)
- min_xfer=child_stat->actual;
- if(child_stat->actual < min_xfer)
- min_xfer=child_stat->actual;
- if(!min_throughput)
- min_throughput=child_stat->throughput;
- if(child_stat->throughput < min_throughput)
- min_throughput=child_stat->throughput;
- if(child_stat->throughput > max_throughput)
- max_throughput=child_stat->throughput;
- cputime += child_stat->cputime;
- /* Get the biggest walltime*/
- if (child_stat->walltime < child_stat->cputime)
- child_stat->walltime = child_stat->cputime;
- if (child_stat->walltime > walltime)
- walltime = child_stat->walltime;
- }
- avg_throughput=total_kilos/num_child;
- if(cpuutilflag)
- {
- if (cputime < cputime_res)
- cputime = 0.0;
- }
- if(cpuutilflag)
- store_times (walltime, cputime); /* Must be Before store_dvalue(). */
- store_dvalue(total_kilos);
-#ifdef NO_PRINT_LLD
- if(!silent) printf("\tChildren see throughput for %ld pread readers \t= %10.2f %s/sec\n", num_child, total_kilos,unit);
- if(!silent && !distributed) printf("\tParent sees throughput for %ld pread readers \t= %10.2f %s/sec\n", num_child, (double)(ptotal)/total_time,unit);
-#else
- if(!silent) printf("\tChildren see throughput for %lld pread readers \t= %10.2f %s/sec\n", num_child, total_kilos,unit);
- if(!silent && !distributed) printf("\tParent sees throughput for %lld pread readers \t= %10.2f %s/sec\n", num_child, (double)(ptotal)/total_time,unit);
-#endif
- if(!silent) printf("\tMin throughput per %s \t\t\t= %10.2f %s/sec \n", port,min_throughput,unit);
- if(!silent) printf("\tMax throughput per %s \t\t\t= %10.2f %s/sec\n", port,max_throughput,unit);
- if(!silent) printf("\tAvg throughput per %s \t\t\t= %10.2f %s/sec\n", port,avg_throughput,unit);
- if(!silent) printf("\tMin xfer \t\t\t\t\t= %10.2f %s\n", min_xfer,unit);
- /* CPU% can be > 100.0 for multiple CPUs */
- if(cpuutilflag)
- {
- if(walltime == 0.0)
- {
- if(!silent) printf("\tCPU utilization: Wall time %8.3f CPU time %8.3f CPU utilization %6.2f %%\n\n",
- walltime, cputime, 0.0);
- }
- else
- {
- if(!silent) printf("\tCPU utilization: Wall time %8.3f CPU time %8.3f CPU utilization %6.2f %%\n\n",
- walltime, cputime, 100.0 * cputime / walltime);
- }
- }
- if(Cflag)
- {
- for(xyz=0;xyz<num_child;xyz++)
- {
- child_stat = (struct child_stats *) &shmaddr[xyz];
- if(cpuutilflag)
- {
- if(!silent) printf("\tChild[%ld] xfer count = %10.2f %s, Throughput = %10.2f %s/sec, wall=%6.3f, cpu=%6.3f, %%=%6.2f\n",
- (long)xyz, child_stat->actual, unit, child_stat->throughput, unit, child_stat->walltime,
- child_stat->cputime, cpu_util(child_stat->cputime, child_stat->walltime));
- }
- else
- {
- if(!silent) printf("\tChild[%ld] xfer count = %10.2f %s, Throughput = %10.2f %s/sec\n",
- (long)xyz, child_stat->actual, unit, child_stat->throughput, unit);
- }
- }
- }
- if((!distributed) || (distributed && master_iozone))
- stop_monitor("Pread");
- sync();
- sleep(2);
- if(restf)
- sleep((int)rest_val);
- if(distributed && master_iozone)
- {
- stop_master_listen(master_listen_socket);
- cleanup_comm();
- }
-#endif
-next8:
- if(include_tflag)
- if(!(include_mask & (long long)FWRITER_MASK))
- goto next9;
- /**************************************************************/
- /*** fwriter throughput tests *********************************/
- /**************************************************************/
- if((!distributed) || (distributed && master_iozone))
- start_monitor("Fwrite");
- toutputindex++;
- strcpy(&toutput[toutputindex][0],throughput_tests[11]);
- walltime = 0.0;
- cputime = 0.0;
- jstarttime=0;
- total_kilos=0;
- if(distributed)
- {
- use_thread=0;
- if(master_iozone)
- master_listen_socket=start_master_listen();
- else
- become_client();
- }
- if(!use_thread)
- {
- for(xx = 0; xx< num_child ; xx++){
- chid=xx;
- childids[xx] = start_child_proc(THREAD_FWRITE_TEST,numrecs64,reclen);
- if(childids[xx]==-1){
- printf("\nFork failed\n");
- for(xy = 0; xy< xx ; xy++){
- Kill((long long)childids[xy],(long long)SIGTERM);
- }
- exit(30);
- }
- if(childids[xx]==0){
-#ifdef _64BIT_ARCH_
- thread_fwrite_test((void *)xx);
-#else
- thread_fwrite_test((void *)((long)xx));
-#endif
- }
- }
- }
-#ifndef NO_THREADS
- else
- {
- for(xx = 0; xx< num_child ; xx++){ /* Create the children */
- if(!barray[xx])
- {
- barray[xx]=(char *) alloc_mem((long long)(MAXBUFFERSIZE+cache_size),(int)0);
- if(barray[xx] == 0) {
- perror("Memory allocation failed:");
- exit(26);
- }
- barray[xx] =(char *)(((long)barray[xx] + cache_size ) &
- ~(cache_size-1));
- }
-#ifdef _64BIT_ARCH_
- childids[xx] = mythread_create( thread_fwrite_test,xx);
-#else
- childids[xx] = mythread_create( thread_fwrite_test,(void *)(long)xx);
-#endif
- if(childids[xx]==-1){
- printf("\nThread create failed\n");
- for(xy = 0; xy< xx ; xy++){
- kill((pid_t)myid,(int)SIGTERM);
- }
- exit(31);
- }
- }
- }
-#endif
- if(myid == (long long)getpid()){
- if(distributed && master_iozone)
- {
- start_master_listen_loop((int) num_child);
- }
- for(i=0;i<num_child; i++){ /* wait for children to start */
- child_stat=(struct child_stats *)&shmaddr[i];
- while(child_stat->flag==CHILD_STATE_HOLD)
- Poll((long long)1);
- }
- for(i=0;i<num_child; i++)
- {
- child_stat=(struct child_stats *)&shmaddr[i];
- child_stat->flag = CHILD_STATE_BEGIN; /* tell children to go */
- if(delay_start!=0)
- Poll((long long)delay_start);
- if(distributed && master_iozone)
- tell_children_begin(i);
- }
- starttime1 = time_so_far();
- goto jumpend1;
- }
-jumpend1:
- getout=0;
- if(myid == (long long)getpid()){ /* Parent here */
- for( i = 0; i < num_child; i++){
- child_stat = (struct child_stats *)&shmaddr[i];
- if(distributed && master_iozone)
- {
- printf("\n\tTest running:");
- wait_dist_join();
- break;
- }
- else
- {
- if(use_thread)
- {
- thread_join(childids[i],(void *)&pstatus);
- }
- else
- {
- wait(0);
- }
- }
- if(!jstarttime)
- jstarttime = time_so_far();
- }
- jtime = (time_so_far()-jstarttime)-time_res;
- if(jtime < (double).000001)
- {
- jtime=time_res;
- }
- }
- total_time = (time_so_far() - starttime1)-time_res; /* Parents time */
- if(total_time < (double).000001)
- {
- total_time=time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-#ifdef JTIME
- total_time=total_time-jtime;/* Remove the join time */
- if(!silent) printf("\nJoin time %10.2f\n",jtime);
-#endif
-
- total_kilos=0;
- ptotal=0;
- min_throughput=max_throughput=min_xfer=0;
- if(!silent) printf("\n");
- for(xyz=0;xyz<num_child;xyz++){
- child_stat=(struct child_stats *)&shmaddr[xyz];
- total_kilos+=child_stat->throughput;
- ptotal+=child_stat->actual;
- if(!min_xfer)
- min_xfer=child_stat->actual;
- if(child_stat->actual < min_xfer)
- min_xfer=child_stat->actual;
- if(!min_throughput)
- min_throughput=child_stat->throughput;
- if(child_stat->throughput < min_throughput)
- min_throughput=child_stat->throughput;
- if(child_stat->throughput > max_throughput)
- max_throughput=child_stat->throughput;
- cputime += child_stat->cputime;
- /* Get the earliest start time and latest fini time to calc. elapsed time. */
- if (child_stat->walltime < child_stat->cputime)
- child_stat->walltime = child_stat->cputime;
- if (child_stat->walltime > walltime)
- walltime = child_stat->walltime;
- }
- avg_throughput=total_kilos/num_child;
- if(cpuutilflag)
- {
- if (cputime < cputime_res)
- cputime = 0.0;
- }
- if(cpuutilflag)
- store_times (walltime, cputime); /* Must be Before store_dvalue(). */
- store_dvalue(total_kilos);
-#ifdef NO_PRINT_LLD
- if(!silent) printf("\tChildren see throughput for %2ld fwriters \t= %10.2f %s/sec\n", num_child, total_kilos,unit);
- if(!silent && !distributed) printf("\tParent sees throughput for %2ld fwriters \t\t= %10.2f %s/sec\n", num_child, (double)(ptotal)/total_time,unit);
-#else
- if(!silent) printf("\tChildren see throughput for %2lld fwriters \t= %10.2f %s/sec\n", num_child, total_kilos,unit);
- if(!silent && !distributed) printf("\tParent sees throughput for %2lld fwriters \t\t= %10.2f %s/sec\n", num_child, (double)(ptotal)/total_time,unit);
-#endif
- if(!silent) printf("\tMin throughput per %s \t\t\t= %10.2f %s/sec \n", port,min_throughput,unit);
- if(!silent) printf("\tMax throughput per %s \t\t\t= %10.2f %s/sec\n", port,max_throughput,unit);
- if(!silent) printf("\tAvg throughput per %s \t\t\t= %10.2f %s/sec\n", port,avg_throughput,unit);
- if(!silent) printf("\tMin xfer \t\t\t\t\t= %10.2f %s\n", min_xfer,unit);
- /* CPU% can be > 100.0 for multiple CPUs */
- if(cpuutilflag)
- {
- if(walltime == 0.0)
- {
- if(!silent) printf("\tCPU utilization: Wall time %8.3f CPU time %8.3f CPU utilization %6.2f %%\n\n",
- walltime, cputime, 0.0);
- }
- else
- {
- if(!silent) printf("\tCPU utilization: Wall time %8.3f CPU time %8.3f CPU utilization %6.2f %%\n\n",
- walltime, cputime, 100.0 * cputime / walltime);
- }
- }
- if(Cflag)
- {
- for(xyz=0;xyz<num_child;xyz++)
- {
- child_stat = (struct child_stats *) &shmaddr[xyz];
- if(cpuutilflag)
- {
- if(!silent) printf("\tChild[%ld] xfer count = %10.2f %s, Throughput = %10.2f %s/sec, wall=%6.3f, cpu=%6.3f, %%=%6.2f\n",
- (long)xyz, child_stat->actual, unit, child_stat->throughput, unit, child_stat->walltime,
- child_stat->cputime, cpu_util(child_stat->cputime, child_stat->walltime));
- }
- else
- {
- if(!silent) printf("\tChild[%ld] xfer count = %10.2f %s, Throughput = %10.2f %s/sec\n",
- (long)xyz, child_stat->actual, unit, child_stat->throughput, unit);
- }
- }
- }
- if((!distributed) || (distributed && master_iozone))
- stop_monitor("Fwrite");
- /**********************************************************/
- /*************** End of fwrite throughput ****************/
- /**********************************************************/
- sync();
- sleep(2);
- if(restf)
- sleep((int)rest_val);
- if(distributed && master_iozone)
- {
- stop_master_listen(master_listen_socket);
- cleanup_comm();
- }
-next9:
- if(include_tflag)
- if(!(include_mask & (long long)FREADER_MASK))
- goto next10;
- /**************************************************************/
- /*** freader throughput tests *********************************/
- /**************************************************************/
- if((!distributed) || (distributed && master_iozone))
- start_monitor("Fread");
- toutputindex++;
- strcpy(&toutput[toutputindex][0],throughput_tests[12]);
- walltime = 0.0;
- cputime = 0.0;
- jstarttime=0;
- total_kilos=0;
- if(distributed)
- {
- use_thread=0;
- if(master_iozone)
- master_listen_socket=start_master_listen();
- else
- become_client();
- }
- if(!use_thread)
- {
- for(xx = 0; xx< num_child ; xx++){
- chid=xx;
- childids[xx] = start_child_proc(THREAD_FREAD_TEST,numrecs64,reclen);
- if(childids[xx]==-1){
- printf("\nFork failed\n");
- for(xy = 0; xy< xx ; xy++){
- Kill((long long)childids[xy],(long long)SIGTERM);
- }
- exit(30);
- }
- if(childids[xx]==0){
-#ifdef _64BIT_ARCH_
- thread_fread_test((void *)xx);
-#else
- thread_fread_test((void *)((long)xx));
-#endif
- }
- }
- }
-#ifndef NO_THREADS
- else
- {
- for(xx = 0; xx< num_child ; xx++){ /* Create the children */
- if(!barray[xx])
- {
- barray[xx]=(char *) alloc_mem((long long)(MAXBUFFERSIZE+cache_size),(int)0);
- if(barray[xx] == 0) {
- perror("Memory allocation failed:");
- exit(26);
- }
- barray[xx] =(char *)(((long)barray[xx] + cache_size ) &
- ~(cache_size-1));
- }
-#ifdef _64BIT_ARCH_
- childids[xx] = mythread_create( thread_fread_test,xx);
-#else
- childids[xx] = mythread_create( thread_fread_test,(void *)(long)xx);
-#endif
- if(childids[xx]==-1){
- printf("\nThread create failed\n");
- for(xy = 0; xy< xx ; xy++){
- kill((pid_t)myid,(int)SIGTERM);
- }
- exit(31);
- }
- }
- }
-#endif
- if(myid == (long long)getpid()){
- if(distributed && master_iozone)
- {
- start_master_listen_loop((int) num_child);
- }
- for(i=0;i<num_child; i++){ /* wait for children to start */
- child_stat=(struct child_stats *)&shmaddr[i];
- while(child_stat->flag==CHILD_STATE_HOLD)
- Poll((long long)1);
- }
- for(i=0;i<num_child; i++)
- {
- child_stat=(struct child_stats *)&shmaddr[i];
- child_stat->flag = CHILD_STATE_BEGIN; /* tell children to go */
- if(delay_start!=0)
- Poll((long long)delay_start);
- if(distributed && master_iozone)
- tell_children_begin(i);
- }
- starttime1 = time_so_far();
- goto jumpend3;
- }
-jumpend3:
- getout=0;
- if(myid == (long long)getpid()){ /* Parent here */
- for( i = 0; i < num_child; i++){
- child_stat = (struct child_stats *)&shmaddr[i];
- if(distributed && master_iozone)
- {
- printf("\n\tTest running:");
- wait_dist_join();
- break;
- }
- else
- {
- if(use_thread)
- {
- thread_join(childids[i],(void *)&pstatus);
- }
- else
- {
- wait(0);
- }
- }
- if(!jstarttime)
- jstarttime = time_so_far();
- }
- jtime = (time_so_far()-jstarttime)-time_res;
- if(jtime < (double).000001)
- {
- jtime=time_res;
- }
- }
- total_time = (time_so_far() - starttime1)-time_res; /* Parents time */
- if(total_time < (double).000001)
- {
- total_time=time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-#ifdef JTIME
- total_time=total_time-jtime;/* Remove the join time */
- if(!silent) printf("\nJoin time %10.2f\n",jtime);
-#endif
-
- total_kilos=0;
- ptotal=0;
- min_throughput=max_throughput=min_xfer=0;
- if(!silent) printf("\n");
- for(xyz=0;xyz<num_child;xyz++){
- child_stat=(struct child_stats *)&shmaddr[xyz];
- total_kilos+=child_stat->throughput;
- ptotal+=child_stat->actual;
- if(!min_xfer)
- min_xfer=child_stat->actual;
- if(child_stat->actual < min_xfer)
- min_xfer=child_stat->actual;
- if(!min_throughput)
- min_throughput=child_stat->throughput;
- if(child_stat->throughput < min_throughput)
- min_throughput=child_stat->throughput;
- if(child_stat->throughput > max_throughput)
- max_throughput=child_stat->throughput;
- cputime += child_stat->cputime;
- /* Get the earliest start time and latest fini time to calc. elapsed time. */
- if (child_stat->walltime < child_stat->cputime)
- child_stat->walltime = child_stat->cputime;
- if (child_stat->walltime > walltime)
- walltime = child_stat->walltime;
- }
- avg_throughput=total_kilos/num_child;
- if(cpuutilflag)
- {
- if (cputime < cputime_res)
- cputime = 0.0;
- }
- if(cpuutilflag)
- store_times (walltime, cputime); /* Must be Before store_dvalue(). */
- store_dvalue(total_kilos);
-#ifdef NO_PRINT_LLD
- if(!silent) printf("\tChildren see throughput for %2ld freaders \t= %10.2f %s/sec\n", num_child, total_kilos,unit);
- if(!silent && !distributed) printf("\tParent sees throughput for %2ld freaders \t\t= %10.2f %s/sec\n", num_child, (double)(ptotal)/total_time,unit);
-#else
- if(!silent) printf("\tChildren see throughput for %2lld freaders \t= %10.2f %s/sec\n", num_child, total_kilos,unit);
- if(!silent && !distributed) printf("\tParent sees throughput for %2lld freaders \t\t= %10.2f %s/sec\n", num_child, (double)(ptotal)/total_time,unit);
-#endif
- if(!silent) printf("\tMin throughput per %s \t\t\t= %10.2f %s/sec \n", port,min_throughput,unit);
- if(!silent) printf("\tMax throughput per %s \t\t\t= %10.2f %s/sec\n", port,max_throughput,unit);
- if(!silent) printf("\tAvg throughput per %s \t\t\t= %10.2f %s/sec\n", port,avg_throughput,unit);
- if(!silent) printf("\tMin xfer \t\t\t\t\t= %10.2f %s\n", min_xfer,unit);
- /* CPU% can be > 100.0 for multiple CPUs */
- if(cpuutilflag)
- {
- if(walltime == 0.0)
- {
- if(!silent) printf("\tCPU utilization: Wall time %8.3f CPU time %8.3f CPU utilization %6.2f %%\n\n",
- walltime, cputime, 0.0);
- }
- else
- {
- if(!silent) printf("\tCPU utilization: Wall time %8.3f CPU time %8.3f CPU utilization %6.2f %%\n\n",
- walltime, cputime, 100.0 * cputime / walltime);
- }
- }
- if(Cflag)
- {
- for(xyz=0;xyz<num_child;xyz++)
- {
- child_stat = (struct child_stats *) &shmaddr[xyz];
- if(cpuutilflag)
- {
- if(!silent) printf("\tChild[%ld] xfer count = %10.2f %s, Throughput = %10.2f %s/sec, wall=%6.3f, cpu=%6.3f, %%=%6.2f\n",
- (long)xyz, child_stat->actual, unit, child_stat->throughput, unit, child_stat->walltime,
- child_stat->cputime, cpu_util(child_stat->cputime, child_stat->walltime));
- }
- else
- {
- if(!silent) printf("\tChild[%ld] xfer count = %10.2f %s, Throughput = %10.2f %s/sec\n",
- (long)xyz, child_stat->actual, unit, child_stat->throughput, unit);
- }
- }
- }
- if((!distributed) || (distributed && master_iozone))
- stop_monitor("Fread");
- /**********************************************************/
- /*************** End of fread throughput ******************/
- /**********************************************************/
- sync();
- sleep(2);
- if(restf)
- sleep((int)rest_val);
- if(distributed && master_iozone)
- {
- stop_master_listen(master_listen_socket);
- cleanup_comm();
- }
-next10:
- sleep(2); /* You need this. If you stop and restart the
- master_listen it will fail on Linux */
- if (!no_unlink) {
- /**********************************************************/
- /* Cleanup all of the temporary files */
- /* This is not really a test. It behaves like a test so */
- /* it can unlink all of the same files that the other */
- /* tests left hanging around. */
- /**********************************************************/
- /* Hooks to start the distributed Iozone client/server code */
- if(distributed)
- {
- use_thread=0; /* Turn of any Posix threads */
- if(master_iozone)
- master_listen_socket = start_master_listen();
- else
- become_client();
- }
- if(!use_thread)
- {
- for(xx = 0; xx< num_child ; xx++){
- chid=xx;
- childids[xx] = start_child_proc(THREAD_CLEANUP_TEST,numrecs64,reclen);
- if(childids[xx]==-1){
- printf("\nFork failed\n");
- for(xy = 0; xy< xx ; xy++){
- Kill((long long)childids[xy],(long long)SIGTERM);
- }
- exit(28);
- }
- if(childids[xx] == 0){
-#ifdef _64BIT_ARCH_
- thread_cleanup_test((void *)xx);
-#else
- thread_cleanup_test((void *)((long)xx));
-#endif
- }
- }
- }
-#ifndef NO_THREADS
- else
- {
- for(xx = 0; xx< num_child ; xx++){ /* Create the children */
-#ifdef _64BIT_ARCH_
- childids[xx] = mythread_create( thread_cleanup_test,xx);
-#else
- childids[xx] = mythread_create( thread_cleanup_test,(void *)(long)xx);
-#endif
- if(childids[xx]==-1){
- printf("\nThread create failed\n");
- for(xy = 0; xy< xx ; xy++){
- Kill((long long)myid,(long long)SIGTERM);
- }
- exit(29);
- }
- }
- }
-#endif
- if((long long)myid == getpid())
- {
- if(distributed && master_iozone)
- {
- start_master_listen_loop((int) num_child);
- }
- for(i=0;i<num_child; i++){
- child_stat = (struct child_stats *)&shmaddr[i];
- /* wait for children to start */
- while(child_stat->flag==CHILD_STATE_HOLD)
- Poll((long long)1);
- }
- for(i=0;i<num_child; i++)
- {
- child_stat = (struct child_stats *)&shmaddr[i];
- child_stat->flag = CHILD_STATE_BEGIN; /* tell children to go */
- if(delay_start!=0)
- Poll((long long)delay_start);
- if(distributed && master_iozone)
- tell_children_begin(i);
- }
- }
-
- getout=0;
- if((long long)myid == getpid()){ /* Parent only here */
- for( i = 0; i < num_child; i++){
- child_stat=(struct child_stats *)&shmaddr[i];
- if(distributed && master_iozone)
- {
- printf("\n\tTest cleanup:");
- wait_dist_join();
- break;
- }
- else
- {
- if(use_thread)
- {
- thread_join(childids[i],(void *)&pstatus);
- }
- else
- {
- wait(0);
- }
- }
- }
- }
-
- for(xyz=0;xyz<num_child;xyz++){ /* Reset state to 0 (HOLD) */
- child_stat=(struct child_stats *)&shmaddr[xyz];
- child_stat->flag = CHILD_STATE_HOLD;
- }
- sync();
- sleep(2);
- if(distributed && master_iozone)
- {
- stop_master_listen(master_listen_socket);
-#ifdef Windows
- /* windows needs time before shutting down sockets */
- sleep(1);
-#endif
- cleanup_comm();
- }
- }
- /********************************************************/
- /* End of cleanup */
- /********************************************************/
- sync();
- if(!silent) printf("\n");
- if(!silent) printf("\n");
- return;
-}
-
-
-/************************************************************************/
-/* Time measurement routines. */
-/************************************************************************/
-
-#ifdef HAVE_ANSIC_C
-static double
-time_so_far(void)
-#else
-static double
-time_so_far()
-#endif
-{
-#ifdef Windows
- LARGE_INTEGER freq,counter;
- double wintime,bigcounter;
- struct timeval tp;
- /* For Windows the time_of_day() is useless. It increments in 55 milli
- * second increments. By using the Win32api one can get access to the
- * high performance measurement interfaces. With this one can get back
- * into the 8 to 9 microsecond resolution.
- */
- if(pit_hostname[0]){
- if (pit_gettimeofday(&tp, (struct timezone *) NULL, pit_hostname,
- pit_service) == -1)
- perror("pit_gettimeofday");
- return ((double) (tp.tv_sec)) + (((double) tp.tv_usec) * 0.000001 );
- }
- else
- {
- QueryPerformanceFrequency(&freq);
- QueryPerformanceCounter(&counter);
- bigcounter=(double)counter.HighPart *(double)0xffffffff +
- (double)counter.LowPart;
- wintime = (double)(bigcounter/(double)freq.LowPart);
- return((double)wintime);
- }
-#else
-#if defined (OSFV4) || defined(OSFV3) || defined(OSFV5)
- struct timespec gp;
-
- if (getclock(TIMEOFDAY, (struct timespec *) &gp) == -1)
- perror("getclock");
- return (( (double) (gp.tv_sec)) +
- ( ((float)(gp.tv_nsec)) * 0.000000001 ));
-#else
- struct timeval tp;
-
- if(pit_hostname[0]){
- if (pit_gettimeofday(&tp, (struct timezone *) NULL, pit_hostname, pit_service) == -1)
- perror("pit_gettimeofday");
- return ((double) (tp.tv_sec)) + (((double) tp.tv_usec) * 0.000001 );
- }
- else
- {
- if (gettimeofday(&tp, (struct timezone *) NULL) == -1)
- perror("gettimeofday");
- return ((double) (tp.tv_sec)) + (((double) tp.tv_usec) * 0.000001 );
- }
-#endif
-#endif
-}
-
-/************************************************************************/
-/* FETCHIT () */
-/* */
-/* Routine to make the on chip data cache hot for this buffer. The */
-/* on chip cache may have been blown by other code in the application */
-/* or in the OS. Remember, on some machines, the data cache is direct */
-/* mapped and virtual indexed. */
-/************************************************************************/
-
-#ifdef HAVE_ANSIC_C
-void fetchit(char *buffer,long long length)
-#else
-void fetchit(buffer,length)
-char *buffer;
-long long length;
-#endif
-{
- char *where;
- volatile long long x[4];
- long long i;
- where=(char *)buffer;
- for(i=0;i<(length/cache_line_size);i++)
- {
- x[(i & 3)]=*(where);
- where+=cache_line_size;
-
- }
-}
-
-/************************************************************************/
-/* Verify that the buffer contains expected pattern */
-/************************************************************************/
-/* sverify == 0 means full check of pattern for every byte. */
-/* severify == 1 means partial check of pattern for each page. */
-/* sverify == 2 means no check, but partial touch for each page. */
-/************************************************************************/
-
-#ifdef HAVE_ANSIC_C
-long long
-verify_buffer(volatile char *buffer,long long length, off64_t recnum, long long recsize,unsigned long long patt,
- char sverify)
-#else
-long long
-verify_buffer(buffer,length, recnum, recsize,patt,sverify)
-char *buffer;
-long long length;
-off64_t recnum;
-long long recsize;
-unsigned long long patt;
-char sverify;
-#endif
-{
- volatile unsigned long long *where;
- volatile unsigned long long dummy;
- long *de_ibuf, *de_obuf;
- long long j,k;
- off64_t file_position=0;
- off64_t i;
- char *where2;
- char *pattern_ptr;
- long long mpattern,xx2;
- unsigned int seed;
- unsigned long x;
- unsigned long long value,value1;
- unsigned long long a= 0x01020304;
- unsigned long long b = 0x05060708;
- unsigned long long c= 0x01010101;
- unsigned long long d = 0x01010101;
- unsigned long long pattern_buf;
- int lite = 1; /* Only validate 1 long when running
- de-deup validation */
-
- value = (a<<32) | b;
- value1 = (c<<32) | d;
-
- /* printf("Verify Sverify %d verify %d diag_v %d\n",sverify,verify,diag_v); */
- x=0;
- xx2=chid;
- if(share_file)
- xx2=(long long)0;
- mpattern=patt;
- pattern_buf=patt;
- where=(unsigned long long *)buffer;
- if(sverify == 2)
- {
- for(i=0;i<(length);i+=page_size)
- {
- dummy = *where;
- where+=(page_size/sizeof(long long));
- }
- return(0);
- }
- if(dedup)
- {
- gen_new_buf((char *)dedup_ibuf,(char *)dedup_temp, (long)recnum, (int)length,(int)dedup, (int) dedup_interior, dedup_compress, 0);
- de_ibuf = (long *)buffer;
- de_obuf = (long *)dedup_temp;
- if(lite) /* short touch to reduce intrusion */
- length = (long) sizeof(long);
- for(i=0;i<length/sizeof(long);i++)
- {
- if(de_ibuf[i]!= de_obuf[i])
- {
- if(!silent)
-#ifdef NO_PRINT_LLD
- printf("\nDedup mis-compare at %ld\n",
- (long long)((recnum*recsize)+(i*sizeof(long))) );
-#else
- printf("\nDedup mis-compare at %lld\n",
- (long long)((recnum*recsize)+(i*sizeof(long))) );
- printf("Found %.lx Expecting %.lx \n",de_ibuf[i], de_obuf[i]);
-#endif
- return(1);
- }
- }
- return(0);
- }
- if(diag_v)
- {
- if(no_unlink)
- base_time=0;
- seed= (unsigned int)(base_time+xx2+recnum);
- srand(seed);
- mpattern=(long long)rand();
- mpattern=(mpattern<<48) | (mpattern<<32) | (mpattern<<16) | mpattern;
- mpattern=mpattern+value;
- }
-
- /* printf("verify patt %llx CHid %d\n",mpattern,chid);*/
-
- where=(unsigned long long *)buffer;
-
- if(!verify)
- printf("\nOOPS You have entered verify_buffer unexpectedly !!! \n");
-
- if(sverify == 1)
- {
- for(i=0;i<(length);i+=page_size)
- {
- if((unsigned long long)(*where) != (unsigned long long)((pattern_buf<<32) | pattern_buf))
- {
- file_position = (off64_t)( (recnum * recsize)+ i);
- printf("\n\n");
-#ifdef NO_PRINT_LLD
- printf("Error in file: Found ?%lx? Expecting ?%lx? addr %lx\n",*where, (long long)((pattern_buf<<32)|pattern_buf),where);
- printf("Error in file: Position %ld \n",file_position);
- printf("Record # %ld Record size %ld kb \n",recnum,recsize/1024);
- printf("where %8.8llx loop %ld\n",where,i);
-#else
- printf("Error in file: Found ?%llx? Expecting ?%llx? addr %lx\n",*where, (long long)((pattern_buf<<32)|pattern_buf),((long)where));
- printf("Error in file: Position %lld \n",file_position);
- printf("Record # %lld Record size %lld kb \n",recnum,recsize/1024);
- printf("where %8.8lx loop %lld\n",(long)where,(long long)i);
-#endif
- return(1);
- }
- where+=(page_size/sizeof(long long));
- }
- }
- if(sverify == 0)
- {
- for(i=0;i<(length/cache_line_size);i++)
- {
- for(j=0;j<(cache_line_size/sizeof(long long));j++)
- {
- if(diag_v)
- {
- pattern_buf=mpattern;
- }
- else
- {
- pattern_buf= mpattern<<32 | mpattern;
- }
-
- pattern_ptr =(char *)&pattern_buf;
-
- if(*where != (unsigned long long)pattern_buf)
- {
- file_position = (off64_t)( (recnum * recsize))+
- ((i*cache_line_size)+(j*sizeof(long long)));
- where2=(char *)where;
- for(k=0;k<sizeof(long long);k++){
- if(*where2 != *pattern_ptr)
- break;
- where2++;
- pattern_ptr++;
- }
- file_position+=k;
- printf("\n\n");
-#ifdef NO_PRINT_LLD
- printf("Error in file: Position %ld %ld %ld \n",i,j,k);
- printf("Error in file: Position %ld \n",file_position);
- printf("Record # %ld Record size %ld kb \n",recnum,recsize/1024);
-#else
- printf("Error in file: Position %lld %lld %lld \n",i,j,k);
- printf("Error in file: Position %lld \n",file_position);
- printf("Record # %lld Record size %lld kb \n",recnum,recsize/1024);
-#endif
- printf("Found pattern: Char >>%c<< Expecting >>%c<<\n", *where2,*pattern_ptr);
- printf("Found pattern: Hex >>%x<< Expecting >>%x<<\n", *where2,*pattern_ptr);
- return(1);
- }
- where++;
- if(diag_v)
- mpattern=mpattern+value1;
- }
- }
- }
- return(0);
-}
-/************************************************************************/
-/* Fill the buffer */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void
-fill_buffer(char *buffer,long long length,long long pattern,char sverify,long long recnum)
-#else
-void
-fill_buffer(buffer,length,pattern,sverify,recnum)
-char *buffer;
-long long length;
-long long pattern;
-long long recnum;
-char sverify;
-#endif
-{
- unsigned long long *where;
- long long i,j,xx2;
- long long mpattern;
- unsigned int seed;
- unsigned long x;
- unsigned long long value,value1;
- unsigned long long a = 0x01020304;
- unsigned long long b = 0x05060708;
- unsigned long long c = 0x01010101;
- unsigned long long d = 0x01010101;
-
- value = (a << 32) | b;
- value1 = (c << 32) | d;
-
- xx2=chid;
- if(share_file)
- xx2=(long long)0;
- x=0;
- mpattern=pattern;
- /* printf("Fill: Sverify %d verify %d diag_v %d\n",sverify,verify,diag_v);*/
- if(dedup)
- {
- gen_new_buf((char *)dedup_ibuf,(char *)buffer, (long)recnum, (int)length,(int)dedup, (int) dedup_interior, dedup_compress, 1);
- return;
- }
- if(diag_v)
- {
- /*if(client_iozone)
- base_time=0;
- */
- if(no_unlink)
- base_time=0;
- seed= (unsigned int)(base_time+xx2+recnum);
- srand(seed);
- mpattern=(long long)rand();
- mpattern=(mpattern<<48) | (mpattern<<32) | (mpattern<<16) | mpattern;
- mpattern=mpattern+value;
- }
- where=(unsigned long long *)buffer;
- if(sverify == 1)
- {
- for(i=0;i<(length);i+=page_size)
- {
- *where = (long long)((pattern<<32) | pattern);
- where+=(page_size/sizeof(long long));
- /* printf("Filling page %lld \n",i/page_size);*/
- }
- }
- else
- {
- for(i=0;i<(length/cache_line_size);i++)
- {
- for(j=0;j<(cache_line_size/sizeof(long long));j++)
- {
- if(diag_v)
- {
- *where = (long long)(mpattern);
- mpattern=mpattern+value1;
- }
- else
- *where = (long long)((pattern<<32) | pattern);
- where++;
- }
- }
- }
-}
-
-/************************************************************************/
-/* PURGEIT() */
-/* */
-/* Routine to make the on chip data cache cold for this buffer. */
-/* Remember, on some machines, the data cache is direct mapped and */
-/* virtual indexed. */
-/************************************************************************/
-
-#ifdef HAVE_ANSIC_C
-void
-purgeit(char *buffer,long long reclen)
-#else
-void
-purgeit(buffer,reclen)
-char *buffer;
-long long reclen;
-#endif
-{
- char *where;
- long rsize;
- long tsize;
- VOLATILE long long x[200];
- long i,cache_lines_per_rec;
- long cache_lines_per_cache;
- tsize = 200;
- cache_lines_per_rec = (long)(reclen/cache_line_size);
- cache_lines_per_cache = (long)(cache_size/cache_line_size);
- rsize = (long)l_min((long long)cache_lines_per_rec,(long long)cache_lines_per_cache);
-#ifdef _64BIT_ARCH_
- where=(char *)pbuffer + ((unsigned long long)buffer & (cache_size-1));
-#else
- where=(char *)pbuffer + ((long)buffer & ((long)cache_size-1));
-#endif
- for(i=0;i<(rsize);i++)
- {
- x[i%tsize]=*(where);
- where+=cache_line_size;
-
- }
-}
-
-#ifdef HAVE_ANSIC_C
-void
-prepage(char *buffer,long long reclen)
-#else
-void
-prepage(buffer, reclen)
-char *buffer;
-long long reclen;
-#endif
-{
- char *where;
- long long i;
- where=(char *)buffer;
- for(i=0;i<(reclen/cache_line_size);i++)
- {
- *(where)=PATTERN;
- where+=cache_line_size;
- }
-}
-
-/************************************************************************/
-/* write_perf_test () */
-/* Write and re-write test */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void write_perf_test(off64_t kilo64,long long reclen ,long long *data1,long long *data2)
-#else
-void write_perf_test(kilo64,reclen ,data1,data2)
-off64_t kilo64;
-long long reclen;
-long long *data1;
-long long *data2;
-#endif
-{
- double starttime1;
- double writetime[2];
- double walltime[2], cputime[2];
- double qtime_start,qtime_stop;
- double hist_time;
- double compute_val = (double)0;
-#ifdef unix
- double qtime_u_start,qtime_u_stop;
- double qtime_s_start,qtime_s_stop;
-#endif
- long long i,j;
- off64_t numrecs64,traj_offset;
- off64_t lock_offset=0;
- long long Index = 0;
- long long file_flags = 0;
- long long traj_size;
- unsigned long long writerate[2];
- off64_t filebytes64;
- int ltest;
- char *maddr;
- char *wmaddr,*free_addr;
- char *pbuff;
- char *nbuff;
- int fd,wval;
-#ifdef ASYNC_IO
- struct cache *gc=0;
-#else
- long long *gc=0;
-#endif
-
- int test_foo;
-
-#ifdef unix
- qtime_u_start=qtime_u_stop=0;
- qtime_s_start=qtime_s_stop=0;
-#endif
- nbuff=wmaddr=free_addr=0;
- traj_offset=0;
- test_foo=0;
- hist_time=qtime_start=qtime_stop=0;
- maddr=0;
- pbuff=mainbuffer;
- if(w_traj_flag)
- {
- filebytes64 = w_traj_fsize;
- numrecs64=w_traj_ops;
- }
- else
- {
- numrecs64 = (kilo64*1024)/reclen;
- filebytes64 = numrecs64*reclen;
- }
-
- if(Q_flag && (!wol_opened))
- {
- wol_opened++;
- wqfd=fopen("wol.dat","a");
- if(wqfd==0)
- {
- printf("Unable to open wol.dat\n");
- exit(40);
- }
- fprintf(wqfd,"Offset in Kbytes Latency in microseconds Transfer size in bytes\n");
- rwqfd=fopen("rwol.dat","a");
- if(rwqfd==0)
- {
- printf("Unable to open rwol.dat\n");
- exit(41);
- }
- fprintf(rwqfd,"Offset in Kbytes Latency in microseconds Transfer size in bytes\n");
- }
- fd = 0;
- if(oflag)
- file_flags = O_RDWR|O_SYNC;
- else
- file_flags = O_RDWR;
-#if defined(O_DSYNC)
- if(odsync)
- file_flags |= O_DSYNC;
-#endif
-#if defined(_HPUX_SOURCE) || defined(linux) || defined(__FreeBSD__) || defined(__DragonFly__)
- if(read_sync)
- file_flags |=O_RSYNC|O_SYNC;
-#endif
-
-#if ! defined(DONT_HAVE_O_DIRECT)
-#if defined(linux) || defined(__AIX__) || defined(IRIX) || defined(IRIX64) || defined(Windows) || defined (__FreeBSD__)
- if(direct_flag)
- file_flags |=O_DIRECT;
-#endif
-#if defined(TRU64)
- if(direct_flag)
- file_flags |=O_DIRECTIO;
-#endif
-#endif
-
-/* Sanity check */
-/* Some filesystems do not behave correctly and fail
- * when this sequence is performned. This is a very
- * bad thing. It breaks many applications and lurks
- * around quietly. This code should never get
- * triggered, but in the case of running iozone on
- * an NFS client, the filesystem type on the server
- * that is being exported can cause this failure.
- * If this failure happens, then the NFS client is
- * going to going to have problems, but the acutal
- * problem is the filesystem on the NFS server.
- * It's not NFS, it's the local filesystem on the
- * NFS server that is not correctly permitting
- * the sequence to function.
- */
-/* _SUA_ Services for Unix Applications, under Windows
- does not have a truncate, so this must be skipped */
-#if !defined(_SUA_)
- if((fd = I_OPEN(filename, (int)O_CREAT|O_WRONLY,0))<0)
- {
- printf("\nCan not open temp file: %s\n",
- filename);
- perror("open");
- exit(44);
- }
- if(!notruncate)
- {
- if(check_filename(filename))
- {
- wval=ftruncate(fd,0);
- if(wval < 0)
- {
- printf("\n\nSanity check failed. Do not deploy this filesystem in a production environment !\n");
- exit(44);
- }
- }
- close(fd);
-
- if(check_filename(filename))
- unlink(filename);
- }
-/* Sanity check */
-
-#endif
- if(noretest)
- ltest=1;
- else
- ltest=2;
-
- for( j=0; j<ltest; j++)
- {
- if(cpuutilflag)
- {
- walltime[j] = time_so_far();
- cputime[j] = cputime_so_far();
- }
- if(Uflag) /* Unmount and re-mount the mountpoint */
- {
- purge_buffer_cache();
- }
- if(j==0)
- {
-#if defined(Windows)
- if(unbuffered)
- {
- hand=CreateFile(filename,
- GENERIC_READ|GENERIC_WRITE,
- FILE_SHARE_WRITE|FILE_SHARE_READ,
- NULL,OPEN_ALWAYS,FILE_FLAG_NO_BUFFERING|
- FILE_FLAG_WRITE_THROUGH|FILE_FLAG_POSIX_SEMANTICS,
- NULL);
- }
- else
- {
-#endif
- if(!notruncate)
- {
- if((fd = I_CREAT(filename, 0640))<0)
- {
- printf("\nCan not create temp file: %s\n",
- filename);
- perror("creat");
- exit(42);
- }
- }
-#if defined(Windows)
- }
-#endif
- }
-#if defined(Windows)
- if(unbuffered)
- CloseHandle(hand);
- else
- {
-#endif
- if(fd)
- close(fd);
-#if defined(Windows)
- }
-#endif
-
-#if defined(Windows)
- if(unbuffered)
- {
- hand=CreateFile(filename,
- GENERIC_READ|GENERIC_WRITE,
- FILE_SHARE_WRITE|FILE_SHARE_READ,
- NULL,OPEN_EXISTING,FILE_FLAG_NO_BUFFERING|
- FILE_FLAG_WRITE_THROUGH|FILE_FLAG_POSIX_SEMANTICS,
- NULL);
- }
- else
- {
-#endif
- if((fd = I_OPEN(filename, (int)file_flags,0))<0)
- {
- printf("\nCan not open temp file: %s\n",
- filename);
- perror("open");
- exit(44);
- }
-#if defined(Windows)
- }
-#endif
-#ifdef VXFS
- if(direct_flag)
- {
- ioctl(fd,VX_SETCACHE,VX_DIRECT);
- ioctl(fd,VX_GETCACHE,&test_foo);
- if(test_foo == 0)
- {
- if(!client_iozone)
- printf("\nVxFS advanced setcache feature not available.\n");
- exit(3);
- }
- }
-#endif
-#if defined(solaris)
- if(direct_flag)
- {
- test_foo = directio(fd, DIRECTIO_ON);
- if(test_foo != 0)
- {
- if(!client_iozone)
- printf("\ndirectio not available.\n");
- exit(3);
- }
- }
-#endif
-
- if(file_lock)
- if(mylockf((int) fd, (int) 1, (int)0)!=0)
- printf("File lock for write failed. %d\n",errno);
- if(mmapflag)
- {
- maddr=(char *)initfile(fd,filebytes64,1,PROT_READ|PROT_WRITE);
- }
- if(mmap_mix)
- {
- wval=write(fd, pbuff, (size_t) page_size);
- if(wval != page_size)
- {
-#ifdef NO_PRINT_LLD
- printf("\nError writing block %ld, fd= %d\n", (long long)0, fd);
-#else
- printf("\nError writing block %lld, fd= %d\n", (long long)0, fd);
-#endif
- if(wval==-1)
- perror("write");
- signal_handler();
- }
- I_LSEEK(fd,0,SEEK_SET);
- };
- wval=fsync(fd);
- if(wval==-1){
- perror("fsync");
- signal_handler();
- }
-#ifdef ASYNC_IO
- if(async_flag)
- async_init(&gc,fd,direct_flag);
-#endif
- pbuff=mainbuffer;
- if(fetchon)
- fetchit(pbuff,reclen);
- if(verify || dedup || dedup_interior)
- fill_buffer(pbuff,reclen,(long long)pattern,sverify,(long long)0);
- starttime1 = time_so_far();
-#ifdef unix
- if(Q_flag)
- {
- qtime_u_start=utime_so_far();
- qtime_s_start=stime_so_far();
- }
-#endif
- if(w_traj_flag)
- {
- rewind(w_traj_fd);
- }
- compute_val=(double)0;
- w_traj_ops_completed=0;
- w_traj_bytes_completed=0;
- for(i=0; i<numrecs64; i++){
- if(w_traj_flag)
- {
- traj_offset=get_traj(w_traj_fd, (long long *)&traj_size,(float *)&compute_time,(long)1);
- reclen=traj_size;
-#if defined(Windows)
- if(unbuffered)
- SetFilePointer(hand,(LONG)traj_offset,0,FILE_BEGIN);
- else
-#endif
- I_LSEEK(fd,traj_offset,SEEK_SET);
- }
- if(Q_flag)
- {
-#if defined(Windows)
- if(unbuffered)
- traj_offset=SetFilePointer(hand,(LONG)0,0,FILE_CURRENT);
- else
-#endif
- traj_offset=I_LSEEK(fd,0,SEEK_CUR);
- }
- if(rlocking)
- {
- lock_offset=I_LSEEK(fd,0,SEEK_CUR);
- mylockr((int) fd, (int) 1, (int)0,
- lock_offset, reclen);
- }
- if((verify && diag_v) || dedup || dedup_interior)
- fill_buffer(pbuff,reclen,(long long)pattern,sverify,i);
- if(compute_flag)
- compute_val+=do_compute(compute_time);
- if(multi_buffer)
- {
- Index +=reclen;
- if(Index > (MAXBUFFERSIZE-reclen))
- Index=0;
- pbuff = mbuffer + Index;
- if(verify || dedup || dedup_interior)
- fill_buffer(pbuff,reclen,(long long)pattern,sverify,(long long)0);
- }
- if(async_flag && no_copy_flag)
- {
- free_addr=nbuff=(char *)malloc((size_t)reclen+page_size);
- nbuff=(char *)(((long)nbuff+(long)page_size) & (long)~(page_size-1));
- if(verify || dedup || dedup_interior)
- fill_buffer(nbuff,reclen,(long long)pattern,sverify,i);
- if(purge)
- purgeit(nbuff,reclen);
- }
- if(purge)
- purgeit(pbuff,reclen);
- if(Q_flag || hist_summary)
- {
- qtime_start=time_so_far();
- }
- if(mmapflag)
- {
- wmaddr = &maddr[i*reclen];
- fill_area((long long*)pbuff,(long long*)wmaddr,(long long)reclen);
- if(!mmapnsflag)
- {
- if(mmapasflag)
- msync(wmaddr,(size_t)reclen,MS_ASYNC);
- if(mmapssflag)
- msync(wmaddr,(size_t)reclen,MS_SYNC);
- }
- }
- else
- {
- if(async_flag)
- {
- if(no_copy_flag)
- async_write_no_copy(gc, (long long)fd, nbuff, reclen, (i*reclen), depth,free_addr);
- else
- async_write(gc, (long long)fd, pbuff, reclen, (i*reclen), depth);
- }
- else
- {
-#if defined(Windows)
- if(unbuffered)
- {
- WriteFile(hand, pbuff, reclen,(LPDWORD)&wval,
- 0);
- }
- else
- {
-#endif
- wval=write(fd, pbuff, (size_t ) reclen);
- if(wval != reclen)
- {
-#ifdef NO_PRINT_LLD
- printf("\nError writing block %ld, fd= %d\n", i,
- fd);
-#else
- printf("\nError writing block %lld, fd= %d\n", i,
- fd);
-#endif
- if(wval == -1)
- perror("write");
- signal_handler();
- }
-#if defined(Windows)
- }
-#endif
- }
- }
- if(hist_summary)
- {
- qtime_stop=time_so_far();
- hist_time =(qtime_stop-qtime_start-time_res);
- hist_insert(hist_time);
- }
- if(Q_flag)
- {
- qtime_stop=time_so_far();
- if(j==0)
-#ifdef NO_PRINT_LLD
- fprintf(wqfd,"%10.1ld %10.0f %10.1ld\n",(traj_offset)/1024,((qtime_stop-qtime_start-time_res))*1000000,reclen);
- else
- fprintf(rwqfd,"%10.1ld %10.0f %10.1ld\n",(traj_offset)/1024,((qtime_stop-qtime_start-time_res))*1000000,reclen);
-#else
- fprintf(wqfd,"%10.1lld %10.0f %10.1lld\n",(traj_offset)/1024,((qtime_stop-qtime_start-time_res))*1000000,reclen);
- else
- fprintf(rwqfd,"%10.1lld %10.0f %10.1lld\n",(traj_offset)/1024,((qtime_stop-qtime_start-time_res))*1000000,reclen);
-#endif
- }
- w_traj_ops_completed++;
- w_traj_bytes_completed+=reclen;
- if(rlocking)
- {
- mylockr((int) fd, (int) 0, (int)0,
- lock_offset, reclen);
- }
- }
-#ifdef unix
- if(Q_flag)
- {
- qtime_u_stop=utime_so_far();
- qtime_s_stop=stime_so_far();
- if(j==0)
- fprintf(wqfd,"\nSystem time %10.3f User time %10.3f Real %10.3f (seconds)\n",
- (qtime_s_stop-qtime_s_start)/sc_clk_tck,
- (qtime_u_stop-qtime_u_start)/sc_clk_tck,
- time_so_far()-starttime1);
- else
- fprintf(rwqfd,"\nSystem time %10.3f User time %10.3f Real %10.3f (seconds)\n",
- (qtime_s_stop-qtime_s_start)/sc_clk_tck,
- (qtime_u_stop-qtime_u_start)/sc_clk_tck,
- time_so_far()-starttime1);
- }
-#endif
-
-#ifdef ASYNC_IO
- if(async_flag)
- {
- end_async(gc);
- gc=0;
- }
-#endif
- if(include_flush)
- {
- if(mmapflag){
- msync(maddr,(size_t)filebytes64,MS_SYNC);
- }
- else
- {
- wval=fsync(fd);
- if(wval==-1){
- perror("fsync");
- signal_handler();
- }
- }
- }
- if(file_lock)
- if(mylockf((int) fd,(int)0,(int)0))
- printf("Unlock failed %d\n",errno);
- if(include_close)
- {
- if(mmapflag)
- {
- mmap_end(maddr,(unsigned long long)filebytes64);
- }
-#if defined(Windows)
- if(unbuffered)
- CloseHandle(hand);
- else
-#endif
- wval=close(fd);
- if(wval==-1){
- perror("close");
- signal_handler();
- }
- }
- writetime[j] = ((time_so_far() - starttime1)-time_res)
- -compute_val;
- if(writetime[j] < (double).000001)
- {
- writetime[j]=time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
- if(!include_close)
- {
- if(mmapflag)
- msync(maddr,(size_t)filebytes64,MS_SYNC);/* Clean up before read starts */
- else
- {
- wval=fsync(fd);
- if(wval==-1){
- perror("fsync");
- signal_handler();
- }
- }
- if(mmapflag)
- {
- mmap_end(maddr,(unsigned long long)filebytes64);
- }
-#if defined(Windows)
- if(unbuffered)
- CloseHandle(hand);
- else
-#endif
- wval=close(fd);
- if(wval==-1){
- perror("close");
- signal_handler();
- }
- }
- if(cpuutilflag)
- {
- cputime[j] = cputime_so_far() - cputime[j];
- if (cputime[j] < cputime_res)
- cputime[j] = 0.0;
- walltime[j] = time_so_far() - walltime[j];
- if (walltime[j] < cputime[j])
- walltime[j] = cputime[j];
- }
- if(restf)
- sleep((int)rest_val);
- }
- if(OPS_flag || MS_flag){
- filebytes64=w_traj_ops_completed;
- /*filebytes64=filebytes64/reclen;*/
- }else
- filebytes64=w_traj_bytes_completed;
-
- for(j=0;j<ltest;j++)
- {
- if(MS_flag)
- {
- writerate[j]=1000000.0*(writetime[j] / (double)filebytes64);
- continue;
- }
- else
- {
- writerate[j] =
- (unsigned long long) ((double) filebytes64 / writetime[j]);
- }
- if(!(OPS_flag || MS_flag))
- writerate[j] >>= 10;
- }
- data1[0]=writerate[0];
- if(noretest)
- {
- writerate[1]=(long long) 0;
- if(cpuutilflag)
- {
- walltime[1]=0.0;
- cputime[1]=0.0;
- }
- }
- /* Must save walltime & cputime before calling store_value() for each/any cell.*/
- if(cpuutilflag)
- store_times(walltime[0], cputime[0]);
- store_value((off64_t)writerate[0]);
- if(cpuutilflag)
- store_times(walltime[1], cputime[1]);
- store_value((off64_t)writerate[1]);
-#ifdef NO_PRINT_LLD
- if(!silent) printf("%8ld",writerate[0]);
- if(!silent) printf("%8ld",writerate[1]);
- if(!silent) fflush(stdout);
-#else
- if(!silent) printf("%8lld",writerate[0]);
- if(!silent) printf("%8lld",writerate[1]);
- if(!silent) fflush(stdout);
-#endif
-}
-/************************************************************************/
-/* fwrite_perf_test () */
-/* fWrite and fre-write test */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void fwrite_perf_test(off64_t kilo64,long long reclen ,long long *data1,long long *data2)
-#else
-void fwrite_perf_test(kilo64,reclen ,data1,data2)
-off64_t kilo64;
-long long reclen;
-long long *data1;
-long long *data2;
-#endif
-{
- double starttime1;
- double writetime[2];
- double walltime[2], cputime[2];
- double compute_val = (double)0;
- long long i,j;
- off64_t numrecs64;
- long long Index = 0;
- unsigned long long writerate[2];
- off64_t filebytes64;
- FILE *stream = NULL;
- int fd;
- int wval;
- int ltest;
- char *how;
- char *stdio_buf;
-
- if(mmapflag || async_flag)
- return;
- numrecs64 = (kilo64*1024)/reclen;
- filebytes64 = numrecs64*reclen;
- stdio_buf=(char *)malloc((size_t)reclen);
- if(noretest)
- ltest=1;
- else
- ltest=2;
-
- for( j=0; j<ltest; j++)
- {
- if(cpuutilflag)
- {
- walltime[j] = time_so_far();
- cputime[j] = cputime_so_far();
- }
- if(Uflag) /* Unmount and re-mount the mountpoint */
- {
- purge_buffer_cache();
- }
- if(j==0)
- {
- if(check_filename(filename))
- how="r+"; /* file exists, don't create and zero a new one. */
- else
- how="w+"; /* file doesn't exist. create it. */
- }
- else
- how="r+"; /* re-tests should error out if file does not exist. */
-#ifdef IRIX64
- if((stream=(FILE *)fopen(filename,how)) == 0)
- {
- printf("\nCan not fdopen temp file: %s %lld\n",
- filename,errno);
- perror("fdopen");
- exit(48);
- }
-#else
- if((stream=(FILE *)I_FOPEN(filename,how)) == 0)
- {
-#ifdef NO_PRINT_LLD
- printf("\nCan not fdopen temp file: %s %d\n",
- filename,errno);
-#else
- printf("\nCan not fdopen temp file: %s %d\n",
- filename,errno);
-#endif
- perror("fdopen");
- exit(49);
- }
-#endif
- fd=fileno(stream);
- fsync(fd);
- setvbuf(stream,stdio_buf,_IOFBF,reclen);
- buffer=mainbuffer;
- if(fetchon)
- fetchit(buffer,reclen);
- if(verify || dedup || dedup_interior)
- fill_buffer(buffer,reclen,(long long)pattern,sverify,(long long)0);
- starttime1 = time_so_far();
- compute_val=(double)0;
- for(i=0; i<numrecs64; i++){
- if(compute_flag)
- compute_val+=do_compute(compute_time);
- if(multi_buffer)
- {
- Index +=reclen;
- if(Index > (MAXBUFFERSIZE-reclen))
- Index=0;
- buffer = mbuffer + Index;
- }
- if((verify & diag_v) || dedup || dedup_interior)
- fill_buffer(buffer,reclen,(long long)pattern,sverify,i);
- if(purge)
- purgeit(buffer,reclen);
- if(fwrite(buffer, (size_t) reclen, 1, stream) != 1)
- {
-#ifdef NO_PRINT_LLD
- printf("\nError fwriting block %ld, fd= %d\n", i,
- fd);
-#else
- printf("\nError fwriting block %lld, fd= %d\n", i,
- fd);
-#endif
- perror("fwrite");
- signal_handler();
- }
- }
-
- if(include_flush)
- {
- fflush(stream);
- wval=fsync(fd);
- if(wval==-1){
- perror("fsync");
- signal_handler();
- }
- }
- if(include_close)
- {
- wval=fclose(stream);
- if(wval==-1){
- perror("fclose");
- signal_handler();
- }
- }
- writetime[j] = ((time_so_far() - starttime1)-time_res)
- -compute_val;
- if(writetime[j] < (double).000001)
- {
- writetime[j]= time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
- if(!include_close)
- {
- wval=fflush(stream);
- if(wval==-1){
- perror("fflush");
- signal_handler();
- }
- wval=fsync(fd);
- if(wval==-1){
- perror("fsync");
- signal_handler();
- }
- wval=fclose(stream);
- if(wval==-1){
- perror("fclose");
- signal_handler();
- }
- }
-
- if(cpuutilflag)
- {
- cputime[j] = cputime_so_far() - cputime[j];
- if (cputime[j] < cputime_res)
- cputime[j] = 0.0;
- walltime[j] = time_so_far() - walltime[j];
- if (walltime[j] < cputime[j])
- walltime[j] = cputime[j];
- }
- if(restf)
- sleep((int)(int)rest_val);
- }
- free(stdio_buf);
- if(OPS_flag || MS_flag){
- filebytes64=filebytes64/reclen;
- }
- for(j=0;j<ltest;j++)
- {
- if(MS_flag)
- {
- writerate[j]=1000000.0*(writetime[j] / (double)filebytes64);
- continue;
- }
- else
- {
- writerate[j] =
- (unsigned long long) ((double) filebytes64 / writetime[j]);
- }
- if(!(OPS_flag || MS_flag))
- writerate[j] >>= 10;
- }
- /* Must save walltime & cputime before calling store_value() for each/any cell.*/
- if(noretest)
- {
- writerate[1]=(long long)0;
- if(cpuutilflag)
- {
- walltime[1]=0.0;
- cputime[1]=0.0;
- }
- }
- if(cpuutilflag)
- store_times(walltime[0], cputime[0]);
- store_value((off64_t)writerate[0]);
- if(cpuutilflag)
- store_times(walltime[1], cputime[1]);
- store_value((off64_t)writerate[1]);
- data1[0]=writerate[0];
-#ifdef NO_PRINT_LLD
- if(!silent) printf("%9ld",writerate[0]);
- if(!silent) printf("%9ld",writerate[1]);
- if(!silent) fflush(stdout);
-#else
- if(!silent) printf("%9lld",writerate[0]);
- if(!silent) printf("%9lld",writerate[1]);
- if(!silent) fflush(stdout);
-#endif
-}
-
-/************************************************************************/
-/* fread_perf_test */
-/* fRead and fre-read test */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void fread_perf_test(off64_t kilo64,long long reclen,long long *data1,long long *data2)
-#else
-void fread_perf_test(kilo64,reclen,data1,data2)
-off64_t kilo64;
-long long reclen;
-long long *data1,*data2;
-#endif
-{
- double starttime2;
- double readtime[2];
- double walltime[2], cputime[2];
- double compute_val = (double)0;
- long long j;
- off64_t i,numrecs64;
- long long Index = 0;
- unsigned long long readrate[2];
- off64_t filebytes64;
- FILE *stream = 0;
- char *stdio_buf;
- int fd,ltest;
-
- if(mmapflag || async_flag)
- return;
- numrecs64 = (kilo64*1024)/reclen;
- filebytes64 = numrecs64*reclen;
- stdio_buf=(char *)malloc((size_t)reclen);
-
- if(noretest)
- ltest=1;
- else
- ltest=2;
-
- for( j=0; j<ltest; j++ )
- {
- if(cpuutilflag)
- {
- walltime[j] = time_so_far();
- cputime[j] = cputime_so_far();
- }
-
- if(Uflag) /* Unmount and re-mount the mountpoint */
- {
- purge_buffer_cache();
- }
-#ifdef IRIX64
- if((stream=(FILE *)fopen(filename,"r")) == 0)
- {
- printf("\nCan not fdopen temp file: %s\n",
- filename);
- perror("fdopen");
- exit(51);
- }
-#else
- if((stream=(FILE *)I_FOPEN(filename,"r")) == 0)
- {
- printf("\nCan not fdopen temp file: %s\n",
- filename);
- perror("fdopen");
- exit(52);
- }
-#endif
- fd=I_OPEN(filename,O_RDONLY,0);
- fsync(fd);
- close(fd);
- setvbuf(stream,stdio_buf,_IOFBF,reclen);
- buffer=mainbuffer;
- if(fetchon)
- fetchit(buffer,reclen);
- compute_val=(double)0;
- starttime2 = time_so_far();
- for(i=0; i<numrecs64; i++)
- {
- if(compute_flag)
- compute_val+=do_compute(compute_time);
- if(multi_buffer)
- {
- Index +=reclen;
- if(Index > (MAXBUFFERSIZE-reclen))
- Index=0;
- buffer = mbuffer + Index;
- }
- if(purge)
- purgeit(buffer,reclen);
- if(fread(buffer, (size_t) reclen,1, stream) != 1)
- {
-#ifdef _64BIT_ARCH_
-#ifdef NO_PRINT_LLD
- printf("\nError freading block %lu %lx\n", i,
- (unsigned long long)buffer);
-#else
- printf("\nError freading block %llu %llx\n", i,
- (unsigned long long)buffer);
-#endif
-#else
-#ifdef NO_PRINT_LLD
- printf("\nError freading block %lu %lx\n", i,
- (long)buffer);
-#else
- printf("\nError freading block %llu %lx\n", i,
- (long)buffer);
-#endif
-#endif
- perror("read");
- exit(54);
- }
- if(verify){
- if(verify_buffer(buffer,reclen,(off64_t)i,reclen,(long long)pattern,sverify)){
- exit(55);
- }
- }
- }
- if(include_flush)
- fflush(stream);
- if(include_close)
- {
- fclose(stream);
- }
- readtime[j] = ((time_so_far() - starttime2)-time_res)
- -compute_val;
- if(readtime[j] < (double).000001)
- {
- readtime[j]= time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
- if(!include_close)
- {
- fflush(stream);
- fclose(stream);
- }
- stream = NULL;
- if(cpuutilflag)
- {
- cputime[j] = cputime_so_far() - cputime[j];
- if (cputime[j] < cputime_res)
- cputime[j] = 0.0;
- walltime[j] = time_so_far() - walltime[j];
- if (walltime[j] < cputime[j])
- walltime[j] = cputime[j];
- }
- if(restf)
- sleep((int)rest_val);
- }
- free(stdio_buf);
- if(OPS_flag || MS_flag){
- filebytes64=filebytes64/reclen;
- }
- for(j=0;j<ltest;j++)
- {
- if(MS_flag)
- {
- readrate[j]=1000000.0*(readtime[j] / (double)filebytes64);
- continue;
- }
- else
- {
- readrate[j] =
- (unsigned long long) ((double) filebytes64 / readtime[j]);
- }
- if(!(OPS_flag || MS_flag))
- readrate[j] >>= 10;
- }
- data1[0]=readrate[0];
- data2[0]=1;
- if(noretest)
- {
- readrate[1]=(long long)0;
- if(cpuutilflag)
- {
- walltime[1]=0.0;
- cputime[1]=0.0;
- }
- }
- /* Must save walltime & cputime before calling store_value() for each/any cell.*/
- if(cpuutilflag)
- store_times(walltime[0], cputime[0]);
- store_value((off64_t)readrate[0]);
- if(cpuutilflag)
- store_times(walltime[1], cputime[1]);
- store_value((off64_t)readrate[1]);
-#ifdef NO_PRINT_LLD
- if(!silent) printf("%8ld",readrate[0]);
- if(!silent) printf("%9ld",readrate[1]);
- if(!silent) fflush(stdout);
-#else
- if(!silent) printf("%8lld",readrate[0]);
- if(!silent) printf("%9lld",readrate[1]);
- if(!silent) fflush(stdout);
-#endif
-}
-
-/************************************************************************/
-/* read_perf_test */
-/* Read and re-fread test */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void
-read_perf_test(off64_t kilo64,long long reclen,long long *data1,long long *data2)
-#else
-void
-read_perf_test(kilo64,reclen,data1,data2)
-off64_t kilo64;
-long long reclen;
-long long *data1,*data2;
-#endif
-{
- double starttime2;
- double compute_val = (double)0;
- double readtime[2];
- double walltime[2], cputime[2];
-#ifdef unix
- double qtime_u_start,qtime_u_stop;
- double qtime_s_start,qtime_s_stop;
-#endif
- long long j;
- long long traj_size;
- off64_t i,numrecs64,traj_offset;
- off64_t lock_offset=0;
- long long Index = 0;
- unsigned long long readrate[2];
- off64_t filebytes64;
- volatile char *buffer1;
- char *nbuff;
- char *maddr;
- char *wmaddr;
- int fd,open_flags;
- int test_foo,ltest;
- long wval;
- double qtime_start,qtime_stop;
- double hist_time;
-#ifdef ASYNC_IO
- struct cache *gc=0;
-
-#else
- long long *gc=0;
-#endif
-#ifdef unix
- qtime_u_start=qtime_u_stop=0;
- qtime_s_start=qtime_s_stop=0;
-#endif
- hist_time=qtime_start=qtime_stop=0;
- maddr=0;
- traj_offset=0;
- test_foo=0;
- numrecs64 = (kilo64*1024)/reclen;
-
- open_flags = O_RDONLY;
-#if defined(_HPUX_SOURCE) || defined(linux)
- if(read_sync)
- open_flags |=O_RSYNC|O_SYNC;
-#endif
-#if ! defined(DONT_HAVE_O_DIRECT)
-#if defined(linux) || defined(__AIX__) || defined(IRIX) || defined(IRIX64) || defined(Windows) || defined (__FreeBSD__)
- if(direct_flag)
- open_flags |=O_DIRECT;
-#endif
-#if defined(TRU64)
- if(direct_flag)
- open_flags |=O_DIRECTIO;
-#endif
-#endif
- if(r_traj_flag)
- {
- numrecs64=r_traj_ops;
- filebytes64 = r_traj_fsize;
- } else
- filebytes64 = numrecs64*reclen;
- fd = 0;
- if(Q_flag && (!rol_opened))
- {
- rol_opened++;
- rqfd=fopen("rol.dat","a");
- if(rqfd==0)
- {
- printf("Unable to open rol.dat\n");
- exit(56);
- }
- fprintf(rqfd,"Offset in Kbytes Latency in microseconds Transfer size in bytes\n");
- rrqfd=fopen("rrol.dat","a");
- if(rrqfd==0)
- {
- printf("Unable to open rrol.dat\n");
- exit(57);
- }
- fprintf(rrqfd,"Offset in Kbytes Latency in microseconds Transfer size in bytes\n");
- }
- /*
- * begin real testing
- */
- if(noretest)
- ltest=1;
- else
- ltest=2;
-
- for( j=0; j<ltest; j++ )
- {
-
- if(cpuutilflag)
- {
- walltime[j] = time_so_far();
- cputime[j] = cputime_so_far();
- }
-
- if(Uflag) /* Unmount and re-mount the mountpoint */
- {
- purge_buffer_cache();
- }
-#if defined(Windows)
- if(unbuffered)
- {
- hand=CreateFile(filename,
- GENERIC_READ|GENERIC_WRITE,
- FILE_SHARE_WRITE|FILE_SHARE_READ,
- NULL,OPEN_EXISTING,FILE_FLAG_NO_BUFFERING|
- FILE_FLAG_WRITE_THROUGH|FILE_FLAG_POSIX_SEMANTICS,
- NULL);
- }
- else
- {
-#endif
- if((fd = I_OPEN(filename, open_flags,0))<0)
- {
- printf("\nCan not open temporary file %s for read\n",filename);
- perror("open");
- exit(58);
- }
-#if defined(Windows)
- }
-#endif
-#ifdef ASYNC_IO
- if(async_flag)
- async_init(&gc,fd,direct_flag);
-#endif
-
-#ifdef VXFS
- if(direct_flag)
- {
- ioctl(fd,VX_SETCACHE,VX_DIRECT);
- ioctl(fd,VX_GETCACHE,&test_foo);
- if(test_foo == 0)
- {
- if(!client_iozone)
- printf("\nVxFS advanced setcache feature not available.\n");
- exit(3);
- }
- }
-#endif
-#if defined(solaris)
- if(direct_flag)
- {
- test_foo = directio(fd, DIRECTIO_ON);
- if(test_foo != 0)
- {
- if(!client_iozone)
- printf("\ndirectio not available.\n");
- exit(3);
- }
- }
-#endif
- if(file_lock)
- if(mylockf((int) fd, (int) 1, (int)1) != 0)
- printf("File lock for read failed. %d\n",errno);
- if(mmapflag)
- {
- maddr=(char *)initfile(fd,filebytes64,0,PROT_READ);
- }
-#if defined(Windows)
- if(!unbuffered)
-#endif
- fsync(fd);
- /*
- * Need to prime the instruction cache & TLB
- */
- nbuff=mainbuffer;
- if(fetchon)
- fetchit(nbuff,reclen);
-#if defined(Windows)
- if(!unbuffered)
- {
-#endif
- if(read(fd, (void *)nbuff, (size_t) reclen) != reclen)
- {
-#ifdef _64BIT_ARCH_
- printf("\nError reading block %d %llx\n", 0,
- (unsigned long long)nbuff);
-#else
- printf("\nError reading block %d %lx\n", 0,
- (long)nbuff);
-#endif
- perror("read");
- exit(60);
- }
- I_LSEEK(fd,0,SEEK_SET);
-#if defined(Windows)
- }
- if(unbuffered)
- SetFilePointer(hand,(LONG)0,0,FILE_BEGIN);
-#endif
- nbuff=mainbuffer;
-
- if(fetchon)
- fetchit(nbuff,reclen);
- starttime2 = time_so_far();
-#ifdef unix
- if(Q_flag || hist_summary)
- {
- qtime_u_start=utime_so_far();
- qtime_s_start=stime_so_far();
- }
-#endif
- if(r_traj_flag)
- {
- rewind(r_traj_fd);
- }
- compute_val=(double)0;
- r_traj_ops_completed=0;
- r_traj_bytes_completed=0;
- for(i=0; i<numrecs64; i++)
- {
- if(disrupt_flag && ((i%DISRUPT)==0))
- {
-#if defined(Windows)
-
- if(unbuffered)
- disruptw(hand);
- else
- disrupt(fd);
-#else
- disrupt(fd);
-#endif
- }
- if(r_traj_flag)
- {
- traj_offset=get_traj(r_traj_fd, (long long *)&traj_size,(float *)&compute_time, (long)0);
- reclen=traj_size;
-#if defined(Windows)
- if(unbuffered)
- SetFilePointer(hand,(LONG)traj_offset,0,FILE_BEGIN);
- else
-#endif
- I_LSEEK(fd,traj_offset,SEEK_SET);
- }
- if(Q_flag)
- {
-#if defined(Windows)
- if(unbuffered)
- traj_offset=SetFilePointer(hand,(LONG)0,0,FILE_CURRENT);
- else
-#endif
- traj_offset=I_LSEEK(fd,0,SEEK_CUR);
- }
- if(rlocking)
- {
- lock_offset=I_LSEEK(fd,0,SEEK_CUR);
- mylockr((int) fd, (int) 1, (int)1,
- lock_offset, reclen);
- }
- if(compute_flag)
- compute_val+=do_compute(compute_time);
- if(multi_buffer)
- {
- Index +=reclen;
- if(Index > (MAXBUFFERSIZE-reclen))
- Index=0;
- nbuff = mbuffer + Index;
- }
- if(purge)
- purgeit(nbuff,reclen);
- if(Q_flag || hist_summary)
- qtime_start=time_so_far();
- if(mmapflag)
- {
- wmaddr=&maddr[i*reclen];
- fill_area((long long*)wmaddr,(long long*)nbuff,(long long)reclen);
- }
- else
- {
- if(async_flag)
- {
- if(no_copy_flag)
- async_read_no_copy(gc, (long long)fd, &buffer1, (i*reclen), reclen,
- 1LL,(numrecs64*reclen),depth);
- else
- async_read(gc, (long long)fd, nbuff, (i*reclen),reclen,
- 1LL,(numrecs64*reclen),depth);
- }
- else
- {
-#if defined(Windows)
- if(unbuffered)
- {
- ReadFile(hand, nbuff, reclen,(LPDWORD)&wval,
- 0);
- }
- else
-#endif
- wval=read((int)fd, (void*)nbuff, (size_t) reclen);
- if(wval != reclen)
- {
-#ifdef _64BIT_ARCH_
-#ifdef NO_PRINT_LLD
- printf("\nError reading block %ld %lx\n", i,
- (unsigned long long)nbuff);
-#else
- printf("\nError reading block %lld %llx\n", i,
- (unsigned long long)nbuff);
-#endif
-#else
-#ifdef NO_PRINT_LLD
- printf("\nError reading block %ld %x\n", i,
- (long)nbuff);
-#else
- printf("\nError reading block %lld %lx\n", i,
- (long)nbuff);
-#endif
-#endif
- perror("read");
- exit(61);
- }
- }
- }
- if(verify) {
- if(async_flag && no_copy_flag)
- {
- if(verify_buffer(buffer1,reclen,(off64_t)i,reclen,(long long)pattern,sverify)){
- exit(62);
- }
- }
- else
- {
- if(verify_buffer(nbuff,reclen,(off64_t)i,reclen,(long long)pattern,sverify)){
- exit(63);
- }
- }
- }
- if(async_flag && no_copy_flag)
- async_release(gc);
- buffer1=0;
- if(hist_summary)
- {
- qtime_stop=time_so_far();
- hist_time =(qtime_stop-qtime_start-time_res);
- hist_insert(hist_time);
- }
- if(Q_flag)
- {
- qtime_stop=time_so_far();
- if(j==0)
-#ifdef NO_PRINT_LLD
- fprintf(rqfd,"%10.1ld %10.0f %10.1ld\n",(traj_offset)/1024,(qtime_stop-qtime_start-time_res)*1000000,reclen);
- else
- fprintf(rrqfd,"%10.1ld %10.0f %10.1ld\n",(traj_offset)/1024,(qtime_stop-qtime_start-time_res)*1000000,reclen);
-#else
- fprintf(rqfd,"%10.1lld %10.0f %10.1lld\n",(traj_offset)/1024,(qtime_stop-qtime_start-time_res)*1000000,reclen);
- else
- fprintf(rrqfd,"%10.1lld %10.0f %10.1lld\n",(traj_offset)/1024,(qtime_stop-qtime_start-time_res)*1000000,reclen);
-#endif
- }
- r_traj_ops_completed++;
- r_traj_bytes_completed+=reclen;
- }
- if(rlocking)
- {
- mylockr((int) fd, (int) 0, (int)1,
- lock_offset, reclen);
- }
- if(file_lock)
- if(mylockf((int) fd, (int) 0, (int)1))
- printf("Read unlock failed. %d\n",errno);
-#ifdef unix
- if(Q_flag)
- {
- qtime_u_stop=utime_so_far();
- qtime_s_stop=stime_so_far();
- if(j==0)
- fprintf(rqfd,"\nSystem time %10.3f User time %10.3f Real %10.3f (seconds)\n",
- (qtime_s_stop-qtime_s_start)/sc_clk_tck,
- (qtime_u_stop-qtime_u_start)/sc_clk_tck,
- time_so_far()-starttime2);
- else
- fprintf(rrqfd,"\nSystem time %10.3f User time %10.3f Real %10.3f (seconds)\n",
- (qtime_s_stop-qtime_s_start)/sc_clk_tck,
- (qtime_u_stop-qtime_u_start)/sc_clk_tck,
- time_so_far()-starttime2);
- }
-#endif
-#ifdef ASYNC_IO
- if(async_flag)
- {
- end_async(gc);
- gc=0;
- }
-#endif
- if(include_flush)
- {
- if(mmapflag)
- msync(maddr,(size_t)filebytes64,MS_SYNC);
- else
- fsync(fd);
- }
- if(include_close)
- {
- if(mmapflag)
- {
- mmap_end(maddr,(unsigned long long)filebytes64);
- }
-#if defined(Windows)
- if(unbuffered)
- CloseHandle(hand);
- else
-#endif
- close(fd);
- }
- readtime[j] = ((time_so_far() - starttime2)-time_res)-compute_val;
- if(readtime[j] < (double).000001)
- {
- readtime[j]= time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
- if(!include_close)
- {
- if(mmapflag)
- msync(maddr,(size_t)filebytes64,MS_SYNC);
- else
- fsync(fd);
- if(mmapflag)
- {
- mmap_end(maddr,(unsigned long long)filebytes64);
- }
-#if defined(Windows)
- if(unbuffered)
- CloseHandle(hand);
- else
-#endif
- close(fd);
- }
- if(cpuutilflag)
- {
- cputime[j] = cputime_so_far() - cputime[j];
- if (cputime[j] < cputime_res)
- cputime[j] = 0.0;
- walltime[j] = time_so_far() - walltime[j];
- if (walltime[j] < cputime[j])
- walltime[j] = cputime[j];
- }
- if(restf)
- sleep((int)rest_val);
- }
- if(OPS_flag || MS_flag){
- filebytes64=r_traj_ops_completed;
- /*filebytes64=filebytes64/reclen;*/
- } else
- filebytes64=r_traj_bytes_completed;
-
- for(j=0;j<ltest;j++)
- {
- if(MS_flag)
- {
- readrate[j]=1000000.0*(readtime[j] / (double)filebytes64);
- continue;
- }
- else
- {
- readrate[j] =
- (unsigned long long) ((double) filebytes64 / readtime[j]);
- }
- if(!(OPS_flag || MS_flag))
- readrate[j] >>= 10;
-
- }
- data1[0]=readrate[0];
- data2[0]=1;
- if(noretest)
- {
- readrate[1]=(long long)0;
- if(cpuutilflag)
- {
- walltime[1]=0.0;
- cputime[1]=0.0;
- }
- }
- /* Must save walltime & cputime before calling store_value() for each/any cell.*/
- if(cpuutilflag)
- store_times(walltime[0], cputime[0]);
- store_value((off64_t)readrate[0]);
- if(cpuutilflag)
- store_times(walltime[1], cputime[1]);
- store_value((off64_t)readrate[1]);
-#ifdef NO_PRINT_LLD
- if(!silent) printf("%9ld",readrate[0]);
- if(!silent) printf("%9ld",readrate[1]);
- if(!silent) fflush(stdout);
-#else
- if(!silent) printf("%9lld",readrate[0]);
- if(!silent) printf("%9lld",readrate[1]);
- if(!silent) fflush(stdout);
-#endif
-}
-
-
-/************************************************************************/
-/* random_perf_test */
-/* Random read and write test */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void random_perf_test(off64_t kilo64,long long reclen,long long *data1,long long *data2)
-#else
-void random_perf_test(kilo64,reclen,data1,data2)
-off64_t kilo64;
-long long reclen;
-long long *data1, *data2;
-#endif
-{
- double randreadtime[2];
- double starttime2;
- double walltime[2], cputime[2];
- double compute_val = (double)0;
-#if defined (bsd4_2) || defined(Windows)
- long long rand1,rand2,rand3;
-#endif
- unsigned long long big_rand;
- long long j;
- off64_t i,numrecs64;
- long long Index=0;
- int flags;
- unsigned long long randreadrate[2];
- off64_t filebytes64;
- off64_t lock_offset=0;
- volatile char *buffer1;
- char *wmaddr,*nbuff;
- char *maddr,*free_addr;
- int fd,wval;
- long long *recnum= 0;
-#if defined(VXFS) || defined(solaris)
- int test_foo=0;
-#endif
-#ifdef ASYNC_IO
- struct cache *gc=0;
-#else
- long long *gc=0;
-#endif
-#ifdef MERSENNE
- unsigned long long init[4]={0x12345ULL, 0x23456ULL, 0x34567ULL, 0x45678ULL};
- unsigned long long length=4;
-#endif
-
- maddr=free_addr=0;
- numrecs64 = (kilo64*1024)/reclen;
-#ifdef MERSENNE
- init_by_array64(init, length);
-#else
-#ifdef bsd4_2
- srand(0);
-#else
-#ifdef Windows
- srand(0);
-#else
- srand48(0);
-#endif
-#endif
-#endif
- recnum = (long long *)malloc(sizeof(*recnum)*numrecs64);
- if (recnum){
- /* pre-compute random sequence based on
- Fischer-Yates (Knuth) card shuffle */
- for(i = 0; i < numrecs64; i++){
- recnum[i] = i;
- }
- for(i = 0; i < numrecs64; i++) {
- long long tmp;
-#ifdef MERSENNE
- big_rand=genrand64_int64();
-#else
-#ifdef bsd4_2
- rand1=(long long)rand();
- rand2=(long long)rand();
- rand3=(long long)rand();
- big_rand=(rand1<<32)|(rand2<<16)|(rand3);
-#else
-#ifdef Windows
- rand1=(long long)rand();
- rand2=(long long)rand();
- rand3=(long long)rand();
- big_rand=(rand1<<32)|(rand2<<16)|(rand3);
-#else
- big_rand = lrand48();
-#endif
-#endif
-#endif
- big_rand = big_rand%numrecs64;
- tmp = recnum[i];
- recnum[i] = recnum[big_rand];
- recnum[big_rand] = tmp;
- }
- }
- else
- {
- fprintf(stderr,"Random uniqueness fallback.\n");
- }
- flags = O_RDWR;
-#if ! defined(DONT_HAVE_O_DIRECT)
-#if defined(linux) || defined(__AIX__) || defined(IRIX) || defined(IRIX64) || defined(Windows) || defined (__FreeBSD__)
- if(direct_flag)
- flags |=O_DIRECT;
-#endif
-#if defined(TRU64)
- if(direct_flag)
- flags |=O_DIRECTIO;
-#endif
-#endif
- fd=0;
- if(oflag)
- flags |= O_SYNC;
-#if defined(O_DSYNC)
- if(odsync)
- flags |= O_DSYNC;
-#endif
-#if defined(_HPUX_SOURCE) || defined(linux)
- if(read_sync)
- flags |=O_RSYNC|O_SYNC;
-#endif
- filebytes64 = numrecs64*reclen;
- for( j=0; j<2; j++ )
- {
- if(j==0)
- flags |=O_CREAT;
- if (no_write && (j == 1))
- continue;
- if(cpuutilflag)
- {
- walltime[j] = time_so_far();
- cputime[j] = cputime_so_far();
- }
- if(Uflag) /* Unmount and re-mount the mountpoint */
- {
- purge_buffer_cache();
- }
- if((fd = I_OPEN(filename, ((int)flags),0640))<0){
- printf("\nCan not open temporary file for read/write\n");
- perror("open");
- exit(66);
- }
-#ifdef ASYNC_IO
- if(async_flag)
- async_init(&gc,fd,direct_flag);
-#endif
-
-#ifdef VXFS
- if(direct_flag)
- {
- ioctl(fd,VX_SETCACHE,VX_DIRECT);
- ioctl(fd,VX_GETCACHE,&test_foo);
- if(test_foo == 0)
- {
- if(!client_iozone)
- printf("\nVxFS advanced setcache feature not available.\n");
- exit(3);
- }
- }
-#endif
-#if defined(solaris)
- if(direct_flag)
- {
- test_foo = directio(fd, DIRECTIO_ON);
- if(test_foo != 0)
- {
- if(!client_iozone)
- printf("\ndirectio not available.\n");
- exit(3);
- }
- }
-#endif
- if(mmapflag)
- {
- maddr=(char *)initfile(fd,filebytes64,0,PROT_READ|PROT_WRITE);
- }
- nbuff=mainbuffer;
- if(fetchon)
- fetchit(nbuff,reclen);
-#ifdef MERSENNE
- init_by_array64(init, length);
-#else
-#ifdef bsd4_2
- srand(0);
-#else
-#ifdef Windows
- srand(0);
-#else
- srand48(0);
-#endif
-#endif
-#endif
- compute_val=(double)0;
- starttime2 = time_so_far();
- if ( j==0 ){
- for(i=0; i<numrecs64; i++) {
- if(compute_flag)
- compute_val+=do_compute(compute_time);
- if(multi_buffer)
- {
- Index +=reclen;
- if(Index > (MAXBUFFERSIZE-reclen))
- Index=0;
- nbuff = mbuffer + Index;
- }
- if(purge)
- purgeit(nbuff,reclen);
- if (recnum) {
- offset64 = reclen * (long long)recnum[i];
- }
- else
- {
-
-#ifdef MERSENNE
- big_rand =genrand64_int64();
- offset64 = reclen * (big_rand%numrecs64);
-#else
-#ifdef bsd4_2
- rand1=(long long)rand();
- rand2=(long long)rand();
- rand3=(long long)rand();
- big_rand=(rand1<<32)|(rand2<<16)|(rand3);
- offset64 = reclen * (big_rand%numrecs64);
-#else
-#ifdef Windows
- rand1=(long long)rand();
- rand2=(long long)rand();
- rand3=(long long)rand();
- big_rand=(rand1<<32)|(rand2<<16)|(rand3);
- offset64 = reclen * (big_rand%numrecs64);
-#else
- offset64 = reclen * (lrand48()%numrecs64);
-#endif
-#endif
-#endif
- }
-
- if( !(h_flag || k_flag || mmapflag))
- {
- if(I_LSEEK( fd, offset64, SEEK_SET )<0)
- {
- perror("lseek");
- exit(68);
- };
- }
- if(rlocking)
- {
- lock_offset=I_LSEEK(fd,0,SEEK_CUR);
- mylockr((int) fd, (int) 1, (int)1,
- lock_offset, reclen);
- }
- if(mmapflag)
- {
- wmaddr=&maddr[offset64];
- fill_area((long long*)wmaddr,(long long*)nbuff,(long long)reclen);
- }
- else
- {
- if(async_flag)
- {
- if(no_copy_flag)
- async_read_no_copy(gc, (long long)fd, &buffer1, offset64,reclen,
- 0LL,(numrecs64*reclen),depth);
- else
- async_read(gc, (long long)fd, nbuff, (offset64),reclen,
- 0LL,(numrecs64*reclen),0LL);
- }
- else
- {
- if(read(fd, (void *)nbuff, (size_t)reclen) != reclen)
- {
-#ifdef NO_PRINT_LLD
- printf("\nError reading block at %ld\n",
- offset64);
-#else
- printf("\nError reading block at %lld\n",
- offset64);
-#endif
- perror("read");
- exit(70);
- }
- }
- }
- if(verify){
- if(async_flag && no_copy_flag)
- {
- if(verify_buffer(buffer1,reclen,(off64_t)offset64/reclen,reclen,(long long)pattern,sverify)){
- exit(71);
- }
- }
- else
- {
- if(verify_buffer(nbuff,reclen,(off64_t)offset64/reclen,reclen,(long long)pattern,sverify)){
- exit(72);
- }
- }
- }
- if(async_flag && no_copy_flag)
- async_release(gc);
- if(rlocking)
- {
- lock_offset=I_LSEEK(fd,0,SEEK_CUR);
- mylockr((int) fd, (int) 1, (int)1,
- lock_offset, reclen);
- }
- }
- }
- else
- {
- if(verify || dedup || dedup_interior)
- fill_buffer(nbuff,reclen,(long long)pattern,sverify,(long long)0);
- for(i=0; i<numrecs64; i++)
- {
- if(compute_flag)
- compute_val+=do_compute(compute_time);
- if(multi_buffer)
- {
- Index +=reclen;
- if(Index > (MAXBUFFERSIZE-reclen))
- Index=0;
- nbuff = mbuffer + Index;
- }
- if (recnum) {
- offset64 = reclen * (long long)recnum[i];
- }
- else
- {
-#ifdef bsd4_2
- rand1=(long long)rand();
- rand2=(long long)rand();
- rand3=(long long)rand();
- big_rand=(rand1<<32)|(rand2<<16)|(rand3);
- offset64 = reclen * (big_rand%numrecs64);
-#else
-#ifdef Windows
- rand1=(long long)rand();
- rand2=(long long)rand();
- rand3=(long long)rand();
- big_rand=(rand1<<32)|(rand2<<16)|(rand3);
- offset64 = reclen * (big_rand%numrecs64);
-#else
- offset64 = reclen * (lrand48()%numrecs64);
-#endif
-#endif
- }
- if(async_flag && no_copy_flag)
- {
- free_addr=nbuff=(char *)malloc((size_t)reclen+page_size);
- nbuff=(char *)(((long)nbuff+(long)page_size) & (long)~(page_size-1));
- if(verify || dedup || dedup_interior)
- fill_buffer(nbuff,reclen,(long long)pattern,sverify,offset64/reclen);
- }
- if(purge)
- purgeit(nbuff,reclen);
-
- if((verify & diag_v) || dedup || dedup_interior)
- fill_buffer(nbuff,reclen,(long long)pattern,sverify,offset64/reclen);
-
- if (!(h_flag || k_flag || mmapflag))
- {
- I_LSEEK( fd, offset64, SEEK_SET );
- }
- if(rlocking)
- {
- lock_offset=I_LSEEK(fd,0,SEEK_CUR);
- mylockr((int) fd, (int) 1, (int)0,
- lock_offset, reclen);
- }
- if(mmapflag)
- {
- wmaddr=&maddr[offset64];
- fill_area((long long*)nbuff,(long long*)wmaddr,(long long)reclen);
- if(!mmapnsflag)
- {
- if(mmapasflag)
- msync(wmaddr,(size_t)reclen,MS_ASYNC);
- if(mmapssflag)
- msync(wmaddr,(size_t)reclen,MS_SYNC);
- }
- }
- else
- {
- if(async_flag)
- {
- if(no_copy_flag)
- async_write_no_copy(gc, (long long)fd, nbuff, reclen, offset64,
- depth,free_addr);
- else
- async_write(gc, (long long)fd, nbuff, reclen, offset64, depth);
- }
- else
- {
- wval=write(fd, nbuff,(size_t)reclen);
- if(wval != reclen)
- {
-#ifdef NO_PRINT_LLD
- printf("\nError writing block at %ld\n",
- offset64);
-#else
- printf("\nError writing block at %lld\n",
- offset64);
-#endif
- if(wval==-1)
- perror("write");
- signal_handler();
- }
- }
- }
- if(rlocking)
- {
- mylockr((int) fd, (int) 0, (int)0,
- lock_offset, reclen);
- }
- }
- } /* end of modifications *kcollins:2-5-96 */
-#ifdef ASYNC_IO
- if(async_flag)
- {
- end_async(gc);
- gc=0;
- }
-#endif
- if(include_flush)
- {
- if(mmapflag)
- msync(maddr,(size_t)filebytes64,MS_SYNC);/* Clean up before read starts running */
- else
- {
- wval=fsync(fd);
- if(wval==-1){
- perror("fsync");
- signal_handler();
- }
- }
- }
- if(include_close)
- {
- if(mmapflag)
- {
- mmap_end(maddr,(unsigned long long)filebytes64);
- }
- wval=close(fd);
- if(wval==-1){
- perror("close");
- signal_handler();
- }
- }
- randreadtime[j] = ((time_so_far() - starttime2)-time_res)-
- compute_val;
- if(randreadtime[j] < (double).000001)
- {
- randreadtime[j]=time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
- if(!include_close)
- {
- if(mmapflag)
- {
- msync(maddr,(size_t)filebytes64,MS_SYNC);/* Clean up before read starts running */
- }
- else
- {
- wval=fsync(fd);
- if(wval==-1){
- perror("fsync");
- signal_handler();
- }
- }
- if(mmapflag)
- mmap_end(maddr,(unsigned long long)filebytes64);
- wval=close(fd);
- if(wval==-1){
- perror("close");
- signal_handler();
- }
- }
- if(cpuutilflag)
- {
- cputime[j] = cputime_so_far() - cputime[j];
- if (cputime[j] < cputime_res)
- cputime[j] = 0.0;
- walltime[j] = time_so_far() - walltime[j];
- if (walltime[j] < cputime[j])
- walltime[j] = cputime[j];
- }
- if(restf)
- sleep((int)rest_val);
- }
- if(OPS_flag || MS_flag){
- filebytes64=filebytes64/reclen;
- }
- for(j=0;j<2;j++)
- {
- if(no_write && (j==1))
- {
- randreadrate[1] = 0.0;
- continue;
- }
- if(MS_flag)
- {
- randreadrate[j]=1000000.0*(randreadtime[j] / (double)filebytes64);
- continue;
- }
- else
- {
- randreadrate[j] =
- (unsigned long long) ((double) filebytes64 / randreadtime[j]);
- }
- if(!(OPS_flag || MS_flag))
- randreadrate[j] >>= 10;
- }
- /* Must save walltime & cputime before calling store_value() for each/any cell.*/
- if(cpuutilflag)
- store_times(walltime[0], cputime[0]);
- store_value((off64_t)randreadrate[0]);
- if(cpuutilflag)
- store_times(walltime[1], cputime[1]);
- store_value((off64_t)randreadrate[1]);
-#ifdef NO_PRINT_LLD
- if(!silent) printf("%8ld",randreadrate[0]);
- if(!silent) printf("%8ld",randreadrate[1]);
- if(!silent) fflush(stdout);
-#else
- if(!silent) printf("%8lld",randreadrate[0]);
- if(!silent) printf("%8lld",randreadrate[1]);
- if(!silent) fflush(stdout);
-#endif
- if(recnum)
- free(recnum);
-}
-
-/************************************************************************/
-/* reverse_perf_test */
-/* Reverse read test */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void reverse_perf_test(off64_t kilo64,long long reclen,long long *data1,long long *data2)
-#else
-void reverse_perf_test(kilo64,reclen,data1,data2)
-off64_t kilo64;
-long long reclen;
-long long *data1,*data2;
-#endif
-{
- double revreadtime[2];
- double starttime2;
- double walltime[2], cputime[2];
- double compute_val = (double)0;
- long long j;
- off64_t i,numrecs64;
- long long Index = 0;
- unsigned long long revreadrate[2];
- off64_t filebytes64;
- off64_t lock_offset=0;
- int fd,open_flags;
- char *maddr,*wmaddr;
- volatile char *buffer1;
- int ltest;
- char *nbuff;
-#if defined(VXFS) || defined(solaris)
- int test_foo=0;
-#endif
-#ifdef ASYNC_IO
- struct cache *gc=0;
-#else
- long long *gc=0;
-#endif
-
- maddr=wmaddr=0;
- open_flags=O_RDONLY;
-#if ! defined(DONT_HAVE_O_DIRECT)
-#if defined(linux) || defined(__AIX__) || defined(IRIX) || defined(IRIX64) || defined(Windows) || defined (__FreeBSD__)
- if(direct_flag)
- open_flags |=O_DIRECT;
-#endif
-#if defined(TRU64)
- if(direct_flag)
- open_flags |=O_DIRECTIO;
-#endif
-#endif
-#if defined(_HPUX_SOURCE) || defined(linux)
- if(read_sync)
- open_flags |=O_RSYNC|O_SYNC;
-#endif
- numrecs64 = (kilo64*1024)/reclen;
- filebytes64 = numrecs64*reclen;
- fd = 0;
- if(noretest)
- ltest=1;
- else
- ltest=2;
- for( j=0; j<ltest; j++ )
- {
- if(cpuutilflag)
- {
- walltime[j] = time_so_far();
- cputime[j] = cputime_so_far();
- }
- if(Uflag) /* Unmount and re-mount the mountpoint */
- {
- purge_buffer_cache();
- }
- if((fd = I_OPEN(filename, open_flags,0))<0){
- printf("\nCan not open temporary file for read\n");
- perror("open");
- exit(75);
- }
-#ifdef ASYNC_IO
- if(async_flag)
- async_init(&gc,fd,direct_flag);
-#endif
-
-#ifdef VXFS
- if(direct_flag)
- {
- ioctl(fd,VX_SETCACHE,VX_DIRECT);
- ioctl(fd,VX_GETCACHE,&test_foo);
- if(test_foo == 0)
- {
- if(!client_iozone)
- printf("\nVxFS advanced setcache feature not available.\n");
- exit(3);
- }
- }
-#endif
-#if defined(solaris)
- if(direct_flag)
- {
- test_foo = directio(fd, DIRECTIO_ON);
- if(test_foo != 0)
- {
- if(!client_iozone)
- printf("\ndirectio not available.\n");
- exit(3);
- }
- }
-#endif
- if(mmapflag)
- {
- maddr=(char *)initfile(fd,filebytes64,0,PROT_READ);
- }
- fsync(fd);
- nbuff=mainbuffer;
- mbuffer=mainbuffer;
- if(fetchon)
- fetchit(nbuff,reclen);
- starttime2 = time_so_far();
- if (!(h_flag || k_flag || mmapflag))
- {
- if(check_filename(filename))
- {
- if(I_LSEEK( fd, -reclen, SEEK_END )<0)
- {
- perror("lseek");
- exit(77);
- };
- }
- else
- {
- if(I_LSEEK( fd, filebytes64-reclen, SEEK_SET )<0)
- {
- perror("lseek");
- exit(77);
- };
- }
- }
- compute_val=(double)0;
- for(i=0; i<numrecs64; i++)
- {
- if(rlocking)
- {
- lock_offset=I_LSEEK(fd,0,SEEK_CUR);
- mylockr((int) fd, (int) 1, (int)1,
- lock_offset, reclen);
- }
- if(compute_flag)
- compute_val+=do_compute(compute_time);
- if(multi_buffer)
- {
- Index +=reclen;
- if(Index > (MAXBUFFERSIZE-reclen))
- Index=0;
- nbuff = mbuffer + Index;
- }
-
- if(purge)
- purgeit(nbuff,reclen);
- if(mmapflag)
- {
- wmaddr = &maddr[((numrecs64-1)-i)*reclen];
- fill_area((long long*)wmaddr,(long long*)nbuff,(long long)reclen);
- }
- else
- if(async_flag)
- {
- if(no_copy_flag)
- async_read_no_copy(gc, (long long)fd, &buffer1, ((((numrecs64-1)-i)*reclen)),
- reclen, -1LL,(numrecs64*reclen),depth);
- else
- async_read(gc, (long long)fd, nbuff, (((numrecs64-1)-i)*reclen),
- reclen,-1LL,(numrecs64*reclen),depth);
- }else
- {
- if(read((int)fd, (void*)nbuff, (size_t) reclen) != reclen)
- {
-#ifdef NO_PRINT_LLD
- printf("\nError reading block %ld\n", i);
-#else
- printf("\nError reading block %lld\n", i);
-#endif
- perror("read");
- exit(79);
- }
- }
- if(verify){
- if(async_flag && no_copy_flag)
- {
- if(verify_buffer(buffer1,reclen,(off64_t)(numrecs64-1)-i,reclen,(long long)pattern,sverify)){
- exit(80);
- }
- }
- else
- {
- if(verify_buffer(nbuff,reclen,(off64_t)(numrecs64-1)-i,reclen,(long long)pattern,sverify)){
- exit(81);
- }
- }
- }
- if(async_flag && no_copy_flag)
- async_release(gc);
- if(rlocking)
- {
- mylockr((int) fd, (int) 0, (int)1,
- lock_offset, reclen);
- }
- if (!(h_flag || k_flag || mmapflag))
- {
- I_LSEEK( fd, (off64_t)-2*reclen, SEEK_CUR );
- }
- }
-#ifdef ASYNC_IO
- if(async_flag)
- {
- end_async(gc);
- gc=0;
- }
-#endif
- if(include_flush)
- {
- if(mmapflag)
- msync(maddr,(size_t)filebytes64,MS_SYNC);
- else
- fsync(fd);
- }
- if(include_close)
- {
- if(mmapflag)
- {
- mmap_end(maddr,(unsigned long long)filebytes64);
- }
- close(fd);
- }
- revreadtime[j] = ((time_so_far() - starttime2)-time_res)
- -compute_val;
- if(revreadtime[j] < (double).000001)
- {
- revreadtime[j]= time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
- if(!include_close)
- {
- if(mmapflag)
- msync(maddr,(size_t)filebytes64,MS_SYNC);
- else
- fsync(fd);
- if(mmapflag)
- {
- mmap_end(maddr,(unsigned long long)filebytes64);
- }
- close(fd);
- }
- if(cpuutilflag)
- {
- cputime[j] = cputime_so_far() - cputime[j];
- if (cputime[j] < cputime_res)
- cputime[j] = 0.0;
- walltime[j] = time_so_far() - walltime[j];
- if (walltime[j] < cputime[j])
- walltime[j] = cputime[j];
- }
- if(restf)
- sleep((int)rest_val);
- }
- if(OPS_flag || MS_flag){
- filebytes64=filebytes64/reclen;
- }
- for(j=0;j<ltest;j++){
- if(MS_flag)
- {
- revreadrate[j]=1000000.0*(revreadtime[j] / (double)filebytes64);
- continue;
- }
- else
- {
- revreadrate[j] =
- (unsigned long long) ((double) filebytes64 / revreadtime[j]);
- }
- if(!(OPS_flag || MS_flag))
- revreadrate[j] >>= 10;
- }
- /* Must save walltime & cputime before calling store_value() for each/any cell.*/
- if(cpuutilflag)
- store_times(walltime[0], cputime[0]);
- store_value((off64_t)revreadrate[0]);
-#ifdef NO_PRINT_LLD
- if(!silent) printf("%8ld",revreadrate[0]);
-#else
- if(!silent) printf("%8lld",revreadrate[0]);
-#endif
- if(!silent) fflush(stdout);
-}
-
-/************************************************************************/
-/* rewriterec_perf_test */
-/* Re-write the same record */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void rewriterec_perf_test(off64_t kilo64 ,long long reclen,long long *data1,long long *data2)
-#else
-void rewriterec_perf_test(kilo64 ,reclen,data1,data2)
-off64_t kilo64;
-long long reclen;
-long long *data1,*data2;
-#endif
-{
- double writeintime;
- double starttime1;
- double walltime, cputime;
- double compute_val = (double)0;
- long long i;
- off64_t numrecs64;
- long long flags;
- long long Index=0;
- unsigned long long writeinrate;
- off64_t filebytes64;
- off64_t lock_offset=0;
- int fd,wval;
- char *maddr;
- char *wmaddr,*free_addr,*nbuff;
-#if defined(VXFS) || defined(solaris)
- int test_foo=0;
-#endif
-#ifdef ASYNC_IO
- struct cache *gc=0;
-#else
- long long *gc=0;
-#endif
-
- walltime=cputime=0;
- maddr=wmaddr=free_addr=nbuff=0;
- numrecs64 = (kilo64*1024)/reclen;
- filebytes64 = numrecs64*reclen;
-/* flags = O_RDWR|O_CREAT|O_TRUNC;*/
- flags = O_RDWR|O_CREAT;
-#if ! defined(DONT_HAVE_O_DIRECT)
-#if defined(linux) || defined(__AIX__) || defined(IRIX) || defined(IRIX64) || defined(Windows) || defined (__FreeBSD__)
- if(direct_flag)
- flags |=O_DIRECT;
-#endif
-#if defined(TRU64)
- if(direct_flag)
- flags |=O_DIRECTIO;
-#endif
-#endif
- if(oflag)
- flags |= O_SYNC;
-#if defined(O_DSYNC)
- if(odsync)
- flags |= O_DSYNC;
-#endif
-#if defined(_HPUX_SOURCE) || defined(linux)
- if(read_sync)
- flags |=O_RSYNC|O_SYNC;
-#endif
-/*
- if (!no_unlink)
- {
- if(check_filename(filename))
- unlink(filename);
- }
-*/
- if(Uflag) /* Unmount and re-mount the mountpoint */
- {
- purge_buffer_cache();
- }
- if((fd = I_OPEN(filename, (int)flags,0640))<0)
- {
- printf("\nCan not open temporary file %s for write.\n",filename);
- perror("open");
- exit(84);
- }
-#ifdef VXFS
- if(direct_flag)
- {
- ioctl(fd,VX_SETCACHE,VX_DIRECT);
- ioctl(fd,VX_GETCACHE,&test_foo);
- if(test_foo == 0)
- {
- if(!client_iozone)
- printf("\nVxFS advanced setcache feature not available.\n");
- exit(3);
- }
- }
-#endif
-#if defined(solaris)
- if(direct_flag)
- {
- test_foo = directio(fd, DIRECTIO_ON);
- if(test_foo != 0)
- {
- if(!client_iozone)
- printf("\ndirectio not available.\n");
- exit(3);
- }
- }
-#endif
- if(mmapflag)
- {
- maddr=(char *)initfile(fd,filebytes64,1,PROT_READ|PROT_WRITE);
- }
-#ifdef ASYNC_IO
- if(async_flag)
- async_init(&gc,fd,direct_flag);
-#endif
- wval=fsync(fd);
- if(wval==-1){
- perror("fsync");
- signal_handler();
- }
- nbuff=mainbuffer;
- mbuffer=mainbuffer;
- if(fetchon)
- fetchit(nbuff,reclen);
- /*
- wval=write(fd, nbuff, (size_t) reclen);
- if(wval != reclen)
- {
-#ifdef NO_PRINT_LLD
- printf("\nError writing block %ld, fd= %d\n", 0, fd);
-#else
- printf("\nError writing block %lld, fd= %d\n", 0, fd);
-#endif
- if(wval==-1)
- perror("write");
- signal_handler();
- }
- */
- if(verify || dedup || dedup_interior)
- fill_buffer(nbuff,reclen,(long long)pattern,sverify,(long long)0);
- starttime1 = time_so_far();
- if(cpuutilflag)
- {
- walltime = time_so_far();
- cputime = cputime_so_far();
- }
- for(i=0; i<numrecs64; i++){
- if(rlocking)
- {
- lock_offset=I_LSEEK(fd,0,SEEK_CUR);
- mylockr((int) fd, (int) 1, (int)0,
- lock_offset, reclen);
- }
- if(compute_flag)
- compute_val+=do_compute(compute_time);
- if(multi_buffer)
- {
- Index +=reclen;
- if(Index > (MAXBUFFERSIZE-reclen))
- Index=0;
- nbuff = mbuffer + Index;
- }
- if(async_flag && no_copy_flag)
- {
- free_addr=nbuff=(char *)malloc((size_t)reclen+page_size);
- nbuff=(char *)(((long)nbuff+(long)page_size) & (long)~(page_size-1));
- if(verify || dedup || dedup_interior)
- fill_buffer(nbuff,reclen,(long long)pattern,sverify,(long long)0);
- }
- if((verify & diag_v) || dedup || dedup_interior)
- fill_buffer(nbuff,reclen,(long long)pattern,sverify,(long long)0);
- if(purge)
- purgeit(nbuff,reclen);
- if(mmapflag)
- {
- wmaddr = &maddr[i*reclen];
- fill_area((long long*)nbuff,(long long*)wmaddr,(long long)reclen);
- if(!mmapnsflag)
- {
- if(mmapasflag)
- msync(wmaddr,(size_t)reclen,MS_ASYNC);
- if(mmapssflag)
- msync(wmaddr,(size_t)reclen,MS_SYNC);
- }
- }
- else
- {
- if(async_flag)
- {
- if(no_copy_flag)
- async_write_no_copy(gc, (long long)fd, nbuff, reclen, (i*reclen), depth,free_addr);
- else
- async_write(gc, (long long)fd, nbuff, reclen, (i*reclen), depth);
- }
- else
- {
- wval=write(fd, nbuff, (size_t) reclen);
- if(wval != reclen)
- {
-#ifdef NO_PRINT_LLD
- printf("\nError writing block %ld, fd= %d\n", i, fd);
-#else
- printf("\nError writing block %lld, fd= %d\n", i, fd);
-#endif
- if(wval==-1)
- perror("write");
- signal_handler();
- }
- }
- }
- if(rlocking)
- {
- mylockr((int) fd, (int) 0, (int)0,
- lock_offset, reclen);
- }
- if (!(h_flag || k_flag || mmapflag))
- {
- I_LSEEK(fd, (off64_t)0,SEEK_SET);
- }
- }
-
-#ifdef ASYNC_IO
- if(async_flag)
- {
- end_async(gc);
- gc=0;
- }
-#endif
- if(include_flush)
- {
- if(mmapflag)
- msync(maddr,(size_t)filebytes64,MS_SYNC);/* Clean up before read starts running */
- else
- {
- wval=fsync(fd);
- if(wval==-1){
- perror("fsync");
- signal_handler();
- }
- }
- }
- if(include_close)
- {
- if(mmapflag)
- mmap_end(maddr,(unsigned long long)filebytes64);
- wval=close(fd);
- if(wval==-1){
- perror("close");
- signal_handler();
- }
- }
- writeintime = ((time_so_far() - starttime1)-time_res)-
- compute_val;
- if(cpuutilflag)
- {
- cputime = cputime_so_far() - cputime;
- if (cputime < cputime_res)
- cputime = 0.0;
- walltime = time_so_far() - walltime;
- if (walltime < cputime)
- walltime = cputime;
- }
- if(writeintime < (double).000001)
- {
- writeintime= time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-
- if(!include_close)
- {
- if(mmapflag)
- msync(maddr,(size_t)filebytes64,MS_SYNC);/* Clean up before read starts running */
- else
- {
- wval=fsync(fd);
- if(wval==-1){
- perror("fsync");
- signal_handler();
- }
- }
- if(mmapflag)
- mmap_end(maddr,(unsigned long long)filebytes64);
- wval=close(fd);
- if(wval==-1){
- perror("close");
- signal_handler();
- }
-
- }
-
- if(OPS_flag || MS_flag){
- filebytes64=filebytes64/reclen;
- }
- if(MS_flag)
- {
- writeinrate=1000000.0*(writeintime / (double)filebytes64);
- }
- else
- {
- writeinrate = (unsigned long long) ((double) filebytes64 / writeintime);
- }
- if(!(OPS_flag || MS_flag))
- writeinrate >>= 10;
- /* Must save walltime & cputime before calling store_value() for each/any cell.*/
- if(cpuutilflag)
- store_times(walltime, cputime);
- store_value((off64_t)writeinrate);
-#ifdef NO_PRINT_LLD
- if(!silent) printf(" %8ld",writeinrate);
-#else
- if(!silent) printf(" %8lld",writeinrate);
-#endif
- if(!silent) fflush(stdout);
- if(restf)
- sleep((int)rest_val);
-}
-
-/************************************************************************/
-/* read_stride_perf_test */
-/* Read with a constant stride test */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void read_stride_perf_test(off64_t kilos64,long long reclen,long long *data1,long long *data2)
-#else
-void read_stride_perf_test(kilos64,reclen,data1,data2)
-off64_t kilos64;
-long long reclen;
-long long *data1, *data2;
-#endif
-{
- double strideintime;
- double starttime1;
- double compute_val = (double)0;
- double walltime, cputime;
- off64_t numrecs64,current_position;
- long long Index = 0;
- off64_t i,savepos64 = 0;
- unsigned long long strideinrate;
- off64_t filebytes64;
- off64_t lock_offset=0;
- long long uu;
- off64_t stripewrap=0;
- int fd,open_flags;
- volatile char *buffer1;
- char *nbuff;
- char *maddr;
- char *wmaddr;
-#if defined(VXFS) || defined(solaris)
- int test_foo=0;
-#endif
-#ifdef ASYNC_IO
- struct cache *gc=0;
-#else
- long long *gc=0;
-#endif
-
- walltime=cputime=0;
- nbuff=maddr=wmaddr=0;
- open_flags=O_RDONLY;
-#if ! defined(DONT_HAVE_O_DIRECT)
-#if defined(linux) || defined(__AIX__) || defined(IRIX) || defined(IRIX64) || defined(Windows) || defined (__FreeBSD__)
- if(direct_flag)
- open_flags |=O_DIRECT;
-#endif
-#if defined(TRU64)
- if(direct_flag)
- open_flags |=O_DIRECTIO;
-#endif
-#endif
-#if defined(_HPUX_SOURCE) || defined(linux)
- if(read_sync)
- open_flags |=O_RSYNC|O_SYNC;
-#endif
- next64 = (off64_t)0;
- numrecs64 = (kilos64*1024)/reclen;
- filebytes64 = numrecs64*reclen;
- if(Uflag) /* Unmount and re-mount the mountpoint */
- {
- purge_buffer_cache();
- }
- if((fd = I_OPEN(filename, (int)open_flags, 0640))<0)
- {
- printf("\nCan not open temporary file for read\n");
- perror("open");
- exit(86);
- }
-#ifdef ASYNC_IO
- if(async_flag)
- async_init(&gc,fd,direct_flag);
-#endif
-
-#ifdef VXFS
- if(direct_flag)
- {
- ioctl(fd,VX_SETCACHE,VX_DIRECT);
- ioctl(fd,VX_GETCACHE,&test_foo);
- if(test_foo == 0)
- {
- if(!client_iozone)
- printf("\nVxFS advanced setcache feature not available.\n");
- exit(3);
- }
- }
-#endif
-#if defined(solaris)
- if(direct_flag)
- {
- test_foo = directio(fd, DIRECTIO_ON);
- if(test_foo != 0)
- {
- if(!client_iozone)
- printf("\ndirectio not available.\n");
- exit(3);
- }
- }
-#endif
- if(mmapflag)
- {
- maddr=(char *)initfile(fd,filebytes64,0,PROT_READ);
- }
- fsync(fd);
- current_position=0;
- nbuff=mainbuffer;
- mbuffer=mainbuffer;
- if(fetchon)
- fetchit(nbuff,reclen);
- starttime1 = time_so_far();
- if(cpuutilflag)
- {
- walltime = time_so_far();
- cputime = cputime_so_far();
- }
- for(i=0; i<numrecs64; i++){
- if(rlocking)
- {
- lock_offset=I_LSEEK(fd,0,SEEK_CUR);
- mylockr((int) fd, (int) 1, (int)1,
- lock_offset, reclen);
- }
- if(compute_flag)
- compute_val+=do_compute(compute_time);
- if(multi_buffer)
- {
- Index +=reclen;
- if(Index > (MAXBUFFERSIZE-reclen))
- Index=0;
- nbuff = mbuffer + Index;
- }
- if(purge)
- purgeit(nbuff,reclen);
- if(verify)
- {
- savepos64=current_position/reclen;
- }
- if(mmapflag)
- {
- wmaddr = &maddr[current_position];
- fill_area((long long*)wmaddr,(long long*)nbuff,(long long)reclen);
- }
- else
- {
- if(async_flag)
- {
- if(no_copy_flag)
- async_read_no_copy(gc, (long long)fd, &buffer1, current_position,
- reclen, stride,(numrecs64*reclen),depth);
- else
- async_read(gc, (long long)fd, nbuff, current_position, reclen,
- stride,(numrecs64*reclen),depth);
- }
- else
- {
- if((uu=read((int)fd, (void*)nbuff, (size_t) reclen)) != reclen)
- {
-#ifdef NO_PRINT_LLD
- printf("\nError reading block %ld, fd= %d Filename %s Read returned %ld\n", i, fd,filename,uu);
- printf("\nSeeked to %ld Reclen = %ld\n", savepos64,reclen);
-#else
- printf("\nError reading block %lld, fd= %d Filename %s Read returned %lld\n", i, fd,filename,uu);
- printf("\nSeeked to %lld Reclen = %lld\n", savepos64,reclen);
-#endif
- perror("read");
- exit(88);
- }
- }
- }
- if(rlocking)
- {
- mylockr((int) fd, (int) 0, (int)1,
- lock_offset, reclen);
- }
- current_position+=reclen;
- if(verify){
- if(async_flag && no_copy_flag)
- {
- if(verify_buffer(buffer1,reclen, (off64_t)savepos64 ,reclen,(long long)pattern,sverify)){
- exit(89);
- }
- }
- else
- {
- if(verify_buffer(nbuff,reclen, (off64_t)savepos64 ,reclen,(long long)pattern,sverify)){
- exit(90);
- }
- }
- }
- if(async_flag && no_copy_flag)
- async_release(gc);
-
- /* This is a bit tricky. The goal is to read with a stride through
- the file. The problem is that you need to touch all of the file
- blocks. So.. the first pass through you read with a constant stride.
- When you hit eof then add 1 to the beginning offset of the next
- time through the file. The rub here is that eventually adding
- 1 will cause the initial start location plus the STRIDE to be
- beyond eof. So... when this happens the initial offset for the
- next pass needs to be set back to 0.
- */
- if(current_position + (stride * reclen) >= (numrecs64 * reclen)-reclen)
- {
- current_position=0;
-
- stripewrap++;
-
- if(numrecs64 <= stride)
- {
- current_position=0;
- }
- else
- {
- current_position = (off64_t)((stripewrap)%numrecs64)*reclen;
- }
-
- if (!(h_flag || k_flag || mmapflag))
- {
- if(I_LSEEK(fd,current_position,SEEK_SET)<0)
- {
- perror("lseek");
- exit(91);
- }
- }
- }
- else
- {
- current_position+=(stride*reclen)-reclen;
- if (!(h_flag || k_flag || mmapflag))
- {
- if(I_LSEEK(fd,current_position,SEEK_SET)<0)
- {
- perror("lseek");
- exit(93);
- };
- }
- }
- }
- if(cpuutilflag)
- {
- cputime = cputime_so_far() - cputime;
- if (cputime < cputime_res)
- cputime = 0.0;
- walltime = time_so_far() - walltime;
- if (walltime < cputime)
- walltime = cputime;
- }
-
-#ifdef ASYNC_IO
- if(async_flag)
- {
- end_async(gc);
- gc=0;
- }
-#endif
- if(include_flush)
- {
- if(mmapflag)
- msync(maddr,(size_t)filebytes64,MS_SYNC);
- else
- fsync(fd);
- }
- if(include_close)
- {
- if(mmapflag)
- {
- mmap_end(maddr,(unsigned long long)filebytes64);
- }
- close(fd);
- }
- strideintime = ((time_so_far() - starttime1)-time_res)
- -compute_val;
- if(strideintime < (double).000001)
- {
- strideintime= time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-
- if(!include_close)
- {
- if(mmapflag)
- msync(maddr,(size_t)filebytes64,MS_SYNC);
- else
- fsync(fd);
- if(mmapflag)
- {
- mmap_end(maddr,(unsigned long long)filebytes64);
- }
- close(fd);
- }
-
- if(OPS_flag || MS_flag){
- filebytes64=filebytes64/reclen;
- }
- if(MS_flag)
- {
- strideinrate=1000000.0*(strideintime / (double)filebytes64);
- }
- else
- {
- strideinrate = (unsigned long long) ((double) filebytes64 / strideintime);
- }
- if(!(OPS_flag || MS_flag))
- strideinrate >>= 10;
- /* Must save walltime & cputime before calling store_value() for each/any cell.*/
- if(cpuutilflag)
- store_times(walltime, cputime);
- store_value((off64_t)strideinrate);
-#ifdef NO_PRINT_LLD
- if(!silent) printf(" %8ld",strideinrate);
-#else
- if(!silent) printf(" %8lld",strideinrate);
-#endif
- if(!silent) fflush(stdout);
- if(restf)
- sleep((int)rest_val);
-}
-
-#ifdef HAVE_PREAD
-/************************************************************************/
-/* pwrite_perf_test */
-/* pwrite and re-write test */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void pwrite_perf_test(off64_t kilos64,long long reclen,long long *data1,long long *data2)
-#else
-void pwrite_perf_test(kilos64,reclen,data1,data2)
-off64_t kilos64;
-long long reclen;
-long long *data1,*data2;
-#endif
-{
- double pwritetime[2];
- double starttime1;
- double walltime[2], cputime[2];
- double compute_val = (double)0;
- long long i,j;
- long long Index = 0;
- unsigned long long pwriterate[2];
- off64_t filebytes64;
- long long flags_here = 0;
- int fd,ltest,wval;
- off64_t numrecs64,traj_offset;
- off64_t lock_offset=0;
- long long traj_size;
-#if defined(VXFS) || defined(solaris)
- int test_foo=0;
-#endif
- char *nbuff;
-
- traj_offset=0;
- nbuff=mainbuffer;
- if(w_traj_flag)
- {
- filebytes64 = w_traj_fsize;
- numrecs64=w_traj_ops;
- }
- else
- {
- numrecs64 = (kilos64*1024)/reclen;
- filebytes64 = numrecs64*reclen;
- }
- fd = 0;
- if(oflag){
- flags_here = O_SYNC|O_RDWR;
- }
- else
- {
- flags_here = O_RDWR;
- }
-#if defined(O_DSYNC)
- if(odsync)
- flags_here |= O_DSYNC;
-#endif
-
-#if defined(_HPUX_SOURCE) || defined(linux)
- if(read_sync)
- flags_here |=O_RSYNC|O_SYNC;
-#endif
-
-#if ! defined(DONT_HAVE_O_DIRECT)
-#if defined(linux) || defined(__AIX__) || defined(IRIX) || defined(IRIX64) || defined(Windows) || defined (__FreeBSD__)
- if(direct_flag)
- flags_here |=O_DIRECT;
-#endif
-#if defined(TRU64)
- if(direct_flag)
- flags_here |=O_DIRECTIO;
-#endif
-#endif
- if(noretest)
- ltest=1;
- else
- ltest=2;
- for( j=0; j<ltest; j++)
- {
- if(j==0)
- flags_here |=O_CREAT;
- if(cpuutilflag)
- {
- walltime[j] = time_so_far();
- cputime[j] = cputime_so_far();
- }
- if(Uflag) /* Unmount and re-mount the mountpoint */
- {
- purge_buffer_cache();
- }
- if((fd = I_OPEN(filename, (int)flags_here,0640))<0)
- {
- printf("\nCan not open temp file: %s\n",
- filename);
- perror("open");
- exit(97);
- }
-#ifdef VXFS
- if(direct_flag)
- {
- ioctl(fd,VX_SETCACHE,VX_DIRECT);
- ioctl(fd,VX_GETCACHE,&test_foo);
- if(test_foo == 0)
- {
- if(!client_iozone)
- printf("\nVxFS advanced setcache feature not available.\n");
- exit(3);
- }
- }
-#endif
-#if defined(solaris)
- if(direct_flag)
- {
- test_foo = directio(fd, DIRECTIO_ON);
- if(test_foo != 0)
- {
- if(!client_iozone)
- printf("\ndirectio not available.\n");
- exit(3);
- }
- }
-#endif
- fsync(fd);
- nbuff=mainbuffer;
- mbuffer=mainbuffer;
- if(fetchon)
- fetchit(nbuff,reclen);
- if(verify || dedup || dedup_interior)
- fill_buffer(nbuff,reclen,(long long)pattern,sverify,(long long)0);
- starttime1 = time_so_far();
- compute_val=(double)0;
- if(w_traj_flag)
- {
- rewind(w_traj_fd);
- }
- for(i=0; i<numrecs64; i++){
- if(w_traj_flag)
- {
- traj_offset=get_traj(w_traj_fd, (long long *)&traj_size,(float *)&compute_time,(long)1);
- reclen=traj_size;
- }
- else
- traj_offset=(i * reclen);
- if(rlocking)
- {
- lock_offset=traj_offset;
- mylockr((int) fd, (int) 1, (int)0,
- lock_offset, reclen);
- }
- if(compute_flag)
- compute_val+=do_compute(compute_time);
- if(multi_buffer)
- {
- Index +=reclen;
- if(Index > (MAXBUFFERSIZE-reclen))
- Index=0;
- nbuff = mbuffer + Index;
- }
- if((verify && diag_v) || dedup || dedup_interior)
- fill_buffer(nbuff,reclen,(long long)pattern,sverify,i);
- if(purge)
- purgeit(nbuff,reclen);
- if(I_PWRITE(fd, nbuff, reclen, traj_offset) != reclen)
- {
-#ifdef NO_PRINT_LLD
- printf("\nError pwriting block %ld, fd= %d\n", i,
- fd);
-#else
- printf("\nError pwriting block %lld, fd= %d\n", i,
- fd);
-#endif
- perror("pwrite");
- signal_handler();
- }
- if(rlocking)
- {
- mylockr((int) fd, (int) 0, (int)0,
- lock_offset, reclen);
- }
- }
- if(include_flush)
- {
- wval=fsync(fd);
- if(wval==-1){
- perror("fsync");
- signal_handler();
- }
- }
- if(include_close)
- {
- wval=close(fd);
- if(wval==-1){
- perror("close");
- signal_handler();
- }
- }
- pwritetime[j] = ((time_so_far() - starttime1)-time_res)
- -compute_val;
- if(pwritetime[j] < (double).000001)
- {
- pwritetime[j]= time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
- if(!include_close)
- {
- wval=fsync(fd);
- if(wval==-1){
- perror("fsync");
- signal_handler();
- }
- wval=close(fd);
- if(wval==-1){
- perror("close");
- signal_handler();
- }
- }
-
- if(cpuutilflag)
- {
- cputime[j] = cputime_so_far() - cputime[j];
- if (cputime[j] < cputime_res)
- cputime[j] = 0.0;
- walltime[j] = time_so_far() - walltime[j];
- if (walltime[j] < cputime[j])
- walltime[j] = cputime[j];
- }
- if(restf)
- sleep((int)rest_val);
- }
- if(OPS_flag || MS_flag){
- filebytes64=filebytes64/reclen;
- }
- for(j=0;j<ltest;j++){
- if(MS_flag)
- {
- pwriterate[j]=1000000.0*(pwritetime[j] / (double)filebytes64);
- continue;
- }
- else
- {
- pwriterate[j] =
- (unsigned long long) ((double) filebytes64 / pwritetime[j]);
- }
- if(!(OPS_flag || MS_flag))
- pwriterate[j] >>= 10;
- }
- /* Must save walltime & cputime before calling store_value() for each/any cell.*/
- if(noretest)
- {
- pwriterate[1]=(long long)0;
- if(cpuutilflag)
- {
- walltime[1]=0.0;
- cputime[1]=0.0;
- }
- }
-
- if(cpuutilflag)
- store_times(walltime[0], cputime[0]);
- store_value((off64_t)pwriterate[0]);
- if(cpuutilflag)
- store_times(walltime[1], cputime[1]);
- store_value((off64_t)pwriterate[1]);
-#ifdef NO_PRINT_LLD
- if(!silent) printf("%8ld",pwriterate[0]);
- if(!silent) printf("%9ld",pwriterate[1]);
- if(!silent) fflush(stdout);
-#else
- if(!silent) printf("%8lld",pwriterate[0]);
- if(!silent) printf("%9lld",pwriterate[1]);
- if(!silent) fflush(stdout);
-#endif
-}
-
-/************************************************************************/
-/* pread_perf_test */
-/* pread and re-pread test */
-/************************************************************************/
-#ifdef HAVE_PREAD
-#ifdef HAVE_ANSIC_C
-void pread_perf_test(off64_t kilos64,long long reclen,long long *data1,long long *data2)
-#else
-void pread_perf_test(kilos64,reclen,data1,data2)
-off64_t kilos64;
-long long reclen;
-long long *data1, *data2;
-#endif
-{
- double starttime2;
- double preadtime[2];
- double walltime[2], cputime[2];
- double compute_val = (double)0;
- long long numrecs64,i;
- long long j;
- long long Index = 0;
- unsigned long long preadrate[2];
- off64_t filebytes64;
- off64_t lock_offset=0;
- int fd,open_flags;
- int ltest;
- off64_t traj_offset;
- long long traj_size;
-#if defined(VXFS) || defined(solaris)
- int test_foo = 0;
-#endif
- char *nbuff;
-
- traj_offset=0;
- nbuff=mainbuffer;
- open_flags=O_RDONLY;
-#if ! defined(DONT_HAVE_O_DIRECT)
-#if defined(linux) || defined(__AIX__) || defined(IRIX) || defined(IRIX64) || defined(Windows) || defined (__FreeBSD__)
- if(direct_flag)
- open_flags |=O_DIRECT;
-#endif
-#if defined(TRU64)
- if(direct_flag)
- open_flags |=O_DIRECTIO;
-#endif
-#endif
-#if defined(_HPUX_SOURCE) || defined(linux) || defined(__FreeBSD__) || defined(__DragonFly__)
- if(read_sync)
- open_flags |=O_RSYNC|O_SYNC;
-#endif
- if(r_traj_flag)
- {
- filebytes64 = r_traj_fsize;
- numrecs64=r_traj_ops;
- }
- else
- {
- numrecs64 = (kilos64*1024)/reclen;
- filebytes64 = numrecs64*reclen;
- }
-
- fd = 0;
- if(noretest)
- ltest=1;
- else
- ltest=2;
- for( j=0; j<ltest; j++ ) /* Pread and Re-Pread */
- {
- if(cpuutilflag)
- {
- walltime[j] = time_so_far();
- cputime[j] = cputime_so_far();
- }
- if(Uflag) /* Unmount and re-mount the mountpoint */
- {
- purge_buffer_cache();
- }
- if((fd = I_OPEN(filename, (int)open_flags,0))<0)
- {
- printf("\nCan not open temporary file %s for read\n",filename);
- perror("open");
- exit(101);
- }
-#ifdef VXFS
- if(direct_flag)
- {
- ioctl(fd,VX_SETCACHE,VX_DIRECT);
- ioctl(fd,VX_GETCACHE,&test_foo);
- if(test_foo == 0)
- {
- if(!client_iozone)
- printf("\nVxFS advanced setcache feature not available.\n");
- exit(3);
- }
- }
-#endif
-#if defined(solaris)
- if(direct_flag)
- {
- test_foo = directio(fd, DIRECTIO_ON);
- if(test_foo != 0)
- {
- if(!client_iozone)
- printf("\ndirectio not available.\n");
- exit(3);
- }
- }
-#endif
- nbuff=mainbuffer;
- mbuffer=mainbuffer;
- if(fetchon)
- fetchit(nbuff,reclen);
- starttime2 = time_so_far();
- compute_val=(double)0;
- if(r_traj_flag)
- {
- rewind(r_traj_fd);
- }
- for(i=0; i<numrecs64; i++)
- {
- if(r_traj_flag)
- {
- traj_offset=get_traj(r_traj_fd, (long long *)&traj_size,(float *)&compute_time,(long)1);
- reclen=traj_size;
- }
- else
- traj_offset=(i * reclen);
- if(rlocking)
- {
- lock_offset=traj_offset;
- mylockr((int) fd, (int) 1, (int)1,
- lock_offset, reclen);
- }
- if(compute_flag)
- compute_val+=do_compute(compute_time);
- if(multi_buffer)
- {
- Index +=reclen;
- if(Index > (MAXBUFFERSIZE-reclen))
- Index=0;
- nbuff = mbuffer + Index;
- }
-
- if(purge)
- purgeit(nbuff,reclen);
- if(I_PREAD(((int)fd), ((void*)nbuff), ((size_t) reclen),traj_offset )
- != reclen)
- {
-#ifdef NO_PRINT_LLD
- printf("\nError reading block %ld %lx\n", i,(unsigned long)nbuff);
-#else
- printf("\nError reading block %lld %lx\n", i,(unsigned long)nbuff);
-#endif
- perror("pread");
- exit(103);
- }
- if(verify){
- if(verify_buffer(nbuff,reclen,(off64_t)i,reclen,(long long)pattern,sverify)){
- exit(104);
- }
- }
- if(rlocking)
- {
- lock_offset=I_LSEEK(fd,0,SEEK_CUR);
- mylockr((int) fd, (int) 1, (int)1,
- lock_offset, reclen);
- }
- }
- if(include_flush)
- fsync(fd);
- if(include_close)
- close(fd);
- preadtime[j] = ((time_so_far() - starttime2)-time_res)
- -compute_val;
- if(preadtime[j] < (double).000001)
- {
- preadtime[j]= time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
- if(!include_close)
- {
- fsync(fd);
- close(fd);
- }
-
- if(cpuutilflag)
- {
- cputime[j] = cputime_so_far() - cputime[j];
- if (cputime[j] < cputime_res)
- cputime[j] = 0.0;
- walltime[j] = time_so_far() - walltime[j];
- if (walltime[j] < cputime[j])
- walltime[j] = cputime[j];
- }
- if(restf)
- sleep((int)rest_val);
- }
-
- filebytes64 = numrecs64*reclen;
- if(OPS_flag || MS_flag){
- filebytes64=filebytes64/reclen;
- }
- for(j=0;j<ltest;j++){
- if(MS_flag)
- {
- preadrate[j]=1000000.0*(preadtime[j] / (double)filebytes64);
- continue;
- }
- else
- {
- preadrate[j] =
- (unsigned long long) ((double) filebytes64 / preadtime[j]);
- }
- if(!(OPS_flag || MS_flag))
- preadrate[j] >>= 10;
- }
- if(noretest)
- {
- preadrate[1]=(long long)0;
- if(cpuutilflag)
- {
- walltime[1]=0.0;
- cputime[1]=0.0;
- }
- }
-
- /* Must save walltime & cputime before calling store_value() for each/any cell.*/
- if(cpuutilflag)
- store_times(walltime[0], cputime[0]);
- store_value((off64_t)preadrate[0]);
- if(cpuutilflag)
- store_times(walltime[1], cputime[1]);
- store_value((off64_t)preadrate[1]);
-#ifdef NO_PRINT_LLD
- if(!silent) printf("%8ld",preadrate[0]);
- if(!silent) printf("%9ld",preadrate[1]);
- if(!silent) fflush(stdout);
-#else
- if(!silent) printf("%8lld",preadrate[0]);
- if(!silent) printf("%9lld",preadrate[1]);
- if(!silent) fflush(stdout);
-#endif
-}
-#endif
-
-#ifdef HAVE_PREADV
-/************************************************************************/
-/* pwritev_perf_test */
-/* pwritev and re-pwritev test */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void pwritev_perf_test(off64_t kilos64,long long reclen,long long *data1,long long *data2)
-#else
-void pwritev_perf_test(kilos64,reclen,data1,data2)
-off64_t kilos64;
-long long reclen;
-long long *data1,*data2;
-#endif
-{
- int wval;
- double starttime1;
- double pwritevtime[2];
- double walltime[2], cputime[2];
- double compute_val = (double)0;
- long long list_off[PVECMAX];
- long long numvecs,j,xx;
- unsigned long long pwritevrate[2];
- off64_t filebytes64,i;
- off64_t numrecs64;
- int fd,ltest;
-#if defined(VXFS) || defined(solaris)
- int test_foo = 0;
-#endif
- long long flags_here;
- char *nbuff;
-#ifdef MERSENNE
- unsigned long long init[4]={0x12345ULL, 0x23456ULL, 0x34567ULL, 0x45678ULL}, length=4;
-#endif
-
- numrecs64 = (kilos64*1024)/reclen;
- filebytes64 = numrecs64*reclen;
- nbuff = mainbuffer;
- fd = 0;
- if(oflag)
- flags_here = O_SYNC|O_RDWR;
- else
- flags_here = O_RDWR;
-#if defined(O_DSYNC)
- if(odsync)
- flags_here |= O_DSYNC;
-#endif
-#if defined(_HPUX_SOURCE) || defined(linux)
- if(read_sync)
- flags_here |=O_RSYNC|O_SYNC;
-#endif
-
-#if ! defined(DONT_HAVE_O_DIRECT)
-#if defined(linux) || defined(__AIX__) || defined(IRIX) || defined(IRIX64) || defined(Windows) || defined (__FreeBSD__)
- if(direct_flag)
- flags_here |=O_DIRECT;
-#endif
-#if defined(TRU64)
- if(direct_flag)
- flags_here |=O_DIRECTIO;
-#endif
-#endif
-
- if(noretest)
- ltest=1;
- else
- ltest=2;
-
- for( j=0; j<ltest; j++)
- {
- if(j==0)
- flags_here |=O_CREAT;
- if(cpuutilflag)
- {
- walltime[j] = time_so_far();
- cputime[j] = cputime_so_far();
- }
- if(Uflag) /* Unmount and re-mount the mountpoint */
- {
- purge_buffer_cache();
- }
- if((fd = I_OPEN(filename, (int)flags_here,0640))<0)
- {
- printf("\nCan not open temp file: %s\n",
- filename);
- perror("open");
- exit(109);
- }
-#ifdef VXFS
- if(direct_flag)
- {
- ioctl(fd,VX_SETCACHE,VX_DIRECT);
- ioctl(fd,VX_GETCACHE,&test_foo);
- if(test_foo == 0)
- {
- if(!client_iozone)
- printf("\nVxFS advanced setcache feature not available.\n");
- exit(3);
- }
- }
-#endif
-#if defined(solaris)
- if(direct_flag)
- {
- test_foo = directio(fd, DIRECTIO_ON);
- if(test_foo != 0)
- {
- if(!client_iozone)
- printf("\ndirectio not available.\n");
- exit(3);
- }
- }
-#endif
- nbuff=mainbuffer;
- mbuffer=mainbuffer;
- if(fetchon)
- fetchit(nbuff,reclen);
- numvecs=PVECMAX;
- if(numrecs64 < numvecs) numvecs=numrecs64;
- if(MAXBUFFERSIZE/reclen < PVECMAX) numvecs=MAXBUFFERSIZE/reclen;
-
-#ifdef MERSENNE
- init_by_array64(init, length);
-#else
-#ifdef bsd4_2
- srand(0);
-#else
-#ifdef Windows
- srand(0);
-#else
- srand48(0);
-#endif
-#endif
-#endif
- starttime1 = time_so_far();
- compute_val=(double)0;
- for(i=0; i<numrecs64; i+=numvecs){
- if(compute_flag)
- compute_val+=do_compute(compute_time);
- if((numrecs64-i) < numvecs)
- numvecs=numrecs64-i;
- create_list((long long *)list_off, reclen, numrecs64);
- for(xx=0;xx<numvecs;xx++)
- {
- piov[xx].piov_base =
- (caddr_t)(nbuff+(xx * reclen));
- if(verify || dedup || dedup_interior)
- fill_buffer(piov[xx].piov_base,reclen,(long long)pattern,sverify,i);
- piov[xx].piov_len = reclen;
-#ifdef PER_VECTOR_OFFSET
- piov[xx].piov_offset = list_off[xx];
-#endif
- if(purge)
- purgeit(piov[xx].piov_base,reclen);
- }
- if(pwritev(fd, piov,numvecs
-#ifndef PER_VECTOR_OFFSET
- , list_off[0]
-#endif
- ) != (reclen*numvecs))
- {
-#ifdef NO_PRINT_LLD
- printf("\nError pwriteving block %ld, fd= %d\n", i,
- fd);
-#else
- printf("\nError pwriteving block %lld, fd= %d\n", i,
- fd);
-#endif
- perror("pwritev");
- exit(113);
- }
- }
-
- if(include_flush)
- {
- wval=fsync(fd);
- if(wval==-1){
- perror("fsync");
- signal_handler();
- }
- }
- if(include_close)
- {
- wval=close(fd);
- if(wval==-1){
- perror("close");
- signal_handler();
- }
- }
- pwritevtime[j] = ((time_so_far() - starttime1)-time_res)
- -compute_val;
- if(pwritevtime[j] < (double).000001)
- {
- pwritevtime[j]= time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
- if(!include_close)
- {
- wval=fsync(fd);
- if(wval==-1){
- perror("fsync");
- signal_handler();
- }
- wval=close(fd);
- if(wval==-1){
- perror("close");
- signal_handler();
- }
- }
-
- if(cpuutilflag)
- {
- cputime[j] = cputime_so_far() - cputime[j];
- if (cputime[j] < cputime_res)
- cputime[j] = 0.0;
- walltime[j] = time_so_far() - walltime[j];
- if (walltime[j] < cputime[j])
- walltime[j] = cputime[j];
- }
- if(restf)
- sleep((int)rest_val);
- }
- if(OPS_flag || MS_flag){
- filebytes64=filebytes64/reclen;
- }
- for(j=0;j<ltest;j++){
- if(MS_flag)
- {
- pwritevrate[j]=1000000.0*(pwritevtime[j] / (double)filebytes64);
- continue;
- }
- else
- {
- pwritevrate[j] =
- (unsigned long long) ((double) filebytes64 / pwritevtime[j]);
- }
- if(!(OPS_flag || MS_flag))
- pwritevrate[j] >>= 10;
- }
- if(noretest)
- {
- pwritevrate[1]=(long long)0;
- if(cpuutilflag)
- {
- walltime[1]=0.0;
- cputime[1]=0.0;
- }
- }
- /* Must save walltime & cputime before calling store_value() for each/any cell.*/
- if(cpuutilflag)
- store_times(walltime[0], cputime[0]);
- store_value((off64_t)pwritevrate[0]);
- if(cpuutilflag)
- store_times(walltime[1], cputime[1]);
- store_value((off64_t)pwritevrate[1]);
-#ifdef NO_PRINT_LLD
- if(!silent) printf("%9ld",pwritevrate[0]);
- if(!silent) printf("%10ld",pwritevrate[1]);
- if(!silent) fflush(stdout);
-#else
- if(!silent) printf("%9lld",pwritevrate[0]);
- if(!silent) printf("%10lld",pwritevrate[1]);
- if(!silent) fflush(stdout);
-#endif
-}
-#endif
-
-
-#ifdef HAVE_PREADV
-/**************************************************************************/
-/* create_list() */
-/* Creates a list of PVECMAX entries that are unique (non over lapping ). */
-/* Each of these offsets are then used in a vector (preadv/pwritev) */
-/**************************************************************************/
-#ifdef HAVE_ANSIC_C
-void create_list(long long *list_off, long long reclen, off64_t numrecs64)
-#else
-void create_list(list_off, reclen, numrecs64)
-long long *list_off;
-long long reclen;
-off64_t numrecs64;
-#endif
-{
- long long found,i,j;
- long long numvecs;
- unsigned long long big_rand = -1;
-#if defined (bsd4_2) || defined(Windows)
- long long rand1,rand2,rand3;
-#endif
-
- numvecs = PVECMAX;
- if(numrecs64< numvecs)
- numvecs = numrecs64;
- for(j=0;j<numvecs;j++)
- list_off[j]=0;
- for(j=0;j<numvecs;j++)
- {
-again:
- found = 0;
-#ifdef MERSENNE
- big_rand = genrand64_int64();
- offset64 = reclen * (big_rand%numrecs64);
-#else
-#ifdef bsd4_2
- rand1=(long long)rand();
- rand2=(long long)rand();
- rand3=(long long)rand();
- big_rand=(rand1<<32)|(rand2<<16)|(rand3);
- offset64 = reclen * (big_rand%numrecs64);
-#else
-#ifdef Windows
- rand1=(long long)rand();
- rand2=(long long)rand();
- rand3=(long long)rand();
- big_rand=(rand1<<32)|(rand2<<16)|(rand3);
- offset64 = reclen * (big_rand%numrecs64);
-#else
- offset64 = reclen * (lrand48()%numrecs64);
-#endif
-#endif
-#endif
-
- for(i=0;i<j;i++)
- {
- if(list_off[i] == offset64)
- {
- found++;
- break;
- }
- }
- if(!found)
- list_off[j]=offset64;
- else
- {
- goto again;
- }
- }
-}
-#endif
-
-#ifdef HAVE_PREADV
-/************************************************************************/
-/* preadv_perf_test */
-/* preadv and re-preadv test */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void preadv_perf_test(off64_t kilos64,long long reclen,long long *data1,long long *data2)
-#else
-void preadv_perf_test(kilos64,reclen,data1,data2)
-off64_t kilos64;
-long long reclen;
-long long *data1,*data2;
-#endif
-{
- double starttime2;
- double preadvtime[2];
- double walltime[2], cputime[2];
- double compute_val = (double)0;
- long long list_off[PVECMAX];
- long long numvecs,i,j,xx;
- off64_t numrecs64;
- unsigned long long preadvrate[2];
- off64_t filebytes64;
- int fd,open_flags,ltest;
-#if defined(VXFS) || defined(solaris)
- int test_foo = 0;
-#endif
- char *nbuff;
-#ifdef MERSENNE
- unsigned long long init[4]={0x12345ULL, 0x23456ULL, 0x34567ULL, 0x45678ULL}, length=4;
-#endif
-
- open_flags=O_RDONLY;
-#if ! defined(DONT_HAVE_O_DIRECT)
-#if defined(linux) || defined(__AIX__) || defined(IRIX) || defined(IRIX64) || defined(Windows) || defined (__FreeBSD__)
- if(direct_flag)
- open_flags |=O_DIRECT;
-#endif
-#if defined(TRU64)
- if(direct_flag)
- open_flags |=O_DIRECTIO;
-#endif
-#endif
-#if defined(_HPUX_SOURCE) || defined(linux)
- if(read_sync)
- open_flags |=O_RSYNC|O_SYNC;
-#endif
- numrecs64 = (kilos64*1024)/reclen;
- filebytes64 = numrecs64*reclen;
- nbuff = mainbuffer;
- fd = 0;
- if(noretest)
- ltest=1;
- else
- ltest=2;
-
- for( j=0; j<ltest; j++ )
- {
- if(cpuutilflag)
- {
- walltime[j] = time_so_far();
- cputime[j] = cputime_so_far();
- }
- if(Uflag) /* Unmount and re-mount the mountpoint */
- {
- purge_buffer_cache();
- }
-
- if((fd = I_OPEN(filename, (int)open_flags,0))<0)
- {
- printf("\nCan not open temporary file for preadv\n");
- perror("open");
- exit(114);
- }
-#ifdef VXFS
- if(direct_flag)
- {
- ioctl(fd,VX_SETCACHE,VX_DIRECT);
- ioctl(fd,VX_GETCACHE,&test_foo);
- if(test_foo == 0)
- {
- if(!client_iozone)
- printf("\nVxFS advanced setcache feature not available.\n");
- exit(3);
- }
- }
-#endif
-#if defined(solaris)
- if(direct_flag)
- {
- test_foo = directio(fd, DIRECTIO_ON);
- if(test_foo != 0)
- {
- if(!client_iozone)
- printf("\ndirectio not available.\n");
- exit(3);
- }
- }
-#endif
- nbuff=mainbuffer;
- mbuffer=mainbuffer;
- if(fetchon)
- fetchit(nbuff,reclen);
- numvecs=PVECMAX;
- if(numrecs64 < numvecs) numvecs=numrecs64;
- if(MAXBUFFERSIZE/reclen < PVECMAX) numvecs=MAXBUFFERSIZE/reclen;
-
-#ifdef MERSENNE
- init_by_array64(init, length);
-#else
-#ifdef bsd4_2
- srand(0);
-#else
-#ifdef Windows
- srand(0);
-#else
- srand48(0);
-#endif
-#endif
-#endif
- starttime2 = time_so_far();
- compute_val=(double)0;
- for(i=0; i<(numrecs64); i+=numvecs)
- {
- if(compute_flag)
- compute_val+=do_compute(compute_time);
- if((numrecs64-i) < numvecs)
- numvecs=numrecs64-i;
- create_list((long long *)list_off, reclen, numrecs64);
- for(xx=0;xx<numvecs;xx++)
- {
- piov[xx].piov_base =
- (caddr_t)(nbuff+(xx * reclen));
- piov[xx].piov_len = reclen;
-#ifdef PER_VECTOR_OFFSET
- piov[xx].piov_offset = list_off[xx];
-#endif
- if(purge)
- purgeit(piov[xx].piov_base,reclen);
- }
- if(preadv(fd, piov, numvecs
-#ifndef PER_VECTOR_OFFSET
- , list_off[0]
-#endif
- ) != (numvecs * reclen))
- {
-#ifdef NO_PRINT_LLD
- printf("\nError preadving block %ld \n", i);
-#else
- printf("\nError preadving block %lld \n", i);
-#endif
- perror("preadv");
- exit(116);
- }
- }
- if(include_flush)
- fsync(fd);
- if(include_close)
- close(fd);
- preadvtime[j] = ((time_so_far() - starttime2)-time_res)
- -compute_val;
- if(preadvtime[j] < (double).000001)
- {
- preadvtime[j]= time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
- if(!include_close)
- {
- fsync(fd);
- close(fd);
- }
-
- if(cpuutilflag)
- {
- cputime[j] = cputime_so_far() - cputime[j];
- if (cputime[j] < cputime_res)
- cputime[j] = 0.0;
- walltime[j] = time_so_far() - walltime[j];
- if (walltime[j] < cputime[j])
- walltime[j] = cputime[j];
- }
- if(restf)
- sleep((int)rest_val);
- }
- if(OPS_flag || MS_flag){
- filebytes64=filebytes64/reclen;
- }
- for(j=0;j<ltest;j++){
- if(MS_flag)
- {
- preadvrate[j]=1000000.0*(preadvtime[j] / (double)filebytes64);
- continue;
- }
- else
- {
- preadvrate[j] =
- (unsigned long long) ((double) filebytes64 / preadvtime[j]);
- }
- if(!(OPS_flag || MS_flag))
- preadvrate[j] >>= 10;
- }
- if(noretest)
- {
- preadvrate[1]=(long long)0;
- if(cpuutilflag)
- {
- walltime[1]=0.0;
- cputime[1]=0.0;
- }
- }
-
- /* Must save walltime & cputime before calling store_value() for each/any cell.*/
- if(cpuutilflag)
- store_times(walltime[0], cputime[0]);
- store_value((off64_t)preadvrate[0]);
- if(cpuutilflag)
- store_times(walltime[1], cputime[1]);
- store_value((off64_t)preadvrate[1]);
-#ifdef NO_PRINT_LLD
- if(!silent) printf("%10ld",preadvrate[0]);
- if(!silent) printf("%9ld",preadvrate[1]);
- if(!silent) printf("\n");
- if(!silent) fflush(stdout);
-#else
- if(!silent) printf("%10lld",preadvrate[0]);
- if(!silent) printf("%9lld",preadvrate[1]);
- if(!silent) printf("\n");
- if(!silent) fflush(stdout);
-#endif
-}
-#endif
-
-/************************************************************************/
-/* print_header() */
-/* Prints the header for the output from Iozone. */
-/************************************************************************/
-#endif
-#ifdef HAVE_ANSIC_C
-void print_header(void)
-#else
-void print_header()
-#endif
-{
- if(Eflag)
- {
- if(!silent) printf(CONTROL_STRING2,
- " ",
- " ",
- " ",
- " ",
- " ",
- " ",
- "random", /*kcollins:2-5-96*/
- "random", /*kcollins:2-5-96*/
- "bkwd",
- "record",
- "stride",
- " ",
- " ",
- " ",
- " "
-#ifdef HAVE_PREAD
- ," ",
- " ",
- " ",
- " "
-#ifdef HAVE_PREADV
- ," ",
- " ",
- " ",
- " "
-#endif
-#endif
- );
- if(!silent) printf(CONTROL_STRING2,
- "KB",
- "reclen",
- "write",
- "rewrite",
- "read",
- "reread",
- "read", /*kcollins:2-5-96*/
- "write", /*kcollins:2-5-96*/
- "read",
- "rewrite",
- "read",
- "fwrite",
- "frewrite",
- "fread",
- "freread"
-#ifdef HAVE_PREAD
- ,"pwrite",
- "repwrite",
- "pread",
- "repread"
-#ifdef HAVE_PREADV
- ,"pwritev",
- "repwritev",
- "preadv",
- "repreadv"
-#endif
-#endif
- );
- }else
- if(RWONLYflag){ /*kcollins 8-21-96*/
- if(!silent) printf(CONTROL_STRING4, /*kcollins 8-21-96*/
- " ", /*kcollins 8-21-96*/
- " ", /*kcollins 8-21-96*/
- " ", /*kcollins 8-21-96*/
- " ", /*kcollins 8-21-96*/
- " ", /*kcollins 8-21-96*/
- " " /*kcollins 8-21-96*/
- ); /*kcollins 8-21-96*/
- if(!silent) printf(CONTROL_STRING4, /*kcollins 8-21-96*/
- "KB", /*kcollins 8-21-96*/
- "reclen", /*kcollins 8-21-96*/
- "write", /*kcollins 8-21-96*/
- "rewrite", /*kcollins 8-21-96*/
- "read", /*kcollins 8-21-96*/
- "reread" /*kcollins 8-21-96*/
- ); /*kcollins 8-21-96*/
- }else{
- if(!(mmapflag || async_flag))
- {
- if(!silent) printf(CONTROL_STRING3,
- " ",
- " ",
- " ",
- " ",
- " ",
- " ",
- "random", /*kcollins:2-5-96*/
- "random", /*kcollins:2-5-96*/
- "bkwd",
- "record",
- "stride",
- "",
- "",
- "",
- ""
- );
- if(!silent) printf(CONTROL_STRING3,
- "KB",
- "reclen",
- "write",
- "rewrite",
- "read",
- "reread",
- "read", /*kcollins:2-5-96*/
- "write", /*kcollins:2-5-96*/
- "read",
- "rewrite",
- "read",
- "fwrite",
- "frewrite",
- "fread",
- "freread"
- );
- }else
- {
- if(!silent) printf(CONTROL_STRING3,
- " ",
- " ",
- " ",
- " ",
- " ",
- " ",
- "random", /*kcollins:2-5-96*/
- "random", /*kcollins:2-5-96*/
- "bkwd",
- "record",
- "stride",
- "",
- "",
- "",
- ""
- );
- if(!silent) printf(CONTROL_STRING3,
- "KB",
- "reclen",
- "write",
- "rewrite",
- "read",
- "reread",
- "read", /*kcollins:2-5-96*/
- "write", /*kcollins:2-5-96*/
- "read",
- "rewrite",
- "read",
- "",
- "",
- "",
- ""
- );
- }
- }
-}
-
-/************************************************************************/
-/* store_value() */
-/* Stores a value in an in memory array. Used by the report function */
-/* to re-organize the output for Excel */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void
-store_value(off64_t value)
-#else
-store_value(value)
-off64_t value;
-#endif
-{
- report_array[current_x][current_y]=value;
- current_x++;
- if(current_x > max_x)
- max_x=current_x;
- if(current_y > max_y)
- max_y=current_y;
- if(max_x >= MAX_X)
- {
- printf("\nMAX_X too small\n");
- exit(117);
- }
- if(max_y >= MAX_Y)
- {
- printf("\nMAX_Y too small\n");
- exit(118);
- }
-}
-
-/************************************************************************/
-/* store_times() */
-/* Stores runtime (walltime & cputime) in a memory array. */
-/* Used by the report function to re-organize the output for Excel */
-/* For now, must be called immediately before calling store_value() for */
-/* each cell. */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void
-store_times(double walltime, double cputime)
-#else
-store_times(walltime, cputime)
-double walltime, cputime;
-#endif
-{
- runtimes [current_x][current_y].walltime = walltime;
- runtimes [current_x][current_y].cputime = cputime;
- runtimes [current_x][current_y].cpuutil = cpu_util(cputime, walltime);
-}
-
-/************************************************************************/
-/* dump_report() */
-/* Dumps the Excel report on standard output. */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void dump_report(long long who)
-#else
-dump_report(who)
-long long who;
-#endif
-{
- long long i;
- off64_t current_file_size;
- off64_t rec_size;
-
- if(bif_flag)
- bif_column++;
- if(!silent) printf(" ");
-
- /*
- * Need to reconstruct the record size list
- * as the crossover in -a changed the list.
- */
- del_record_sizes();
- init_record_sizes(orig_min_rec_size, orig_max_rec_size);
-
- for(rec_size=get_next_record_size(0); rec_size <= orig_max_rec_size;
- rec_size=get_next_record_size(rec_size))
- {
- if (rec_size == 0) break;
- if(bif_flag)
- do_float(bif_fd,(double)(rec_size/1024),bif_row,bif_column++);
-#ifdef NO_PRINT_LLD
- if(!silent) printf(" %c%ld%c",'"',rec_size/1024,'"');
-#else
- if(!silent) printf(" %c%lld%c",'"',rec_size/1024,'"');
-#endif
- }
- if(!silent) printf("\n");
- if(bif_flag)
- {
- bif_column=0;
- bif_row++;
- }
-
- current_file_size = report_array[0][0];
- if(bif_flag)
- {
- do_float(bif_fd,(double)(current_file_size),bif_row,bif_column++);
- }
-#ifdef NO_PRINT_LLD
- if(!silent) printf("%c%ld%c ",'"',current_file_size,'"');
-#else
- if(!silent) printf("%c%lld%c ",'"',current_file_size,'"');
-#endif
- for(i=0;i<=max_y;i++){
- if(report_array[0][i] != current_file_size){
- if(!silent) printf("\n");
- current_file_size = report_array[0][i];
- if(bif_flag)
- {
- bif_row++;
- bif_column=0;
- do_float(bif_fd,(double)(current_file_size),bif_row,bif_column++);
- }
-#ifdef NO_PRINT_LLD
- if(!silent) printf("%c%ld%c ",'"',current_file_size,'"');
-#else
- if(!silent) printf("%c%lld%c ",'"',current_file_size,'"');
-#endif
- }
- if(bif_flag)
- do_float(bif_fd,(double)(report_array[who][i]),bif_row,bif_column++);
-#ifdef NO_PRINT_LLD
- if(!silent) printf(" %ld ",report_array[who][i]);
-#else
- if(!silent) printf(" %lld ",report_array[who][i]);
-#endif
- }
- if(bif_flag)
- {
- bif_row++;
- bif_column=0;
- }
- if(!silent) printf("\n");
-}
-
-/************************************************************************/
-/* Wrapper that dumps each of the collected data sets. */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void dump_excel(void)
-#else
-void dump_excel()
-#endif
-{
- if(bif_flag)
- {
- bif_fd=create_xls(bif_filename);
- do_label(bif_fd,command_line,bif_row++,bif_column);
- do_label(bif_fd," ",bif_row++,bif_column);
- do_label(bif_fd,"The top row is records sizes, the left column is file sizes",bif_row++,bif_column);
- }
- if(!silent) printf("Excel output is below:\n");
-
- if ((!include_tflag) || (include_mask & (long long)WRITER_MASK)) {
- if(bif_flag)
- do_label(bif_fd,"Writer Report",bif_row++,bif_column);
- if(!silent) printf("\n%cWriter report%c\n",'"','"');
- dump_report(2);
- if(bif_flag)
- do_label(bif_fd,"Re-writer Report",bif_row++,bif_column);
- if(!silent) printf("\n%cRe-writer report%c\n",'"','"');
- dump_report(3);
- }
-
- if ((!include_tflag) || (include_mask & (long long)READER_MASK)) {
- if(bif_flag)
- do_label(bif_fd,"Reader Report",bif_row++,bif_column);
- if(!silent) printf("\n%cReader report%c\n",'"','"');
- dump_report(4);
- if(bif_flag)
- do_label(bif_fd,"Re-reader Report",bif_row++,bif_column);
- if(!silent) printf("\n%cRe-Reader report%c\n",'"','"');
- dump_report(5);
- }
-
- if ((!include_tflag) || (include_mask & (long long)RANDOM_RW_MASK)) {
- if(bif_flag)
- do_label(bif_fd,"Random Read Report",bif_row++,bif_column);
- if(!silent) printf("\n%cRandom read report%c\n",'"','"');
- dump_report(6);
- if(bif_flag)
- do_label(bif_fd,"Random Write Report",bif_row++,bif_column);
- if(!silent) printf("\n%cRandom write report%c\n",'"','"');
- dump_report(7);
- }
-
- if ((!include_tflag) || (include_mask & (long long)REVERSE_MASK)) {
- if(bif_flag)
- do_label(bif_fd,"Backward Read Report",bif_row++,bif_column);
- if(!silent) printf("\n%cBackward read report%c\n",'"','"');
- dump_report(8);
- }
-
- if ((!include_tflag) || (include_mask & (long long)REWRITE_REC_MASK)) {
- if(bif_flag)
- do_label(bif_fd,"Record Rewrite Report",bif_row++,bif_column);
- if(!silent) printf("\n%cRecord rewrite report%c\n",'"','"');
- dump_report(9);
- }
-
- if ((!include_tflag) || (include_mask & (long long)STRIDE_READ_MASK)) {
- if(bif_flag)
- do_label(bif_fd,"Stride Read Report",bif_row++,bif_column);
- if(!silent) printf("\n%cStride read report%c\n",'"','"');
- dump_report(10);
- }
-
- if ((!include_tflag) || (include_mask & (long long)FWRITER_MASK)) {
- if(bif_flag)
- do_label(bif_fd,"Fwrite Report",bif_row++,bif_column);
- if(!silent) printf("\n%cFwrite report%c\n",'"','"');
- dump_report(11);
- if(bif_flag)
- do_label(bif_fd,"Re-fwrite Report",bif_row++,bif_column);
- if(!silent) printf("\n%cRe-Fwrite report%c\n",'"','"');
- dump_report(12);
- }
-
- if ((!include_tflag) || (include_mask & (long long)FREADER_MASK)) {
- if(bif_flag)
- do_label(bif_fd,"Fread Report",bif_row++,bif_column);
- if(!silent) printf("\n%cFread report%c\n",'"','"');
- dump_report(13);
- if(bif_flag)
- do_label(bif_fd,"Re-fread Report",bif_row++,bif_column);
- if(!silent) printf("\n%cRe-Fread report%c\n",'"','"');
- dump_report(14);
- }
-
-#ifdef HAVE_PREAD
- if(Eflag)
- {
- if ((!include_tflag) || (include_mask & (long long)PWRITER_MASK)) {
- if(bif_flag)
- do_label(bif_fd,"Pwrite Report",bif_row++,bif_column);
- if(!silent) printf("\n%cPwrite report%c\n",'"','"');
- dump_report(15);
- if(bif_flag)
- do_label(bif_fd,"Re-pwrite Report",bif_row++,bif_column);
- if(!silent) printf("\n%cRe-Pwrite report%c\n",'"','"');
- dump_report(16);
- }
-
- if ((!include_tflag) || (include_mask & (long long)PREADER_MASK)) {
- if(bif_flag)
- do_label(bif_fd,"Pread Report",bif_row++,bif_column);
- if(!silent) printf("\n%cPread report%c\n",'"','"');
- dump_report(17);
- if(bif_flag)
- do_label(bif_fd,"Re-pread Report",bif_row++,bif_column);
- if(!silent) printf("\n%cRe-Pread report%c\n",'"','"');
- dump_report(18);
- }
-
-#ifdef HAVE_PREADV
- if ((!include_tflag) || (include_mask & (long long)PWRITEV_MASK)) {
- if(bif_flag)
- do_label(bif_fd,"Pwritev Report",bif_row++,bif_column);
- if(!silent) printf("\n%cPwritev report%c\n",'"','"');
- dump_report(19);
- if(bif_flag)
- do_label(bif_fd,"Re-pwritev Report",bif_row++,bif_column);
- if(!silent) printf("\n%cRe-Pwritev report%c\n",'"','"');
- dump_report(20);
- }
-
- if ((!include_tflag) || (include_mask & (long long)PREADV_MASK)) {
- if(bif_flag)
- do_label(bif_fd,"Preadv Report",bif_row++,bif_column);
- if(!silent) printf("\n%cPreadv report%c\n",'"','"');
- dump_report(21);
- if(bif_flag)
- do_label(bif_fd,"Re-preadv Report",bif_row++,bif_column);
- if(!silent) printf("\n%cRe-Preadv report%c\n",'"','"');
- dump_report(22);
- }
-#endif
- }
-#endif
- if (cpuutilflag)
- dump_cputimes();
- if(bif_flag)
- close_xls(bif_fd);
-}
-
-/************************************************************************/
-/* dump_times() */
-/* Dumps the Excel CPU times report to stdout and to the bif file. */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void dump_times(long long who)
-#else
-dump_times(who)
-long long who;
-#endif
-{
- long long i;
- off64_t current_file_size;
- off64_t rec_size;
-
- if (bif_flag)
- bif_column++;
- if(!silent) printf(" ");
-
- for (rec_size = get_next_record_size(0); rec_size <= orig_max_rec_size;
- rec_size = get_next_record_size(rec_size))
- {
- if (rec_size == 0) break;
- if (bif_flag)
- do_float(bif_fd, (double)(rec_size/1024), bif_row, bif_column++);
-#ifdef NO_PRINT_LLD
- if(!silent) printf(" %c%ld%c",'"',rec_size/1024,'"');
-#else
- if(!silent) printf(" %c%lld%c",'"',rec_size/1024,'"');
-#endif
- }
- if(!silent) printf("\n");
- if (bif_flag)
- {
- bif_column=0;
- bif_row++;
- }
-
- current_file_size = report_array[0][0];
- if (bif_flag)
- {
- do_float(bif_fd, (double)(current_file_size), bif_row, bif_column++);
- }
-#ifdef NO_PRINT_LLD
- if(!silent) printf("%c%ld%c ",'"',current_file_size,'"');
-#else
- if(!silent) printf("%c%lld%c ",'"',current_file_size,'"');
-#endif
- for (i = 0; i <= max_y; i++) {
- if (report_array[0][i] != current_file_size) {
- if(!silent) printf("\n");
- current_file_size = report_array[0][i];
- if (bif_flag)
- {
- bif_row++;
- bif_column=0;
- do_float(bif_fd, (double)(current_file_size), bif_row, bif_column++);
- }
-#ifdef NO_PRINT_LLD
- if(!silent) printf("%c%ld%c ",'"',current_file_size,'"');
-#else
- if(!silent) printf("%c%lld%c ",'"',current_file_size,'"');
-#endif
- }
- if (bif_flag)
- do_float(bif_fd, (double)(runtimes [who][i].cpuutil), bif_row, bif_column++);
- if(!silent) printf(" %6.2f", runtimes [who][i].cpuutil);
- }
- if(!silent) printf("\n");
- if (bif_flag)
- {
- bif_row++;
- bif_column=0;
- }
-}
-
-/************************************************************************/
-/* Wrapper that dumps each of the collected data sets. */
-/* This one dumps only the collected CPU times. */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void dump_cputimes(void)
-#else
-void dump_cputimes(void)
-#endif
-{
- bif_row++;
- bif_column = 0;
-
- if ((!include_tflag) || (include_mask & (long long)WRITER_MASK)) {
- if(bif_flag)
- do_label(bif_fd, "Writer CPU utilization report (Zero values should be ignored)", bif_row++, bif_column);
- if(!silent) printf("\n%cWriter CPU utilization report (Zero values should be ignored)%c\n",'"','"');
- dump_times(2);
- if(bif_flag)
- do_label(bif_fd, "Re-writer CPU utilization report (Zero values should be ignored)", bif_row++, bif_column);
- if(!silent) printf("\n%cRe-writer CPU utilization report (Zero values should be ignored)%c\n",'"','"');
- dump_times(3);
- }
-
- if ((!include_tflag) || (include_mask & (long long)READER_MASK)) {
- if(bif_flag)
- do_label(bif_fd, "Reader CPU utilization report (Zero values should be ignored)", bif_row++, bif_column);
- if(!silent) printf("\n%cReader CPU utilization report (Zero values should be ignored)%c\n",'"','"');
- dump_times(4);
- if(bif_flag)
- do_label(bif_fd, "Re-reader CPU utilization report (Zero values should be ignored)", bif_row++, bif_column);
- if(!silent) printf("\n%cRe-Reader CPU utilization report (Zero values should be ignored)%c\n",'"','"');
- dump_times(5);
- }
-
- if ((!include_tflag) || (include_mask & (long long)RANDOM_RW_MASK)) {
- if(bif_flag)
- do_label(bif_fd, "Random Read CPU utilization report (Zero values should be ignored)", bif_row++, bif_column);
- if(!silent) printf("\n%cRandom read CPU utilization report (Zero values should be ignored)%c\n",'"','"');
- dump_times(6);
- if(bif_flag)
- do_label(bif_fd, "Random Write CPU utilization report (Zero values should be ignored)", bif_row++, bif_column);
- if(!silent) printf("\n%cRandom write CPU utilization report (Zero values should be ignored)%c\n",'"','"');
- dump_times(7);
- }
-
- if ((!include_tflag) || (include_mask & (long long)REVERSE_MASK)) {
- if(bif_flag)
- do_label(bif_fd, "Backward Read CPU utilization report (Zero values should be ignored)", bif_row++, bif_column);
- if(!silent) printf("\n%cBackward read CPU utilization report (Zero values should be ignored)%c\n",'"','"');
- dump_times(8);
- }
-
- if ((!include_tflag) || (include_mask & (long long)REWRITE_REC_MASK)) {
- if(bif_flag)
- do_label(bif_fd, "Record Rewrite CPU utilization report (Zero values should be ignored)", bif_row++, bif_column);
- if(!silent) printf("\n%cRecord rewrite CPU utilization report (Zero values should be ignored)%c\n",'"','"');
- dump_times(9);
- }
-
- if ((!include_tflag) || (include_mask & (long long)STRIDE_READ_MASK)) {
- if(bif_flag)
- do_label(bif_fd, "Stride Read CPU utilization report (Zero values should be ignored)", bif_row++, bif_column);
- if(!silent) printf("\n%cStride read CPU utilization report (Zero values should be ignored)%c\n",'"','"');
- dump_times(10);
- }
-
- if ((!include_tflag) || (include_mask & (long long)FWRITER_MASK)) {
- if(bif_flag)
- do_label(bif_fd, "Fwrite CPU utilization report (Zero values should be ignored)", bif_row++, bif_column);
- if(!silent) printf("\n%cFwrite CPU utilization report (Zero values should be ignored)%c\n",'"','"');
- dump_times(11);
- if(bif_flag)
- do_label(bif_fd, "Re-fwrite CPU utilization report (Zero values should be ignored)", bif_row++, bif_column);
- if(!silent) printf("\n%cRe-Fwrite CPU utilization report (Zero values should be ignored)%c\n",'"','"');
- dump_times(12);
- }
-
- if ((!include_tflag) || (include_mask & (long long)FREADER_MASK)) {
- if(bif_flag)
- do_label(bif_fd, "Fread CPU utilization report (Zero values should be ignored)", bif_row++, bif_column);
- if(!silent) printf("\n%cFread CPU utilization report (Zero values should be ignored)%c\n",'"','"');
- dump_times(13);
- if(bif_flag)
- do_label(bif_fd, "Re-fread CPU utilization report (Zero values should be ignored)", bif_row++, bif_column);
- if(!silent) printf("\n%cRe-Fread CPU utilization report (Zero values should be ignored)%c\n",'"','"');
- dump_times(14);
- }
-
-#ifdef HAVE_PREAD
- if(Eflag)
- {
- if ((!include_tflag) || (include_mask & (long long)PWRITER_MASK)) {
- if(bif_flag)
- do_label(bif_fd, "Pwrite CPU utilization report (Zero values should be ignored)", bif_row++, bif_column);
- if(!silent) printf("\n%cPwrite CPU utilization report (Zero values should be ignored)%c\n",'"','"');
- dump_times(15);
- if(bif_flag)
- do_label(bif_fd, "Re-pwrite CPU utilization report (Zero values should be ignored)", bif_row++, bif_column);
- if(!silent) printf("\n%cRe-Pwrite CPU utilization report (Zero values should be ignored)%c\n",'"','"');
- dump_times(16);
- }
-
- if ((!include_tflag) || (include_mask & (long long)PREADER_MASK)) {
- if(bif_flag)
- do_label(bif_fd, "Pread CPU utilization report (Zero values should be ignored)", bif_row++, bif_column);
- if(!silent) printf("\n%cPread CPU utilization report (Zero values should be ignored)%c\n",'"','"');
- dump_times(17);
- if(bif_flag)
- do_label(bif_fd, "Re-pread CPU utilization report (Zero values should be ignored)", bif_row++, bif_column);
- if(!silent) printf("\n%cRe-Pread CPU utilization report (Zero values should be ignored)%c\n",'"','"');
- dump_times(18);
- }
-
-#ifdef HAVE_PREADV
- if ((!include_tflag) || (include_mask & (long long)PWRITEV_MASK)) {
- if(bif_flag)
- do_label(bif_fd, "Pwritev CPU utilization report (Zero values should be ignored)", bif_row++, bif_column);
- if(!silent) printf("\n%cPwritev CPU utilization report (Zero values should be ignored)%c\n",'"','"');
- dump_times(19);
- if(bif_flag)
- do_label(bif_fd, "Re-pwritev CPU utilization report (Zero values should be ignored)", bif_row++, bif_column);
- if(!silent) printf("\n%cRe-Pwritev CPU utilization report (Zero values should be ignored)%c\n",'"','"');
- dump_times(20);
- }
-
- if ((!include_tflag) || (include_mask & (long long)PREADV_MASK)) {
- if(bif_flag)
- do_label(bif_fd, "Preadv CPU utilization report (Zero values should be ignored)", bif_row++, bif_column);
- if(!silent) printf("\n%cPreadv CPU utilization report (Zero values should be ignored)%c\n",'"','"');
- dump_times(21);
- if(bif_flag)
- do_label(bif_fd, "Re-preadv CPU utilization report (Zero values should be ignored)", bif_row++, bif_column);
- if(!silent) printf("\n%cRe-Preadv CPU utilization report (Zero values should be ignored)%c\n",'"','"');
- dump_times(22);
- }
-#endif
- }
-#endif
-}
-
-/************************************************************************/
-/* Internal memory allocation mechanism. Uses shared memory or mmap */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-char *
-alloc_mem(long long size, int shared_flag)
-#else
-char *
-alloc_mem(size,shared_flag)
-long long size;
-int shared_flag;
-#endif
-{
- long long size1;
- char *addr,*dumb;
- int shmid;
- int tfd;
- long long tmp;
-#if defined(solaris)
- char mmapFileName[]="mmap_tmp_XXXXXX";
-#endif
-
- tmp = 0;
- dumb = (char *)0;
- tfd=0;
- size1=l_max(size,page_size);
- if(!distributed)
- {
- if(!trflag)
- {
- addr=(char *)malloc((size_t)size1);
- return(addr);
- }
- if(use_thread)
- {
- addr=(char *)malloc((size_t)size1);
- return(addr);
- }
- }
- if(!shared_flag)
- {
- addr=(char *)malloc((size_t)size1);
- return(addr);
- }
-#ifdef SHARED_MEM
- size1=l_max(size,page_size);
- size1=(size1 +page_size) & ~(page_size-1);
- shmid=(int)shmget((key_t)(IPC_PRIVATE), (size_t)size1 , (int)(IPC_CREAT|0666));
- if(shmid < (int)0)
- {
- printf("\nUnable to get shared memory segment(shmget)\n");
-#ifdef NO_PRINT_LLD
- printf("shmid = %d, size = %ld, size1 = %lu, Error %d\n",shmid,size,(size_t)size1,errno);
-#else
- printf("shmid = %d, size = %lld, size1 = %lu, Error %d\n",shmid,size,(unsigned long)size1,errno);
-#endif
- exit(119);
- }
- /*addr = (char *)shmat(shmid, 0, SHM_W);*/
- /* Some systems will not take the above but
- * will default to read/write if no flags
- * are provided. (AIX)
- * The POSIX standard states that if SHM_RDONLY
- * is not specified then it will be read/write.
- */
- addr = (char *)shmat((int)shmid, 0, 0);
-#ifdef _64BIT_ARCH_
- if((long long)addr == (long long)-1)
-#else
- if((long)addr == (long)-1)
-#endif
- {
- printf("\nUnable to get shared memory segment\n");
- printf("..Error %d\n",errno);
- exit(120);
- }
- shmctl(shmid, IPC_RMID, 0);
- return(addr);
-#else
-
- size1=l_max(size,page_size);
- size1=(size1 +page_size) & ~(page_size-1);
-#if defined(bsd4_2) && !defined(macosx)
- if((tfd = creat("mmap.tmp", 0666))<0)
- {
- printf("Unable to create tmp file\n");
- exit(121);
- }
- addr=(char *)mmap(0,&size1,PROT_WRITE|PROT_READ,
- MAP_ANON|MAP_SHARED, tfd, 0);
- unlink("mmap.tmp");
-#else
-
-
-#if defined(solaris)
- tfd=mkstemp(mmapFileName);
- if(tfd < 0)
- {
- printf("Unable to create tmp file\n");
- exit(121);
- }
- dumb=(char *)malloc((size_t)size1);
- bzero(dumb,size1);
- write(tfd,dumb,size1);
- free(dumb);
- addr=(char *)mmap(0,(size_t)size1,PROT_WRITE|PROT_READ,
- MAP_SHARED, tfd, 0);
- unlink(mmapFileName);
-#else
-#if defined(SCO) || defined(SCO_Unixware_gcc) || defined(Windows)
- char mmapFileName[]="mmap_tmp_XXXXXX";
- tfd=mkstemp(mmapFileName);
- if(tfd < 0)
- {
- printf("Unable to create tmp file\n");
- exit(121);
- }
- dumb=(char *)malloc((size_t)size1);
- bzero(dumb,size1);
- write(tfd,dumb,size1);
- free(dumb);
- addr=(char *)mmap(0,(size_t)size1,PROT_WRITE|PROT_READ,
- MAP_SHARED, tfd, 0);
- unlink(mmapFileName);
-#else
- addr=(char *)mmap(0,(size_t)size1,PROT_WRITE|PROT_READ,
- MAP_ANONYMOUS|MAP_SHARED, -1, 0);
-#endif
-#endif
-#endif
- if((char *)addr == (char *)-1)
- {
- printf("\nUnable to get memory segment\n");
- printf("Error %d\n",errno);
- exit(122);
- }
- if(debug1)
- printf("Got shared memory for size %d\n",size1);
-
- return(addr);
-#endif
-}
-
-/************************************************************************/
-/* Implementation of poll() function. */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void Poll(long long time1)
-#else
-void Poll(time1)
-long long time1;
-#endif
-{
- struct timeval howlong;
- howlong.tv_sec=(int)(time1/100000);
- howlong.tv_usec=(int)(time1%100000); /* Get into u.s. */
- select(0, 0, 0, 0, &howlong);
-}
-
-/************************************************************************/
-/* Implementation of max() function. */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-long long l_max(long long one,long long two)
-#else
-long long l_max(one,two)
-long long one,two;
-#endif
-{
- if(one > two)
- return(one);
- else
- return(two);
-}
-
-/************************************************************************/
-/* Internal Kill. With stonewalling disabled, kill does nothing */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void Kill(long long pid,long long sig)
-#else
-void Kill(pid,sig)
-long long pid,sig;
-#endif
-{
- if(!xflag)
- {
- /*printf("Killing %d\n",pid);*/
- kill((pid_t)pid,(int)sig);
- }
-}
-/************************************************************************/
-/* Implementation of min() function. */
-/************************************************************************/
-
-#ifdef HAVE_ANSIC_C
-long long l_min(long long num1,long long num2)
-#else
-long long l_min(num1,num2)
-long long num1,num2;
-#endif
-{
- if(num1 >= num2)
- return num2;
- else
- return num1;
-}
-
-/************************************************************************/
-/* Routine to call throughput tests many times. */
-/************************************************************************/
-
-#ifdef HAVE_ANSIC_C
-void
-multi_throughput_test(long long mint,long long maxt)
-#else
-void multi_throughput_test(mint, maxt)
-long long mint, maxt;
-#endif
-{
- int *t_rangeptr, *t_rangecurs;
- int *saveptr = (int *)0;
- int tofree = 0;
- long long i;
- if(t_count == 0){
- t_count = (int) maxt - mint + 1;
- t_rangeptr = (int *) malloc((size_t)sizeof(int)*t_count);
- saveptr = t_rangeptr;
- tofree = 1;
- t_rangecurs = t_rangeptr;
- for(i=mint; i<= maxt; i++) {
- *(t_rangecurs++) = i;
- }
- }
- else {
- t_rangeptr = &t_range[0];
- }
- for(i=0; i < t_count; i++){
- num_child = *(t_rangeptr++);
- current_client_number=0; /* Need to start with 1 */
- throughput_test();
- current_x=0;
- current_y++;
- }
- if(Rflag)
- dump_throughput();
- if(tofree)
- free(saveptr);
-
-}
-
-
-
-/************************************************************************/
-/* Routine to purge the buffer cache by unmounting drive. */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void
-purge_buffer_cache()
-#else
-purge_buffer_cache()
-#endif
-{
- char command[1024];
- int ret,i;
- strcpy(command,"umount ");
- strcat(command, mountname);
- /*
- umount might fail if the device is still busy, so
- retry unmounting several times with increasing delays
- */
- for (i = 1; i < 200; ++i) {
- ret = system(command);
- if (ret == 0)
- break;
- sleep(i); /* seconds */
- }
- strcpy(command,"mount ");
- strcat(command, mountname);
- /*
- mount might fail if the device is still busy, so
- retry mounting several times with increasing delays
- */
- for (i = 1; i < 10; ++i) {
- ret = system(command);
- if (ret == 0)
- break;
- sleep(i); /* seconds */
- }
-}
-
-/************************************************************************/
-/* Thread write test */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void *
-thread_write_test(void *x)
-#else
-void *
-thread_write_test( x)
-#endif
-{
-
- struct child_stats *child_stat;
- double starttime1 = 0;
- double temp_time;
- double walltime, cputime;
- double compute_val = (double)0;
- float delay = (float)0;
- double thread_qtime_stop,thread_qtime_start;
- double hist_time;
- double desired_op_rate_time;
- double actual_rate;
- off64_t traj_offset;
- off64_t lock_offset=0;
- off64_t save_offset=0;
- long long flags,traj_size;
- long long w_traj_bytes_completed;
- long long w_traj_ops_completed;
- FILE *w_traj_fd;
- int fd;
- long long recs_per_buffer;
- long long stopped,i;
- off64_t written_so_far, read_so_far, re_written_so_far,re_read_so_far;
- long long xx,xx2;
- char *dummyfile [MAXSTREAMS]; /* name of dummy file */
- char *nbuff;
- char *maddr;
- char *wmaddr,*free_addr;
- char now_string[30];
- int anwser,bind_cpu,wval;
-#if defined(VXFS) || defined(solaris)
- int test_foo = 0;
-#endif
- off64_t filebytes64;
- char tmpname[256];
- FILE *thread_wqfd;
- FILE *thread_Lwqfd;
-
-#ifdef ASYNC_IO
- struct cache *gc=0;
-
-#else
- long long *gc=0;
-#endif
-
- if(compute_flag)
- delay=compute_time;
- nbuff=maddr=wmaddr=free_addr=0;
- hist_time=thread_qtime_stop=thread_qtime_start=0;
- thread_wqfd=w_traj_fd=thread_Lwqfd=(FILE *)0;
- traj_offset=walltime=cputime=0;
- anwser=bind_cpu=0;
- if(w_traj_flag)
- {
- filebytes64 = w_traj_fsize;
- numrecs64=w_traj_ops;
- }
- else
- {
- filebytes64 = numrecs64*reclen;
- }
- written_so_far=read_so_far=re_written_so_far=re_read_so_far=0;
- w_traj_bytes_completed=w_traj_ops_completed=0;
- recs_per_buffer = cache_size/reclen ;
-#ifdef NO_THREADS
- xx=chid;
-#else
- if(use_thread)
- {
- xx = (long long)((long)x);
- }
- else
- {
- xx=chid;
- }
-#endif
-#ifndef NO_THREADS
-#if defined(_HPUX_SOURCE) || defined(linux)
- if(ioz_processor_bind)
- {
- bind_cpu=(begin_proc+(int)xx)%num_processors;
-#if defined(_HPUX_SOURCE)
- pthread_processor_bind_np(PTHREAD_BIND_FORCED_NP,
- (pthread_spu_t *)&anwser, (pthread_spu_t)bind_cpu, pthread_self());
-#else
- cpu_set_t cpuset;
-
- CPU_ZERO(&cpuset);
- CPU_SET(bind_cpu, &cpuset);
-
- pthread_setaffinity_np(pthread_self(), sizeof(cpuset),&cpuset);
-#endif
- my_nap(40); /* Switch to new cpu */
- }
-#endif
-#endif
- if(use_thread)
- nbuff=barray[xx];
- else
- nbuff=buffer;
- if(debug1 )
- {
- if(use_thread)
-#ifdef NO_PRINT_LLD
- printf("\nStarting child %ld\n",xx);
-#else
- printf("\nStarting child %lld\n",xx);
-#endif
- else
-#ifdef NO_PRINT_LLD
- printf("\nStarting process %d slot %ld\n",getpid(),xx);
-#else
- printf("\nStarting process %d slot %lld\n",getpid(),xx);
-#endif
-
- }
- dummyfile[xx]=(char *)malloc((size_t)MAXNAMESIZE);
- xx2=xx;
- if(share_file)
- xx2=(long long)0;
- if(mfflag)
- {
-#ifdef NO_PRINT_LLD
- sprintf(dummyfile[xx],"%s",filearray[xx2]);
-#else
- sprintf(dummyfile[xx],"%s",filearray[xx2]);
-#endif
- }
- else
- {
-#ifdef NO_PRINT_LLD
- sprintf(dummyfile[xx],"%s.DUMMY.%ld",filearray[xx2],xx2);
-#else
- sprintf(dummyfile[xx],"%s.DUMMY.%lld",filearray[xx2],xx2);
-#endif
- }
- /*****************/
- /* Children only */
- /*******************************************************************/
- /* Initial write throughput performance test. **********************/
- /*******************************************************************/
-#if defined(Windows)
- if(unbuffered)
- {
- hand=CreateFile(dummyfile[xx],
- GENERIC_READ|GENERIC_WRITE,
- FILE_SHARE_WRITE|FILE_SHARE_READ,
- NULL,OPEN_ALWAYS,FILE_FLAG_NO_BUFFERING|
- FILE_FLAG_WRITE_THROUGH|FILE_FLAG_POSIX_SEMANTICS,
- NULL);
- CloseHandle(hand);
- }
-#endif
- if(oflag)
- flags=O_RDWR|O_SYNC|O_CREAT;
- else
- flags=O_RDWR|O_CREAT;
-#if defined(O_DSYNC)
- if(odsync)
- flags |= O_DSYNC;
-#endif
-#if defined(_HPUX_SOURCE) || defined(linux)
- if(read_sync)
- flags |=O_RSYNC|O_SYNC;
-#endif
-
-#if ! defined(DONT_HAVE_O_DIRECT)
-#if defined(linux) || defined(__AIX__) || defined(IRIX) || defined(IRIX64) || defined(Windows) || defined (__FreeBSD__)
- if(direct_flag)
- flags |=O_DIRECT;
-#endif
-#if defined(TRU64)
- if(direct_flag)
- flags |=O_DIRECTIO;
-#endif
-#endif
-#if defined(Windows)
- if(unbuffered)
- {
- hand=CreateFile(dummyfile[xx],
- GENERIC_READ|GENERIC_WRITE,
- FILE_SHARE_WRITE|FILE_SHARE_READ,
- NULL,OPEN_EXISTING,FILE_FLAG_NO_BUFFERING|
- FILE_FLAG_WRITE_THROUGH|FILE_FLAG_POSIX_SEMANTICS,
- NULL);
- }
- else
- {
-#endif
- if((fd = I_OPEN(dummyfile[xx], (int)flags,0640))<0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- printf("\nCan not open temp file: %s\n",
- filename);
- perror("open");
- exit(125);
- }
-#if defined(Windows)
- }
-#endif
-#ifdef VXFS
- if(direct_flag)
- {
- ioctl(fd,VX_SETCACHE,VX_DIRECT);
- ioctl(fd,VX_GETCACHE,&test_foo);
- if(test_foo == 0)
- {
- if(!client_iozone)
- printf("\nVxFS advanced setcache feature not available.\n");
- exit(3);
- }
- }
-#endif
-#if defined(solaris)
- if(direct_flag)
- {
- test_foo = directio(fd, DIRECTIO_ON);
- if(test_foo != 0)
- {
- if(!client_iozone)
- printf("\ndirectio not available.\n");
- exit(3);
- }
- }
-#endif
-#ifdef ASYNC_IO
- if(async_flag)
- async_init(&gc,fd,direct_flag);
-#endif
- if(mmapflag)
- {
- maddr=(char *)initfile(fd,(filebytes64),1,PROT_READ|PROT_WRITE);
- }
- if(reclen < cache_size )
- {
- recs_per_buffer = cache_size/reclen ;
- nbuff=&nbuff[(xx%recs_per_buffer)*reclen];
- }
- if(fetchon) /* Prefetch into processor cache */
- fetchit(nbuff,reclen);
- if((verify && !no_copy_flag) || dedup || dedup_interior)
- fill_buffer(nbuff,reclen,(long long)pattern,sverify,(long long)0);
-
- if(w_traj_flag)
- w_traj_fd=open_w_traj();
-
- child_stat = (struct child_stats *)&shmaddr[xx];
- child_stat->throughput = 0;
- child_stat->actual = 0;
- child_stat->flag=CHILD_STATE_READY; /* Tell parent child is ready to go */
- if(distributed && client_iozone)
- tell_master_ready(chid);
- if(distributed && client_iozone)
- {
- if(cdebug)
- {
- fprintf(newstdout,"Child %d waiting for go from master\n",(int)xx);
- fflush(newstdout);
- }
- wait_for_master_go(chid);
- if(cdebug)
- {
- fprintf(newstdout,"Child %d received go from master\n",(int)xx);
- fflush(newstdout);
- }
- }
- else
- {
- while(child_stat->flag!=CHILD_STATE_BEGIN) /* Wait for signal from parent */
- Poll((long long)1);
- }
-
- written_so_far=0;
- child_stat = (struct child_stats *)&shmaddr[xx];
- child_stat->actual = 0;
- child_stat->throughput = 0;
- stopped=0;
- if(file_lock)
- if(mylockf((int) fd, (int) 1, (int)0) != 0)
- printf("File lock for write failed. %d\n",errno);
- if(Q_flag)
- {
- sprintf(tmpname,"Child_%d_wol.dat",(int)xx);
- thread_wqfd=fopen(tmpname,"a");
- if(thread_wqfd==0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- printf("Unable to open %s\n",tmpname);
- exit(40);
- }
- fprintf(thread_wqfd,"Offset in Kbytes Latency in microseconds Transfer size in bytes\n");
- }
- if(L_flag)
- {
- sprintf(tmpname,"Child_%d.log",(int)xx);
- thread_Lwqfd=fopen(tmpname,"a");
- if(thread_Lwqfd==0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- printf("Unable to open %s\n",tmpname);
- exit(40);
- }
- get_date(now_string);
- fprintf(thread_Lwqfd,"%-25s %s","Write test start: ",now_string);
- }
- starttime1 = time_so_far();
- if(cpuutilflag)
- {
- walltime = starttime1;
- cputime = cputime_so_far();
- }
- if(w_traj_flag)
- rewind(w_traj_fd);
- for(i=0; i<numrecs64; i++){
- if(w_traj_flag)
- {
- traj_offset=get_traj(w_traj_fd, (long long *)&traj_size,(float *)&delay, (long)1);
- reclen=traj_size;
-#if defined(Windows)
- if(unbuffered)
- SetFilePointer(hand,(LONG)traj_offset,0,FILE_BEGIN);
- else
-#endif
- I_LSEEK(fd,traj_offset,SEEK_SET);
- }
- if(Q_flag)
- {
-#if defined(Windows)
- if(unbuffered)
- traj_offset=SetFilePointer(hand,0,0,FILE_CURRENT);
- else
-#endif
- traj_offset=I_LSEEK(fd,0,SEEK_CUR);
- }
- if(rlocking)
- {
- lock_offset=I_LSEEK(fd,0,SEEK_CUR);
- mylockr((int) fd, (int) 1, (int)0,
- lock_offset, reclen);
- }
- if((verify && !no_copy_flag) || dedup || dedup_interior)
- fill_buffer(nbuff,reclen,(long long)pattern,sverify,i);
- if(compute_flag)
- compute_val+=do_compute(delay);
- if(*stop_flag && !stopped){
- if(include_flush)
- {
- if(mmapflag)
- msync(maddr,(size_t)filebytes64,MS_SYNC);
- else
- fsync(fd);
- }
- /* Close and re-open to get close in measurment */
- if(include_close)
- {
- save_offset=I_LSEEK(fd,0,SEEK_CUR);
- close(fd);
- }
- child_stat->throughput =
- (time_so_far() - starttime1)-time_res;
- if(include_close)
- {
- if((fd = I_OPEN(dummyfile[xx], (int)flags,0))<0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- printf("\nCan not open temp file: %s\n",
- filename);
- perror("open");
- exit(125);
- }
- I_LSEEK(fd,save_offset,SEEK_SET);
- }
- if(child_stat->throughput < (double).000001)
- {
- child_stat->throughput = time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-
- if(OPS_flag){
- /*written_so_far=(written_so_far*1024)/reclen;*/
- written_so_far=w_traj_ops_completed;
- }
- child_stat->throughput =
- (double)written_so_far/child_stat->throughput;
- child_stat->actual = (double)written_so_far;
- if(debug1)
- {
- printf("\n(%ld) Stopped by another\n", (long)xx);
- }
- stopped=1;
- }
- if(purge)
- purgeit(nbuff,reclen);
- if(Q_flag || hist_summary || op_rate_flag)
- {
- thread_qtime_start=time_so_far();
- }
-again:
- if(mmapflag)
- {
- wmaddr = &maddr[i*reclen];
- fill_area((long long*)nbuff,(long long*)wmaddr,(long long)reclen);
- /*printf("CHid: %lld Writing offset %lld for length of %lld\n",chid,i*reclen,reclen);*/
- if(!mmapnsflag)
- {
- if(mmapasflag)
- msync(wmaddr,(size_t)reclen,MS_ASYNC);
- if(mmapssflag)
- msync(wmaddr,(size_t)reclen,MS_SYNC);
- }
- }
- else
- {
- if(async_flag)
- {
- if(no_copy_flag)
- {
- free_addr=nbuff=(char *)malloc((size_t)reclen+page_size);
- nbuff=(char *)(((long)nbuff+(long)page_size) & (long)~(page_size-1));
- if(verify || dedup || dedup_interior)
- fill_buffer(nbuff,reclen,(long long)pattern,sverify,i);
- async_write_no_copy(gc, (long long)fd, nbuff, reclen, (i*reclen), depth,free_addr);
- }
- else
- async_write(gc, (long long)fd, nbuff, reclen, (i*reclen), depth);
- }
- else
- {
-#if defined(Windows)
- if(unbuffered)
- {
- WriteFile(hand,nbuff,reclen, (LPDWORD)&wval,0);
- }
- else
- {
-#endif
- wval=write(fd, nbuff, (size_t) reclen);
-#if defined(Windows)
- }
-#endif
- if(wval != reclen)
- {
- if(*stop_flag && !stopped){
- if(include_flush)
- {
- if(mmapflag)
- msync(maddr,(size_t)filebytes64,MS_SYNC);
- else
- fsync(fd);
- }
- temp_time = time_so_far();
- child_stat->throughput =
- (temp_time - starttime1)-time_res;
- if(child_stat->throughput < (double).000001)
- {
- child_stat->throughput= time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-
- if(OPS_flag){
- /*written_so_far=(written_so_far*1024)/reclen;*/
- written_so_far=w_traj_ops_completed;
- }
- child_stat->throughput =
- (double)written_so_far/child_stat->throughput;
- child_stat->actual = (double)written_so_far;
- if(debug1)
- {
- printf("\n(%ld) Stopped by another\n", (long)xx);
- }
- stopped=1;
- goto again;
- }
- /* Note: Writer must finish even though told
- to stop. Otherwise the readers will fail.
- The code will capture bytes transfered
- before told to stop but let the writer
- complete.
- */
-#ifdef NO_PRINT_LLD
- printf("\nError writing block %ld, fd= %d\n", i,
- fd);
-#else
- printf("\nError writing block %lld, fd= %d\n", i,
- fd);
-#endif
- if(wval==-1)
- perror("write");
- if (!no_unlink)
- {
- if(check_filename(dummyfile[xx]))
- unlink(dummyfile[xx]);
- }
- child_stat->flag = CHILD_STATE_HOLD;
- exit(127);
- }
- }
- }
- if(hist_summary)
- {
- thread_qtime_stop=time_so_far();
- hist_time =(thread_qtime_stop-thread_qtime_start);
- hist_insert(hist_time);
- }
- if(op_rate_flag)
- {
- thread_qtime_stop=time_so_far();
- desired_op_rate_time = ((double)1.0/(double)op_rate);
- actual_rate = (double)(thread_qtime_stop-thread_qtime_start);
-/*
-printf("Desired rate %g Actual rate %g Nap %g microseconds\n",desired_op_rate_time,
- actual_rate, (desired_op_rate_time-actual_rate));
-*/
- if( actual_rate < desired_op_rate_time)
- my_unap((unsigned long long)((desired_op_rate_time-actual_rate)*1000000.0 ));
- }
- if(Q_flag)
- {
- thread_qtime_stop=time_so_far();
-#ifdef NO_PRINT_LLD
- fprintf(thread_wqfd,"%10.1ld %10.0f %10.1ld\n",(traj_offset)/1024,((thread_qtime_stop-thread_qtime_start-time_res))*1000000,reclen);
-#else
- fprintf(thread_wqfd,"%10.1lld %10.0f %10.1lld\n",(traj_offset)/1024,((thread_qtime_stop-thread_qtime_start-time_res))*1000000,reclen);
-#endif
- }
- w_traj_ops_completed++;
- w_traj_bytes_completed+=reclen;
- written_so_far+=reclen/1024;
- if(*stop_flag)
- {
- written_so_far-=reclen/1024;
- w_traj_bytes_completed-=reclen;
- }
- if(rlocking)
- {
- mylockr((int) fd, (int) 0, (int)0,
- lock_offset, reclen);
- }
- }
-
-
- if(file_lock)
- if(mylockf((int) fd, (int) 0, (int)0))
- printf("Write unlock failed. %d\n",errno);
-
-#ifdef ASYNC_IO
- if(async_flag)
- {
- end_async(gc);
- gc=0;
- }
-#endif
- if(!xflag)
- {
- *stop_flag=1;
- if(distributed && client_iozone)
- send_stop();
- }
-
- if(include_flush)
- {
- if(mmapflag)
- msync(maddr,(size_t)filebytes64,MS_SYNC);
- else
- fsync(fd);
- }
- if(include_close)
- {
- if(mmapflag)
- mmap_end(maddr,(unsigned long long)filebytes64);
-#if defined(Windows)
- if(unbuffered)
- CloseHandle(hand);
- else
-#endif
- close(fd);
- }
- if(!stopped){
- temp_time = time_so_far();
- child_stat->throughput = ((temp_time - starttime1)-time_res)
- -compute_val;
- if(child_stat->throughput < (double).000001)
- {
- child_stat->throughput= time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-
- if(OPS_flag){
- /*written_so_far=(written_so_far*1024)/reclen;*/
- written_so_far=w_traj_ops_completed;
- }
- child_stat->throughput =
- (double)written_so_far/child_stat->throughput;
- child_stat->actual = (double)written_so_far;
- }
- if(cdebug)
- {
- fprintf(newstdout,"Child %d: throughput %f actual %f \n",(int)chid, child_stat->throughput,
- child_stat->actual);
- fflush(newstdout);
- }
- if(cpuutilflag)
- {
- cputime = cputime_so_far() - cputime;
- if (cputime < cputime_res)
- cputime = 0.0;
- child_stat->cputime = cputime;
- walltime = time_so_far() - walltime;
- child_stat->walltime = walltime;
- }
- if(distributed && client_iozone)
- tell_master_stats(THREAD_WRITE_TEST, chid, child_stat->throughput,
- child_stat->actual,
- child_stat->cputime, child_stat->walltime,
- (char)*stop_flag,
- (long long)CHILD_STATE_HOLD);
-
- if (debug1) {
- printf(" child/slot: %lld, wall-cpu: %8.3f %8.3fC" " -> %6.2f%%\n",
- xx, walltime, cputime,
- cpu_util(cputime, walltime));
- }
- child_stat->flag = CHILD_STATE_HOLD; /* Tell parent I'm done */
- stopped=0;
- /*******************************************************************/
- /* End write performance test. *************************************/
- /*******************************************************************/
- if(debug1)
-#ifdef NO_PRINT_LLD
- printf("\nChild finished %ld\n",xx);
-#else
- printf("\nChild finished %lld\n",xx);
-#endif
- if(!include_close)
- {
- if(mmapflag)
- {
- msync(maddr,(size_t)numrecs64*reclen,MS_SYNC); /*Clean up before read starts running*/
- mmap_end(maddr,(unsigned long long)numrecs64*reclen);
- }else
- fsync(fd);
-
-#if defined(Windows)
- if(unbuffered)
- CloseHandle(hand);
- else
-#endif
- close(fd);
- }
- if(Q_flag && (thread_wqfd !=0) )
- fclose(thread_wqfd);
- free(dummyfile[xx]);
- if(w_traj_flag)
- fclose(w_traj_fd);
-
- if(L_flag)
- {
- get_date(now_string);
- fprintf(thread_Lwqfd,"%-25s %s","Write test finished: ",now_string);
- fclose(thread_Lwqfd);
- }
- if(hist_summary)
- dump_hist("write",(int)xx);
- if(distributed && client_iozone)
- return(0);
-#ifdef NO_THREADS
- exit(0);
-#else
- if(use_thread)
- thread_exit();
- else
- exit(0);
-#endif
-return(0);
-}
-
-#ifdef HAVE_PREAD
-/************************************************************************/
-/* Thread pwrite test */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void *
-thread_pwrite_test(void *x)
-#else
-void *
-thread_pwrite_test( x)
-#endif
-{
-
- struct child_stats *child_stat;
- double starttime1 = 0;
- double temp_time;
- double walltime, cputime;
- double compute_val = (double)0;
- float delay = (float)0;
- double thread_qtime_stop,thread_qtime_start;
- double hist_time;
- double desired_op_rate_time;
- double actual_rate;
- off64_t traj_offset;
- off64_t lock_offset=0;
- long long flags,traj_size;
- long long w_traj_bytes_completed;
- long long w_traj_ops_completed;
- FILE *w_traj_fd;
- int fd;
- long long recs_per_buffer;
- long long stopped,i;
- off64_t written_so_far, read_so_far, re_written_so_far,re_read_so_far;
- long long xx,xx2;
- char *dummyfile [MAXSTREAMS]; /* name of dummy file */
- char *nbuff;
- char *maddr;
- char *wmaddr,*free_addr;
- char now_string[30];
- int anwser,bind_cpu,wval;
-#if defined(VXFS) || defined(solaris)
- int test_foo = 0;
-#endif
- off64_t filebytes64;
- char tmpname[256];
- FILE *thread_wqfd;
- FILE *thread_Lwqfd;
-
-#ifdef ASYNC_IO
- struct cache *gc=0;
-
-#else
- long long *gc=0;
-#endif
-
- if(compute_flag)
- delay=compute_time;
- nbuff=maddr=wmaddr=free_addr=0;
- hist_time=thread_qtime_stop=thread_qtime_start=0;
- thread_wqfd=w_traj_fd=thread_Lwqfd=(FILE *)0;
- traj_offset=walltime=cputime=0;
- anwser=bind_cpu=0;
- if(w_traj_flag)
- {
- filebytes64 = w_traj_fsize;
- numrecs64=w_traj_ops;
- }
- else
- {
- filebytes64 = numrecs64*reclen;
- }
- written_so_far=read_so_far=re_written_so_far=re_read_so_far=0;
- w_traj_bytes_completed=w_traj_ops_completed=0;
- recs_per_buffer = cache_size/reclen ;
-#ifdef NO_THREADS
- xx=chid;
-#else
- if(use_thread)
- {
- xx = (long long)((long)x);
- }
- else
- {
- xx=chid;
- }
-#endif
-#ifndef NO_THREADS
-#if defined( _HPUX_SOURCE ) || defined ( linux )
- if(ioz_processor_bind)
- {
- bind_cpu=(begin_proc+(int)xx)%num_processors;
-#if defined( _HPUX_SOURCE )
- pthread_processor_bind_np(PTHREAD_BIND_FORCED_NP,
- (pthread_spu_t *)&anwser, (pthread_spu_t)bind_cpu, pthread_self());
-#else
- cpu_set_t cpuset;
- CPU_ZERO(&cpuset);
- CPU_SET(bind_cpu, &cpuset);
-
- pthread_setaffinity_np(pthread_self(), sizeof(cpuset),&cpuset);
-#endif
- my_nap(40); /* Switch to new cpu */
- }
-#endif
-#endif
- if(use_thread)
- nbuff=barray[xx];
- else
- nbuff=buffer;
- if(debug1 )
- {
- if(use_thread)
-#ifdef NO_PRINT_LLD
- printf("\nStarting child %ld\n",xx);
-#else
- printf("\nStarting child %lld\n",xx);
-#endif
- else
-#ifdef NO_PRINT_LLD
- printf("\nStarting process %d slot %ld\n",getpid(),xx);
-#else
- printf("\nStarting process %d slot %lld\n",getpid(),xx);
-#endif
-
- }
- dummyfile[xx]=(char *)malloc((size_t)MAXNAMESIZE);
- xx2=xx;
- if(share_file)
- xx2=(long long)0;
- if(mfflag)
- {
-#ifdef NO_PRINT_LLD
- sprintf(dummyfile[xx],"%s",filearray[xx2]);
-#else
- sprintf(dummyfile[xx],"%s",filearray[xx2]);
-#endif
- }
- else
- {
-#ifdef NO_PRINT_LLD
- sprintf(dummyfile[xx],"%s.DUMMY.%ld",filearray[xx2],xx2);
-#else
- sprintf(dummyfile[xx],"%s.DUMMY.%lld",filearray[xx2],xx2);
-#endif
- }
- /*****************/
- /* Children only */
- /*******************************************************************/
- /* Initial pwrite throughput performance test. *********************/
- /*******************************************************************/
- if(!notruncate)
- {
- if((fd = I_CREAT(dummyfile[xx], 0640))<0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- perror(dummyfile[xx]);
- exit(123);
- }
- close(fd);
- }
- if(oflag)
- flags=O_RDWR|O_SYNC|O_CREAT;
- else
- flags=O_RDWR|O_CREAT;
-#if defined(O_DSYNC)
- if(odsync)
- flags |= O_DSYNC;
-#endif
-#if defined(_HPUX_SOURCE) || defined(linux)
- if(read_sync)
- flags |=O_RSYNC|O_SYNC;
-#endif
-
-#if ! defined(DONT_HAVE_O_DIRECT)
-#if defined(linux) || defined(__AIX__) || defined(IRIX) || defined(IRIX64) || defined(Windows) || defined (__FreeBSD__)
- if(direct_flag)
- flags |=O_DIRECT;
-#endif
-#if defined(TRU64)
- if(direct_flag)
- flags |=O_DIRECTIO;
-#endif
-#endif
- if((fd = I_OPEN(dummyfile[xx], (int)flags,0640))<0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- printf("\nCan not open temp file: %s\n",
- filename);
- perror("open");
- exit(125);
- }
-#ifdef VXFS
- if(direct_flag)
- {
- ioctl(fd,VX_SETCACHE,VX_DIRECT);
- ioctl(fd,VX_GETCACHE,&test_foo);
- if(test_foo == 0)
- {
- if(!client_iozone)
- printf("\nVxFS advanced setcache feature not available.\n");
- exit(3);
- }
- }
-#endif
-#if defined(solaris)
- if(direct_flag)
- {
- test_foo = directio(fd, DIRECTIO_ON);
- if(test_foo != 0)
- {
- if(!client_iozone)
- printf("\ndirectio not available.\n");
- exit(3);
- }
- }
-#endif
-#ifdef ASYNC_IO
- if(async_flag)
- async_init(&gc,fd,direct_flag);
-#endif
- if(mmapflag)
- {
- maddr=(char *)initfile(fd,(filebytes64),1,PROT_READ|PROT_WRITE);
- }
- if(reclen < cache_size )
- {
- recs_per_buffer = cache_size/reclen ;
- nbuff=&nbuff[(xx%recs_per_buffer)*reclen];
- }
- if(fetchon) /* Prefetch into processor cache */
- fetchit(nbuff,reclen);
- if((verify && !no_copy_flag) || dedup || dedup_interior)
- fill_buffer(nbuff,reclen,(long long)pattern,sverify,(long long)0);
-
- if(w_traj_flag)
- w_traj_fd=open_w_traj();
-
- child_stat = (struct child_stats *)&shmaddr[xx];
- child_stat->throughput = 0;
- child_stat->actual = 0;
- child_stat->flag=CHILD_STATE_READY; /* Tell parent child is ready to go */
- if(distributed && client_iozone)
- tell_master_ready(chid);
- if(distributed && client_iozone)
- {
- if(cdebug)
- {
- fprintf(newstdout,"Child %d waiting for go from master\n",(int)xx);
- fflush(newstdout);
- }
- wait_for_master_go(chid);
- if(cdebug)
- {
- fprintf(newstdout,"Child %d received go from master\n",(int)xx);
- fflush(newstdout);
- }
- }
- else
- {
- while(child_stat->flag!=CHILD_STATE_BEGIN) /* Wait for signal from parent */
- Poll((long long)1);
- }
-
- written_so_far=0;
- child_stat = (struct child_stats *)&shmaddr[xx];
- child_stat->actual = 0;
- child_stat->throughput = 0;
- stopped=0;
- if(file_lock)
- if(mylockf((int) fd, (int) 1, (int)0) != 0)
- printf("File lock for write failed. %d\n",errno);
- if(Q_flag)
- {
- sprintf(tmpname,"Child_%d_pwol.dat",(int)xx);
- thread_wqfd=fopen(tmpname,"a");
- if(thread_wqfd==0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- printf("Unable to open %s\n",tmpname);
- exit(40);
- }
- fprintf(thread_wqfd,"Offset in Kbytes Latency in microseconds Transfer size in bytes\n");
- }
- if(L_flag)
- {
- sprintf(tmpname,"Child_%d.log",(int)xx);
- thread_Lwqfd=fopen(tmpname,"a");
- if(thread_Lwqfd==0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- printf("Unable to open %s\n",tmpname);
- exit(40);
- }
- get_date(now_string);
- fprintf(thread_Lwqfd,"%-25s %s","Pwrite test start: ",now_string);
- }
- starttime1 = time_so_far();
- if(cpuutilflag)
- {
- walltime = starttime1;
- cputime = cputime_so_far();
- }
- if(w_traj_flag)
- rewind(w_traj_fd);
- for(i=0; i<numrecs64; i++){
- traj_offset= ( i * reclen );
- if(w_traj_flag)
- {
- traj_offset=get_traj(w_traj_fd, (long long *)&traj_size,(float *)&delay, (long)1);
- reclen=traj_size;
- }
- if(rlocking)
- {
- lock_offset=I_LSEEK(fd,0,SEEK_CUR);
- mylockr((int) fd, (int) 1, (int)0,
- lock_offset, reclen);
- }
- if((verify && !no_copy_flag) || dedup || dedup_interior)
- fill_buffer(nbuff,reclen,(long long)pattern,sverify,i);
- if(compute_flag)
- compute_val+=do_compute(delay);
- if(*stop_flag && !stopped){
- if(include_flush)
- {
- if(mmapflag)
- msync(maddr,(size_t)filebytes64,MS_SYNC);
- else
- fsync(fd);
- }
- child_stat->throughput =
- (time_so_far() - starttime1)-time_res;
- if(child_stat->throughput < (double).000001)
- {
- child_stat->throughput = time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-
- if(OPS_flag){
- /*written_so_far=(written_so_far*1024)/reclen;*/
- written_so_far=w_traj_ops_completed;
- }
- child_stat->throughput =
- (double)written_so_far/child_stat->throughput;
- child_stat->actual = (double)written_so_far;
- if(debug1)
- {
- printf("\n(%ld) Stopped by another\n", (long)xx);
- }
- stopped=1;
- }
- if(purge)
- purgeit(nbuff,reclen);
- if(Q_flag || hist_summary || op_rate_flag)
- {
- thread_qtime_start=time_so_far();
- }
-again:
- if(mmapflag)
- {
- wmaddr = &maddr[traj_offset];
- fill_area((long long*)nbuff,(long long*)wmaddr,(long long)reclen);
- /*printf("CHid: %lld Writing offset %lld for length of %lld\n",chid,i*reclen,reclen);*/
- if(!mmapnsflag)
- {
- if(mmapasflag)
- msync(wmaddr,(size_t)reclen,MS_ASYNC);
- if(mmapssflag)
- msync(wmaddr,(size_t)reclen,MS_SYNC);
- }
- }
- else
- {
- if(async_flag)
- {
- if(no_copy_flag)
- {
- free_addr=nbuff=(char *)malloc((size_t)reclen+page_size);
- nbuff=(char *)(((long)nbuff+(long)page_size) & (long)~(page_size-1));
- if(verify || dedup || dedup_interior)
- fill_buffer(nbuff,reclen,(long long)pattern,sverify,i);
- async_write_no_copy(gc, (long long)fd, nbuff, reclen, (traj_offset), depth,free_addr);
- }
- else
- async_write(gc, (long long)fd, nbuff, reclen, (traj_offset), depth);
- }
- else
- {
- wval=I_PWRITE(fd, nbuff, reclen, traj_offset);
- if(wval != reclen)
- {
- if(*stop_flag && !stopped){
- if(include_flush)
- {
- if(mmapflag)
- msync(maddr,(size_t)filebytes64,MS_SYNC);
- else
- fsync(fd);
- }
- temp_time = time_so_far();
- child_stat->throughput =
- (temp_time - starttime1)-time_res;
- if(child_stat->throughput < (double).000001)
- {
- child_stat->throughput= time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-
- if(OPS_flag){
- /*written_so_far=(written_so_far*1024)/reclen;*/
- written_so_far=w_traj_ops_completed;
- }
- child_stat->throughput =
- (double)written_so_far/child_stat->throughput;
- child_stat->actual = (double)written_so_far;
- if(debug1)
- {
- printf("\n(%ld) Stopped by another\n", (long)xx);
- }
- stopped=1;
- goto again;
- }
- /* Note: Writer must finish even though told
- to stop. Otherwise the readers will fail.
- The code will capture bytes transfered
- before told to stop but let the writer
- complete.
- */
-#ifdef NO_PRINT_LLD
- printf("\nError pwriting block %ld, fd= %d\n", i,
- fd);
-#else
- printf("\nError pwriting block %lld, fd= %d\n", i,
- fd);
-#endif
- if(wval==-1)
- perror("pwrite");
- if (!no_unlink)
- {
- if(check_filename(dummyfile[xx]))
- unlink(dummyfile[xx]);
- }
- child_stat->flag = CHILD_STATE_HOLD;
- exit(127);
- }
- }
- }
- if(rlocking)
- {
- mylockr((int) fd, (int) 0, (int)0,
- lock_offset, reclen);
- }
- if(hist_summary)
- {
- thread_qtime_stop=time_so_far();
- hist_time =(thread_qtime_stop-thread_qtime_start-time_res);
- hist_insert(hist_time);
- }
- if(op_rate_flag)
- {
- thread_qtime_stop=time_so_far();
- desired_op_rate_time = ((double)1.0/(double)op_rate);
- actual_rate = (double)(thread_qtime_stop-thread_qtime_start);
-/*
-printf("Desired rate %g Actual rate %g Nap %g microseconds\n",desired_op_rate_time,
- actual_rate, (desired_op_rate_time-actual_rate));
-*/
- if( actual_rate < desired_op_rate_time)
- my_unap((unsigned long long) ((desired_op_rate_time-actual_rate)*1000000.0 ));
- }
- if(Q_flag)
- {
- thread_qtime_stop=time_so_far();
-#ifdef NO_PRINT_LLD
- fprintf(thread_wqfd,"%10.1ld %10.0f %10.1ld\n",(traj_offset)/1024,((thread_qtime_stop-thread_qtime_start-time_res))*1000000,reclen);
-#else
- fprintf(thread_wqfd,"%10.1lld %10.0f %10.1lld\n",(traj_offset)/1024,((thread_qtime_stop-thread_qtime_start-time_res))*1000000,reclen);
-#endif
- }
- w_traj_ops_completed++;
- w_traj_bytes_completed+=reclen;
- written_so_far+=reclen/1024;
- if(*stop_flag)
- {
- written_so_far-=reclen/1024;
- w_traj_bytes_completed-=reclen;
- }
- }
-
-
- if(file_lock)
- if(mylockf((int) fd, (int) 0, (int)0))
- printf("Write unlock failed. %d\n",errno);
-
-#ifdef ASYNC_IO
- if(async_flag)
- {
- end_async(gc);
- gc=0;
- }
-#endif
- if(!xflag)
- {
- *stop_flag=1;
- if(distributed && client_iozone)
- send_stop();
- }
-
- if(include_flush)
- {
- if(mmapflag)
- msync(maddr,(size_t)filebytes64,MS_SYNC);
- else
- fsync(fd);
- }
- if(include_close)
- {
- if(mmapflag)
- mmap_end(maddr,(unsigned long long)filebytes64);
- close(fd);
- }
- if(!stopped){
- temp_time = time_so_far();
- child_stat->throughput = ((temp_time - starttime1)-time_res)
- -compute_val;
- if(child_stat->throughput < (double).000001)
- {
- child_stat->throughput= time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-
- if(OPS_flag){
- /*written_so_far=(written_so_far*1024)/reclen;*/
- written_so_far=w_traj_ops_completed;
- }
- child_stat->throughput =
- (double)written_so_far/child_stat->throughput;
- child_stat->actual = (double)written_so_far;
- }
- if(cdebug)
- {
- fprintf(newstdout,"Child %d: throughput %f actual %f \n",(int)chid, child_stat->throughput,
- child_stat->actual);
- fflush(newstdout);
- }
- if(cpuutilflag)
- {
- cputime = cputime_so_far() - cputime;
- if (cputime < cputime_res)
- cputime = 0.0;
- child_stat->cputime = cputime;
- walltime = time_so_far() - walltime;
- child_stat->walltime = walltime;
- }
- if(distributed && client_iozone)
- tell_master_stats(THREAD_PWRITE_TEST, chid, child_stat->throughput,
- child_stat->actual,
- child_stat->cputime, child_stat->walltime,
- (char)*stop_flag,
- (long long)CHILD_STATE_HOLD);
-
- if (debug1) {
- printf(" child/slot: %lld, wall-cpu: %8.3f %8.3fC" " -> %6.2f%%\n",
- xx, walltime, cputime,
- cpu_util(cputime, walltime));
- }
- child_stat->flag = CHILD_STATE_HOLD; /* Tell parent I'm done */
- stopped=0;
- /*******************************************************************/
- /* End pwrite performance test. *************************************/
- /*******************************************************************/
- if(debug1)
-#ifdef NO_PRINT_LLD
- printf("\nChild finished %ld\n",xx);
-#else
- printf("\nChild finished %lld\n",xx);
-#endif
- if(!include_close)
- {
- if(mmapflag)
- {
- msync(maddr,(size_t)numrecs64*reclen,MS_SYNC); /*Clean up before read starts running*/
- mmap_end(maddr,(unsigned long long)numrecs64*reclen);
- }else
- fsync(fd);
-
- close(fd);
- }
- if(Q_flag && (thread_wqfd !=0) )
- fclose(thread_wqfd);
- free(dummyfile[xx]);
- if(w_traj_flag)
- fclose(w_traj_fd);
-
- if(L_flag)
- {
- get_date(now_string);
- fprintf(thread_Lwqfd,"%-25s %s","Pwrite test finished: ",now_string);
- fclose(thread_Lwqfd);
- }
- if(hist_summary)
- dump_hist("Pwrite",(int)xx);
- if(distributed && client_iozone)
- return(0);
-#ifdef NO_THREADS
- exit(0);
-#else
- if(use_thread)
- thread_exit();
- else
- exit(0);
-#endif
-return(0);
-}
-#endif
-
-/************************************************************************/
-/* Thread re-write test */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void *
-thread_rwrite_test(void *x)
-#else
-void *
-thread_rwrite_test(x)
-#endif
-{
- /************************/
- /* Children only here */
- /************************/
- struct child_stats *child_stat;
- long long xx,xx2;
- double compute_val = (double)0;
- double walltime, cputime;
- float delay = (float)0;
- double thread_qtime_stop,thread_qtime_start;
- double hist_time;
- double desired_op_rate_time;
- double actual_rate;
- off64_t traj_offset;
- off64_t lock_offset=0;
- long long w_traj_bytes_completed;
- long long w_traj_ops_completed;
- int fd;
- FILE *w_traj_fd;
- long long flags = 0;
- double starttime1 = 0;
- double temp_time;
- long long recs_per_buffer,traj_size;
- long long i;
- off64_t written_so_far, read_so_far, re_written_so_far,re_read_so_far=0;
- char *dummyfile [MAXSTREAMS]; /* name of dummy file */
- char *nbuff;
- char *maddr,*free_addr;
- char *wmaddr;
- char now_string[30];
- int anwser,bind_cpu,wval;
- FILE *thread_rwqfd,*thread_Lwqfd;
- char tmpname[256];
-#if defined(VXFS) || defined(solaris)
- int test_foo = 0;
-#endif
-#ifdef ASYNC_IO
- struct cache *gc=0;
-
-#else
- long long *gc=0;
-#endif
-
- if(compute_flag)
- delay=compute_time;
- wmaddr=nbuff=maddr=free_addr=0;
- thread_rwqfd=w_traj_fd=thread_Lwqfd=(FILE *)0;
- hist_time=traj_offset=thread_qtime_stop=thread_qtime_start=0;
- walltime=cputime=0;
- anwser=bind_cpu=0;
- w_traj_bytes_completed=w_traj_ops_completed=0;
- written_so_far=read_so_far=re_written_so_far=re_read_so_far=0;
- recs_per_buffer = cache_size/reclen ;
- if(w_traj_flag)
- {
- filebytes64 = w_traj_fsize;
- numrecs64=w_traj_ops;
- }
- else
- {
- filebytes64 = numrecs64*reclen;
- }
-#ifdef NO_THREADS
- xx=chid;
-#else
- if(use_thread)
- xx=(long long)((long)x);
- else
- {
- xx=chid;
- }
-#endif
-#ifndef NO_THREADS
-#if defined( _HPUX_SOURCE ) || defined ( linux )
- if(ioz_processor_bind)
- {
- bind_cpu=(begin_proc+(int)xx)%num_processors;
-#if defined( _HPUX_SOURCE )
- pthread_processor_bind_np(PTHREAD_BIND_FORCED_NP,
- (pthread_spu_t *)&anwser, (pthread_spu_t)bind_cpu, pthread_self());
-#else
- cpu_set_t cpuset;
- CPU_ZERO(&cpuset);
- CPU_SET(bind_cpu, &cpuset);
-
- pthread_setaffinity_np(pthread_self(), sizeof(cpuset),&cpuset);
-#endif
- my_nap(40); /* Switch to new cpu */
- }
-#endif
-#endif
- if(use_thread)
- nbuff=barray[xx];
- else
- nbuff=buffer;
- child_stat = (struct child_stats *)&shmaddr[xx];
- child_stat->throughput = 0;
- child_stat->actual = 0;
- if(debug1)
- {
- if(use_thread)
-#ifdef NO_PRINT_LLD
- printf("\nStarting child %ld\n",xx);
-#else
- printf("\nStarting child %lld\n",xx);
-#endif
- else
-#ifdef NO_PRINT_LLD
- printf("\nStarting process %d slot %ld\n",getpid(),xx);
-#else
- printf("\nStarting process %d slot %lld\n",getpid(),xx);
-#endif
-
- }
- dummyfile[xx]=(char *)malloc((size_t)MAXNAMESIZE);
- xx2=xx;
- if(share_file)
- xx2=(long long)0;
- if(mfflag)
- {
-#ifdef NO_PRINT_LLD
- sprintf(dummyfile[xx],"%s",filearray[xx2]);
-#else
- sprintf(dummyfile[xx],"%s",filearray[xx2]);
-#endif
- }
- else
- {
-#ifdef NO_PRINT_LLD
- sprintf(dummyfile[xx],"%s.DUMMY.%ld",filearray[xx2],xx2);
-#else
- sprintf(dummyfile[xx],"%s.DUMMY.%lld",filearray[xx2],xx2);
-#endif
- }
- flags = O_RDWR;
- if(oflag)
- flags|= O_SYNC;
-#if defined(O_DSYNC)
- if(odsync)
- flags|= O_DSYNC;
-#endif
-#if defined(_HPUX_SOURCE) || defined(linux)
- if(read_sync)
- flags |=O_RSYNC|O_SYNC;
-#endif
-
-#if ! defined(DONT_HAVE_O_DIRECT)
-#if defined(linux) || defined(__AIX__) || defined(IRIX) || defined(IRIX64) || defined(Windows) || defined (__FreeBSD__)
- if(direct_flag)
- flags |=O_DIRECT;
-#endif
-#if defined(TRU64)
- if(direct_flag)
- flags |=O_DIRECTIO;
-#endif
-#endif
-
-#if defined(Windows)
- if(unbuffered)
- {
- hand=CreateFile(dummyfile[xx],
- GENERIC_READ|GENERIC_WRITE,
- FILE_SHARE_WRITE|FILE_SHARE_READ,
- NULL,OPEN_ALWAYS,FILE_FLAG_NO_BUFFERING|
- FILE_FLAG_WRITE_THROUGH|FILE_FLAG_POSIX_SEMANTICS,
- NULL);
- }
- else
- {
-#endif
- if((fd = I_OPEN(dummyfile[xx], (int)flags,0))<0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
-#ifdef NO_PRINT_LLD
- printf("\nChild %ld\n",xx);
-#else
- printf("\nChild %lld\n",xx);
-#endif
- child_stat->flag = CHILD_STATE_HOLD;
- perror(dummyfile[xx]);
- exit(128);
- }
-#if defined(Windows)
- }
-#endif
-#ifdef VXFS
- if(direct_flag)
- {
- ioctl(fd,VX_SETCACHE,VX_DIRECT);
- ioctl(fd,VX_GETCACHE,&test_foo);
- if(test_foo == 0)
- {
- if(!client_iozone)
- printf("\nVxFS advanced setcache feature not available.\n");
- exit(3);
- }
- }
-#endif
-#if defined(solaris)
- if(direct_flag)
- {
- test_foo = directio(fd, DIRECTIO_ON);
- if(test_foo != 0)
- {
- if(!client_iozone)
- printf("\ndirectio not available.\n");
- exit(3);
- }
- }
-#endif
-#ifdef ASYNC_IO
- if(async_flag)
- async_init(&gc,fd,direct_flag);
-#endif
- if(mmapflag)
- {
- maddr=(char *)initfile(fd,(numrecs64*reclen),1,PROT_READ|PROT_WRITE);
- }
- if(fetchon)
- fetchit(nbuff,reclen);
- if(w_traj_flag)
- w_traj_fd=open_w_traj();
- if(Q_flag)
- {
- sprintf(tmpname,"Child_%d_rwol.dat",(int)xx);
- thread_rwqfd=fopen(tmpname,"a");
- if(thread_rwqfd==0)
- {
- printf("Unable to open %s\n",tmpname);
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- exit(40);
- }
- fprintf(thread_rwqfd,"Offset in Kbytes Latency in microseconds Transfer size in bytes\n");
- }
- if(L_flag)
- {
- sprintf(tmpname,"Child_%d.log",(int)xx);
- thread_Lwqfd=fopen(tmpname,"a");
- if(thread_Lwqfd==0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- printf("Unable to open %s\n",tmpname);
- exit(40);
- }
- get_date(now_string);
- fprintf(thread_Lwqfd,"%-25s %s","Rewrite test start: ",now_string);
- }
- child_stat->flag = CHILD_STATE_READY;
- if(distributed && client_iozone)
- tell_master_ready(chid);
- if(distributed && client_iozone)
- {
- if(cdebug)
- {
- fprintf(newstdout,"Child %d waiting for go from master\n",(int)xx);
- fflush(newstdout);
- }
- wait_for_master_go(chid);
- if(cdebug)
- {
- fprintf(newstdout,"Child %d received go from master\n",(int)xx);
- fflush(newstdout);
- }
- }
- else
- {
- while(child_stat->flag!=CHILD_STATE_BEGIN) /* Wait for signal from parent */
- Poll((long long)1);
- }
- starttime1 = time_so_far();
- if(cpuutilflag)
- {
- walltime = starttime1;
- cputime = cputime_so_far();
- }
- if(file_lock)
- if(mylockf((int) fd, (int) 1, (int)0) != 0)
- printf("File lock for write failed. %d\n",errno);
- if(cpuutilflag)
- {
- walltime = starttime1;
- cputime = cputime_so_far();
- }
- if(w_traj_flag)
- rewind(w_traj_fd);
- if((verify && !no_copy_flag) || dedup || dedup_interior)
- fill_buffer(nbuff,reclen,(long long)pattern,sverify,(long long)0);
- for(i=0; i<numrecs64; i++){
- traj_offset= i*reclen ;
- if(w_traj_flag)
- {
- traj_offset=get_traj(w_traj_fd, (long long *)&traj_size,(float *)&delay,(long)1);
- reclen=traj_size;
-#if defined(Windows)
- if(unbuffered)
- SetFilePointer(hand,(LONG)traj_offset,0,FILE_BEGIN);
- else
-#endif
- I_LSEEK(fd,traj_offset,SEEK_SET);
- }
- if(Q_flag)
- {
-#if defined(Windows)
- if(unbuffered)
- traj_offset=SetFilePointer(hand,(LONG)0,0,FILE_CURRENT);
- else
-#endif
- traj_offset=I_LSEEK(fd,0,SEEK_CUR);
- }
- if(rlocking)
- {
- lock_offset=I_LSEEK(fd,0,SEEK_CUR);
- mylockr((int) fd, (int) 1, (int)0,
- lock_offset, reclen);
- }
- if(compute_flag)
- compute_val+=do_compute(delay);
- if(*stop_flag && !mmapflag)
- {
- if(debug1)
- printf("\nStop_flag 1\n");
- break;
- }
- if((verify && !no_copy_flag) || dedup || dedup_interior)
- {
- fill_buffer(nbuff,reclen,(long long)pattern,sverify,i);
- }
- if(purge)
- purgeit(nbuff,reclen);
- if(Q_flag || hist_summary || op_rate_flag)
- {
- thread_qtime_start=time_so_far();
- }
- if(mmapflag)
- {
- wmaddr = &maddr[i*reclen];
- if(cdebug)
- {
-fprintf(newstdout,"Chid: %lld Rewriting offset %lld for length of %lld\n",chid, i*reclen,reclen);
- fflush(newstdout);
- }
- fill_area((long long*)nbuff,(long long*)wmaddr,(long long)reclen);
- if(!mmapnsflag)
- {
- if(mmapasflag)
- msync(wmaddr,(size_t)reclen,MS_ASYNC);
- if(mmapssflag)
- msync(wmaddr,(size_t)reclen,MS_SYNC);
- }
- }
- else
- {
- if(async_flag)
- {
- if(no_copy_flag)
- {
- free_addr=nbuff=(char *)malloc((size_t)reclen+page_size);
- nbuff=(char *)(((long)nbuff+(long)page_size) & (long)~(page_size-1));
- if(verify || dedup || dedup_interior)
- fill_buffer(nbuff,reclen,(long long)pattern,sverify,i);
- async_write_no_copy(gc, (long long)fd, nbuff, reclen, (i*reclen), depth,free_addr);
- }
- else
- async_write(gc, (long long)fd, nbuff, reclen, (i*reclen), depth);
- }
- else
- {
-#if defined(Windows)
- if(unbuffered)
- {
- WriteFile(hand,nbuff,reclen,(LPDWORD)&wval,0);
- }
- else
-#endif
- wval=write(fd, nbuff, (size_t) reclen);
- if(wval != reclen)
- {
- if(*stop_flag)
- {
- if(debug1)
- printf("\nStop_flag 2\n");
- break;
- }
-#ifdef NO_PRINT_LLD
- printf("\nError writing block %ld, fd= %d\n", i,
- fd);
-#else
- printf("\nError writing block %lld, fd= %d\n", i,
- fd);
-#endif
- if(wval==-1)
- perror("write");
- if (!no_unlink)
- {
- if(check_filename(dummyfile[xx]))
- unlink(dummyfile[xx]);
- }
- child_stat->flag = CHILD_STATE_HOLD;
- signal_handler();
- }
- }
- }
- re_written_so_far+=reclen/1024;
- w_traj_ops_completed++;
- w_traj_bytes_completed+=reclen;
- if(*stop_flag)
- {
- re_written_so_far-=reclen/1024;
- w_traj_bytes_completed-=reclen;
- }
- if(hist_summary)
- {
- thread_qtime_stop=time_so_far();
- hist_time =(thread_qtime_stop-thread_qtime_start-time_res);
- hist_insert(hist_time);
- }
- if(op_rate_flag)
- {
- thread_qtime_stop=time_so_far();
- desired_op_rate_time = ((double)1.0/(double)op_rate);
- actual_rate = (double)(thread_qtime_stop-thread_qtime_start);
-/*
-printf("Desired rate %g Actual rate %g Nap %g microseconds\n",desired_op_rate_time,
- actual_rate, (desired_op_rate_time-actual_rate));
-*/
- if( actual_rate < desired_op_rate_time)
- my_unap((unsigned long long) ((desired_op_rate_time-actual_rate)*1000000.0 ));
- }
- if(Q_flag)
- {
- thread_qtime_stop=time_so_far();
-#ifdef NO_PRINT_LLD
- fprintf(thread_rwqfd,"%10.1ld %10.0f %10.1ld\n",(traj_offset)/1024,((thread_qtime_stop-thread_qtime_start-time_res))*1000000,reclen);
-#else
- fprintf(thread_rwqfd,"%10.1lld %10.0f %10.1lld\n",(traj_offset)/1024,((thread_qtime_stop-thread_qtime_start-time_res))*1000000,reclen);
-#endif
- }
- if(rlocking)
- {
- mylockr((int) fd, (int) 0, (int)0,
- lock_offset, reclen);
- }
- }
- if(file_lock)
- if(mylockf((int) fd, (int) 0, (int)0))
- printf("Write unlock failed. %d\n",errno);
-#ifdef ASYNC_IO
- if(async_flag)
- {
- end_async(gc);
- gc=0;
- }
-#endif
- if(include_flush)
- {
- if(mmapflag)
- {
- msync(maddr,(size_t)(filebytes64),MS_SYNC);
- }else
- fsync(fd);
- }
- if(include_close)
- {
- if(mmapflag)
- {
- mmap_end(maddr,(unsigned long long)filebytes64);
- }
-#if defined(Windows)
- if(unbuffered)
- CloseHandle(hand);
- else
-#endif
- close(fd);
- }
- temp_time=time_so_far();
- child_stat=(struct child_stats *)&shmaddr[xx];
- child_stat->throughput = ((temp_time - starttime1)-time_res)
- -compute_val;
- if(child_stat->throughput < (double).000001)
- {
- child_stat->throughput= time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-
- if(OPS_flag){
- /*re_written_so_far=(re_written_so_far*1024)/reclen;*/
- re_written_so_far=w_traj_ops_completed;
- }
- child_stat->throughput =
- (double)re_written_so_far/child_stat->throughput;
- child_stat->actual = (double)re_written_so_far;
- if(!xflag)
- {
- *stop_flag=1;
- if(distributed && client_iozone)
- send_stop();
- }
- if(cdebug)
- {
- fprintf(newstdout,"Child %d: throughput %f actual %f \n",(int)chid, child_stat->throughput,
- child_stat->actual);
- fflush(newstdout);
- }
- if(cpuutilflag)
- {
- cputime = cputime_so_far() - cputime;
- if (cputime < cputime_res)
- cputime = 0.0;
- child_stat->cputime = cputime;
- walltime = time_so_far() - walltime;
- child_stat->walltime = walltime;
- }
- if(distributed && client_iozone)
- tell_master_stats(THREAD_REWRITE_TEST, chid, child_stat->throughput,
- child_stat->actual,
- child_stat->cputime, child_stat->walltime,
- (char)*stop_flag,
- (long long)CHILD_STATE_HOLD);
- child_stat->flag = CHILD_STATE_HOLD; /* Tell parent I'm done */
- if(!include_close)
- {
- if(mmapflag)
- {
- msync(maddr,(size_t)(filebytes64),MS_SYNC);
- mmap_end(maddr,(unsigned long long)filebytes64);
- }
- else
- fsync(fd);
-#if defined(Windows)
- if(unbuffered)
- CloseHandle(hand);
- else
-#endif
- close(fd);
- }
- free(dummyfile[xx]);
-
- if(Q_flag && (thread_rwqfd !=0) )
- fclose(thread_rwqfd);
-
- if(w_traj_flag)
- fclose(w_traj_fd);
- if(debug1)
-#ifdef NO_PRINT_LLD
- printf("\nChild Stopping %ld\n",xx);
-#else
- printf("\nChild Stopping %lld\n",xx);
-#endif
-
- if(L_flag)
- {
- get_date(now_string);
- fprintf(thread_Lwqfd,"%-25s %s","Rewrite test finished: ",now_string);
- fclose(thread_Lwqfd);
- }
- if(hist_summary)
- dump_hist("Rewrite",(int)xx);
- if(distributed && client_iozone)
- return(0);
-#ifdef NO_THREADS
- exit(0);
-#else
- if(use_thread)
- thread_exit();
- else
- exit(0);
-#endif
-return(0);
-}
-
-/************************************************************************/
-/* Thread read test */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void *
-thread_read_test(void *x)
-#else
-void *
-thread_read_test(x)
-#endif
-{
- long long xx,xx2;
- struct child_stats *child_stat;
- double walltime, cputime;
- long long r_traj_bytes_completed;
- long long r_traj_ops_completed;
- int fd;
- FILE *r_traj_fd,*thread_rqfd;
- FILE *thread_Lwqfd;
- long long flags = 0;
- off64_t traj_offset;
- off64_t lock_offset=0;
- double starttime1 = 0;
- float delay = 0;
- double temp_time;
- double thread_qtime_start,thread_qtime_stop;
- double hist_time;
- double desired_op_rate_time;
- double actual_rate;
- double compute_val = (double)0;
- off64_t written_so_far, read_so_far, re_written_so_far,re_read_so_far;
- long long recs_per_buffer,traj_size;
- off64_t i;
- char *dummyfile[MAXSTREAMS]; /* name of dummy file */
- char *nbuff=0;
- char *maddr=0;
- char *wmaddr=0;
- char tmpname[256];
- volatile char *buffer1;
- char now_string[30];
- int anwser,bind_cpu;
- long wval;
-#if defined(VXFS) || defined(solaris)
- int test_foo = 0;
-#endif
-#ifdef ASYNC_IO
- struct cache *gc=0;
-#else
- long long *gc=0;
-#endif
-
- if(compute_flag)
- delay=compute_time;
- thread_rqfd=thread_Lwqfd=r_traj_fd=(FILE *)0;
- hist_time=traj_offset=thread_qtime_stop=thread_qtime_start=0;
- walltime=cputime=0;
- anwser=bind_cpu=0;
- r_traj_bytes_completed=r_traj_ops_completed=0;
- written_so_far=read_so_far=re_written_so_far=re_read_so_far=0;
- recs_per_buffer = cache_size/reclen ;
- if(r_traj_flag)
- {
- filebytes64 = r_traj_fsize;
- numrecs64=r_traj_ops;
- }
- else
- {
- filebytes64 = numrecs64*reclen;
- }
-
-#ifdef NO_THREADS
- xx=chid;
-#else
- if(use_thread)
- xx = (long long)((long)x);
- else
- {
- xx=chid;
- }
-#endif
-#ifndef NO_THREADS
-#if defined( _HPUX_SOURCE ) || defined ( linux )
- if(ioz_processor_bind)
- {
- bind_cpu=(begin_proc+(int)xx)%num_processors;
-#if defined(_HPUX_SOURCE)
- pthread_processor_bind_np(PTHREAD_BIND_FORCED_NP,
- (pthread_spu_t *)&anwser, (pthread_spu_t)bind_cpu, pthread_self());
-#else
- cpu_set_t cpuset;
-
- CPU_ZERO(&cpuset);
- CPU_SET(bind_cpu, &cpuset);
-
- pthread_setaffinity_np(pthread_self(), sizeof(cpuset),&cpuset);
-#endif
- my_nap(40); /* Switch to new cpu */
- }
-#endif
-#endif
- if(use_thread)
- nbuff=barray[xx];
- else
- nbuff=buffer;
- dummyfile[xx]=(char *)malloc((size_t)MAXNAMESIZE);
- xx2=xx;
- if(share_file)
- xx2=(long long)0;
- if(mfflag)
- {
-#ifdef NO_PRINT_LLD
- sprintf(dummyfile[xx],"%s",filearray[xx2]);
-#else
- sprintf(dummyfile[xx],"%s",filearray[xx2]);
-#endif
- }
- else
- {
-#ifdef NO_PRINT_LLD
- sprintf(dummyfile[xx],"%s.DUMMY.%ld",filearray[xx2],xx2);
-#else
- sprintf(dummyfile[xx],"%s.DUMMY.%lld",filearray[xx2],xx2);
-#endif
- }
- if(oflag)
- flags=O_RDONLY|O_SYNC;
- else
- flags=O_RDONLY;
-#if defined(_HPUX_SOURCE) || defined(linux)
- if(read_sync)
- flags |=O_RSYNC|O_SYNC;
-#endif
-
-#if ! defined(DONT_HAVE_O_DIRECT)
-#if defined(linux) || defined(__AIX__) || defined(IRIX) || defined(IRIX64) || defined(Windows) || defined (__FreeBSD__)
- if(direct_flag)
- flags |=O_DIRECT;
-#endif
-#if defined(TRU64)
- if(direct_flag)
- flags |=O_DIRECTIO;
-#endif
-#endif
-#if defined(Windows)
- if(unbuffered)
- {
- hand=CreateFile(dummyfile[xx],
- GENERIC_READ|GENERIC_WRITE,
- FILE_SHARE_WRITE|FILE_SHARE_READ,
- NULL,OPEN_EXISTING,FILE_FLAG_NO_BUFFERING|
- FILE_FLAG_WRITE_THROUGH|FILE_FLAG_POSIX_SEMANTICS,
- NULL);
- SetFilePointer(hand,(LONG)0,0,FILE_BEGIN);
- }
- else
- {
-#endif
- if((fd = I_OPEN(dummyfile[xx], (int)flags,0))<0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- perror(dummyfile[xx]);
- exit(130);
- }
-#if defined(Windows)
- }
-#endif
-#ifdef ASYNC_IO
- if(async_flag)
- async_init(&gc,fd,direct_flag);
-#endif
-#ifdef VXFS
- if(direct_flag)
- {
- ioctl(fd,VX_SETCACHE,VX_DIRECT);
- ioctl(fd,VX_GETCACHE,&test_foo);
- if(test_foo == 0)
- {
- if(!client_iozone)
- printf("\nVxFS advanced setcache feature not available.\n");
- exit(3);
- }
- }
-#endif
-#if defined(solaris)
- if(direct_flag)
- {
- test_foo = directio(fd, DIRECTIO_ON);
- if(test_foo != 0)
- {
- if(!client_iozone)
- printf("\ndirectio not available.\n");
- exit(3);
- }
- }
-#endif
- if(mmapflag)
- {
- maddr=(char *)initfile(fd,(numrecs64*reclen),0,PROT_READ);
- }
- child_stat = (struct child_stats *)&shmaddr[xx];
- child_stat->throughput = 0;
- child_stat->actual = 0;
- if(debug1)
- {
- if(use_thread)
-#ifdef NO_PRINT_LLD
- printf("\nStarting child %ld\n",xx);
-#else
- printf("\nStarting child %lld\n",xx);
-#endif
- else
-#ifdef NO_PRINT_LLD
- printf("\nStarting process %d slot %ld\n",getpid(),xx);
-#else
- printf("\nStarting process %d slot %lld\n",getpid(),xx);
-#endif
-
- }
- /*****************/
- /* Children only */
- /*****************/
- if(Q_flag)
- {
- sprintf(tmpname,"Child_%d_rol.dat",(int)xx);
- thread_rqfd=fopen(tmpname,"a");
- if(thread_rqfd==0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- printf("Unable to open %s\n",tmpname);
- exit(40);
- }
- fprintf(thread_rqfd,"Offset in Kbytes Latency in microseconds Transfer size in bytes\n");
- }
- if(L_flag)
- {
- sprintf(tmpname,"Child_%d.log",(int)xx);
- thread_Lwqfd=fopen(tmpname,"a");
- if(thread_Lwqfd==0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- printf("Unable to open %s\n",tmpname);
- exit(40);
- }
- get_date(now_string);
- fprintf(thread_Lwqfd,"%-25s %s","Read test start: ",now_string);
- }
-
- if(r_traj_flag)
- r_traj_fd=open_r_traj();
- if(fetchon)
- fetchit(nbuff,reclen);
- child_stat=(struct child_stats *)&shmaddr[xx];
- child_stat->flag = CHILD_STATE_READY;
- if(distributed && client_iozone)
- {
- tell_master_ready(chid);
- wait_for_master_go(chid);
- }
- else
- {
- /* Wait for signal from parent */
- while(child_stat->flag!=CHILD_STATE_BEGIN)
- Poll((long long)1);
- }
- if(file_lock)
- if(mylockf((int) fd, (int) 1, (int)1) != 0)
- printf("File lock for read failed. %d\n",errno);
- starttime1 = time_so_far();
- if(cpuutilflag)
- {
- walltime = starttime1;
- cputime = cputime_so_far();
- }
-
- if(r_traj_flag)
- rewind(r_traj_fd);
- for(i=0; i<numrecs64; i++){
- traj_offset= i*reclen;
- if(disrupt_flag && ((i%DISRUPT)==0))
- {
-#if defined(Windows)
-
- if(unbuffered)
- disruptw(hand);
- else
- disrupt(fd);
-#else
- disrupt(fd);
-#endif
- }
- if(r_traj_flag)
- {
- traj_offset=get_traj(r_traj_fd, (long long *)&traj_size,(float *)&delay,(long)0);
- reclen=traj_size;
-#if defined(Windows)
- if(unbuffered)
- SetFilePointer(hand,(LONG)traj_offset,0,FILE_BEGIN);
- else
-#endif
- I_LSEEK(fd,traj_offset,SEEK_SET);
- }
- if(Q_flag)
- {
-#if defined(Windows)
- if(unbuffered)
- traj_offset=SetFilePointer(hand,0,0,FILE_CURRENT);
- else
-#endif
- traj_offset=I_LSEEK(fd,0,SEEK_CUR);
- }
- if(rlocking)
- {
- lock_offset=I_LSEEK(fd,0,SEEK_CUR);
- mylockr((int) fd, (int) 1, (int)1,
- lock_offset, reclen);
- }
- if(compute_flag)
- compute_val+=do_compute(delay);
- if(*stop_flag)
- {
- if(debug1)
- printf("\n(%ld) Stopped by another 2\n", (long)xx);
- break;
- }
- if(purge)
- purgeit(nbuff,reclen);
- if(Q_flag || hist_summary || op_rate_flag)
- {
- thread_qtime_start=time_so_far();
- }
- if(mmapflag)
- {
- wmaddr = &maddr[i*reclen];
- fill_area((long long*)wmaddr,(long long*)nbuff,(long long)reclen);
- }
- else
- {
- if(async_flag)
- {
- if(no_copy_flag)
- async_read_no_copy(gc, (long long)fd, &buffer1, (i*reclen), reclen,
- 1LL,(numrecs64*reclen),depth);
- else
- async_read(gc, (long long)fd, nbuff, (i*reclen), reclen,
- 1LL,(numrecs64*reclen),depth);
- }
- else
- {
-#if defined(Windows)
- if(unbuffered)
- {
- ReadFile(hand,nbuff,reclen,(LPDWORD)&wval,0);
- }
- else
-#endif
- wval=read((int)fd, (void*)nbuff, (size_t) reclen);
- if(wval != reclen)
- {
- if(*stop_flag)
- {
- if(debug1)
- printf("\n(%ld) Stopped by another 2\n", (long)xx);
- break;
- }
-#ifdef NO_PRINT_LLD
- printf("\nError reading block %ld, fd= %d\n", i,
- fd);
-#else
- printf("\nError reading block %lld, fd= %d\n", i,
- fd);
-#endif
- perror("read");
- if (!no_unlink)
- {
- if(check_filename(dummyfile[xx]))
- unlink(dummyfile[xx]);
- }
- child_stat->flag = CHILD_STATE_HOLD;
- exit(132);
- }
- }
- }
- if(verify){
- if(async_flag && no_copy_flag)
- {
- if(verify_buffer(buffer1,reclen,(off64_t)i,reclen,(long long)pattern,sverify)){
- if (!no_unlink)
- {
- if(check_filename(dummyfile[xx]))
- unlink(dummyfile[xx]);
- }
- child_stat->flag = CHILD_STATE_HOLD;
- exit(133);
- }
- }
- else
- {
- if(verify_buffer(nbuff,reclen,(off64_t)i,reclen,(long long)pattern,sverify)){
- if (!no_unlink)
- {
- if(check_filename(dummyfile[xx]))
- unlink(dummyfile[xx]);
- }
- child_stat->flag = CHILD_STATE_HOLD;
- exit(134);
- }
- }
- }
- if(async_flag && no_copy_flag)
- async_release(gc);
- read_so_far+=reclen/1024;
- r_traj_bytes_completed+=reclen;
- r_traj_ops_completed++;
- if(*stop_flag)
- {
- read_so_far-=reclen/1024;
- r_traj_bytes_completed-=reclen;
- }
- if(hist_summary)
- {
- thread_qtime_stop=time_so_far();
- hist_time =(thread_qtime_stop-thread_qtime_start-time_res);
- hist_insert(hist_time);
- }
- if(op_rate_flag)
- {
- thread_qtime_stop=time_so_far();
- desired_op_rate_time = ((double)1.0/(double)op_rate);
- actual_rate = (double)(thread_qtime_stop-thread_qtime_start);
-/*
-printf("Desired rate %g Actual rate %g Nap %g microseconds\n",desired_op_rate_time,
- actual_rate, (desired_op_rate_time-actual_rate));
-*/
- if( actual_rate < desired_op_rate_time)
- my_unap((unsigned long long) ((desired_op_rate_time-actual_rate)*1000000.0 ));
- }
- if(Q_flag)
- {
- thread_qtime_stop=time_so_far();
-#ifdef NO_PRINT_LLD
- fprintf(thread_rqfd,"%10.1ld %10.0f %10.1ld\n",(traj_offset)/1024,((thread_qtime_stop-thread_qtime_start-time_res))*1000000,reclen);
-#else
- fprintf(thread_rqfd,"%10.1lld %10.0f %10.1lld\n",(traj_offset)/1024,((thread_qtime_stop-thread_qtime_start-time_res))*1000000,reclen);
-#endif
- }
-
- if(rlocking)
- {
- mylockr((int) fd, (int) 0, (int)1,
- lock_offset, reclen);
- }
- }
- if(file_lock)
- if(mylockf((int) fd, (int) 0, (int)1))
- printf("Read unlock failed. %d\n",errno);
-#ifdef ASYNC_IO
- if(async_flag)
- {
- end_async(gc);
- gc=0;
- }
-#endif
- if(include_flush)
- {
- if(mmapflag)
- {
- msync(maddr,(size_t)(filebytes64),MS_SYNC);
- }else
- fsync(fd);
- }
- if(include_close)
- {
- if(mmapflag)
- {
- mmap_end(maddr,(unsigned long long)filebytes64);
- }
-#if defined(Windows)
- if(unbuffered)
- CloseHandle(hand);
- else
-#endif
- close(fd);
- }
- temp_time = time_so_far();
- child_stat=(struct child_stats *)&shmaddr[xx];
- child_stat->throughput = ((temp_time - starttime1)-time_res)
- -compute_val;
- if(child_stat->throughput < (double).000001)
- {
- child_stat->throughput= time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-
- if(OPS_flag){
- /*read_so_far=(read_so_far*1024)/reclen;*/
- read_so_far=r_traj_ops_completed;
- }
- child_stat->throughput = read_so_far/child_stat->throughput;
- child_stat->actual = read_so_far;
- if(!xflag)
- {
- *stop_flag=1;
- if(distributed && client_iozone)
- send_stop();
- }
- if(cdebug)
- {
- fprintf(newstdout,"Child %d: throughput %f actual %f \n",(int)chid,child_stat->throughput,
- child_stat->actual);
- fflush(newstdout);
- }
- if(cpuutilflag)
- {
- cputime = cputime_so_far() - cputime;
- if (cputime < cputime_res)
- cputime = 0.0;
- child_stat->cputime = cputime;
- walltime = time_so_far() - walltime;
- child_stat->walltime = walltime;
- }
- if(distributed && client_iozone)
- tell_master_stats(THREAD_READ_TEST, chid, child_stat->throughput,
- child_stat->actual,
- child_stat->cputime, child_stat->walltime,
- (char)*stop_flag,
- (long long)CHILD_STATE_HOLD);
- child_stat->flag = CHILD_STATE_HOLD; /* Tell parent I'm done */
- /*fsync(fd);*/
- if(!include_close)
- {
- if(mmapflag)
- {
- msync(maddr,(size_t)(filebytes64),MS_SYNC);
- mmap_end(maddr,(unsigned long long)filebytes64);
- }else
- fsync(fd);
-#if defined(Windows)
- if(unbuffered)
- CloseHandle(hand);
- else
-#endif
- close(fd);
- }
- if(Q_flag && (thread_rqfd !=0) )
- fclose(thread_rqfd);
- free(dummyfile[xx]);
- if(r_traj_flag)
- fclose(r_traj_fd);
- if(debug1)
-#ifdef NO_PRINT_LLD
- printf("\nChild finished %ld\n",xx);
-#else
- printf("\nChild finished %lld\n",xx);
-#endif
-
- if(L_flag)
- {
- get_date(now_string);
- fprintf(thread_Lwqfd,"%-25s %s","Read test finished: ",now_string);
- fclose(thread_Lwqfd);
- }
- if(hist_summary)
- dump_hist("Read",(int)xx);
- if(distributed && client_iozone)
- return(0);
-#ifdef NO_THREADS
- exit(0);
-#else
- if(use_thread)
- thread_exit();
- else
- exit(0);
-#endif
-return(0);
-}
-
-#ifdef HAVE_PREAD
-/************************************************************************/
-/* Thread pread test */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void *
-thread_pread_test(void *x)
-#else
-void *
-thread_pread_test(x)
-#endif
-{
- long long xx,xx2;
- struct child_stats *child_stat;
- double walltime, cputime;
- long long r_traj_bytes_completed;
- long long r_traj_ops_completed;
- int fd;
- FILE *r_traj_fd,*thread_rqfd;
- FILE *thread_Lwqfd;
- long long flags = 0;
- off64_t traj_offset;
- off64_t lock_offset=0;
- double starttime1 = 0;
- float delay = 0;
- double temp_time;
- double thread_qtime_start,thread_qtime_stop;
- double hist_time;
- double desired_op_rate_time;
- double actual_rate;
- double compute_val = (double)0;
- off64_t written_so_far, read_so_far, re_written_so_far,re_read_so_far;
- long long recs_per_buffer,traj_size;
- off64_t i;
- char *dummyfile[MAXSTREAMS]; /* name of dummy file */
- char *nbuff=0;
- char *maddr=0;
- char *wmaddr=0;
- char tmpname[256];
- char now_string[30];
- volatile char *buffer1;
- int anwser,bind_cpu;
-#if defined(VXFS) || defined(solaris)
- int test_foo = 0;
-#endif
-#ifdef ASYNC_IO
- struct cache *gc=0;
-#else
- long long *gc=0;
-#endif
-
- if(compute_flag)
- delay=compute_time;
- thread_rqfd=thread_Lwqfd=r_traj_fd=(FILE *)0;
- hist_time=traj_offset=thread_qtime_stop=thread_qtime_start=0;
- walltime=cputime=0;
- anwser=bind_cpu=0;
- r_traj_bytes_completed=r_traj_ops_completed=0;
- written_so_far=read_so_far=re_written_so_far=re_read_so_far=0;
- recs_per_buffer = cache_size/reclen ;
- if(r_traj_flag)
- {
- filebytes64 = r_traj_fsize;
- numrecs64=r_traj_ops;
- }
- else
- {
- filebytes64 = numrecs64*reclen;
- }
-
-#ifdef NO_THREADS
- xx=chid;
-#else
- if(use_thread)
- xx = (long long)((long)x);
- else
- {
- xx=chid;
- }
-#endif
-#ifndef NO_THREADS
-#ifdef _HPUX_SOURCE
- if(ioz_processor_bind)
- {
- bind_cpu=(begin_proc+(int)xx)%num_processors;
- pthread_processor_bind_np(PTHREAD_BIND_FORCED_NP,
- (pthread_spu_t *)&anwser, (pthread_spu_t)bind_cpu, pthread_self());
- my_nap(40); /* Switch to new cpu */
- }
-#endif
-#endif
- if(use_thread)
- nbuff=barray[xx];
- else
- nbuff=buffer;
- dummyfile[xx]=(char *)malloc((size_t)MAXNAMESIZE);
- xx2=xx;
- if(share_file)
- xx2=(long long)0;
- if(mfflag)
- {
-#ifdef NO_PRINT_LLD
- sprintf(dummyfile[xx],"%s",filearray[xx2]);
-#else
- sprintf(dummyfile[xx],"%s",filearray[xx2]);
-#endif
- }
- else
- {
-#ifdef NO_PRINT_LLD
- sprintf(dummyfile[xx],"%s.DUMMY.%ld",filearray[xx2],xx2);
-#else
- sprintf(dummyfile[xx],"%s.DUMMY.%lld",filearray[xx2],xx2);
-#endif
- }
- if(oflag)
- flags=O_RDONLY|O_SYNC;
- else
- flags=O_RDONLY;
-#if defined(_HPUX_SOURCE) || defined(linux)
- if(read_sync)
- flags |=O_RSYNC|O_SYNC;
-#endif
-
-#if ! defined(DONT_HAVE_O_DIRECT)
-#if defined(linux) || defined(__AIX__) || defined(IRIX) || defined(IRIX64) || defined(Windows) || defined (__FreeBSD__)
- if(direct_flag)
- flags |=O_DIRECT;
-#endif
-#if defined(TRU64)
- if(direct_flag)
- flags |=O_DIRECTIO;
-#endif
-#endif
- if((fd = I_OPEN(dummyfile[xx], (int)flags,0))<0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- perror(dummyfile[xx]);
- exit(130);
- }
-#ifdef ASYNC_IO
- if(async_flag)
- async_init(&gc,fd,direct_flag);
-#endif
-#ifdef VXFS
- if(direct_flag)
- {
- ioctl(fd,VX_SETCACHE,VX_DIRECT);
- ioctl(fd,VX_GETCACHE,&test_foo);
- if(test_foo == 0)
- {
- if(!client_iozone)
- printf("\nVxFS advanced setcache feature not available.\n");
- exit(3);
- }
- }
-#endif
-#if defined(solaris)
- if(direct_flag)
- {
- test_foo = directio(fd, DIRECTIO_ON);
- if(test_foo != 0)
- {
- if(!client_iozone)
- printf("\ndirectio not available.\n");
- exit(3);
- }
- }
-#endif
- if(mmapflag)
- {
- maddr=(char *)initfile(fd,(numrecs64*reclen),0,PROT_READ);
- }
- child_stat = (struct child_stats *)&shmaddr[xx];
- child_stat->throughput = 0;
- child_stat->actual = 0;
- if(debug1)
- {
- if(use_thread)
-#ifdef NO_PRINT_LLD
- printf("\nStarting child %ld\n",xx);
-#else
- printf("\nStarting child %lld\n",xx);
-#endif
- else
-#ifdef NO_PRINT_LLD
- printf("\nStarting process %d slot %ld\n",getpid(),xx);
-#else
- printf("\nStarting process %d slot %lld\n",getpid(),xx);
-#endif
-
- }
- /*****************/
- /* Children only */
- /*****************/
- if(Q_flag)
- {
- sprintf(tmpname,"Child_%d_prol.dat",(int)xx);
- thread_rqfd=fopen(tmpname,"a");
- if(thread_rqfd==0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- printf("Unable to open %s\n",tmpname);
- exit(40);
- }
- fprintf(thread_rqfd,"Offset in Kbytes Latency in microseconds Transfer size in bytes\n");
- }
- if(L_flag)
- {
- sprintf(tmpname,"Child_%d.log",(int)xx);
- thread_Lwqfd=fopen(tmpname,"a");
- if(thread_Lwqfd==0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- printf("Unable to open %s\n",tmpname);
- exit(40);
- }
- get_date(now_string);
- fprintf(thread_Lwqfd,"%-25s %s","Pread test start: ",now_string);
- }
-
- if(r_traj_flag)
- r_traj_fd=open_r_traj();
- if(fetchon)
- fetchit(nbuff,reclen);
- child_stat=(struct child_stats *)&shmaddr[xx];
- child_stat->flag = CHILD_STATE_READY;
- if(distributed && client_iozone)
- {
- tell_master_ready(chid);
- wait_for_master_go(chid);
- }
- else
- {
- /* Wait for signal from parent */
- while(child_stat->flag!=CHILD_STATE_BEGIN)
- Poll((long long)1);
- }
- if(file_lock)
- if(mylockf((int) fd, (int) 1, (int)1) != 0)
- printf("File lock for read failed. %d\n",errno);
- starttime1 = time_so_far();
- if(cpuutilflag)
- {
- walltime = starttime1;
- cputime = cputime_so_far();
- }
-
- if(r_traj_flag)
- rewind(r_traj_fd);
- for(i=0; i<numrecs64; i++){
- traj_offset = i*reclen;
- if(disrupt_flag && ((i%DISRUPT)==0))
- {
- disrupt(fd);
- }
- if(r_traj_flag)
- {
- traj_offset=get_traj(r_traj_fd, (long long *)&traj_size,(float *)&delay,(long)0);
- reclen=traj_size;
- I_LSEEK(fd,traj_offset,SEEK_SET);
- }
- if(Q_flag)
- {
- traj_offset=I_LSEEK(fd,0,SEEK_CUR);
- }
- if(rlocking)
- {
- lock_offset=I_LSEEK(fd,0,SEEK_CUR);
- mylockr((int) fd, (int) 1, (int)0,
- lock_offset, reclen);
- }
- if(compute_flag)
- compute_val+=do_compute(delay);
- if(*stop_flag)
- {
- if(debug1)
- printf("\n(%ld) Stopped by another 2\n", (long)xx);
- break;
- }
- if(purge)
- purgeit(nbuff,reclen);
- if(Q_flag || hist_summary || op_rate_flag)
- {
- thread_qtime_start=time_so_far();
- }
- if(mmapflag)
- {
- wmaddr = &maddr[traj_offset];
- fill_area((long long*)wmaddr,(long long*)nbuff,(long long)reclen);
- }
- else
- {
- if(async_flag)
- {
- if(no_copy_flag)
- async_read_no_copy(gc, (long long)fd, &buffer1, (i*reclen), reclen,
- 1LL,(numrecs64*reclen),depth);
- else
- async_read(gc, (long long)fd, nbuff, (traj_offset), reclen,
- 1LL,(numrecs64*reclen),depth);
- }
- else
- {
- if(I_PREAD((int)fd, (void*)nbuff, (size_t) reclen,(traj_offset) ) != reclen)
- {
- if(*stop_flag)
- {
- if(debug1)
- printf("\n(%ld) Stopped by another 2\n", (long)xx);
- break;
- }
-#ifdef NO_PRINT_LLD
- printf("\nError preading block %ld, fd= %d\n", i,
- fd);
-#else
- printf("\nError preading block %lld, fd= %d\n", i,
- fd);
-#endif
- perror("pread");
- if (!no_unlink)
- {
- if(check_filename(dummyfile[xx]))
- unlink(dummyfile[xx]);
- }
- child_stat->flag = CHILD_STATE_HOLD;
- exit(132);
- }
- }
- }
- if(verify){
- if(async_flag && no_copy_flag)
- {
- if(verify_buffer(buffer1,reclen,(off64_t)i,reclen,(long long)pattern,sverify)){
- if (!no_unlink)
- {
- if(check_filename(dummyfile[xx]))
- unlink(dummyfile[xx]);
- }
- child_stat->flag = CHILD_STATE_HOLD;
- exit(133);
- }
- }
- else
- {
- if(verify_buffer(nbuff,reclen,(off64_t)i,reclen,(long long)pattern,sverify)){
- if (!no_unlink)
- {
- if(check_filename(dummyfile[xx]))
- unlink(dummyfile[xx]);
- }
- child_stat->flag = CHILD_STATE_HOLD;
- exit(134);
- }
- }
- }
- if(async_flag && no_copy_flag)
- async_release(gc);
- read_so_far+=reclen/1024;
- r_traj_bytes_completed+=reclen;
- r_traj_ops_completed++;
- if(*stop_flag)
- {
- read_so_far-=reclen/1024;
- r_traj_bytes_completed-=reclen;
- }
- if(hist_summary)
- {
- thread_qtime_stop=time_so_far();
- hist_time =(thread_qtime_stop-thread_qtime_start-time_res);
- hist_insert(hist_time);
- }
- if(op_rate_flag)
- {
- thread_qtime_stop=time_so_far();
- desired_op_rate_time = ((double)1.0/(double)op_rate);
- actual_rate = (double)(thread_qtime_stop-thread_qtime_start);
-/*
-printf("Desired rate %g Actual rate %g Nap %g microseconds\n",desired_op_rate_time,
- actual_rate, (desired_op_rate_time-actual_rate));
-*/
- if( actual_rate < desired_op_rate_time)
- my_unap((unsigned long long) ((desired_op_rate_time-actual_rate)*1000000.0 ));
- }
- if(Q_flag)
- {
- thread_qtime_stop=time_so_far();
-#ifdef NO_PRINT_LLD
- fprintf(thread_rqfd,"%10.1ld %10.0f %10.1ld\n",(traj_offset)/1024,((thread_qtime_stop-thread_qtime_start-time_res))*1000000,reclen);
-#else
- fprintf(thread_rqfd,"%10.1lld %10.0f %10.1lld\n",(traj_offset)/1024,((thread_qtime_stop-thread_qtime_start-time_res))*1000000,reclen);
-#endif
- }
-
- if(rlocking)
- {
- mylockr((int) fd, (int) 0, (int)1,
- lock_offset, reclen);
- }
- }
- if(file_lock)
- if(mylockf((int) fd, (int) 0, (int)1))
- printf("Read unlock failed. %d\n",errno);
-#ifdef ASYNC_IO
- if(async_flag)
- {
- end_async(gc);
- gc=0;
- }
-#endif
- if(include_flush)
- {
- if(mmapflag)
- {
- msync(maddr,(size_t)(filebytes64),MS_SYNC);
- }else
- fsync(fd);
- }
- if(include_close)
- {
- if(mmapflag)
- {
- mmap_end(maddr,(unsigned long long)filebytes64);
- }
- close(fd);
- }
- temp_time = time_so_far();
- child_stat=(struct child_stats *)&shmaddr[xx];
- child_stat->throughput = ((temp_time - starttime1)-time_res)
- -compute_val;
- if(child_stat->throughput < (double).000001)
- {
- child_stat->throughput= time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-
- if(OPS_flag){
- /*read_so_far=(read_so_far*1024)/reclen;*/
- read_so_far=r_traj_ops_completed;
- }
- child_stat->throughput = read_so_far/child_stat->throughput;
- child_stat->actual = read_so_far;
- if(!xflag)
- {
- *stop_flag=1;
- if(distributed && client_iozone)
- send_stop();
- }
- if(cdebug)
- {
- fprintf(newstdout,"Child %d: throughput %f actual %f \n",(int)chid,child_stat->throughput,
- child_stat->actual);
- fflush(newstdout);
- }
- if(cpuutilflag)
- {
- cputime = cputime_so_far() - cputime;
- if (cputime < cputime_res)
- cputime = 0.0;
- child_stat->cputime = cputime;
- walltime = time_so_far() - walltime;
- child_stat->walltime = walltime;
- }
- if(distributed && client_iozone)
- tell_master_stats(THREAD_READ_TEST, chid, child_stat->throughput,
- child_stat->actual,
- child_stat->cputime, child_stat->walltime,
- (char)*stop_flag,
- (long long)CHILD_STATE_HOLD);
- child_stat->flag = CHILD_STATE_HOLD; /* Tell parent I'm done */
- /*fsync(fd);*/
- if(!include_close)
- {
- if(mmapflag)
- {
- msync(maddr,(size_t)(filebytes64),MS_SYNC);
- mmap_end(maddr,(unsigned long long)filebytes64);
- }else
- fsync(fd);
- close(fd);
- }
- if(Q_flag && (thread_rqfd !=0) )
- fclose(thread_rqfd);
- free(dummyfile[xx]);
- if(r_traj_flag)
- fclose(r_traj_fd);
- if(debug1)
-#ifdef NO_PRINT_LLD
- printf("\nChild finished %ld\n",xx);
-#else
- printf("\nChild finished %lld\n",xx);
-#endif
-
- if(L_flag)
- {
- get_date(now_string);
- fprintf(thread_Lwqfd,"%-25s %s","Pread test finished: ",
- now_string);
- fclose(thread_Lwqfd);
- }
- if(hist_summary)
- dump_hist("Pread",(int)xx);
- if(distributed && client_iozone)
- return(0);
-#ifdef NO_THREADS
- exit(0);
-#else
- if(use_thread)
- thread_exit();
- else
- exit(0);
-#endif
-return(0);
-}
-#endif
-
-/************************************************************************/
-/* Thread re-read test */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void *
-thread_rread_test(void *x)
-#else
-void *
-thread_rread_test(x)
-#endif
-{
- long long xx,xx2;
- char *nbuff;
- struct child_stats *child_stat;
- int fd;
- FILE *r_traj_fd,*thread_rrqfd;
- FILE *thread_Lwqfd;
- long long r_traj_bytes_completed;
- double walltime, cputime;
- long long r_traj_ops_completed;
- off64_t traj_offset;
- off64_t lock_offset=0;
- long long flags = 0;
- double starttime1 = 0;
- float delay = 0;
- double temp_time;
- double thread_qtime_start,thread_qtime_stop;
- double hist_time;
- double desired_op_rate_time;
- double actual_rate;
- double compute_val = (double)0;
- long long recs_per_buffer,traj_size;
- off64_t i;
- off64_t written_so_far, read_so_far, re_written_so_far,
- re_read_so_far;
- char *dummyfile[MAXSTREAMS]; /* name of dummy file */
- char *maddr=0;
- char *wmaddr=0;
- char now_string[30];
- volatile char *buffer1;
- int anwser,bind_cpu;
- long wval;
- char tmpname[256];
-#if defined(VXFS) || defined(solaris)
- int test_foo = 0;
-#endif
-#ifdef ASYNC_IO
- struct cache *gc=0;
-#else
- long long *gc=0;
-#endif
- /*****************/
- /* Children only */
- /*****************/
- if(compute_flag)
- delay=compute_time;
- hist_time=thread_qtime_stop=thread_qtime_start=0;
- thread_rrqfd=r_traj_fd=thread_Lwqfd=(FILE *)0;
- traj_offset=walltime=cputime=0;
- anwser=bind_cpu=0;
- r_traj_bytes_completed=r_traj_ops_completed=0;
- written_so_far=read_so_far=re_written_so_far=re_read_so_far=0;
- recs_per_buffer = cache_size/reclen ;
-#ifdef NO_THREADS
- xx=chid;
-#else
- if(r_traj_flag)
- {
- filebytes64 = r_traj_fsize;
- numrecs64=r_traj_ops;
- }
- else
- {
- filebytes64 = numrecs64*reclen;
- }
- if(use_thread)
- xx = (long long)((long)x);
- else
- {
- xx=chid;
- }
-#endif
-#ifndef NO_THREADS
-#if defined( _HPUX_SOURCE ) || defined ( linux )
- if(ioz_processor_bind)
- {
- bind_cpu=(begin_proc+(int)xx)%num_processors;
-#if defined(_HPUX_SOURCE)
- pthread_processor_bind_np(PTHREAD_BIND_FORCED_NP,
- (pthread_spu_t *)&anwser, (pthread_spu_t)bind_cpu, pthread_self());
-#else
- cpu_set_t cpuset;
-
- CPU_ZERO(&cpuset);
- CPU_SET(bind_cpu, &cpuset);
-
- pthread_setaffinity_np(pthread_self(), sizeof(cpuset),&cpuset);
-#endif
- my_nap(40); /* Switch to new cpu */
- }
-#endif
-#endif
- if(use_thread)
- nbuff=barray[xx];
- else
- nbuff=buffer;
- if(debug1)
- {
- if(use_thread)
-#ifdef NO_PRINT_LLD
- printf("\nStarting child %ld\n",xx);
-#else
- printf("\nStarting child %lld\n",xx);
-#endif
- else
-#ifdef NO_PRINT_LLD
- printf("\nStarting process %d slot %ld\n",getpid(),xx);
-#else
- printf("\nStarting process %d slot %lld\n",getpid(),xx);
-#endif
-
- }
- dummyfile[xx]=(char *)malloc((size_t)MAXNAMESIZE);
- xx2=xx;
- if(share_file)
- xx2=(long long)0;
- if(mfflag)
- {
-#ifdef NO_PRINT_LLD
- sprintf(dummyfile[xx],"%s",filearray[xx2]);
-#else
- sprintf(dummyfile[xx],"%s",filearray[xx2]);
-#endif
- }
- else
- {
-#ifdef NO_PRINT_LLD
- sprintf(dummyfile[xx],"%s.DUMMY.%ld",filearray[xx2],xx2);
-#else
- sprintf(dummyfile[xx],"%s.DUMMY.%lld",filearray[xx2],xx2);
-#endif
- }
- if(oflag)
- flags=O_RDONLY|O_SYNC;
- else
- flags=O_RDONLY;
-#if defined(_HPUX_SOURCE) || defined(linux)
- if(read_sync)
- flags |=O_RSYNC|O_SYNC;
-#endif
-
-#if ! defined(DONT_HAVE_O_DIRECT)
-#if defined(linux) || defined(__AIX__) || defined(IRIX) || defined(IRIX64) || defined(Windows) || defined (__FreeBSD__)
- if(direct_flag)
- flags |=O_DIRECT;
-#endif
-#if defined(TRU64)
- if(direct_flag)
- flags |=O_DIRECTIO;
-#endif
-#endif
-
-#if defined(Windows)
- if(unbuffered)
- {
- hand=CreateFile(dummyfile[xx],
- GENERIC_READ|GENERIC_WRITE,
- FILE_SHARE_WRITE|FILE_SHARE_READ,
- NULL,OPEN_EXISTING,FILE_FLAG_NO_BUFFERING|
- FILE_FLAG_WRITE_THROUGH|FILE_FLAG_POSIX_SEMANTICS,
- NULL);
- SetFilePointer(hand,(LONG)0,0,FILE_BEGIN);
- }
- else
- {
-#endif
- if((fd = I_OPEN(dummyfile[xx], ((int)flags),0))<0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- perror(dummyfile[xx]);
- exit(135);
- }
-#if defined(Windows)
- }
-#endif
-#ifdef ASYNC_IO
- if(async_flag)
- async_init(&gc,fd,direct_flag);
-#endif
-#ifdef VXFS
- if(direct_flag)
- {
- ioctl(fd,VX_SETCACHE,VX_DIRECT);
- ioctl(fd,VX_GETCACHE,&test_foo);
- if(test_foo == 0)
- {
- if(!client_iozone)
- printf("\nVxFS advanced setcache feature not available.\n");
- exit(3);
- }
- }
-#endif
-#if defined(solaris)
- if(direct_flag)
- {
- test_foo = directio(fd, DIRECTIO_ON);
- if(test_foo != 0)
- {
- if(!client_iozone)
- printf("\ndirectio not available.\n");
- exit(3);
- }
- }
-#endif
- if(mmapflag)
- {
- maddr=(char *)initfile(fd,(filebytes64),0,PROT_READ);
- }
- if(r_traj_flag)
- r_traj_fd=open_r_traj();
- if(fetchon)
- fetchit(nbuff,reclen);
- if(Q_flag)
- {
- sprintf(tmpname,"Child_%d_rrol.dat",(int)xx);
- thread_rrqfd=fopen(tmpname,"a");
- if(thread_rrqfd==0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- printf("Unable to open %s\n",tmpname);
- exit(40);
- }
- fprintf(thread_rrqfd,"Offset in Kbytes Latency in microseconds Transfer size in bytes\n");
- }
- if(L_flag)
- {
- sprintf(tmpname,"Child_%d.log",(int)xx);
- thread_Lwqfd=fopen(tmpname,"a");
- if(thread_Lwqfd==0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- printf("Unable to open %s\n",tmpname);
- exit(40);
- }
- get_date(now_string);
- fprintf(thread_Lwqfd,"%-25s %s","Reread test start: ",now_string);
- }
-
- child_stat = (struct child_stats *)&shmaddr[xx];
- child_stat->throughput = 0;
- child_stat->actual = 0;
- child_stat->flag = CHILD_STATE_READY;
-
- if(distributed && client_iozone)
- {
- tell_master_ready(chid);
- wait_for_master_go(chid);
- }
- else
-
- /* Wait for signal from parent */
- while(child_stat->flag!=CHILD_STATE_BEGIN)
- Poll((long long)1);
- if(file_lock)
- if(mylockf((int) fd, (int) 1, (int)1) != 0)
- printf("File lock for read failed. %d\n",errno);
- starttime1 = time_so_far();
- if(cpuutilflag)
- {
- walltime = starttime1;
- cputime = cputime_so_far();
- }
-
- if(r_traj_flag)
- rewind(r_traj_fd);
- for(i=0; i<numrecs64; i++){
- traj_offset=i*reclen;
- if(disrupt_flag && ((i%DISRUPT)==0))
- {
-#if defined(Windows)
-
- if(unbuffered)
- disruptw(hand);
- else
- disrupt(fd);
-#else
- disrupt(fd);
-#endif
- }
- if(r_traj_flag)
- {
- traj_offset=get_traj(r_traj_fd, (long long *)&traj_size,(float *)&delay,(long)0);
- reclen=traj_size;
-#if defined(Windows)
- if(unbuffered)
- SetFilePointer(hand,(LONG)traj_offset,0,FILE_BEGIN);
- else
-#endif
- I_LSEEK(fd,traj_offset,SEEK_SET);
- }
- if(Q_flag)
- {
-#if defined(Windows)
- if(unbuffered)
- traj_offset=SetFilePointer(hand,(LONG)0,0,FILE_CURRENT);
- else
-#endif
- traj_offset=I_LSEEK(fd,0,SEEK_CUR);
- }
- if(rlocking)
- {
- lock_offset=I_LSEEK(fd,0,SEEK_CUR);
- mylockr((int) fd, (int) 1, (int)1,
- lock_offset, reclen);
- }
- if(compute_flag)
- compute_val+=do_compute(delay);
- if(*stop_flag)
- {
- if(debug1)
- printf("\n(%ld) Stopped by another 3\n", (long)xx);
- break;
- }
- if(purge)
- purgeit(nbuff,reclen);
- if(Q_flag || hist_summary || op_rate_flag)
- {
- thread_qtime_start=time_so_far();
- }
- if(mmapflag)
- {
- wmaddr = &maddr[i*reclen];
- fill_area((long long*)wmaddr,(long long*)nbuff,(long long)reclen);
- }
- else
- {
- if(async_flag)
- {
- if(no_copy_flag)
- async_read_no_copy(gc, (long long)fd, &buffer1, (i*reclen),reclen,
- 1LL,(filebytes64),depth);
- else
- async_read(gc, (long long)fd, nbuff, (i*reclen),reclen,
- 1LL,(filebytes64),depth);
- }
- else
- {
-#if defined(Windows)
- if(unbuffered)
- {
- ReadFile(hand,nbuff,reclen,(LPDWORD)&wval,0);
- }
- else
-#endif
- wval=read((int)fd, (void*)nbuff, (size_t) reclen);
- if(wval != reclen)
- {
- if(*stop_flag)
- {
- if(debug1)
- printf("\n(%ld) Stopped by another 4\n", (long)xx);
- break;
- }
-#ifdef NO_PRINT_LLD
- printf("\nError writing block %ld, fd= %d\n", i,
- fd);
-#else
- printf("\nError writing block %lld, fd= %d\n", i,
- fd);
-#endif
- perror("read");
- if (!no_unlink)
- {
- if(check_filename(dummyfile[xx]))
- unlink(dummyfile[xx]);
- }
- child_stat->flag = CHILD_STATE_HOLD;
- exit(137);
- }
- }
- }
- if(verify){
- if(async_flag && no_copy_flag)
- {
- if(verify_buffer(buffer1,reclen,(off64_t)i,reclen,(long long)pattern,sverify)){
- if (!no_unlink)
- {
- if(check_filename(dummyfile[xx]))
- unlink(dummyfile[xx]);
- }
- child_stat->flag = CHILD_STATE_HOLD;
- exit(138);
- }
- }
- else
- {
- if(verify_buffer(nbuff,reclen,(off64_t)i,reclen,(long long)pattern,sverify)){
- if (!no_unlink)
- {
- if(check_filename(dummyfile[xx]))
- unlink(dummyfile[xx]);
- }
- child_stat->flag = CHILD_STATE_HOLD;
- exit(139);
- }
- }
- }
- if(async_flag && no_copy_flag)
- async_release(gc);
- re_read_so_far+=reclen/1024;
- r_traj_bytes_completed+=reclen;
- r_traj_ops_completed++;
- if(*stop_flag)
- {
- re_read_so_far-=reclen/1024;
- r_traj_bytes_completed-=reclen;
- }
- if(hist_summary)
- {
- thread_qtime_stop=time_so_far();
- hist_time =(thread_qtime_stop-thread_qtime_start-time_res);
- hist_insert(hist_time);
- }
- if(op_rate_flag)
- {
- thread_qtime_stop=time_so_far();
- desired_op_rate_time = ((double)1.0/(double)op_rate);
- actual_rate = (double)(thread_qtime_stop-thread_qtime_start);
-/*
-printf("Desired rate %g Actual rate %g Nap %g microseconds\n",desired_op_rate_time,
- actual_rate, (desired_op_rate_time-actual_rate));
-*/
- if( actual_rate < desired_op_rate_time)
- my_unap((unsigned long long) ((desired_op_rate_time-actual_rate)*1000000.0 ));
- }
- if(Q_flag)
- {
- thread_qtime_stop=time_so_far();
-#ifdef NO_PRINT_LLD
- fprintf(thread_rrqfd,"%10.1ld %10.0f %10.1ld\n",(traj_offset)/1024,((thread_qtime_stop-thread_qtime_start-time_res))*1000000,reclen);
-#else
- fprintf(thread_rrqfd,"%10.1lld %10.0f %10.1lld\n",(traj_offset)/1024,((thread_qtime_stop-thread_qtime_start-time_res))*1000000,reclen);
-#endif
- }
-
- if(rlocking)
- {
- mylockr((int) fd, (int) 0, (int)1,
- lock_offset, reclen);
- }
- }
- if(file_lock)
- if(mylockf((int) fd, (int) 0, (int)1))
- printf("Read unlock failed. %d\n",errno);
- /*fsync(fd);*/
-#ifdef ASYNC_IO
- if(async_flag)
- {
- end_async(gc);
- gc=0;
- }
-#endif
- if(include_flush)
- {
- if(mmapflag)
- {
- msync(maddr,(size_t)(filebytes64),MS_SYNC);
- }else
- fsync(fd);
- }
- if(include_close)
- {
- if(mmapflag)
- {
- mmap_end(maddr,(unsigned long long)filebytes64);
- }
-#if defined(Windows)
- if(unbuffered)
- CloseHandle(hand);
- else
-#endif
- close(fd);
- }
- temp_time = time_so_far();
- child_stat->throughput = ((temp_time - starttime1)-time_res)
- -compute_val;
- if(child_stat->throughput < (double).000001)
- {
- child_stat->throughput= time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-
- if(OPS_flag){
- /*re_read_so_far=(re_read_so_far*1024)/reclen;*/
- re_read_so_far=r_traj_ops_completed;
- }
- child_stat->throughput = re_read_so_far/child_stat->throughput;
- child_stat->actual = re_read_so_far;
- if(!xflag)
- {
- *stop_flag=1;
- if(distributed && client_iozone)
- send_stop();
- }
- if(cpuutilflag)
- {
- cputime = cputime_so_far() - cputime;
- if (cputime < cputime_res)
- cputime = 0.0;
- child_stat->cputime = cputime;
- walltime = time_so_far() - walltime;
- child_stat->walltime = walltime;
- }
- if(distributed && client_iozone)
- {
- tell_master_stats(THREAD_REREAD_TEST,chid, child_stat->throughput,
- child_stat->actual,
- child_stat->cputime, child_stat->walltime,
- (char)*stop_flag,
- (long long)CHILD_STATE_HOLD);
- }
- child_stat->flag = CHILD_STATE_HOLD; /* Tell parent I'm done */
- if(!include_close)
- {
- if(mmapflag)
- {
- msync(maddr,(size_t)(filebytes64),MS_SYNC);
- mmap_end(maddr,(unsigned long long)filebytes64);
- }else
- fsync(fd);
-#if defined(Windows)
- if(unbuffered)
- CloseHandle(hand);
- else
-#endif
- close(fd);
- }
- if(Q_flag && (thread_rrqfd !=0) )
- fclose(thread_rrqfd);
- free(dummyfile[xx]);
- if(r_traj_flag)
- fclose(r_traj_fd);
- if(debug1)
-#ifdef NO_PRINT_LLD
- printf("\nChild finished %ld\n",xx);
-#else
- printf("\nChild finished %lld\n",xx);
-#endif
-
- if(L_flag)
- {
- get_date(now_string);
- fprintf(thread_Lwqfd,"%-25s %s","Reread test finished: ",now_string);
- fclose(thread_Lwqfd);
- }
- if(hist_summary)
- dump_hist("Reread",(int)xx);
- if(distributed && client_iozone)
- return(0);
-#ifdef NO_THREADS
- exit(0);
-#else
- if(use_thread)
- thread_exit();
- else
- exit(0);
-#endif
-return(0);
-}
-
-/************************************************************************/
-/* Thread_reverse_perf_test */
-/* Reverse read test */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void *
-thread_reverse_read_test(void *x)
-#else
-void *
-thread_reverse_read_test(x)
-#endif
-{
- long long xx,xx2;
- char *nbuff;
- struct child_stats *child_stat;
- int fd;
- long long flags = 0;
- double walltime, cputime;
- double thread_qtime_stop,thread_qtime_start;
- double hist_time;
- double desired_op_rate_time;
- double actual_rate;
- double starttime2 = 0;
- float delay = 0;
- double temp_time;
- double compute_val = (double)0;
- long long recs_per_buffer;
- off64_t i,t_offset;
- off64_t lock_offset=0;
- off64_t current_position=0;
- off64_t written_so_far, reverse_read, re_read_so_far,read_so_far;
- char *dummyfile[MAXSTREAMS]; /* name of dummy file */
- char *maddr=0;
- char *wmaddr=0;
- char now_string[30];
- volatile char *buffer1;
- int anwser,bind_cpu;
- off64_t traj_offset;
- char tmpname[256];
- FILE *thread_revqfd=0;
- FILE *thread_Lwqfd=0;
-#if defined(VXFS) || defined(solaris)
- int test_foo = 0;
-#endif
-#ifdef ASYNC_IO
- struct cache *gc=0;
-#else
- long long *gc=0;
-#endif
- /*****************/
- /* Children only */
- /*****************/
- if(compute_flag)
- delay=compute_time;
- hist_time=thread_qtime_stop=thread_qtime_start=0;
- traj_offset=walltime=cputime=0;
- anwser=bind_cpu=0;
- written_so_far=read_so_far=reverse_read=re_read_so_far=0;
- recs_per_buffer = cache_size/reclen ;
-#ifdef NO_THREADS
- xx=chid;
-#else
- if(use_thread)
- xx = (long long)((long)x);
- else
- {
- xx=chid;
- }
-#endif
-#ifndef NO_THREADS
-#if defined( _HPUX_SOURCE ) || defined ( linux )
- if(ioz_processor_bind)
- {
- bind_cpu=(begin_proc+(int)xx)%num_processors;
-#if defined(_HPUX_SOURCE)
- pthread_processor_bind_np(PTHREAD_BIND_FORCED_NP,
- (pthread_spu_t *)&anwser, (pthread_spu_t)bind_cpu, pthread_self());
-#else
- cpu_set_t cpuset;
-
- CPU_ZERO(&cpuset);
- CPU_SET(bind_cpu, &cpuset);
-
- pthread_setaffinity_np(pthread_self(), sizeof(cpuset),&cpuset);
-#endif
- my_nap(40); /* Switch to new cpu */
- }
-#endif
-#endif
- if(use_thread)
- nbuff=barray[xx];
- else
- nbuff=buffer;
- if(debug1)
- {
- if(use_thread)
-#ifdef NO_PRINT_LLD
- printf("\nStarting child %ld\n",xx);
-#else
- printf("\nStarting child %lld\n",xx);
-#endif
- else
-#ifdef NO_PRINT_LLD
- printf("\nStarting process %d slot %ld\n",getpid(),xx);
-#else
- printf("\nStarting process %d slot %lld\n",getpid(),xx);
-#endif
-
- }
- dummyfile[xx]=(char *)malloc((size_t)MAXNAMESIZE);
- xx2=xx;
- if(share_file)
- xx2=(long long)0;
- if(mfflag)
- {
-#ifdef NO_PRINT_LLD
- sprintf(dummyfile[xx],"%s",filearray[xx2]);
-#else
- sprintf(dummyfile[xx],"%s",filearray[xx2]);
-#endif
- }
- else
- {
-#ifdef NO_PRINT_LLD
- sprintf(dummyfile[xx],"%s.DUMMY.%ld",filearray[xx2],xx2);
-#else
- sprintf(dummyfile[xx],"%s.DUMMY.%lld",filearray[xx2],xx2);
-#endif
- }
- if(oflag)
- flags=O_RDONLY|O_SYNC;
- else
- flags=O_RDONLY;
-#if defined(_HPUX_SOURCE) || defined(linux)
- if(read_sync)
- flags |=O_RSYNC|O_SYNC;
-#endif
-
-#if ! defined(DONT_HAVE_O_DIRECT)
-#if defined(linux) || defined(__AIX__) || defined(IRIX) || defined(IRIX64) || defined(Windows) || defined (__FreeBSD__)
- if(direct_flag)
- flags |=O_DIRECT;
-#endif
-#if defined(TRU64)
- if(direct_flag)
- flags |=O_DIRECTIO;
-#endif
-#endif
-#if defined(Windows)
- if(unbuffered)
- {
- hand=CreateFile(dummyfile[xx],
- GENERIC_READ|GENERIC_WRITE,
- FILE_SHARE_WRITE|FILE_SHARE_READ,
- NULL,OPEN_EXISTING,FILE_FLAG_NO_BUFFERING|
- FILE_FLAG_WRITE_THROUGH|FILE_FLAG_POSIX_SEMANTICS,
- NULL);
- }
-#endif
-
- if((fd = I_OPEN(dummyfile[xx], ((int)flags),0))<0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- perror(dummyfile[xx]);
- exit(140);
- }
-#ifdef ASYNC_IO
- if(async_flag)
- async_init(&gc,fd,direct_flag);
-#endif
-#ifdef VXFS
- if(direct_flag)
- {
- ioctl(fd,VX_SETCACHE,VX_DIRECT);
- ioctl(fd,VX_GETCACHE,&test_foo);
- if(test_foo == 0)
- {
- if(!client_iozone)
- printf("\nVxFS advanced setcache feature not available.\n");
- exit(3);
- }
- }
-#endif
-#if defined(solaris)
- if(direct_flag)
- {
- test_foo = directio(fd, DIRECTIO_ON);
- if(test_foo != 0)
- {
- if(!client_iozone)
- printf("\ndirectio not available.\n");
- exit(3);
- }
- }
-#endif
- if(mmapflag)
- {
- maddr=(char *)initfile(fd,(numrecs64*reclen),0,PROT_READ);
- }
- if(fetchon)
- fetchit(nbuff,reclen);
- if(Q_flag)
- {
- sprintf(tmpname,"Child_%d_revol.dat",(int)xx);
- thread_revqfd=fopen(tmpname,"a");
- if(thread_revqfd==0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- printf("Unable to open %s\n",tmpname);
- exit(40);
- }
- fprintf(thread_revqfd,"Offset in Kbytes Latency in microseconds Transfer size in bytes\n");
- }
- if(L_flag)
- {
- sprintf(tmpname,"Child_%d.log",(int)xx);
- thread_Lwqfd=fopen(tmpname,"a");
- if(thread_Lwqfd==0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- printf("Unable to open %s\n",tmpname);
- exit(40);
- }
- get_date(now_string);
- fprintf(thread_Lwqfd,"%-25s %s","Reverse read start: ",now_string);
- }
- child_stat = (struct child_stats *)&shmaddr[xx];
- child_stat->throughput = 0;
- child_stat->actual = 0;
- child_stat->flag = CHILD_STATE_READY;
- if(distributed && client_iozone)
- {
- tell_master_ready(chid);
- wait_for_master_go(chid);
- }
- else
- {
- while(child_stat->flag!=CHILD_STATE_BEGIN) /* Wait for signal from parent */
- Poll((long long)1);
- }
- starttime2 = time_so_far();
- if(cpuutilflag)
- {
- walltime = starttime2;
- cputime = cputime_so_far();
- }
-
- t_offset = (off64_t)reclen;
- if (!(h_flag || k_flag || mmapflag))
- {
- if(check_filename(dummyfile[xx]))
- {
- if((I_LSEEK( fd, -t_offset, SEEK_END ))<0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- perror("lseek");
- exit(142);
- }
- }
- else
- {
- if(I_LSEEK( fd, (numrecs64*reclen)-t_offset, SEEK_SET )<0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- perror("lseek");
- exit(77);
- }
- }
- }
- current_position=(reclen*numrecs64)-reclen;
- if(file_lock)
- if(mylockf((int) fd, (int) 1, (int)1)!=0)
- printf("File lock for read failed. %d\n",errno);
- for(i=0; i<numrecs64; i++)
- {
- if(rlocking)
- {
- lock_offset=I_LSEEK(fd,0,SEEK_CUR);
- mylockr((int) fd, (int) 1, (int)1,
- lock_offset, reclen);
- }
- if(disrupt_flag && ((i%DISRUPT)==0))
- {
- disrupt(fd);
- }
- if(compute_flag)
- compute_val+=do_compute(delay);
- if(Q_flag)
- {
- traj_offset=I_LSEEK(fd,0,SEEK_CUR);
- }
- if(*stop_flag)
- {
- if(debug1)
- printf("\n(%ld) Stopped by another 3\n", (long)xx);
- break;
- }
- if(purge)
- purgeit(nbuff,reclen);
- if(Q_flag || hist_summary || op_rate_flag)
- {
- thread_qtime_start=time_so_far();
- }
- if(mmapflag)
- {
- wmaddr = &maddr[current_position];
- fill_area((long long*)wmaddr,(long long*)nbuff,(long long)reclen);
- }
- else
- {
- if(async_flag)
- {
- if(no_copy_flag)
- async_read_no_copy(gc, (long long)fd, &buffer1, (current_position),
- reclen, -1LL,(numrecs64*reclen),depth);
- else
- async_read(gc, (long long)fd, nbuff, (current_position),reclen,
- -1LL,(numrecs64*reclen),depth);
- }
- else
- {
- if(read((int)fd, (void*)nbuff, (size_t) reclen) != reclen)
- {
- if(*stop_flag)
- {
- if(debug1)
- printf("\n(%ld) Stopped by another 4\n", (long)xx);
- break;
- }
-#ifdef NO_PRINT_LLD
- printf("\nError reading block %ld\n", i);
-#else
- printf("\nError reading block %lld\n", i);
-#endif
- perror("read");
- if (!no_unlink)
- {
- if(check_filename(dummyfile[xx]))
- unlink(dummyfile[xx]);
- }
- child_stat->flag = CHILD_STATE_HOLD;
- exit(144);
- }
- }
- }
- if(verify){
- if(async_flag && no_copy_flag)
- {
- if(verify_buffer(buffer1,reclen,(off64_t)(current_position/reclen),reclen,(long long)pattern,sverify)){
- if (!no_unlink)
- {
- if(check_filename(dummyfile[xx]))
- unlink(dummyfile[xx]);
- }
- child_stat->flag = CHILD_STATE_HOLD;
- exit(145);
- }
- }
- else
- {
- if(verify_buffer(nbuff,reclen,(off64_t)(current_position/reclen),reclen,(long long)pattern,sverify)){
- if (!no_unlink)
- {
- if(check_filename(dummyfile[xx]))
- unlink(dummyfile[xx]);
- }
- child_stat->flag = CHILD_STATE_HOLD;
- exit(146);
- }
- }
- }
- if(rlocking)
- {
- mylockr((int) fd, (int) 0, (int)1,
- lock_offset, reclen);
- }
- current_position+=reclen;
- if(async_flag && no_copy_flag)
- async_release(gc);
- t_offset = (off64_t)reclen*2;
- if (!(h_flag || k_flag || mmapflag))
- {
- I_LSEEK( fd, -t_offset, SEEK_CUR );
- }
- current_position-=(2 *reclen);
- reverse_read +=reclen/1024;
- if(*stop_flag)
- {
- reverse_read -=reclen/1024;
- }
- if(hist_summary)
- {
- thread_qtime_stop=time_so_far();
- hist_time =(thread_qtime_stop-thread_qtime_start-time_res);
- hist_insert(hist_time);
- }
- if(op_rate_flag)
- {
- thread_qtime_stop=time_so_far();
- desired_op_rate_time = ((double)1.0/(double)op_rate);
- actual_rate = (double)(thread_qtime_stop-thread_qtime_start);
-/*
-printf("Desired rate %g Actual rate %g Nap %g microseconds\n",desired_op_rate_time,
- actual_rate, (desired_op_rate_time-actual_rate));
-*/
- if( actual_rate < desired_op_rate_time)
- my_unap((unsigned long long) ((desired_op_rate_time-actual_rate)*1000000.0 ));
- }
- if(Q_flag)
- {
- thread_qtime_stop=time_so_far();
-#ifdef NO_PRINT_LLD
- fprintf(thread_revqfd,"%10.1ld %10.0f %10.1ld\n",(traj_offset)/1024,((thread_qtime_stop-thread_qtime_start-time_res))*1000000,reclen);
-#else
- fprintf(thread_revqfd,"%10.1lld %10.0f %10.1lld\n",(traj_offset)/1024,((thread_qtime_stop-thread_qtime_start-time_res))*1000000,reclen);
-#endif
- }
- }
- if(file_lock)
- if(mylockf((int) fd,(int)0, (int)1))
- printf("Read unlock failed %d\n",errno);
-#ifdef ASYNC_IO
- if(async_flag)
- {
- end_async(gc);
- gc=0;
- }
-#endif
- if(include_flush)
- {
- if(mmapflag)
- {
- msync(maddr,(size_t)(numrecs64*reclen),MS_SYNC);
- }else
- fsync(fd);
- }
- if(include_close)
- {
- if(mmapflag)
- {
- mmap_end(maddr,(unsigned long long)numrecs64*reclen);
- }
- close(fd);
- }
- temp_time = time_so_far();
- child_stat->throughput = ((temp_time - starttime2)-time_res)
- -compute_val;
- if(child_stat->throughput < (double).000001)
- {
- child_stat->throughput= time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
- if(OPS_flag){
- reverse_read=(reverse_read*1024)/reclen;
- }
- child_stat->throughput = reverse_read/child_stat->throughput;
- child_stat->actual = reverse_read;
- if(!xflag)
- {
- *stop_flag=1;
- if(distributed && client_iozone)
- send_stop();
- }
- if(cpuutilflag)
- {
- cputime = cputime_so_far() - cputime;
- if (cputime < cputime_res)
- cputime = 0.0;
- child_stat->cputime = cputime;
- walltime = time_so_far() - walltime;
- child_stat->walltime = walltime;
- }
- if(distributed && client_iozone)
- tell_master_stats(THREAD_REVERSE_READ_TEST, chid, child_stat->throughput,
- child_stat->actual,
- child_stat->cputime, child_stat->walltime,
- (char)*stop_flag,
- (long long)CHILD_STATE_HOLD);
- child_stat->flag = CHILD_STATE_HOLD; /* Tell parent I'm done */
- if(!include_close)
- {
- if(mmapflag)
- {
- msync(maddr,(size_t)(numrecs64*reclen),MS_SYNC);
- mmap_end(maddr,(unsigned long long)numrecs64*reclen);
- }else
- fsync(fd);
- close(fd);
- }
- free(dummyfile[xx]);
- if(Q_flag && (thread_revqfd !=0) )
- fclose(thread_revqfd);
- if(debug1)
-#ifdef NO_PRINT_LLD
- printf("\nChild finished %ld\n",xx);
-#else
- printf("\nChild finished %lld\n",xx);
-#endif
-
- if(L_flag)
- {
- get_date(now_string);
- fprintf(thread_Lwqfd,"%-25s %s","Reverse read finished: ",
- now_string);
- fclose(thread_Lwqfd);
- }
- if(hist_summary)
- dump_hist("Read Backwards",(int)xx);
- if(distributed && client_iozone)
- return(0);
-#ifdef NO_THREADS
- exit(0);
-#else
- if(use_thread)
- thread_exit();
- else
- exit(0);
-#endif
-return(0);
-}
-/************************************************************************/
-/* Thread_stride_read_test */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void *
-thread_stride_read_test(void *x)
-#else
-void *
-thread_stride_read_test(x)
-#endif
-{
- long long xx,xx2;
- char *nbuff=0;
- struct child_stats *child_stat;
- double walltime, cputime;
- int fd;
- long long flags = 0;
- double thread_qtime_stop,thread_qtime_start;
- double hist_time;
- double desired_op_rate_time;
- double actual_rate;
- double starttime2 = 0;
- float delay = 0;
- double compute_val = (double)0;
- double temp_time;
- long long recs_per_buffer;
- off64_t i;
- off64_t lock_offset=0;
- off64_t savepos64=0;
- off64_t written_so_far, stride_read,re_read_so_far,read_so_far;
- off64_t stripewrap = 0;
- off64_t current_position = 0;
- char *dummyfile[MAXSTREAMS]; /* name of dummy file */
- char *maddr=0;
- char *wmaddr=0;
- volatile char *buffer1;
- int anwser,bind_cpu;
- off64_t traj_offset;
- char tmpname[256];
- char now_string[30];
- FILE *thread_strqfd=0;
- FILE *thread_Lwqfd=0;
-#if defined(VXFS) || defined(solaris)
- int test_foo = 0;
-#endif
-#ifdef ASYNC_IO
- struct cache *gc=0;
-#else
- long long *gc=0;
-#endif
- /*****************/
- /* Children only */
- /*****************/
- if(compute_flag)
- delay=compute_time;
- hist_time=thread_qtime_stop=thread_qtime_start=0;
- traj_offset=walltime=cputime=0;
- anwser=bind_cpu=0;
- written_so_far=read_so_far=stride_read=re_read_so_far=0;
- recs_per_buffer = cache_size/reclen ;
-#ifdef NO_THREADS
- xx=chid;
-#else
- if(use_thread)
- xx = (long long)((long)x);
- else
- {
- xx=chid;
- }
-#endif
-#ifndef NO_THREADS
-#if defined( _HPUX_SOURCE ) || defined ( linux )
- if(ioz_processor_bind)
- {
- bind_cpu=(begin_proc+(int)xx)%num_processors;
-#if defined(_HPUX_SOURCE)
- pthread_processor_bind_np(PTHREAD_BIND_FORCED_NP,
- (pthread_spu_t *)&anwser, (pthread_spu_t)bind_cpu, pthread_self());
-#else
- cpu_set_t cpuset;
-
- CPU_ZERO(&cpuset);
- CPU_SET(bind_cpu, &cpuset);
-
- pthread_setaffinity_np(pthread_self(), sizeof(cpuset),&cpuset);
-#endif
- my_nap(40); /* Switch to new cpu */
- }
-#endif
-#endif
- if(use_thread)
- nbuff=barray[xx];
- else
- nbuff=buffer;
- if(debug1)
- {
- if(use_thread)
-#ifdef NO_PRINT_LLD
- printf("\nStarting child %ld\n",xx);
-#else
- printf("\nStarting child %lld\n",xx);
-#endif
- else
-#ifdef NO_PRINT_LLD
- printf("\nStarting process %d slot %ld\n",getpid(),xx);
-#else
- printf("\nStarting process %d slot %lld\n",getpid(),xx);
-#endif
-
- }
- dummyfile[xx]=(char *)malloc((size_t)MAXNAMESIZE);
- xx2=xx;
- if(share_file)
- xx2=(long long)0;
- if(mfflag)
- {
-#ifdef NO_PRINT_LLD
- sprintf(dummyfile[xx],"%s",filearray[xx2]);
-#else
- sprintf(dummyfile[xx],"%s",filearray[xx2]);
-#endif
- }
- else
- {
-#ifdef NO_PRINT_LLD
- sprintf(dummyfile[xx],"%s.DUMMY.%ld",filearray[xx2],xx2);
-#else
- sprintf(dummyfile[xx],"%s.DUMMY.%lld",filearray[xx2],xx2);
-#endif
- }
- if(oflag)
- flags=O_RDONLY|O_SYNC;
- else
- flags=O_RDONLY;
-#if defined(_HPUX_SOURCE) || defined(linux)
- if(read_sync)
- flags |=O_RSYNC|O_SYNC;
-#endif
-#if ! defined(DONT_HAVE_O_DIRECT)
-#if defined(linux) || defined(__AIX__) || defined(IRIX) || defined(IRIX64) || defined(Windows) || defined (__FreeBSD__)
- if(direct_flag)
- flags |=O_DIRECT;
-#endif
-#if defined(TRU64)
- if(direct_flag)
- flags |=O_DIRECTIO;
-#endif
-#endif
-
-#if defined(Windows)
- if(unbuffered)
- {
- hand=CreateFile(dummyfile[xx],
- GENERIC_READ|GENERIC_WRITE,
- FILE_SHARE_WRITE|FILE_SHARE_READ,
- NULL,OPEN_EXISTING,FILE_FLAG_NO_BUFFERING|
- FILE_FLAG_WRITE_THROUGH|FILE_FLAG_POSIX_SEMANTICS,
- NULL);
- }
-#endif
- if((fd = I_OPEN(dummyfile[xx], ((int)flags),0))<0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- perror(dummyfile[xx]);
- exit(147);
- }
-#ifdef ASYNC_IO
- if(async_flag)
- async_init(&gc,fd,direct_flag);
-#endif
-#ifdef VXFS
- if(direct_flag)
- {
- ioctl(fd,VX_SETCACHE,VX_DIRECT);
- ioctl(fd,VX_GETCACHE,&test_foo);
- if(test_foo == 0)
- {
- if(!client_iozone)
- printf("\nVxFS advanced setcache feature not available.\n");
- exit(3);
- }
- }
-#endif
-#if defined(solaris)
- if(direct_flag)
- {
- test_foo = directio(fd, DIRECTIO_ON);
- if(test_foo != 0)
- {
- if(!client_iozone)
- printf("\ndirectio not available.\n");
- exit(3);
- }
- }
-#endif
-
- if(mmapflag)
- {
- maddr=(char *)initfile(fd,(numrecs64*reclen),0,PROT_READ);
- }
- if(fetchon)
- fetchit(nbuff,reclen);
- if(Q_flag)
- {
- sprintf(tmpname,"Child_%d_strol.dat",(int)xx);
- thread_strqfd=fopen(tmpname,"a");
- if(thread_strqfd==0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- printf("Unable to open %s\n",tmpname);
- exit(40);
- }
- fprintf(thread_strqfd,"Offset in Kbytes Latency in microseconds Transfer size in bytes\n");
- }
- if(L_flag)
- {
- sprintf(tmpname,"Child_%d.log",(int)xx);
- thread_Lwqfd=fopen(tmpname,"a");
- if(thread_Lwqfd==0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- printf("Unable to open %s\n",tmpname);
- exit(40);
- }
- get_date(now_string);
- fprintf(thread_Lwqfd,"%-25s %s","Stride test start: ",
- now_string);
- }
- child_stat = (struct child_stats *)&shmaddr[xx];
- child_stat->throughput = 0;
- child_stat->actual = 0;
- child_stat->flag = CHILD_STATE_READY;
- if(distributed && client_iozone)
- {
- tell_master_ready(chid);
- wait_for_master_go(chid);
- }
- else
-
- /* wait for parent to say go */
- while(child_stat->flag!=CHILD_STATE_BEGIN)
- Poll((long long)1);
- if(file_lock)
- if(mylockf((int) fd, (int) 1, (int)1)!=0)
- printf("File lock for write failed. %d\n",errno);
- starttime2 = time_so_far();
- if(cpuutilflag)
- {
- walltime = starttime2;
- cputime = cputime_so_far();
- }
- for(i=0; i<numrecs64; i++){
- if(disrupt_flag && ((i%DISRUPT)==0))
- {
- disrupt(fd);
- }
- if(compute_flag)
- compute_val+=do_compute(delay);
- if(Q_flag)
- {
- traj_offset=I_LSEEK(fd,0,SEEK_CUR);
- }
- if(rlocking)
- {
- lock_offset=I_LSEEK(fd,0,SEEK_CUR);
- mylockr((int) fd, (int) 1, (int)1,
- lock_offset, reclen);
- }
- if(*stop_flag)
- {
- if(debug1)
- printf("\n(%ld) Stopped by another 3\n", (long)xx);
- break;
- }
- if(purge)
- purgeit(nbuff,reclen);
- if(Q_flag || hist_summary || op_rate_flag)
- {
- thread_qtime_start=time_so_far();
- }
- if(verify)
- savepos64=current_position/(off64_t)reclen;
- if(mmapflag)
- {
- wmaddr = &maddr[current_position];
- fill_area((long long*)wmaddr,(long long*)nbuff,(long long)reclen);
- }
- else
- {
- if(async_flag)
- {
- if(no_copy_flag)
- async_read_no_copy(gc, (long long)fd, &buffer1, (current_position),
- reclen, stride,(numrecs64*reclen),depth);
- else
- async_read(gc, (long long)fd, nbuff, (current_position),reclen,
- stride,(numrecs64*reclen),depth);
- }
- else
- {
- if(read((int)fd, (void*)nbuff, (size_t) reclen) != reclen)
- {
- if(*stop_flag)
- {
- if(debug1)
- printf("\n(%ld) Stopped by another 4\n", (long)xx);
- break;
- }
-#ifdef NO_PRINT_LLD
- printf("\nError reading block %ld, fd= %d\n", i, fd);
-#else
- printf("\nError reading block %lld, fd= %d\n", i, fd);
-#endif
- perror("read");
- if (!no_unlink)
- {
- if(check_filename(dummyfile[xx]))
- unlink(dummyfile[xx]);
- }
- child_stat->flag = CHILD_STATE_HOLD;
- exit(149);
- }
- }
- }
- if(rlocking)
- {
- mylockr((int) fd, (int) 0, (int)1,
- lock_offset, reclen);
- }
- current_position+=reclen;
- if(verify){
- if(async_flag && no_copy_flag)
- {
- if(verify_buffer(buffer1,reclen,(off64_t)savepos64,reclen,(long long)pattern,sverify)){
- if (!no_unlink)
- {
- if(check_filename(dummyfile[xx]))
- unlink(dummyfile[xx]);
- }
- child_stat->flag = CHILD_STATE_HOLD;
- exit(150);
- }
- }
- else
- {
- if(verify_buffer(nbuff,reclen,(off64_t)savepos64,reclen,(long long)pattern,sverify)){
- if (!no_unlink)
- {
- if(check_filename(dummyfile[xx]))
- unlink(dummyfile[xx]);
- }
- child_stat->flag = CHILD_STATE_HOLD;
- exit(151);
- }
- }
- }
- if(async_flag && no_copy_flag)
- async_release(gc);
- if(current_position + (stride * reclen) >= (numrecs64 * reclen)-reclen)
- {
- current_position=0;
-
- stripewrap++;
-
- if(numrecs64 <= stride)
- {
- current_position=0;
- }
- else
- {
- current_position = (off64_t)((stripewrap)%numrecs64)*reclen;
- }
- if (!(h_flag || k_flag || mmapflag))
- {
- if(I_LSEEK(fd,current_position,SEEK_SET)<0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- perror("lseek");
- exit(152);
- }
- }
- }
- else
- {
- current_position+=(stride*reclen)-reclen;
- if (!(h_flag || k_flag || mmapflag))
- {
- if(I_LSEEK(fd,current_position,SEEK_SET)<0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- perror("lseek");
- exit(154);
- };
- }
- }
- stride_read +=reclen/1024;
- if(*stop_flag)
- {
- stride_read -=reclen/1024;
- }
- if(hist_summary)
- {
- thread_qtime_stop=time_so_far();
- hist_time =(thread_qtime_stop-thread_qtime_start-time_res);
- hist_insert(hist_time);
- }
- if(op_rate_flag)
- {
- thread_qtime_stop=time_so_far();
- desired_op_rate_time = ((double)1.0/(double)op_rate);
- actual_rate = (double)(thread_qtime_stop-thread_qtime_start);
-/*
-printf("Desired rate %g Actual rate %g Nap %g microseconds\n",desired_op_rate_time,
- actual_rate, (desired_op_rate_time-actual_rate));
-*/
- if( actual_rate < desired_op_rate_time)
- my_unap((unsigned long long) ((desired_op_rate_time-actual_rate)*1000000.0 ));
- }
- if(Q_flag)
- {
- thread_qtime_stop=time_so_far();
-#ifdef NO_PRINT_LLD
- fprintf(thread_strqfd,"%10.1ld %10.0f %10.1ld\n",(traj_offset)/1024,((thread_qtime_stop-thread_qtime_start-time_res))*1000000,reclen);
-#else
- fprintf(thread_strqfd,"%10.1lld %10.0f %10.1lld\n",(traj_offset)/1024,((thread_qtime_stop-thread_qtime_start-time_res))*1000000,reclen);
-#endif
- }
- }
- if(file_lock)
- if(mylockf((int) fd,(int)0,(int)1))
- printf("Read unlock failed %d\n",errno);
-#ifdef ASYNC_IO
- if(async_flag)
- {
- end_async(gc);
- gc=0;
- }
-#endif
- if(include_flush)
- {
- if(mmapflag)
- {
- msync(maddr,(size_t)(numrecs64*reclen),MS_SYNC);
- }else
- fsync(fd);
- }
- if(include_close)
- {
- if(mmapflag)
- {
- mmap_end(maddr,(unsigned long long)numrecs64*reclen);
- }
- close(fd);
- }
- temp_time = time_so_far();
- child_stat->throughput = ((temp_time - starttime2)-time_res)
- -compute_val;
- if(child_stat->throughput < (double).000001)
- {
- child_stat->throughput= time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
- if(OPS_flag){
- stride_read=(stride_read*1024)/reclen;
- }
- child_stat->throughput = stride_read/child_stat->throughput;
- child_stat->actual = stride_read;
- if(!xflag)
- {
- *stop_flag=1;
- if(distributed && client_iozone)
- send_stop();
- }
- if(cpuutilflag)
- {
- cputime = cputime_so_far() - cputime;
- if (cputime < cputime_res)
- cputime = 0.0;
- child_stat->cputime = cputime;
- walltime = time_so_far() - walltime;
- child_stat->walltime = walltime;
- }
- if(distributed && client_iozone)
- {
- tell_master_stats(THREAD_STRIDE_TEST,chid, child_stat->throughput,
- child_stat->actual,
- child_stat->cputime, child_stat->walltime,
- (char)*stop_flag,
- (long long)CHILD_STATE_HOLD);
- }
- child_stat->flag = CHILD_STATE_HOLD; /* Tell parent I'm done */
- if(!include_close)
- {
- if(mmapflag)
- {
- msync(maddr,(size_t)(numrecs64*reclen),MS_SYNC);
- mmap_end(maddr,(unsigned long long)numrecs64*reclen);
- }else
- fsync(fd);
- close(fd);
- }
- if(Q_flag && (thread_strqfd !=0) )
- fclose(thread_strqfd);
- free(dummyfile[xx]);
- if(debug1)
-#ifdef NO_PRINT_LLD
- printf("\nChild finished %ld\n",xx);
-#else
- printf("\nChild finished %lld\n",xx);
-#endif
-
- if(L_flag)
- {
- get_date(now_string);
- fprintf(thread_Lwqfd,"%-25s %s","Stride test finished: ",
- now_string);
- fclose(thread_Lwqfd);
- }
- if(hist_summary)
- dump_hist("Stride Read",(int)xx);
- if(distributed && client_iozone)
- return(0);
-#ifdef NO_THREADS
- exit(0);
-#else
- if(use_thread)
- thread_exit();
- else
- exit(0);
-#endif
-return(0);
-}
-
-/************************************************************************/
-/* Thread random test */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void *
-thread_mix_test(void *x)
-#else
-void *
-thread_mix_test(x)
-#endif
-{
- int selector;
- int num_readers;
- long xx;
-
-#ifdef NO_THREADS
- xx=chid;
-#else
- if(use_thread)
- {
- xx = (long)x;
- }
- else
- {
- xx=(long)chid;
- }
-#endif
- if(pct_read!=0)
- {
- num_readers = (pct_read * num_child)/100;
- if(xx < num_readers)
- selector=0;
- else
- selector=1;
- }
- else
- {
- if(Kplus_flag)
- {
- if(xx+1 <= Kplus_readers)
- selector=0;
- else
- selector=1;
- }
- else
- {
- /* Simple round robin */
- selector= ((int)xx) % 2;
- }
- }
- if(selector==0)
- {
- if(seq_mix)
- thread_read_test(x);
- else
- thread_ranread_test(x);
- }
- else
- {
- if(seq_mix)
- thread_write_test(x);
- else
- thread_ranwrite_test(x);
- }
- return(0);
-}
-/************************************************************************/
-/* Thread random read test */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void *
-thread_ranread_test(void *x)
-#else
-void *
-thread_ranread_test(x)
-#endif
-{
- long long xx,xx2;
- struct child_stats *child_stat;
- double walltime, cputime;
- int fd;
- long long flags = 0;
- double thread_qtime_stop,thread_qtime_start;
- double hist_time;
- double desired_op_rate_time;
- double actual_rate;
- double starttime1 = 0;
- float delay = 0;
- double temp_time;
- double compute_val = (double)0;
- off64_t written_so_far, ranread_so_far, re_written_so_far,re_read_so_far;
- long long recs_per_buffer;
- off64_t current_offset=0;
- off64_t i;
- char *dummyfile[MAXSTREAMS]; /* name of dummy file */
- char *nbuff=0;
- char *maddr=0;
- char *wmaddr=0;
- volatile char *buffer1;
- int anwser,bind_cpu;
- off64_t traj_offset;
- off64_t lock_offset=0;
- char tmpname[256];
- char now_string[30];
- FILE *thread_randrfd=0;
- FILE *thread_Lwqfd=0;
- long long *recnum=0;
-#if defined(VXFS) || defined(solaris)
- int test_foo = 0;
-#endif
- long long save_pos;
-#if defined (bsd4_2) || defined(Windows)
- long long rand1,rand2,rand3;
-#endif
- unsigned long long big_rand;
-#ifdef ASYNC_IO
- struct cache *gc=0;
-#else
- long long *gc=0;
-#endif
-#ifdef MERSENNE
- unsigned long long init[4]={0x12345ULL, 0x23456ULL, 0x34567ULL, 0x45678ULL}, length=4;
-#endif
-
-#ifdef MERSENNE
- init_by_array64(init, length);
-#else
-#ifdef bsd4_2
- srand(0);
-#else
-#ifdef Windows
- srand(0);
-#else
- srand48(0);
-#endif
-#endif
-#endif
- recnum = (long long *)malloc(sizeof(*recnum)*numrecs64);
- if (recnum){
- /* pre-compute random sequence based on
- Fischer-Yates (Knuth) card shuffle */
- for(i = 0; i < numrecs64; i++){
- recnum[i] = i;
- }
- for(i = 0; i < numrecs64; i++) {
- long long tmp = recnum[i];
-#ifdef MERSENNE
- big_rand = genrand64_int64();
-#else
-#ifdef bsd4_2
- rand1=(long long)rand();
- rand2=(long long)rand();
- rand3=(long long)rand();
- big_rand=(rand1<<32)|(rand2<<16)|(rand3);
-#else
-#ifdef Windows
- rand1=(long long)rand();
- rand2=(long long)rand();
- rand3=(long long)rand();
- big_rand=(rand1<<32)|(rand2<<16)|(rand3);
-#else
- big_rand = lrand48();
-#endif
-#endif
-#endif
- big_rand = big_rand%numrecs64;
- tmp = recnum[i];
- recnum[i] = recnum[big_rand];
- recnum[big_rand] = tmp;
- }
- }
- else
- {
- fprintf(stderr,"Random uniqueness fallback.\n");
- }
- if(compute_flag)
- delay=compute_time;
- hist_time=thread_qtime_stop=thread_qtime_start=0;
- traj_offset=walltime=cputime=0;
- anwser=bind_cpu=0;
- written_so_far=ranread_so_far=re_written_so_far=re_read_so_far=0;
- recs_per_buffer = cache_size/reclen ;
-#ifdef NO_THREADS
- xx=chid;
-#else
- if(use_thread)
- xx = (long long)((long)x);
- else
- {
- xx=chid;
- }
-#endif
-#ifndef NO_THREADS
-#if defined( _HPUX_SOURCE ) || defined ( linux )
- if(ioz_processor_bind)
- {
- bind_cpu=(begin_proc+(int)xx)%num_processors;
-#if defined(_HPUX_SOURCE)
- pthread_processor_bind_np(PTHREAD_BIND_FORCED_NP,
- (pthread_spu_t *)&anwser, (pthread_spu_t)bind_cpu, pthread_self());
-#else
- cpu_set_t cpuset;
-
- CPU_ZERO(&cpuset);
- CPU_SET(bind_cpu, &cpuset);
-
- pthread_setaffinity_np(pthread_self(), sizeof(cpuset),&cpuset);
-#endif
- my_nap(40); /* Switch to new cpu */
- }
-#endif
-#endif
- if(use_thread)
- nbuff=barray[xx];
- else
- nbuff=buffer;
- dummyfile[xx]=(char *)malloc((size_t)MAXNAMESIZE);
- xx2=xx;
- if(share_file)
- xx2=(long long)0;
- if(mfflag)
- {
-#ifdef NO_PRINT_LLD
- sprintf(dummyfile[xx],"%s",filearray[xx2]);
-#else
- sprintf(dummyfile[xx],"%s",filearray[xx2]);
-#endif
- }
- else
- {
-#ifdef NO_PRINT_LLD
- sprintf(dummyfile[xx],"%s.DUMMY.%ld",filearray[xx2],xx2);
-#else
- sprintf(dummyfile[xx],"%s.DUMMY.%lld",filearray[xx2],xx2);
-#endif
- }
- if(oflag)
- {
- flags=O_RDONLY|O_SYNC;
- }
- else
- flags=O_RDONLY;
-#if defined(_HPUX_SOURCE) || defined(linux)
- if(read_sync)
- flags |=O_RSYNC|O_SYNC;
-#endif
-
-#if ! defined(DONT_HAVE_O_DIRECT)
-#if defined(linux) || defined(__AIX__) || defined(IRIX) || defined(IRIX64) || defined(Windows) || defined (__FreeBSD__)
- if(direct_flag)
- flags |=O_DIRECT;
-#endif
-#if defined(TRU64)
- if(direct_flag)
- flags |=O_DIRECTIO;
-#endif
-#endif
-
-#if defined(Windows)
- if(unbuffered)
- {
- hand=CreateFile(dummyfile[xx],
- GENERIC_READ|GENERIC_WRITE,
- FILE_SHARE_WRITE|FILE_SHARE_READ,
- NULL,OPEN_EXISTING,FILE_FLAG_NO_BUFFERING|
- FILE_FLAG_WRITE_THROUGH|FILE_FLAG_POSIX_SEMANTICS,
- NULL);
- }
-#endif
- if((fd = I_OPEN(dummyfile[xx], ((int)flags),0))<0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- perror(dummyfile[xx]);
- exit(156);
- }
-#ifdef ASYNC_IO
- if(async_flag)
- async_init(&gc,fd,direct_flag);
-#endif
-
-#ifdef VXFS
- if(direct_flag)
- {
- ioctl(fd,VX_SETCACHE,VX_DIRECT);
- ioctl(fd,VX_GETCACHE,&test_foo);
- if(test_foo == 0)
- {
- if(!client_iozone)
- printf("\nVxFS advanced setcache feature not available.\n");
- exit(3);
- }
- }
-#endif
-#if defined(solaris)
- if(direct_flag)
- {
- test_foo = directio(fd, DIRECTIO_ON);
- if(test_foo != 0)
- {
- if(!client_iozone)
- printf("\ndirectio not available.\n");
- exit(3);
- }
- }
-#endif
-
- if(mmapflag)
- {
- maddr=(char *)initfile(fd,(numrecs64*reclen),0,PROT_READ);
- }
- child_stat = (struct child_stats *)&shmaddr[xx];
- child_stat->throughput = 0;
- child_stat->actual = 0;
- if(debug1)
- {
- if(use_thread)
-#ifdef NO_PRINT_LLD
- printf("\nStarting child %ld\n",xx);
-#else
- printf("\nStarting child %lld\n",xx);
-#endif
- else
-#ifdef NO_PRINT_LLD
- printf("\nStarting process %d slot %ld\n",getpid(),xx);
-#else
- printf("\nStarting process %d slot %lld\n",getpid(),xx);
-#endif
-
- }
- /*****************/
- /* Children only */
- /*****************/
- if(fetchon)
- fetchit(nbuff,reclen);
- if(Q_flag)
- {
- sprintf(tmpname,"Child_%d_randrol.dat",(int)xx);
- thread_randrfd=fopen(tmpname,"a");
- if(thread_randrfd==0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- printf("Unable to open %s\n",tmpname);
- exit(40);
- }
- fprintf(thread_randrfd,"Offset in Kbytes Latency in microseconds Transfer size in bytes\n");
- }
- if(L_flag)
- {
- sprintf(tmpname,"Child_%d.log",(int)xx);
- thread_Lwqfd=fopen(tmpname,"a");
- if(thread_Lwqfd==0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- printf("Unable to open %s\n",tmpname);
- exit(40);
- }
- get_date(now_string);
- fprintf(thread_Lwqfd,"%-25s %s","Random read start: ",
- now_string);
- }
- child_stat=(struct child_stats *)&shmaddr[xx];
- child_stat->flag = CHILD_STATE_READY;
- if(distributed && client_iozone)
- {
- tell_master_ready(chid);
- wait_for_master_go(chid);
- }
- else
- {
- while(child_stat->flag!=CHILD_STATE_BEGIN) /* Wait for signal from parent */
- Poll((long long)1);
- }
- starttime1 = time_so_far();
- if(cpuutilflag)
- {
- walltime = starttime1;
- cputime = cputime_so_far();
- }
-
-#ifdef MERSENNE
- init_by_array64(init, length);
-#else
-#ifdef bsd4_2
- srand(0);
-#else
-#ifdef Windows
- srand(0);
-#else
- srand48(0);
-#endif
-#endif
-#endif
- if(file_lock)
- if(mylockf((int) fd, (int) 1, (int)1)!=0)
- printf("File lock for read failed. %d\n",errno);
- for(i=0; i<numrecs64; i++) {
- if(compute_flag)
- compute_val+=do_compute(delay);
- if(*stop_flag)
- {
- if(debug1)
- printf("\n(%ld) Stopped by another 2\n", (long)xx);
- break;
- }
- if(purge)
- purgeit(nbuff,reclen);
- if (recnum) {
- current_offset = reclen * (long long)recnum[i];
- } else {
-#ifdef MERSENNE
- big_rand = genrand64_int64();
- current_offset = (off64_t)reclen * (big_rand%numrecs64);
-#else
-#ifdef bsd4_2
- rand1=(long long)rand();
- rand2=(long long)rand();
- rand3=(long long)rand();
- big_rand=(rand1<<32)|(rand2<<16)|(rand3);
- current_offset = (off64_t)reclen * (big_rand%numrecs64);
-#else
-#ifdef Windows
- rand1=(long long)rand();
- rand2=(long long)rand();
- rand3=(long long)rand();
- big_rand=(rand1<<32)|(rand2<<16)|(rand3);
- current_offset = (off64_t)reclen * (big_rand%numrecs64);
-#else
- current_offset = reclen * (lrand48()%numrecs64);
-#endif
-#endif
-#endif
- }
-
- if (!(h_flag || k_flag || mmapflag))
- {
- if(I_LSEEK( fd, current_offset, SEEK_SET )<0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- perror("lseek");
- exit(158);
- };
- }
- if(rlocking)
- {
- lock_offset=I_LSEEK(fd,0,SEEK_CUR);
- mylockr((int) fd, (int) 1, (int)1,
- lock_offset, reclen);
- }
- if(Q_flag || hist_summary || op_rate_flag)
- {
- traj_offset=I_LSEEK(fd,0,SEEK_CUR);
- thread_qtime_start=time_so_far();
- }
- if(mmapflag)
- {
- wmaddr = &maddr[current_offset];
- fill_area((long long*)wmaddr,(long long*)nbuff,(long long)reclen);
- }
- else
- {
- if(async_flag)
- {
- if(no_copy_flag)
- async_read_no_copy(gc, (long long)fd, &buffer1, (current_offset),
- reclen, 0LL,(numrecs64*reclen),depth);
- else
- async_read(gc, (long long)fd, nbuff, (current_offset), reclen,
- 0LL,(numrecs64*reclen),depth);
- }
- else
- {
- if(read((int)fd, (void*)nbuff, (size_t)reclen) != reclen)
- {
- if(*stop_flag)
- {
- if(debug1)
- printf("\n(%ld) Stopped by another 2\n", (long)xx);
- break;
- }
-#ifdef NO_PRINT_LLD
- printf("\nError reading block at %ld\n",
- offset);
-#else
- printf("\nError reading block at %lld\n",
- offset);
-#endif
- perror("ranread");
- if (!no_unlink)
- {
- if(check_filename(dummyfile[xx]))
- unlink(dummyfile[xx]);
- }
- child_stat->flag = CHILD_STATE_HOLD;
- exit(160);
- }
- }
- }
- if(rlocking)
- {
- mylockr((int) fd, (int) 0, (int)1,
- lock_offset, reclen);
- }
- save_pos=current_offset/reclen;
- current_offset+=reclen;
- if(verify){
- if(async_flag && no_copy_flag)
- {
- if(verify_buffer(buffer1,reclen,(off64_t)save_pos,reclen,(long long)pattern,sverify)){
- if (!no_unlink)
- {
- if(check_filename(dummyfile[xx]))
- unlink(dummyfile[xx]);
- }
- child_stat->flag = CHILD_STATE_HOLD;
- exit(161);
- }
- }
- else
- {
- if(verify_buffer(nbuff,reclen,(off64_t)save_pos,reclen,(long long)pattern,sverify)){
- if (!no_unlink)
- {
- if(check_filename(dummyfile[xx]))
- unlink(dummyfile[xx]);
- }
- child_stat->flag = CHILD_STATE_HOLD;
- exit(162);
- }
- }
- }
- if(async_flag && no_copy_flag)
- async_release(gc);
- ranread_so_far+=reclen/1024;
- if(*stop_flag)
- {
- ranread_so_far-=reclen/1024;
- }
- if(hist_summary)
- {
- thread_qtime_stop=time_so_far();
- hist_time =(thread_qtime_stop-thread_qtime_start-time_res);
- hist_insert(hist_time);
- }
- if(op_rate_flag)
- {
- thread_qtime_stop=time_so_far();
- desired_op_rate_time = ((double)1.0/(double)op_rate);
- actual_rate = (double)(thread_qtime_stop-thread_qtime_start);
-/*
-printf("Desired rate %g Actual rate %g Nap %g microseconds\n",desired_op_rate_time,
- actual_rate, (desired_op_rate_time-actual_rate));
-*/
- if( actual_rate < desired_op_rate_time)
- my_unap((unsigned long long) ((desired_op_rate_time-actual_rate)*1000000.0 ));
- }
- if(Q_flag)
- {
- thread_qtime_stop=time_so_far();
-#ifdef NO_PRINT_LLD
- fprintf(thread_randrfd,"%10.1ld %10.0f %10.1ld\n",(traj_offset)/1024,((thread_qtime_stop-thread_qtime_start-time_res))*1000000,reclen);
-#else
- fprintf(thread_randrfd,"%10.1lld %10.0f %10.1lld\n",(traj_offset)/1024,((thread_qtime_stop-thread_qtime_start-time_res))*1000000,reclen);
-#endif
- }
- }
- if(file_lock)
- if(mylockf((int) fd,(int)0,(int)1))
- printf("Read unlock failed %d\n",errno);
-#ifdef ASYNC_IO
- if(async_flag)
- {
- end_async(gc);
- gc=0;
- }
-#endif
- if(include_flush)
- {
- if(mmapflag)
- {
- msync(maddr,(size_t)(numrecs64*reclen),MS_SYNC);
- }else
- fsync(fd);
- }
- if(include_close)
- {
- if(mmapflag)
- {
- mmap_end(maddr,(unsigned long long)numrecs64*reclen);
- }
- close(fd);
- }
- temp_time = time_so_far();
- child_stat=(struct child_stats *)&shmaddr[xx];
- child_stat->throughput = ((temp_time - starttime1)-time_res)
- -compute_val;
- if(child_stat->throughput < (double).000001)
- {
- child_stat->throughput= time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
- if(OPS_flag){
- ranread_so_far=(ranread_so_far*1024)/reclen;
- }
- child_stat->throughput = ranread_so_far/child_stat->throughput;
- child_stat->actual = ranread_so_far;
- if(!xflag)
- {
- *stop_flag=1;
- if(distributed && client_iozone)
- send_stop();
- }
- if(cdebug)
- {
- fprintf(newstdout,"Child %d: throughput %f actual %f \n",(int)chid,child_stat->throughput,
- child_stat->actual);
- fflush(newstdout);
- }
- if(cpuutilflag)
- {
- cputime = cputime_so_far() - cputime;
- if (cputime < cputime_res)
- cputime = 0.0;
- child_stat->cputime = cputime;
- walltime = time_so_far() - walltime;
- child_stat->walltime = walltime;
- }
- if(distributed && client_iozone)
- tell_master_stats(THREAD_RANDOM_READ_TEST, chid, child_stat->throughput,
- child_stat->actual,
- child_stat->cputime, child_stat->walltime,
- (char)*stop_flag,
- (long long)CHILD_STATE_HOLD);
- child_stat->flag = CHILD_STATE_HOLD; /* Tell parent I'm done */
- if(!include_close)
- {
- if(mmapflag)
- {
- msync(maddr,(size_t)(numrecs64*reclen),MS_SYNC);
- mmap_end(maddr,(unsigned long long)numrecs64*reclen);
- }else
- fsync(fd);
- close(fd);
- }
- if(Q_flag && (thread_randrfd !=0) )
- fclose(thread_randrfd);
- free(dummyfile[xx]);
- if(debug1)
-#ifdef NO_PRINT_LLD
- printf("\nChild finished %ld\n",xx);
-#else
- printf("\nChild finished %lld\n",xx);
-#endif
-
- if(L_flag)
- {
- get_date(now_string);
- fprintf(thread_Lwqfd,"%-25s %s","Random read finished: ",now_string);
- fclose(thread_Lwqfd);
- }
- if(recnum)
- free(recnum);
- if(hist_summary)
- dump_hist("Random Read",(int)xx);
- if(distributed && client_iozone)
- return(0);
-#ifdef NO_THREADS
- exit(0);
-#else
- if(use_thread)
- thread_exit();
- else
- exit(0);
-#endif
-return(0);
-}
-
-/************************************************************************/
-/* Thread random write test */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void *
-thread_ranwrite_test(void *x)
-#else
-void *
-thread_ranwrite_test( x)
-#endif
-{
-
- struct child_stats *child_stat;
- double starttime1 = 0;
- double temp_time;
- double walltime, cputime;
- double compute_val = (double)0;
- float delay = (double)0;
- double thread_qtime_stop,thread_qtime_start;
- double hist_time;
- double desired_op_rate_time;
- double actual_rate;
- off64_t traj_offset;
- off64_t current_offset=0;
- long long flags;
- long long w_traj_bytes_completed;
- long long w_traj_ops_completed;
- int fd;
- long long recs_per_buffer;
- long long stopped,i;
- off64_t written_so_far, read_so_far, re_written_so_far,re_read_so_far;
- long long xx,xx2;
- char *dummyfile [MAXSTREAMS]; /* name of dummy file */
- char *nbuff=0;
- char *maddr=0;
- char *wmaddr=0;
- char *free_addr=0;
- int anwser,bind_cpu,wval;
- off64_t filebytes64;
- off64_t lock_offset=0;
- char tmpname[256];
- char now_string[30];
- FILE *thread_randwqfd=0;
- FILE *thread_Lwqfd=0;
- long long *recnum = 0;
-#if defined(VXFS) || defined(solaris)
- int test_foo = 0;
-#endif
-#if defined (bsd4_2) || defined(Windows)
- long long rand1,rand2,rand3;
-#endif
- unsigned long long big_rand;
-
-#ifdef ASYNC_IO
- struct cache *gc=0;
-
-#else
- long long *gc=0;
-#endif
-#ifdef MERSENNE
- unsigned long long init[4]={0x12345ULL, 0x23456ULL, 0x34567ULL, 0x45678ULL}, length=4;
-#endif
-
- if(compute_flag)
- delay=compute_time;
- hist_time=thread_qtime_stop=thread_qtime_start=0;
- traj_offset=walltime=cputime=0;
- anwser=bind_cpu=0;
- filebytes64 = numrecs64*reclen;
- written_so_far=read_so_far=re_written_so_far=re_read_so_far=0;
- w_traj_bytes_completed=w_traj_ops_completed=0;
- recs_per_buffer = cache_size/reclen ;
-#ifdef MERSENNE
- init_by_array64(init, length);
-#else
-#ifdef bsd4_2
- srand(0);
-#else
-#ifdef Windows
- srand(0);
-#else
- srand48(0);
-#endif
-#endif
-#endif
- recnum = (long long *) malloc(sizeof(*recnum)*numrecs64);
- if (recnum){
- /* pre-compute random sequence based on
- Fischer-Yates (Knuth) card shuffle */
- for(i = 0; i < numrecs64; i++){
- recnum[i] = i;
- }
- for(i = 0; i < numrecs64; i++) {
- long long tmp = recnum[i];
-#ifdef MERSENNE
- big_rand = genrand64_int64();
-#else
-#ifdef bsd4_2
- rand1=(long long)rand();
- rand2=(long long)rand();
- rand3=(long long)rand();
- big_rand=(rand1<<32)|(rand2<<16)|(rand3);
-#else
-#ifdef Windows
- rand1=(long long)rand();
- rand2=(long long)rand();
- rand3=(long long)rand();
- big_rand=(rand1<<32)|(rand2<<16)|(rand3);
-#else
- big_rand = lrand48();
-#endif
-#endif
-#endif
- big_rand = big_rand%numrecs64;
- tmp = recnum[i];
- recnum[i] = recnum[big_rand];
- recnum[big_rand] = tmp;
- }
- }
- else
- {
- fprintf(stderr,"Random uniqueness fallback.\n");
- }
-#ifdef NO_THREADS
- xx=chid;
-#else
- if(use_thread)
- {
- xx = (long long)((long)x);
- }
- else
- {
- xx=chid;
- }
-#endif
-#ifndef NO_THREADS
-#if defined( _HPUX_SOURCE ) || defined ( linux )
- if(ioz_processor_bind)
- {
- bind_cpu=(begin_proc+(int)xx)%num_processors;
-#if defined(_HPUX_SOURCE)
- pthread_processor_bind_np(PTHREAD_BIND_FORCED_NP,
- (pthread_spu_t *)&anwser, (pthread_spu_t)bind_cpu, pthread_self());
-#else
- cpu_set_t cpuset;
-
- CPU_ZERO(&cpuset);
- CPU_SET(bind_cpu, &cpuset);
-
- pthread_setaffinity_np(pthread_self(), sizeof(cpuset),&cpuset);
-#endif
- my_nap(40); /* Switch to new cpu */
- }
-#endif
-#endif
- if(use_thread)
- nbuff=barray[xx];
- else
- nbuff=buffer;
- if(debug1 )
- {
- if(use_thread)
-#ifdef NO_PRINT_LLD
- printf("\nStarting child %ld\n",xx);
-#else
- printf("\nStarting child %lld\n",xx);
-#endif
- else
-#ifdef NO_PRINT_LLD
- printf("\nStarting process %d slot %ld\n",getpid(),xx);
-#else
- printf("\nStarting process %d slot %lld\n",getpid(),xx);
-#endif
-
- }
- dummyfile[xx]=(char *)malloc((size_t)MAXNAMESIZE);
- xx2=xx;
- if(share_file)
- xx2=(long long)0;
- if(mfflag)
- {
-#ifdef NO_PRINT_LLD
- sprintf(dummyfile[xx],"%s",filearray[xx2]);
-#else
- sprintf(dummyfile[xx],"%s",filearray[xx2]);
-#endif
- }
- else
- {
-#ifdef NO_PRINT_LLD
- sprintf(dummyfile[xx],"%s.DUMMY.%ld",filearray[xx2],xx2);
-#else
- sprintf(dummyfile[xx],"%s.DUMMY.%lld",filearray[xx2],xx2);
-#endif
- }
- /*****************/
- /* Children only */
- /*******************************************************************/
- /* Random write throughput performance test. **********************/
- /*******************************************************************/
- if(oflag)
- flags=O_RDWR|O_SYNC|O_CREAT;
- else
- flags=O_RDWR|O_CREAT;
-#if defined(O_DSYNC)
- if(odsync)
- flags |= O_DSYNC;
-#endif
-#if defined(_HPUX_SOURCE) || defined(linux)
- if(read_sync)
- flags |=O_RSYNC|O_SYNC;
-#endif
-
-#if ! defined(DONT_HAVE_O_DIRECT)
-#if defined(linux) || defined(__AIX__) || defined(IRIX) || defined(IRIX64) || defined(Windows) || defined (__FreeBSD__)
- if(direct_flag)
- flags |=O_DIRECT;
-#endif
-#if defined(TRU64)
- if(direct_flag)
- flags |=O_DIRECTIO;
-#endif
-#endif
-#if defined(Windows)
- if(unbuffered)
- {
- hand=CreateFile(dummyfile[xx],
- GENERIC_READ|GENERIC_WRITE,
- FILE_SHARE_WRITE|FILE_SHARE_READ,
- NULL,OPEN_EXISTING,FILE_FLAG_NO_BUFFERING|
- FILE_FLAG_WRITE_THROUGH|FILE_FLAG_POSIX_SEMANTICS,
- NULL);
- }
-#endif
- if((fd = I_OPEN(dummyfile[xx], ((int)flags),0640))<0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- printf("\nCan not open temp file: %s\n",
- filename);
- perror("open");
- exit(125);
- }
-#ifdef VXFS
- if(direct_flag)
- {
- ioctl(fd,VX_SETCACHE,VX_DIRECT);
- ioctl(fd,VX_GETCACHE,&test_foo);
- if(test_foo == 0)
- {
- if(!client_iozone)
- printf("\nVxFS advanced setcache feature not available.\n");
- exit(3);
- }
- }
-#endif
-#if defined(solaris)
- if(direct_flag)
- {
- test_foo = directio(fd, DIRECTIO_ON);
- if(test_foo != 0)
- {
- if(!client_iozone)
- printf("\ndirectio not available.\n");
- exit(3);
- }
- }
-#endif
-#ifdef ASYNC_IO
- if(async_flag)
- async_init(&gc,fd,direct_flag);
-#endif
- if(mmapflag)
- {
- maddr=(char *)initfile(fd,(filebytes64),1,PROT_READ|PROT_WRITE);
- }
- if(reclen < cache_size )
- {
- recs_per_buffer = cache_size/reclen ;
- nbuff=&nbuff[(xx%recs_per_buffer)*reclen];
- }
- if(fetchon) /* Prefetch into processor cache */
- fetchit(nbuff,reclen);
-
- child_stat = (struct child_stats *)&shmaddr[xx];
- child_stat->throughput = 0;
- child_stat->actual = 0;
- child_stat->flag=CHILD_STATE_READY; /* Tell parent child is ready to go */
- if(distributed && client_iozone)
- {
- tell_master_ready(chid);
- wait_for_master_go(chid);
- }
- else
- {
- while(child_stat->flag!=CHILD_STATE_BEGIN) /* Wait for signal from parent */
- Poll((long long)1);
- }
- written_so_far=0;
- child_stat = (struct child_stats *)&shmaddr[xx];
- child_stat->actual = 0;
- child_stat->throughput = 0;
- stopped=0;
- if(file_lock)
- if(mylockf((int) fd, (int) 1, (int)0) != 0)
- printf("File lock for write failed. %d\n",errno);
- if(Q_flag)
- {
- sprintf(tmpname,"Child_%d_randwol.dat",(int)xx);
- thread_randwqfd=fopen(tmpname,"a");
- if(thread_randwqfd==0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- printf("Unable to open %s\n",tmpname);
- exit(40);
- }
- fprintf(thread_randwqfd,"Offset in Kbytes Latency in microseconds Transfer size in bytes\n");
- }
- if(L_flag)
- {
- sprintf(tmpname,"Child_%d.log",(int)xx);
- thread_Lwqfd=fopen(tmpname,"a");
- if(thread_Lwqfd==0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- printf("Unable to open %s\n",tmpname);
- exit(40);
- }
- get_date(now_string);
- fprintf(thread_Lwqfd,"%-25s %s","Random write start: ",
- now_string);
- }
- if((verify && !no_copy_flag) || dedup || dedup_interior)
- fill_buffer(nbuff,reclen,(long long)pattern,sverify,(long long)0);
- starttime1 = time_so_far();
- if(cpuutilflag)
- {
- walltime = starttime1;
- cputime = cputime_so_far();
- }
- for(i=0; i<numrecs64; i++){
- if(compute_flag)
- compute_val+=do_compute(delay);
- if (recnum) {
- current_offset = reclen * (long long)recnum[i];
- } else {
-#ifdef bsd4_2
- rand1=rand();
- rand2=rand();
- rand3=rand();
- big_rand=(rand1<<32)|(rand2<<16)|(rand3);
- current_offset = (off64_t)reclen * (big_rand%numrecs64);
-#else
-#ifdef Windows
- rand1=rand();
- rand2=rand();
- rand3=rand();
- big_rand=(rand1<<32)|(rand2<<16)|(rand3);
- current_offset = (off64_t)reclen * (big_rand%numrecs64);
-#else
- current_offset = reclen * (lrand48()%numrecs64);
-#endif
-#endif
- }
-
- if (!(h_flag || k_flag || mmapflag))
- {
- if(I_LSEEK( fd, current_offset, SEEK_SET )<0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- perror("lseek");
- exit(158);
- };
- }
- if(Q_flag || hist_summary || op_rate_flag)
- {
- traj_offset=I_LSEEK(fd,0,SEEK_CUR);
- thread_qtime_start=time_so_far();
- }
- if(rlocking)
- {
- lock_offset=I_LSEEK(fd,0,SEEK_CUR);
- mylockr((int) fd, (int) 1, (int)0,
- lock_offset, reclen);
- }
- if((verify && !no_copy_flag) || dedup || dedup_interior)
- fill_buffer(nbuff,reclen,(long long)pattern,sverify,(long long)(current_offset/reclen));
- if(*stop_flag && !stopped){
- if(include_flush)
- {
- if(mmapflag)
- msync(maddr,(size_t)filebytes64,MS_SYNC);
- else
- fsync(fd);
- }
- child_stat->throughput =
- (time_so_far() - starttime1)-time_res;
- if(child_stat->throughput < (double).000001)
- {
- child_stat->throughput = time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-
- if(OPS_flag){
- /*written_so_far=(written_so_far*1024)/reclen;*/
- written_so_far=w_traj_ops_completed;
- }
- child_stat->throughput =
- (double)written_so_far/child_stat->throughput;
- child_stat->actual = (double)written_so_far;
- if(debug1)
- {
- printf("\n(%ld) Stopped by another\n", (long)xx);
- }
- stopped=1;
- }
- if(purge)
- purgeit(nbuff,reclen);
- if(Q_flag || hist_summary)
- {
- thread_qtime_start=time_so_far();
- }
-again:
- if(mmapflag)
- {
- wmaddr = &maddr[current_offset];
- fill_area((long long*)nbuff,(long long*)wmaddr,(long long)reclen);
- if(!mmapnsflag)
- {
- if(mmapasflag)
- msync(wmaddr,(size_t)reclen,MS_ASYNC);
- if(mmapssflag)
- msync(wmaddr,(size_t)reclen,MS_SYNC);
- }
- }
- else
- {
- if(async_flag)
- {
- if(no_copy_flag)
- {
- free_addr=nbuff=(char *)malloc((size_t)reclen+page_size);
- nbuff=(char *)(((long)nbuff+(long)page_size) & (long)~(page_size-1));
- if(verify || dedup || dedup_interior)
- fill_buffer(nbuff,reclen,(long long)pattern,sverify,(long long)(current_offset/reclen));
- async_write_no_copy(gc, (long long)fd, nbuff, reclen, (current_offset), depth,free_addr);
- }
- else
- async_write(gc, (long long)fd, nbuff, reclen, current_offset, depth);
- }
- else
- {
- wval = write(fd, nbuff, (size_t) reclen);
- if(wval != reclen)
- {
- if(*stop_flag && !stopped){
- if(include_flush)
- {
- if(mmapflag)
- msync(maddr,(size_t)filebytes64,MS_SYNC);
- else
- fsync(fd);
- }
- temp_time = time_so_far();
- child_stat->throughput =
- (temp_time - starttime1)-time_res;
- if(child_stat->throughput < (double).000001)
- {
- child_stat->throughput= time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-
- if(OPS_flag){
- /*written_so_far=(written_so_far*1024)/reclen;*/
- written_so_far=w_traj_ops_completed;
- }
- child_stat->throughput =
- (double)written_so_far/child_stat->throughput;
- child_stat->actual = (double)written_so_far;
- if(debug1)
- {
- printf("\n(%ld) Stopped by another\n", (long)xx);
- }
- stopped=1;
- goto again;
- }
- /* Note: Writer must finish even though told
- to stop. Otherwise the readers will fail.
- The code will capture bytes transfered
- before told to stop but let the writer
- complete.
- */
-#ifdef NO_PRINT_LLD
- printf("\nError writing block %ld, fd= %d\n", i,
- fd);
-#else
- printf("\nError writing block %lld, fd= %d\n", i,
- fd);
-#endif
- if(wval==-1)
- perror("write");
- if (!no_unlink)
- {
- if(check_filename(dummyfile[xx]))
- unlink(dummyfile[xx]);
- }
- child_stat->flag = CHILD_STATE_HOLD;
- exit(127);
- }
- }
- }
- if(rlocking)
- {
- mylockr((int) fd, (int) 0, (int)0,
- lock_offset, reclen);
- }
- if(hist_summary)
- {
- thread_qtime_stop=time_so_far();
- hist_time =(thread_qtime_stop-thread_qtime_start-time_res);
- hist_insert(hist_time);
- }
- if(op_rate_flag)
- {
- thread_qtime_stop=time_so_far();
- desired_op_rate_time = ((double)1.0/(double)op_rate);
- actual_rate = (double)(thread_qtime_stop-thread_qtime_start);
-/*
-printf("Desired rate %g Actual rate %g Nap %g microseconds\n",desired_op_rate_time,
- actual_rate, (desired_op_rate_time-actual_rate));
-*/
- if( actual_rate < desired_op_rate_time)
- my_unap((unsigned long long) ((desired_op_rate_time-actual_rate)*1000000.0 ));
- }
- if(Q_flag)
- {
- thread_qtime_stop=time_so_far();
-#ifdef NO_PRINT_LLD
- fprintf(thread_randwqfd,"%10.1ld %10.0f %10.1ld\n",(traj_offset)/1024,((thread_qtime_stop-thread_qtime_start-time_res))*1000000,reclen);
-#else
- fprintf(thread_randwqfd,"%10.1lld %10.0f %10.1lld\n",(traj_offset)/1024,((thread_qtime_stop-thread_qtime_start-time_res))*1000000,reclen);
-#endif
- }
- w_traj_ops_completed++;
- w_traj_bytes_completed+=reclen;
- written_so_far+=reclen/1024;
- if(*stop_flag)
- {
- written_so_far-=reclen/1024;
- w_traj_bytes_completed-=reclen;
- }
- }
-
-
- if(file_lock)
- if(mylockf((int) fd, (int) 0, (int)0))
- printf("Write unlock failed. %d\n",errno);
-
-#ifdef ASYNC_IO
- if(async_flag)
- {
- end_async(gc);
- gc=0;
- }
-#endif
- if(!xflag)
- {
- *stop_flag=1;
- if(distributed && client_iozone)
- send_stop();
- }
-
- if(include_flush)
- {
- if(mmapflag)
- msync(maddr,(size_t)filebytes64,MS_SYNC);
- else
- fsync(fd);
- }
- if(include_close)
- {
- if(mmapflag)
- mmap_end(maddr,(unsigned long long)filebytes64);
- close(fd);
- }
- if(!stopped){
- temp_time = time_so_far();
- child_stat->throughput = ((temp_time - starttime1)-time_res)
- -compute_val;
- if(child_stat->throughput < (double).000001)
- {
- child_stat->throughput= time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-
- if(OPS_flag){
- /*written_so_far=(written_so_far*1024)/reclen;*/
- written_so_far=w_traj_ops_completed;
- }
- child_stat->throughput =
- (double)written_so_far/child_stat->throughput;
- child_stat->actual = (double)written_so_far;
- }
- child_stat->flag = CHILD_STATE_HOLD; /* Tell parent I'm done */
- if(cdebug)
- {
- fprintf(newstdout,"Child %d: throughput %f actual %f \n",(int)chid,child_stat->throughput,
- child_stat->actual);
- fflush(newstdout);
- }
- if(cpuutilflag)
- {
- cputime = cputime_so_far() - cputime;
- if (cputime < cputime_res)
- cputime = 0.0;
- child_stat->cputime = cputime;
- walltime = time_so_far() - walltime;
- child_stat->walltime = walltime;
- }
- if(distributed && client_iozone)
- tell_master_stats(THREAD_RANDOM_WRITE_TEST, chid, child_stat->throughput,
- child_stat->actual,
- child_stat->cputime, child_stat->walltime,
- (char)*stop_flag,
- (long long)CHILD_STATE_HOLD);
- stopped=0;
- /*******************************************************************/
- /* End random write performance test. ******************************/
- /*******************************************************************/
- if(debug1)
-#ifdef NO_PRINT_LLD
- printf("\nChild finished %ld\n",xx);
-#else
- printf("\nChild finished %lld\n",xx);
-#endif
- if(!include_close)
- {
- if(mmapflag)
- {
- msync(maddr,(size_t)numrecs64*reclen,MS_SYNC); /*Clean up before read starts running*/
- mmap_end(maddr,(unsigned long long)numrecs64*reclen);
- }else
- fsync(fd);
-
- close(fd);
- }
- if(Q_flag && (thread_randwqfd !=0) )
- fclose(thread_randwqfd);
- free(dummyfile[xx]);
-
- if(L_flag)
- {
- get_date(now_string);
- fprintf(thread_Lwqfd,"%-25s %s","Random write finished: ",
- now_string);
- fclose(thread_Lwqfd);
- }
- if(recnum)
- free(recnum);
- if(hist_summary)
- dump_hist("Random Write",(int)xx);
- if(distributed && client_iozone)
- return(0);
-#ifdef NO_THREADS
- exit(0);
-#else
- if(use_thread)
- thread_exit();
- else
- exit(0);
-#endif
-return(0);
-}
-
-/************************************************************************/
-/* Thread cleanup test */
-/* This is not a measurement. It is a mechanism to cleanup all of the */
-/* temporary files that were being used. This becomes very important */
-/* when testing multiple clients over a network :-) */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void *
-thread_cleanup_test(void *x)
-#else
-void *
-thread_cleanup_test(x)
-#endif
-{
- long long xx;
- struct child_stats *child_stat;
- char *dummyfile[MAXSTREAMS]; /* name of dummy file */
-
-
-#ifdef NO_THREADS
- xx=chid;
-#else
- if(use_thread)
- xx = (long long)((long)x);
- else
- {
- xx=chid;
- }
-#endif
- dummyfile[xx]=(char *)malloc((size_t)MAXNAMESIZE);
- if(mfflag)
- {
-#ifdef NO_PRINT_LLD
- sprintf(dummyfile[xx],"%s",filearray[xx]);
-#else
- sprintf(dummyfile[xx],"%s",filearray[xx]);
-#endif
- }
- else
- {
-#ifdef NO_PRINT_LLD
- sprintf(dummyfile[xx],"%s.DUMMY.%ld",filearray[xx],xx);
-#else
- sprintf(dummyfile[xx],"%s.DUMMY.%lld",filearray[xx],xx);
-#endif
- }
- if(!no_unlink)
- {
- if(check_filename(dummyfile[xx]))
- unlink(dummyfile[xx]);
- }
-
- child_stat = (struct child_stats *)&shmaddr[xx];
- /*****************/
- /* Children only */
- /*****************/
- child_stat=(struct child_stats *)&shmaddr[xx];
- child_stat->flag = CHILD_STATE_READY;
- if(distributed && client_iozone)
- {
- tell_master_ready(chid);
- wait_for_master_go(chid);
- }
- else
- {
- while(child_stat->flag!=CHILD_STATE_BEGIN) /* Wait for signal from parent */
- Poll((long long)1);
- }
-
- *stop_flag=1;
- if(distributed && client_iozone)
- send_stop();
- if(distributed && client_iozone)
- tell_master_stats(THREAD_CLEANUP_TEST, chid, child_stat->throughput,
- child_stat->actual,
- child_stat->cputime, child_stat->walltime,
- (char)*stop_flag,
- (long long)CHILD_STATE_HOLD);
- child_stat->flag = CHILD_STATE_HOLD; /* Tell parent I'm done */
- free(dummyfile[xx]);
-
- if(distributed && client_iozone)
- return(0);
-#ifdef NO_THREADS
- exit(0);
-#else
- if(use_thread)
- thread_exit();
- else
- exit(0);
-#endif
-return(0);
-}
-
-
-/************************************************************************/
-/* mythread_create() Internal routine that calls pthread_create() */
-/************************************************************************/
-#ifndef NO_THREADS
-#ifdef HAVE_ANSIC_C
-long long
-mythread_create( void *(*func)(void *),void *x)
-#else
-long long
-mythread_create( func,x)
-void *(*func)(void *);
-void *x;
-#endif
-{
- pthread_t ts;
- pthread_attr_t attr;
- int xx;
- int *yy;
-#ifdef _64BIT_ARCH_
- long long meme;
- meme = (long long)x;
-#else
- long meme;
- meme = (long)x;
-#endif
- yy=(int *)x;
-
-
-#ifdef OSFV3
-
- xx=(int )pthread_create(&ts, pthread_attr_default,
- func, (void *)yy);
-
-#else
- pthread_attr_init(&attr);
- xx=(int )pthread_create((pthread_t *)&ts, (pthread_attr_t *) &attr,
- func, (void *)yy);
-#endif
- bcopy(&ts,&p_childids[meme],sizeof(pthread_t));
- if(xx < (int)0)
- printf("Thread create failed. Returned %d Errno = %d\n",xx,errno);
- if(debug1 )
- {
- printf("\nthread created has an id of %lx\n",ts);
- printf("meme %ld\n",meme);
- }
- return((long long)meme);
-}
-#else
-#ifdef HAVE_ANSIC_C
-long long
-mythread_create( void *(*func)(void *),void *x)
-#else
-long long
-mythread_create( func,x)
-void *(*func)(void *);
-void *x;
-#endif
-{
- printf("This version does not support threads\n");
- return(-1);
-}
-#endif
-
-/************************************************************************/
-/* thread_exit() Internal routine that calls pthread_exit() */
-/************************************************************************/
-#ifndef NO_THREADS
-#ifdef HAVE_ANSIC_C
-int
-thread_exit(void)
-#else
-int
-thread_exit()
-#endif
-{
- pthread_exit((void *)NULL);
-return(0);
-}
-#else
-#ifdef HAVE_ANSIC_C
-int
-thread_exit(void)
-#else
-int
-thread_exit()
-#endif
-{
- printf("This version does not support threads\n");
- return(-1);
-}
-#endif
-
-/************************************************************************/
-/* mythread_self() Internal function that calls pthread_self() */
-/************************************************************************/
-#ifndef NO_THREADS
-#ifdef HAVE_ANSIC_C
-pthread_t
-mythread_self(void)
-#else
-pthread_t
-mythread_self()
-#endif
-{
- pthread_t xx;
- xx = pthread_self();
- return(xx);
-}
-#else
-#ifdef HAVE_ANSIC_C
-int
-mythread_self(void)
-#else
-int
-mythread_self()
-#endif
-{
- printf("This version does not support threads\n");
- return(-1);
-}
-#endif
-
-/************************************************************************/
-/* Internal thread_join routine... calls pthread_join */
-/************************************************************************/
-#ifndef NO_THREADS
-#ifdef HAVE_ANSIC_C
-void *
-thread_join( long long tid, void *status)
-#else
-void *
-thread_join( tid, status)
-long long tid;
-void *status;
-#endif
-{
- int xx;
- pthread_t eek;
- pthread_attr_t foo;
-
- bcopy(&p_childids[tid],&eek,sizeof(pthread_t));
- xx=pthread_join(eek,(void **)&foo);
- if(xx<0)
- printf("Thread join returned error %d\n",errno);
- return(0);
-}
-#else
-#ifdef HAVE_ANSIC_C
-void *
-thread_join( long long tid, void *status)
-#else
-void *
-thread_join( tid, status)
-long long tid;
-void *status;
-#endif
-{
- printf("This version does not support threads\n");
- return((void *)-1);
-}
-#endif
-
-
-/************************************************************************/
-/* Dump the CPU utilization data. */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void
-dump_throughput_cpu(void)
-#else
-void
-dump_throughput_cpu()
-#endif
-{
- long long x,y,i,j;
- char *port;
- char *label;
- char print_str[300];
- x=max_x;
- y=max_y;
-
- port = use_thread ? "threads" : "processes";
- printf("\n\"CPU utilization report Y-axis is type of test X-axis is number of %s\"\n",port);
- if (bif_flag)
- {
- sprintf(print_str, "CPU utilization report Y-axis is type of test X-axis is number of %s", port);
- do_label(bif_fd, print_str, bif_row++, bif_column);
- }
- label = OPS_flag ? "ops/sec" :
- MS_flag ? "microseconds/op" : "Kbytes/sec";
-#ifdef NO_PRINT_LLD
- if(!silent) printf("\"Record size = %ld Kbytes \"\n", reclen/1024);
-#else
- if(!silent) printf("\"Record size = %lld Kbytes \"\n", reclen/1024);
-#endif
- if(!silent) printf("\"Output is in CPU%%\"\n\n");
- if (bif_flag)
- {
-#ifdef NO_PRINT_LLD
- sprintf(print_str, "Record size = %ld Kbytes", reclen/1024);
-#else
- sprintf(print_str, "Record size = %lld Kbytes", reclen/1024);
-#endif
- do_label(bif_fd, print_str, bif_row++, bif_column);
- sprintf(print_str, "Output is in CPU%%");
- do_label(bif_fd, print_str, bif_row++, bif_column);
- }
- for (i = 0; i < x; i++)
- {
- if(!silent) printf("\"%15s \"", throughput_tests[i]);
- if (bif_flag)
- {
- sprintf(print_str, "%15s ", throughput_tests[i]);
- do_label(bif_fd, print_str, bif_row, bif_column++);
- bif_column++;
- }
- for (j = 0; j <= y; j++)
- {
- if (bif_flag)
- do_float(bif_fd, runtimes[i][j].cpuutil, bif_row, bif_column++);
- if(!silent) printf(" %10.2f ", runtimes[i][j].cpuutil);
- }
- if(!silent) printf("\n\n");
- if (bif_flag)
- {
- bif_column=0;
- bif_row++;
- }
- }
-}
-
-
-/************************************************************************/
-/* Dump the throughput graphs */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void
-dump_throughput(void)
-#else
-void
-dump_throughput()
-#endif
-{
- long long x,y,i,j;
- char *port;
- char *label;
- char print_str[300];
- x=max_x;
- y=max_y;
-
- if(use_thread)
- port="threads";
- else
- port="processes";
- if(!silent) printf("\n\"Throughput report Y-axis is type of test X-axis is number of %s\"\n",port);
- if(bif_flag)
- {
- bif_fd=create_xls(bif_filename);
- do_label(bif_fd,command_line,bif_row++,bif_column);
- sprintf(print_str,"Throughput report Y-axis is type of test X-axis is number of %s",port);
- do_label(bif_fd,print_str,bif_row++,bif_column);
- }
- if(OPS_flag)
- label="ops/sec";
- else
- if(MS_flag)
- label="microseconds/op";
- else
- label="Kbytes/sec";
-#ifdef NO_PRINT_LLD
- if(!silent) printf("\"Record size = %ld Kbytes \"\n",reclen/1024);
-#else
- if(!silent) printf("\"Record size = %lld Kbytes \"\n",reclen/1024);
-#endif
- if(!silent) printf("\"Output is in %s\"\n\n",label);
- if(bif_flag)
- {
-#ifdef NO_PRINT_LLD
- sprintf(print_str,"Record size = %ld Kbytes",reclen/1024);
-#else
- sprintf(print_str,"Record size = %lld Kbytes",reclen/1024);
-#endif
- do_label(bif_fd,print_str,bif_row++,bif_column);
- sprintf(print_str,"Output is in %s",label);
- do_label(bif_fd,print_str,bif_row++,bif_column);
- }
- for(i=0;i<=toutputindex;i++)
- {
- if(!silent) printf("\"%15s \"",toutput[i]);
- if(bif_flag)
- {
- sprintf(print_str,"%15s ",toutput[i]);
- do_label(bif_fd,print_str,bif_row,bif_column++);
- bif_column++;
- }
- for(j=0;j<=y;j++)
- {
- if(bif_flag)
- {
- do_float(bif_fd,(double)report_darray[i][j],bif_row,bif_column++);
- }
- if(!silent) printf(" %10.2f ",report_darray[i][j]);
- }
- if(!silent) printf("\n\n");
- if(bif_flag)
- {
- bif_column=0;
- bif_row++;
- }
- }
- if (cpuutilflag)
- dump_throughput_cpu();
- if(bif_flag)
- close_xls(bif_fd);
-}
-
-/************************************************************************/
-/* store_dvalue() */
-/* Stores a value in an in memory array. Used by the report function */
-/* to re-organize the output for Excel */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void
-store_dvalue(double value)
-#else
-void
-store_dvalue(value)
-double value;
-#endif
-{
- report_darray[current_x][current_y]=value;
- current_x++;
- if(current_x > max_x)
- max_x=current_x;
- if(current_y > max_y)
- max_y=current_y;
- if(max_x >= MAX_X)
- {
- printf("\nMAX_X too small\n");
- exit(163);
- }
- if(max_y >= MAXSTREAMS)
- {
- printf("\nMAXSTREAMS too small\n");
- exit(164);
- }
-}
-
-/************************************************************************/
-/* Initialize a file that will be used by mmap. */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-char *
-initfile(int fd, off64_t filebytes,int flag,int prot)
-#else
-char *
-initfile(fd, filebytes,flag, prot)
-int fd;
-off64_t filebytes;
-int flag, prot;
-#endif
-{
- char *pa;
- int mflags=0;
- long long x;
- char *tmp,*stmp;
- int file_flags;
- long long recs;
- long long i;
- int dflag = 0;
-
- if(flag)
- {
-
-#ifdef _HPUX_SOURCE
- /*
- * Save time, just have the operating system prealloc
- * the file
- */
- prealloc(fd,filebytes);
-#else
- /*
- * Allocate a temporary buffer to meet any alignment
- * contraints of any method.
- */
- tmp=(char *)malloc((size_t)reclen * 2);
- stmp=tmp;
- /*
- * Align to a reclen boundary.
- */
- tmp = (char *)((((long)tmp + (long)reclen))& ~(((long)reclen-1)));
- /*
- * Special case.. Open O_DIRECT, and going to be mmap()
- * Under Linux, one can not create a sparse file using
- * a file that is opened with O_DIRECT
- */
- file_flags=fcntl(fd,F_GETFL);
-
-#if ! defined(DONT_HAVE_O_DIRECT)
-#if defined(linux) || defined(__AIX__) || defined(IRIX) || defined(IRIX64) || defined(Windows) || defined (__FreeBSD__)
- dflag = O_DIRECT;
-#endif
-#if defined(TRU64)
- if(direct_flag)
- dflag = O_DIRECTIO;
-#endif
-#endif
- if((file_flags & dflag) !=0)
- {
- recs=filebytes/reclen;
- for (i =0; i<recs ;i++)
- {
- x=write(fd,tmp,(size_t)reclen);
- if(x < 1)
- {
- printf("Unable to write file\n");
- exit(182);
- }
- }
- }
- else
- {
- /* Save time, just seek out and touch at the end */
- I_LSEEK(fd,(filebytes-reclen),SEEK_SET);
- x=write(fd,tmp,(size_t)reclen);
- if(x < 1)
- {
- printf("Unable to write file\n");
- exit(181);
- }
- }
- free(stmp);
- I_LSEEK(fd,0,SEEK_SET);
-#endif
- }
-
-#ifdef IRIX64
- if((prot & PROT_WRITE)==PROT_WRITE)
- mflags=MAP_SHARED;
- else
- mflags=MAP_PRIVATE;
-#else
-#ifdef IRIX
- if((prot & PROT_WRITE)==PROT_WRITE)
- mflags=MAP_SHARED;
- else
- mflags=MAP_PRIVATE;
-#else
- if((prot & PROT_WRITE)==PROT_WRITE)
- mflags=MAP_FILE|MAP_SHARED;
- else
- mflags=MAP_FILE|MAP_PRIVATE;
-#endif
-#endif
-
-#if defined(bsd4_2) && !defined(macosx)
- pa = (char *)mmap( 0,&filebytes, (int)prot,
- (int)mflags, (int)fd, 0);
-#else
- pa = (char *)I_MMAP( ((char *)0),filebytes, prot,
- mflags, fd, 0);
-#endif
-#ifdef __convex_spp
- if(pa == (char *)-1)
- {
- printf("\nMmap failed, errno %d Flags %x\n",errno,(int)mflags);
- exit(165);
- }
-#else
-#ifdef linux
- if(pa == (char *)-1)
- {
- printf("Mapping failed, errno %d\n",errno);
- exit(166);
- }
-#else
-#ifdef bsd4_2
- if(pa == (char *)-1)
- {
- printf("Mapping failed, errno %d\n",errno);
- exit(167);
- }
-#else
- if(pa == (char *)MAP_FAILED)
- {
- printf("\nMapping failed, errno %d Flags = %x\n",errno,mflags);
- exit(168);
- }
-#endif
-#endif
-#endif
-#ifndef NO_MADVISE
- if(advise_flag)
- {
- switch(advise_op){
- case 0:
- madvise( (char *)pa, (size_t) filebytes, MADV_NORMAL);
- break;
- case 1:
- madvise( (char *)pa, (size_t) filebytes, MADV_RANDOM);
- break;
- case 2:
- madvise( (char *)pa, (size_t) filebytes, MADV_SEQUENTIAL);
- break;
- case 3:
- madvise( (char *)pa, (size_t) filebytes, MADV_DONTNEED);
- break;
- case 4:
- madvise( (char *)pa, (size_t) filebytes, MADV_WILLNEED);
- break;
- default:
- break;
- };
- }
-
-#endif
- return(pa);
-
-}
-
-
-/************************************************************************/
-/* Release the mmap area. */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void
-mmap_end( char *buffer, long long size)
-#else
-void
-mmap_end( buffer, size)
-char *buffer;
-long long size;
-#endif
-{
- if(munmap(buffer,(size_t)size)<0)
-#ifdef NO_PRINT_LLD
- printf("munmap buffer %lx, size %ld failed.\n",(long)buffer,size);
-#else
- printf("munmap buffer %lx, size %lld failed.\n",(long)buffer,size);
-#endif
-
-}
-
-/************************************************************************/
-/* This is an interesting function. How much data to */
-/* copy is a very good question. Here we are using mmap to */
-/* perform I/O. If the benchmark touches every byte then */
-/* this will include a bcopy of the mmap area into the */
-/* users buffer. This is represenative of an application */
-/* that reads and touches every byte that it read. If */
-/* the benchmark reduces the work to touching only */
-/* a long per page then the numbers go up but it */
-/* does not reflect the application to well. For now */
-/* the best assumption is to believe that the application */
-/* will indeed touch every byte. */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void
-fill_area(long long *src_buffer, long long *dest_buffer, long long length)
-#else
-fill_area( src_buffer, dest_buffer, length)
-long long *src_buffer;
-long long *dest_buffer;
-long long length;
-#endif
-{
- /*printf("Fill area %d\n",(size_t)length);*/
- bcopy((void *)src_buffer,(void *)dest_buffer,(size_t)length);
-}
-
-#ifndef ASYNC_IO
-int
-async_read()
-{
- printf("Your system does not support async I/O\n");
- exit(169);
-}
-size_t
-async_write_no_copy()
-{
- printf("Your system does not support async I/O\n");
- exit(170);
-}
-size_t
-async_write()
-{
- printf("Your system does not support async I/O\n");
- exit(171);
-}
-void
-async_init()
-{
- printf("Your system does not support async I/O\n");
- exit(172);
-}
-int
-async_read_no_copy()
-{
- printf("Your system does not support async I/O\n");
- exit(172);
-}
-void
-async_release()
-{
- printf("Your system does not support async I/O\n");
- exit(173);
-}
-#endif
-
-/************************************************************************/
-/* Nap in microseconds. */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void
-my_nap( int ntime )
-#else
-void
-my_nap( ntime )
-int ntime;
-#endif
-{
- struct timeval nap_time;
- int seconds, microsecs;
- seconds = ntime/1000; /* Now in seconds */
- microsecs = (ntime*1000)%1000000; /* Remaining microsecs */
- nap_time.tv_sec=seconds;
- nap_time.tv_usec=microsecs;
- select(0,0,0,0,&nap_time);
-}
-/************************************************************************/
-/* Nap in microseconds. */
-/************************************************************************/
-int nap_once;
-double nap_res;
-#ifdef HAVE_ANSIC_C
-void
-my_unap( unsigned long long microsecs )
-#else
-void
-my_unap( microsecs )
-unsigned long long microsecs;
-#endif
-{
- struct timeval nap_time;
- int seconds;
- double timein, timeout;
-
- seconds = (int)(microsecs/1000000.0); /* Now in seconds */
- nap_time.tv_sec=seconds;
- nap_time.tv_usec=(int)microsecs;
-
- timein=time_so_far1();
- while(1)
- {
- timeout=time_so_far1();
- /*printf("Sleep for %lld Curtime %g\n",microsecs,timeout-timein);*/
- if(timeout-timein > microsecs)
- break;
- }
-
-/*
- select(0,0,0,0,&nap_time);
-*/
-
-
-}
-
-/************************************************************************/
-/* Function that establishes the resolution */
-/* of the gettimeofday() function. */
-/************************************************************************/
-
-#ifdef HAVE_ANSIC_C
-void
-get_resolution(void)
-#else
-void
-get_resolution()
-#endif
-{
- double starttime, finishtime, besttime = 0;
- long j,delay;
- int k;
-
- finishtime=time_so_far1(); /* Warm up the instruction cache */
- starttime=time_so_far1(); /* Warm up the instruction cache */
- delay=j=0; /* Warm up the data cache */
- for(k=0;k<10;k++)
- {
- while(1)
- {
- starttime=time_so_far1();
- for(j=0;j< delay;j++)
- ;
- finishtime=time_so_far1();
- if(starttime==finishtime)
- delay++;
- else
- {
- if(k==0)
- besttime=(finishtime-starttime);
- if((finishtime-starttime) < besttime)
- besttime=(finishtime-starttime);
- break;
- }
- }
- }
- time_res=besttime/1000000.0;
-}
-
-/************************************************************************/
-/* Function that establishes the resolution */
-/* of the getrusage() function. */
-/************************************************************************/
-
-#ifdef HAVE_ANSIC_C
-void
-get_rusage_resolution(void)
-#else
-void
-get_rusage_resolution()
-#endif
-{
- double starttime, finishtime;
- long j;
-
- finishtime=cputime_so_far(); /* Warm up the instruction cache */
- starttime=cputime_so_far(); /* Warm up the instruction cache */
- delay=j=0; /* Warm up the data cache */
- while(1)
- {
- starttime=cputime_so_far();
- for(j=0;j< delay;j++)
- ;
- finishtime=cputime_so_far();
- if(starttime==finishtime)
-
- delay++;
- else
- break;
- }
- cputime_res = (finishtime-starttime); /* in seconds */
-}
-/************************************************************************/
-/* Time measurement routines. */
-/* Return time in microseconds */
-/************************************************************************/
-
-#ifdef HAVE_ANSIC_C
-static double
-time_so_far1(void)
-#else
-static double
-time_so_far1()
-#endif
-{
- /* For Windows the time_of_day() is useless. It increments in
- 55 milli second increments. By using the Win32api one can
- get access to the high performance measurement interfaces.
- With this one can get back into the 8 to 9 microsecond resolution
- */
-#ifdef Windows
- LARGE_INTEGER freq,counter;
- double wintime;
- double bigcounter;
- struct timeval tp;
-
- if(pit_hostname[0]){
- pit_gettimeofday(&tp, (struct timezone *) NULL, pit_hostname,
- pit_service);
- return ((double) (tp.tv_sec)*1000000.0)+(((double)tp.tv_usec));
- }
- else
- {
-
- QueryPerformanceFrequency(&freq);
- QueryPerformanceCounter(&counter);
- bigcounter=(double)counter.HighPart *(double)0xffffffff +
- (double)counter.LowPart;
- wintime = (double)(bigcounter/(double)freq.LowPart);
- return((double)wintime*1000000.0);
- }
-#else
-#if defined (OSFV4) || defined(OSFV3) || defined(OSFV5)
- struct timespec gp;
-
- if (getclock(TIMEOFDAY, (struct timespec *) &gp) == -1)
- perror("getclock");
- return (( (double) (gp.tv_sec)*1000000.0) +
- ( ((float)(gp.tv_nsec)) * 0.001 ));
-#else
- struct timeval tp;
-
- if(pit_hostname[0]){
- if (pit_gettimeofday(&tp, (struct timezone *) NULL, pit_hostname,
- pit_service) == -1)
- perror("pit_gettimeofday");
- return ((double) (tp.tv_sec)*1000000.0) + (((double) tp.tv_usec) );
- }
- else
- {
- if (gettimeofday(&tp, (struct timezone *) NULL) == -1)
- perror("gettimeofday");
- return ((double) (tp.tv_sec)*1000000.0) + (((double) tp.tv_usec) );
- }
-#endif
-#endif
-}
-
-/************************************************************************/
-/* Return the clocks per tick for the times() call. */
-/************************************************************************/
-#ifdef unix
-#ifdef HAVE_ANSIC_C
-static double
-clk_tck(void) /* Get the clocks per tick for times */
-#else
-static double
-clk_tck() /* Get the clocks per tick for times */
-#endif
-{
- return((double)sysconf(_SC_CLK_TCK));
-}
-
-/************************************************************************/
-/* Return the user time in tics as a double. */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-static double
-utime_so_far(void) /* Return user time in ticks as double */
-#else
-static double
-utime_so_far()
-#endif
-{
- struct tms tp;
-
- times(&tp);
- return ((double) (tp.tms_utime));
-}
-
-/************************************************************************/
-/* Return the system time in tics as a double. */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-static double
-stime_so_far(void) /* Return system time in ticks as double */
-#else
-static double
-stime_so_far()
-#endif
-{
- struct tms tp;
-
- times(&tp);
- return ((double) (tp.tms_stime));
-}
-
-/************************************************************************/
-/* Return the CPU (user + system) time in seconds as a double. */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-static double
-cputime_so_far(void) /* Return CPU time in seconds as double */
-#else
-static double
-cputime_so_far()
-#endif
-{
-#if 0
- struct tms tp;
-
- times(&tp);
- return ((double) (tp.tms_utime + tp.tms_stime) / sc_clk_tck);
-#else
- struct rusage ru;
-
- if (getrusage (RUSAGE_SELF, &ru))
- perror ("getrusage");
- return ((double)(ru.ru_utime.tv_sec + ru.ru_stime.tv_sec) +
- .000001 *(ru.ru_utime.tv_usec + ru.ru_stime.tv_usec));
-#endif
-}
-#endif
-
-/************************************************************************/
-/* Return the CPU utilization ((user + system) / walltime) as a percentage. */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-static double
-cpu_util(double cputime, double walltime)
-#else
-static double
-cpu_util(cputime, walltime)
-double cputime, walltime;
-#endif
-{
- double cpu;
-
- if (walltime <= (double)0.0)
- {
- cpu = (double)0.0;
- return cpu;
- }
- if (cputime <= (double)0.0)
- cputime = 0.0;
- if (walltime <= (double)0.0)
- cpu = (double)100.0;
- else {
- cpu = (((double)100.0 * cputime) / walltime);
- /*
- if (cpu > (double)100.0)
- cpu = (double)99.99;
- */
- }
- return cpu;
-}
-
-/************************************************************************/
-/* This is a locking function that permits the writes and */
-/* reads during the test to hold a file lock. Since each */
-/* tmp file that Iozone creates is a private file, this seems */
-/* like a no-op but it turns out that when using Iozone */
-/* over NFS, life is very, very different. Some vendors */
-/* read and write performance goes to zip when locks are held */
-/* even if there is only one process using the file and having */
-/* it locked. Some implementations of NFS transition from async */
-/* to fully sync reads and writes if any locks are used. Euck... */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-int
-mylockf(int fd, int op, int rdwr)
-#else
-int
-mylockf(fd, op, rdwr)
-int fd, op, rdwr;
-#endif
-{
- struct flock myflock;
- int ret;
- if(op==0) /* Generic unlock the whole file */
- {
- myflock.l_type=F_UNLCK;
- myflock.l_whence=SEEK_SET;
- myflock.l_start=0;
- myflock.l_len=0; /* The whole file */
- myflock.l_pid=getpid();
- ret=fcntl(fd,F_SETLKW, &myflock);
- }
- else
- /* Generic lock the whole file */
- {
- if(rdwr==0)
- myflock.l_type=F_WRLCK; /* Apply write lock */
- else
- myflock.l_type=F_RDLCK; /* Apply read lock */
- myflock.l_whence=SEEK_SET;
- myflock.l_start=0;
- myflock.l_len=0; /* The whole file */
- myflock.l_pid=getpid();
- ret=fcntl(fd,F_SETLKW, &myflock);
- }
- return(ret);
-}
-
-#ifdef HAVE_ANSIC_C
-int
-mylockr(int fd, int op, int rdwr, off64_t offset, off64_t size)
-#else
-int
-mylockr(fd, op, rdwr, offset, size)
-int fd, op, rdwr;
-off64_t offset;
-off64_t size;
-#endif
-{
- struct flock myflock;
- int ret;
- if(op==0) /* Generic unlock the whole file */
- {
- /*printf("Child: %lld Unlock offset %lld size %lld\n",chid,offset,size);*/
- myflock.l_type=F_UNLCK;
- myflock.l_whence=SEEK_SET;
- myflock.l_start=offset;
- myflock.l_len=size; /* The whole file */
- myflock.l_pid=getpid();
- ret=fcntl(fd,F_SETLKW, &myflock);
- }
- else
- /* Generic lock the range */
- {
- if(rdwr==0)
- {
- myflock.l_type=F_WRLCK; /* Apply write lock */
- /* printf("Write ");*/
- }
- else
- {
- myflock.l_type=F_RDLCK; /* Apply read lock */
- /* printf("Read ");*/
- }
- /*printf("Child: %lld Lock offset %lld size %lld\n",chid, offset,size);*/
- myflock.l_whence=SEEK_SET;
- myflock.l_start=offset;
- myflock.l_len=size; /* The whole file */
- myflock.l_pid=getpid();
- ret=fcntl(fd,F_SETLKW, &myflock);
- }
- return(ret);
-}
-/************************************************************************/
-/* This function is used to simulate compute time that does */
-/* not involve the I/O subsystem. */
-/************************************************************************/
-
-#ifdef HAVE_ANSIC_C
-float
-do_compute(float comp_delay)
-#else
-float
-do_compute(comp_delay)
-float comp_delay;
-#endif
-{
- double starttime,tmptime;
- if(comp_delay == (float)0.0)
- return(0.0);
- starttime=time_so_far();
- while(1)
- {
- tmptime=time_so_far()-starttime;
- if(tmptime >= (double)comp_delay)
- return(tmptime);
- }
- return(0.0);
-}
-
-/************************************************************************/
-/* This function is intended to cause an interruption */
-/* in the read pattern. It will make a reader have */
-/* jitter in its access behavior. */
-/* When using direct I/O one must use a pagesize transfer. */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void
-disrupt(int fd)
-#else
-void
-disrupt(fd)
-int fd;
-#endif
-{
- char *nbuff,*free_addr;
- off64_t current;
-
- free_addr=nbuff=(char *)malloc((size_t)page_size+page_size);
- nbuff=(char *)(((long)nbuff+(long)page_size) & (long)~(page_size-1));
-
- /* Save current position */
- current = I_LSEEK(fd,0,SEEK_CUR);
-
- /* Move to beginning of file */
- I_LSEEK(fd,0,SEEK_SET);
-
- /* Read a little of the file */
- if(direct_flag)
- junk=read(fd,nbuff,page_size);
- else
- junk=read(fd,nbuff,1);
-
- /* Skip into the file */
- I_LSEEK(fd,page_size,SEEK_SET);
-
- /* Read a little of the file */
- if(direct_flag)
- junk=read(fd,nbuff,page_size);
- else
- junk=read(fd,nbuff,1);
-
- /* Restore current position in file, before disruption */
- I_LSEEK(fd,current,SEEK_SET);
- free(free_addr);
-
-}
-
-#if defined(Windows)
-/************************************************************************/
-/* This function is intended to cause an interruption */
-/* in the read pattern. It will make a reader have */
-/* jitter in its access behavior. */
-/* When using direct I/O one must use a pagesize transfer. */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void
-disruptw(HANDLE hand)
-#else
-void
-disruptw(HANDLE)
-int hand;
-#endif
-{
- char *nbuff,*free_addr;
- off64_t current;
- long retval;
-
- free_addr=nbuff=(char *)malloc((size_t)page_size+page_size);
- nbuff=(char *)(((long)nbuff+(long)page_size) & (long)~(page_size-1));
-
- /* Save current position */
- current=SetFilePointer(hand,(LONG)0,0,FILE_CURRENT);
-
- /* Move to beginning of file */
- SetFilePointer(hand,(LONG)0,0,FILE_BEGIN);
-
- /* Read a little of the file */
- ReadFile(hand, nbuff, reclen,(LPDWORD)&retval,0);
-
- /* Skip into the file */
- SetFilePointer(hand,(LONG)page_size,0,FILE_BEGIN);
-
- /* Read a little of the file */
- ReadFile(hand, nbuff, reclen,(LPDWORD)&retval,0);
-
- /* Restore current position in file, before disruption */
- SetFilePointer(hand,(LONG)current,0,FILE_BEGIN);
- free(free_addr);
-
-}
-#endif
-
-/************************************************************************/
-/* Read a telemetry file and return the the offset */
-/* for the next operaton. Also, set the size */
-/* in the variable given in the param list. */
-/* which == 0 ... reader calling */
-/* which == 1 ... writer calling */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-long long
-get_traj(FILE *traj_fd, long long *traj_size, float *delay, long which)
-#else
-long long
-get_traj(traj_fd, traj_size, delay, which)
-FILE *traj_fd;
-long long *traj_size;
-float *delay;
-long which;
-#endif
-{
- long long traj_offset = 0;
- long long tmp2 = 0;
- int tmp = 0;
- int tokens;
- int ret=0;
- char *ret1,*where;
- char buf[200];
- char sbuf[200];
- int got_line;
-
- got_line=0;
-
- while(got_line==0)
- {
- tokens=0;
- ret1=fgets(buf,200,traj_fd);
- if(ret1==(char *)0)
- {
- printf("\n\n\tEarly end of telemetry file. Results not accurate.\n");
- signal_handler();
- }
- where=(char *)&buf[0];
- strcpy(sbuf,buf);
- if((*where=='#') || (*where=='\n'))
- continue;
- tokens++;
- strtok(where," ");
- while( (char *)(strtok( (char *)0," ")) != (char *)0)
- {
- tokens++;
- }
- got_line=1;
- }
- if(tokens == 3)
- {
-#ifdef NO_PRINT_LLD
- ret=sscanf(sbuf,"%ld %ld %d\n",&traj_offset,&tmp2,&tmp);
-#else
- ret=sscanf(sbuf,"%lld %lld %d\n",&traj_offset,&tmp2,&tmp);
-#endif
- /*printf("\nReading %s trajectory with %d items\n",which?"write":"read",tokens);*/
- *traj_size=tmp2;
- *delay= ((float)tmp/1000);
- }
- if(tokens == 2)
- {
-#ifdef NO_PRINT_LLD
- ret=sscanf(sbuf,"%ld %ld\n",&traj_offset,traj_size);
-#else
- ret=sscanf(sbuf,"%lld %lld\n",&traj_offset,traj_size);
-#endif
- *delay=compute_time;
- /*printf("\nReading %s trajectory with %d items\n",which?"write":"read",tokens);*/
- }
- if((tokens != 2) && (tokens !=3))
- {
- printf("\n\tInvalid entry in telemetry file. > %s <\n",sbuf);
- exit(178);
- }
- if(ret==EOF)
- {
- printf("\n\n\tEarly end of telemetry file. Results not accurate.\n");
- signal_handler();
- }
-#ifdef DEBUG
-#ifdef NO_PRINT_LLD
- if(!silent) printf("\nOffset %lld Size %ld Compute delay %f\n",traj_offset, *traj_size,*delay);
-#else
- if(!silent) printf("\nOffset %lld Size %lld Compute delay %f\n",traj_offset, *traj_size,*delay);
-#endif
-#endif
- return(traj_offset);
-}
-
-/************************************************************************/
-/* Open the read telemetry file and return file pointer. */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-FILE *
-open_r_traj(void)
-#else
-FILE *
-open_r_traj()
-#endif
-{
- FILE *fd;
- fd=fopen(read_traj_filename,"r");
- if(fd == (FILE *)0)
- {
- printf("Unable to open read telemetry file \"%s\"\n",
- read_traj_filename);
- exit(174);
- }
- return(fd);
-}
-
-/************************************************************************/
-/* Open the write telemetry file and return file pointer. */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-FILE *
-open_w_traj(void)
-#else
-FILE *
-open_w_traj()
-#endif
-{
- FILE *fd;
- fd=fopen(write_traj_filename,"r");
- if(fd == (FILE *)0)
- {
- printf("Unable to open write telemetry file \"%s\"\n",
- write_traj_filename);
- exit(175);
- }
- return(fd);
-}
-
-/************************************************************************/
-/* r_traj_size(void) */
-/* This function scans the read telemetry file */
-/* and establishes the number of entries */
-/* and the maximum file offset. */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-void
-r_traj_size(void)
-#else
-void
-r_traj_size()
-#endif
-{
- FILE *fd;
- int ret;
- long long traj_offset = 0;
- long long traj_size = 0;
- long long max_offset = 0;
- int tokens;
- int dummy;
- int lines;
- char buf[200];
- char sbuf[200];
- char *ret1,*where;
-
- lines=0;
- fd=fopen(read_traj_filename,"r");
- if(fd == (FILE *)0)
- {
- printf("Unable to open read telemetry file \"%s\"\n",
- read_traj_filename);
- exit(174);
- }
- while(1)
- {
- tokens=0;
- ret1=fgets(buf,200,fd);
- if(ret1==(char *)0)
- break;
- where=(char *)&buf[0];
- strcpy(sbuf,buf);
- lines++;
- if((*where=='#') || (*where=='\n'))
- continue;
- tokens++;
- strtok(where," ");
- while( (char *)(strtok( (char *)0," ")) != (char *)0)
- {
- tokens++;
- }
- if(tokens==1)
- {
- printf("\n\tInvalid read telemetry file entry. Line %d",
- lines);
- signal_handler();
- }
-#ifdef DEBUG
- printf("Tokens = %d\n",tokens);
-#endif
- if(tokens==3)
- {
-#ifdef NO_PRINT_LLD
- ret=sscanf(sbuf,"%ld %ld %d\n",&traj_offset,&traj_size,&dummy);
-#else
- ret=sscanf(sbuf,"%lld %lld %d\n",&traj_offset,&traj_size,&dummy);
-#endif
- }
- if(tokens==2)
- {
-#ifdef NO_PRINT_LLD
- ret=sscanf(sbuf,"%ld %ld\n",&traj_offset,&traj_size);
-#else
- ret=sscanf(sbuf,"%lld %lld\n",&traj_offset,&traj_size);
-#endif
- }
- if((tokens != 2) && (tokens !=3))
- {
- printf("\n\tInvalid read telemetry file. Line %d\n",lines);
- exit(178);
- }
- if(traj_offset + traj_size > max_offset)
- max_offset=traj_offset + traj_size;
-
- r_traj_ops++;
- }
- r_traj_fsize=max_offset;
-#ifdef DEBUG
- printf("File size of read %lld Item count %lld\n",r_traj_fsize,r_traj_ops);
-#endif
- fclose(fd);
-}
-
-/************************************************************************/
-/* w_traj_size(void) */
-/* This function scans the write telemetry file */
-/* and establishes the number of entries */
-/* and the maximum file offset. */
-/************************************************************************/
-#ifdef HAVE_ANSIC_C
-long long
-w_traj_size(void)
-#else
-long long
-w_traj_size()
-#endif
-{
- FILE *fd;
- int ret;
- long long traj_offset = 0;
- long long traj_size = 0;
- long long max_offset = 0;
- int dummy;
- int tokens,lines;
- char *ret1;
- char buf[200];
- char sbuf[200];
- char *where;
-
- lines=0;
-
- fd=fopen(write_traj_filename,"r");
- if(fd == (FILE *)0)
- {
- printf("Unable to open write telemetry file \"%s\"\n",
- write_traj_filename);
- exit(174);
- }
- while(1)
- {
- tokens=0;
- ret1=fgets(buf,200,fd);
- if(ret1==(char *)0)
- break;
- lines++;
- where=(char *)&buf[0];
- strcpy(sbuf,buf);
- if((*where=='#') || (*where=='\n'))
- continue;
- tokens++;
- strtok(where," ");
- while( (char *)(strtok( (char *)0," ")) != (char *)0)
- {
- tokens++;
- }
- if(tokens==1)
- {
- printf("\n\tInvalid write telemetry file entry. Line %d\n",
- lines);
- signal_handler();
- }
- if(tokens==3)
- {
-#ifdef NO_PRINT_LLD
- ret=sscanf(sbuf,"%ld %ld %d\n",&traj_offset,&traj_size,&dummy);
-#else
- ret=sscanf(sbuf,"%lld %lld %d",&traj_offset,&traj_size,&dummy);
-#endif
- }
- if(tokens==2)
- {
-#ifdef NO_PRINT_LLD
- ret=sscanf(sbuf,"%ld %ld\n",&traj_offset,&traj_size);
-#else
- ret=sscanf(sbuf,"%lld %lld\n",&traj_offset,&traj_size);
-#endif
- }
- if(tokens > 3)
- {
- printf("\n\tInvalid write telemetry file entry. Line %d\n",
- lines);
- exit(174);
- }
- if(traj_offset + traj_size > max_offset)
- max_offset=traj_offset + traj_size;
-
- w_traj_ops++;
- }
- w_traj_fsize=max_offset;
-#ifdef DEBUG
- printf("File size of write %lld Item count %lld\n",w_traj_fsize,w_traj_ops);
-#endif
- fclose(fd);
- return(max_offset);
-}
-
-/************************************************************************/
-/* Find which version of the telemetry file format is in use. */
-/************************************************************************/
-
-#ifdef HAVE_ANSIC_C
-void
-traj_vers(void)
-#else
-void
-traj_vers()
-#endif
-{
- FILE *fd;
- char *where;
- char buf[200];
- int things;
- char *ret1;
-
- if(r_traj_flag)
- {
- things=0;
- fd=fopen(read_traj_filename,"r");
- if(fd == (FILE *)0)
- {
- printf("Unable to open read telemetry file \"%s\"\n", read_traj_filename);
- exit(174);
- }
-loop1:
- ret1=fgets(buf,200,fd);
- if(ret1==(char *)0)
- {
- fclose(fd);
- return;
- }
- where=(char *)&buf[0];
- if((*where=='#') || (*where=='\n'))
- goto loop1;
- things++;
- strtok(where," ");
- while( (char *)(strtok( (char *)0," ")) != (char *)0)
- {
- things++;
- }
- r_traj_items=things;
-#ifdef DEBUG
- printf("Found %d items in the read telemetry file\n",things);
-#endif
- }
- if(w_traj_flag)
- {
- things=0;
- fd=fopen(write_traj_filename,"r");
- if(fd == (FILE *)0)
- {
- printf("Unable to open write telemetry file \"%s\"\n", write_traj_filename);
- exit(174);
- }
-loop2:
- ret1=fgets(buf,200,fd);
- if(ret1==(char *)0)
- {
- fclose(fd);
- return;
- }
- where=(char *)&buf[0];
- if((*where=='#') || (*where=='\n'))
- goto loop2;
- things++;
- strtok(where," ");
- while( (char *)(strtok( (char *)0," ")) != (char *)0)
- {
- things++;
- }
- fclose(fd);
- w_traj_items=things;
-#ifdef DEBUG
- printf("Found %d items in the write telemetry file\n",things);
-#endif
- }
-}
-
-/********************************************************************/
-/* */
-/* Today this initializes the default set of file sizes for Iozone. */
-/* in the future it may take input from the command line or */
-/* from a file. */
-/* */
-/********************************************************************/
-#ifdef HAVE_ANSIC_C
-void
-init_file_sizes( off64_t min_f_size, off64_t max_f_size)
-#else
-void
-init_file_sizes(min_f_size, max_f_size)
-off64_t min_f_size;
-off64_t max_f_size;
-#endif
-{
- off64_t kilosi;
- int x;
- if(s_count > 1)
- {
- for(x=0; x < s_count; x++)
- {
- kilosi=s_range[x];
- add_file_size((off64_t)kilosi);
- }
- }
- else
- {
- for(kilosi=min_f_size;kilosi<=max_f_size;kilosi*=multiplier)
- {
- add_file_size((off64_t)kilosi);
- }
- }
-}
-
-/********************************************************************/
-/* Used to constuct the list of file sizes to test. */
-/********************************************************************/
-#ifdef HAVE_ANSIC_C
-void
-add_file_size(off64_t size)
-#else
-void
-add_file_size(size)
-off64_t size;
-#endif
-{
- struct size_entry *size_listp;
- struct size_entry *nsize_list;
-
- size_listp=size_list;
-
- if(size_list)
- {
- if(size_listp->next)
- while(size_listp->next!=0)
- size_listp=size_listp->next;
- }
- nsize_list=(struct size_entry *)malloc(sizeof(struct size_entry));
- if(nsize_list==0)
- {
- printf("Malloc failed in add_file_size\n");
- exit(180);
- }
- nsize_list->next=0;
- nsize_list->size=size;
- if(size_list == 0)
- size_list=nsize_list;
- else
- size_listp->next=nsize_list;
- size_listp=size_list;
-}
-
-/********************************************************************/
-/* Return the next file size to test. */
-/********************************************************************/
-#ifdef HAVE_ANSIC_C
-off64_t
-get_next_file_size(off64_t size)
-#else
-off64_t
-get_next_file_size(size)
-off64_t size;
-#endif
-{
- struct size_entry *size_listp;
-
- size_listp=size_list;
-
- for( ; size_listp ; size_listp=size_listp->next )
- {
- if(size_listp->size > size)
- return(size_listp->size);
- }
- return((off64_t)0);
-}
-
-
-/**********************************************************************/
-/* */
-/* Today this initializes the default set of record sizes for Iozone. */
-/* in the future it may take input from the command line or */
-/* from a file. */
-/* */
-/**********************************************************************/
-#ifdef HAVE_ANSIC_C
-void
-init_record_sizes( off64_t min_r_size, off64_t max_r_size)
-#else
-void
-init_record_sizes(min_r_size, max_r_size)
-off64_t min_r_size;
-off64_t max_r_size;
-#endif
-{
- int x;
- off64_t size;
- if(r_count > 1)
- {
- for(x=0; x < r_count; x++)
- {
- size=r_range[x];
- add_record_size((off64_t)size);
- }
- }
- else
- {
- for(size=min_r_size;size<=max_r_size;size*=multiplier)
- {
- add_record_size((off64_t)size);
- }
- }
-}
-
-#ifdef HAVE_ANSIC_C
-void
-del_record_sizes(void)
-#else
-void
-del_record_sizes()
-#endif
-{
- struct size_entry *size_listp;
- struct size_entry *save_item;
-
- size_listp=rec_size_list;
- if(rec_size_list)
- {
- while(size_listp!=0)
- {
- save_item=size_listp->next;
- free(size_listp);
- size_listp=save_item;
- }
- }
- rec_size_list=0;
-}
-
-/********************************************************************/
-/* Used to constuct the list of record sizes to test. */
-/********************************************************************/
-#ifdef HAVE_ANSIC_C
-void
-add_record_size(off64_t size)
-#else
-void
-add_record_size(size)
-off64_t size;
-#endif
-{
- struct size_entry *size_listp;
- struct size_entry *nsize_list;
-
- size_listp=rec_size_list;
-
- if(rec_size_list)
- {
- if(size_listp->next)
- while(size_listp->next!=0)
- size_listp=size_listp->next;
- }
- nsize_list=(struct size_entry *)malloc(sizeof(struct size_entry));
- if(nsize_list==0)
- {
- printf("Malloc failed in add_file_size\n");
- exit(180);
- }
- nsize_list->next=0;
- nsize_list->size=size;
- if(rec_size_list == 0)
- rec_size_list=nsize_list;
- else
- size_listp->next=nsize_list;
- size_listp=rec_size_list;
-}
-
-/********************************************************************/
-/* Return the next record size to test. */
-/********************************************************************/
-#ifdef HAVE_ANSIC_C
-off64_t
-get_next_record_size(off64_t size)
-#else
-off64_t
-get_next_record_size(size)
-off64_t size;
-#endif
-{
- struct size_entry *size_listp;
-
- size_listp=rec_size_list;
-
- for( ; size_listp ; size_listp=size_listp->next )
- {
- if(size_listp->size > size)
- return(size_listp->size);
- }
- return((off64_t)0);
-}
-
-
-/*
- * Socket based communication mechanism.
- * It's intended use is to be the communication mechanism
- * that will be used to get Iozone to run across
- * multiple clients. 1/11/2002 Don Capps
- * The communication model permits a master to send and receive
- * messages to and from clients, and for clients to be able to
- * send and receive messages to and from the master.
- */
-/*
- * Interfaces are:
- Master:
- int start_master_listen(void)
- Called to create masters listening port.
-
- void master_listen(int sock, int size_of_message)
- Call when master wants to block and read
- a message.
-
- int start_master_send(char *child_host_name, int port)
- Call to start a send channel to a client.
-
- void master_send(int child_socket_val, char *host_name,
- char *send_buffer, int send_size)
- Call to send message to a client.
-
- void stop_master_listen(int master_socket_val)
- Call to release the masters listening port.
-
- void stop_master_send(int child_socket_val)
- Call to release the masters send port to a client.
-
- Clients:
- int start_child_listen(int size_of_message)
- Called to create clients listening port.
-
- void child_listen(int sock, int size_of_message)
- Call when client wants to block and read
- a message from the master.
-
- void child_send(int child_socket_val, char *controlling_host_name,
- char *send_buffer, int send_size)
- Call to send message to the master.
-
- void stop_child_listen(int child_socket_val)
- Call to release the clients listening port.
-
- void stop_child_send(int child_socket_val)
- Call to release the clients send port to the master.
-
-
- Messages are sent in command blocks. The structure is
- client_command for messages from the master to the
- client, and master_command for messages sent from
- a client to the master.
-*/
-
-
-/*
- * Allocate the master listening port that
- * all children will use to send messages to the master.
- */
-#ifdef HAVE_ANSIC_C
-int
-start_master_listen(void)
-#else
-int
-start_master_listen()
-#endif
-{
- int s;
- int rc;
- int tmp_port;
- int sockerr;
- struct sockaddr_in addr;
- int recv_buf_size=65536*4;
- int optval=1;
- struct linger dummy={1,0};
-
- s = socket(AF_INET, SOCK_STREAM, 0);
- if (s < 0)
- {
- perror("socket failed:");
- exit(19);
- }
- sockerr = setsockopt (s, SOL_SOCKET, SO_RCVBUF, (char *)
- &recv_buf_size, sizeof(int));
- if ( sockerr == -1 ) {
- perror("Error in setsockopt 1\n");
- }
- sockerr = setsockopt (s, SOL_SOCKET, SO_REUSEADDR, (char *)
- &optval, sizeof(int));
- if ( sockerr == -1 ) {
- perror("Error in setsockopt 2\n");
- }
- sockerr = setsockopt (s, SOL_SOCKET, SO_LINGER, (char *)
- &dummy, sizeof(struct linger));
- if ( sockerr == -1 ) {
- perror("Error in setsockopt 2\n");
- }
- tmp_port=HOST_LIST_PORT;
- bzero(&addr, sizeof(struct sockaddr_in));
- addr.sin_port = htons(tmp_port);
- addr.sin_family = AF_INET;
- addr.sin_addr.s_addr = INADDR_ANY;
- rc = -1;
- while (rc < 0)
- {
- rc = bind(s, (struct sockaddr *)&addr,
- sizeof(struct sockaddr_in));
- if(rc < 0)
- {
- tmp_port++;
- addr.sin_port=htons(tmp_port);
- continue;
- }
- master_listen_port = ntohs(addr.sin_port);
- }
- if(rc < 0)
- {
- perror("bind failed\n");
- exit(20);
- }
-
- if(mdebug)
- printf("Master listening on socket %d Port %d\n",s,tmp_port);
- return(s);
-}
-
-/*
- * Master listens for messages and blocks until
- * something arrives.
- */
-struct sockaddr_in listener_sync_sock;
-
-#ifdef HAVE_ANSIC_C
-void
-master_listen(int sock, int size_of_message)
-#else
-void
-master_listen(sock, size_of_message)
-int sock, size_of_message;
-#endif
-{
- int tsize;
- int s;
- struct sockaddr_in *addr;
- unsigned int me;
- int ns,ret;
- struct master_neutral_command *mnc;
-
- mnc=(struct master_neutral_command *)&master_rcv_buf[0];
- tsize = size_of_message;
- addr=&listener_sync_sock;
- s = sock;
- me=sizeof(struct sockaddr_in);
-
- if(mdebug)
- printf("Master in listening mode on socket %d\n",s);
-again:
- ret=listen(s,MAXSTREAMS);
- if(ret != 0)
- {
- perror("Master: listen returned error\n");
- }
- if(mdebug)
- printf("Master in accepting connection\n");
- ns=accept(s,(void *)addr,&me);
- if(ns < 0)
- {
- printf("Master socket %d\n",s);
- perror("Master: ***** accept returned error *****\n");
- sleep(1);
- goto again;
- }
- if(mdebug)
- printf("Master in reading from connection\n");
-
- ret=read(ns,mnc,tsize);
- if(ret < tsize)
- {
- printf("Master read failed. Ret %d Errno %d\n",ret,errno);
- }
-
- close(ns);
-}
-
-/*
- * Child sends message to master.
- */
-
-#ifdef HAVE_ANSIC_C
-void
-child_send(char *controlling_host_name, struct master_command *send_buffer, int send_size)
-#else
-void
-child_send(controlling_host_name, send_buffer, send_size)
-char *controlling_host_name;
-struct master_command *send_buffer;
-int send_size;
-#endif
-{
-
- int rc,child_socket_val;
- struct hostent *he;
- int tmp_port;
- struct in_addr *ip;
- struct sockaddr_in cs_addr,cs_raddr;
- struct master_neutral_command outbuf;
- struct timespec req,rem;
-
- req.tv_sec = 0;
- req.tv_nsec = 10000000;
- rem.tv_sec = 0;
- rem.tv_nsec = 10000000;
-
- if(cdebug)
- {
- fprintf(newstdout,"Start_child_send: %s Size %d\n",controlling_host_name,send_size);
- fflush(newstdout);
- }
- he = gethostbyname(controlling_host_name);
- if (he == NULL)
- {
- exit(22);
- }
- ip = (struct in_addr *)he->h_addr_list[0];
-
-over:
- cs_raddr.sin_family = AF_INET;
- cs_raddr.sin_port = htons(controlling_host_port);
- cs_raddr.sin_addr.s_addr = ip->s_addr;
- child_socket_val = socket(AF_INET, SOCK_STREAM, 0);
- if (child_socket_val < 0)
- {
- perror("Child: socket failed:");
- exit(23);
- }
- bzero(&cs_addr, sizeof(struct sockaddr_in));
- tmp_port= CHILD_ESEND_PORT;
- cs_addr.sin_port = htons(tmp_port);
- cs_addr.sin_family = AF_INET;
- cs_addr.sin_addr.s_addr = INADDR_ANY;
- rc = -1;
- while (rc < 0)
- {
- rc = bind(child_socket_val, (struct sockaddr *)&cs_addr,
- sizeof(struct sockaddr_in));
- if(rc < 0)
- {
- tmp_port++;
- cs_addr.sin_port=htons(tmp_port);
- continue;
- }
- }
- if (rc < 0)
- {
- perror("Child: bind failed\n");
- exit(24);
- }
- if(cdebug)
- {
- fprintf(newstdout,"Child sender bound to port %d Master port %d \n",tmp_port,HOST_LIST_PORT);
- fflush(newstdout);
- }
-again:
- nanosleep(&req,&rem);
- rc = connect(child_socket_val, (struct sockaddr *)&cs_raddr,
- sizeof(struct sockaddr_in));
- if (rc < 0)
- {
- if((ecount++ < 200) && (errno != EISCONN))
- {
- nanosleep(&req,&rem);
- /*sleep(1);*/
- goto again;
- }
- if(cdebug)
- {
- fprintf(newstdout,"Child: connect failed. Errno %d \n",errno);
- fflush(newstdout);
- }
- close(child_socket_val);
- nanosleep(&req,&rem);
- /*sleep(1);*/
- ecount=0;
- goto over;
- }
- ecount=0;
- if(cdebug)
- {
- fprintf(newstdout,"Child connected\n");
- fflush(newstdout);
- }
-
- /* NOW send */
-
- bzero(&outbuf, sizeof(struct master_neutral_command));
- if(cdebug>=1)
- {
- fprintf(newstdout,"Child %d sending message to %s \n",(int)chid, controlling_host_name);
- fflush(newstdout);
- }
- /*
- * Convert internal commands to string format to neutral format for portability
- */
- strcpy(outbuf.m_host_name,send_buffer->m_host_name);
- strcpy(outbuf.m_client_name,send_buffer->m_client_name);
- sprintf(outbuf.m_client_number,"%d",send_buffer->m_client_number);
- sprintf(outbuf.m_client_error,"%d",send_buffer->m_client_error);
- sprintf(outbuf.m_child_port,"%d",send_buffer->m_child_port);
- sprintf(outbuf.m_child_async_port,"%d",send_buffer->m_child_async_port);
- sprintf(outbuf.m_command,"%d",send_buffer->m_command);
- sprintf(outbuf.m_testnum,"%d",send_buffer->m_testnum);
- sprintf(outbuf.m_version,"%d",send_buffer->m_version);
- sprintf(outbuf.m_mygen,"%d",send_buffer->m_mygen);
- sprintf(outbuf.m_throughput,"%f",send_buffer->m_throughput);
- sprintf(outbuf.m_cputime,"%f", send_buffer->m_cputime);
- sprintf(outbuf.m_walltime,"%f",send_buffer->m_walltime);
- sprintf(outbuf.m_stop_flag,"%d",send_buffer->m_stop_flag);
- sprintf(outbuf.m_actual,"%f",send_buffer->m_actual);
-#ifdef NO_PRINT_LLD
- sprintf(outbuf.m_child_flag,"%ld",send_buffer->m_child_flag);
-#else
- sprintf(outbuf.m_child_flag,"%lld",send_buffer->m_child_flag);
-#endif
- rc=write(child_socket_val,&outbuf,sizeof(struct master_neutral_command));
- if (rc < 0) {
- perror("write failed\n");
- exit(26);
- }
- close(child_socket_val);
-}
-
-
-/*
- * Master sending message to a child
- * There should be a unique child_socket_val for each
- * child.
- */
-#ifdef HAVE_ANSIC_C
-void
-master_send(int child_socket_val, char *host_name, struct client_command *send_buffer, int send_size)
-#else
-void
-master_send(child_socket_val, host_name, send_buffer, send_size)
-int child_socket_val;
-char *host_name;
-struct client_command *send_buffer;
-int send_size;
-#endif
-{
- int rc;
- struct client_neutral_command outbuf;
-
- bzero(&outbuf,sizeof(struct client_neutral_command));
- if(mdebug)
- {
- printf("Master_neutral_command size = %lu\n",(unsigned long)sizeof(struct master_neutral_command));
- printf("Client_neutral_command size = %lu\n",(unsigned long)sizeof(struct client_neutral_command));
- }
- /*
- * Convert internal commands to string format for neutral format/portability
- */
- strcpy(outbuf.c_host_name,send_buffer->c_host_name);
- strcpy(outbuf.c_pit_hostname,send_buffer->c_pit_hostname);
- strcpy(outbuf.c_pit_service,send_buffer->c_pit_service);
- strcpy(outbuf.c_client_name,send_buffer->c_client_name);
- strcpy(outbuf.c_working_dir,send_buffer->c_working_dir);
- strcpy(outbuf.c_file_name,send_buffer->c_file_name);
- strcpy(outbuf.c_path_dir,send_buffer->c_path_dir);
- strcpy(outbuf.c_execute_name,send_buffer->c_execute_name);
- strcpy(outbuf.c_write_traj_filename,send_buffer->c_write_traj_filename);
- strcpy(outbuf.c_read_traj_filename,send_buffer->c_read_traj_filename);
- sprintf(outbuf.c_oflag,"%d",send_buffer->c_oflag);
- sprintf(outbuf.c_mfflag,"%d",send_buffer->c_mfflag);
- sprintf(outbuf.c_unbuffered,"%d",send_buffer->c_unbuffered);
- sprintf(outbuf.c_noretest,"%d",send_buffer->c_noretest);
- sprintf(outbuf.c_notruncate,"%d",send_buffer->c_notruncate);
- sprintf(outbuf.c_read_sync,"%d",send_buffer->c_read_sync);
- sprintf(outbuf.c_jflag,"%d",send_buffer->c_jflag);
- sprintf(outbuf.c_async_flag,"%d",send_buffer->c_async_flag);
- sprintf(outbuf.c_mmapflag,"%d",send_buffer->c_mmapflag);
- sprintf(outbuf.c_k_flag,"%d",send_buffer->c_k_flag);
- sprintf(outbuf.c_h_flag,"%d",send_buffer->c_h_flag);
- sprintf(outbuf.c_mflag,"%d",send_buffer->c_mflag);
- sprintf(outbuf.c_pflag,"%d",send_buffer->c_pflag);
- sprintf(outbuf.c_stride_flag,"%d",send_buffer->c_stride_flag);
- sprintf(outbuf.c_verify,"%d",send_buffer->c_verify);
- sprintf(outbuf.c_sverify,"%d",send_buffer->c_sverify);
- sprintf(outbuf.c_odsync,"%d",send_buffer->c_odsync);
- sprintf(outbuf.c_diag_v,"%d",send_buffer->c_diag_v);
- sprintf(outbuf.c_dedup,"%d",send_buffer->c_dedup);
- sprintf(outbuf.c_dedup_interior,"%d",send_buffer->c_dedup_interior);
- sprintf(outbuf.c_dedup_compress,"%d",send_buffer->c_dedup_compress);
- sprintf(outbuf.c_dedup_mseed,"%d",send_buffer->c_dedup_mseed);
- sprintf(outbuf.c_hist_summary,"%d",send_buffer->c_hist_summary);
- sprintf(outbuf.c_op_rate,"%d",send_buffer->c_op_rate);
- sprintf(outbuf.c_op_rate_flag,"%d",send_buffer->c_op_rate_flag);
- sprintf(outbuf.c_Q_flag,"%d",send_buffer->c_Q_flag);
- sprintf(outbuf.c_L_flag,"%d",send_buffer->c_L_flag);
- sprintf(outbuf.c_include_flush,"%d",send_buffer->c_include_flush);
- sprintf(outbuf.c_OPS_flag,"%d",send_buffer->c_OPS_flag);
- sprintf(outbuf.c_mmapnsflag,"%d",send_buffer->c_mmapnsflag);
- sprintf(outbuf.c_mmapssflag,"%d",send_buffer->c_mmapssflag);
- sprintf(outbuf.c_mmapasflag,"%d",send_buffer->c_mmapasflag);
- sprintf(outbuf.c_no_copy_flag,"%d",send_buffer->c_no_copy_flag);
- sprintf(outbuf.c_include_close,"%d",send_buffer->c_include_close);
- sprintf(outbuf.c_disrupt_flag,"%d",send_buffer->c_disrupt_flag);
- sprintf(outbuf.c_compute_flag,"%d",send_buffer->c_compute_flag);
- sprintf(outbuf.c_xflag,"%d",send_buffer->c_xflag);
- sprintf(outbuf.c_MS_flag,"%d",send_buffer->c_MS_flag);
- sprintf(outbuf.c_mmap_mix,"%d",send_buffer->c_mmap_mix);
- sprintf(outbuf.c_Kplus_flag,"%d",send_buffer->c_Kplus_flag);
- sprintf(outbuf.c_w_traj_flag,"%d",send_buffer->c_w_traj_flag);
- sprintf(outbuf.c_r_traj_flag,"%d",send_buffer->c_r_traj_flag);
- sprintf(outbuf.c_direct_flag,"%d",send_buffer->c_direct_flag);
- sprintf(outbuf.c_cpuutilflag,"%d",send_buffer->c_cpuutilflag);
- sprintf(outbuf.c_seq_mix,"%d",send_buffer->c_seq_mix);
- sprintf(outbuf.c_client_number,"%d",send_buffer->c_client_number);
- sprintf(outbuf.c_command,"%d",send_buffer->c_command);
- sprintf(outbuf.c_testnum,"%d",send_buffer->c_testnum);
- sprintf(outbuf.c_no_unlink,"%d",send_buffer->c_no_unlink);
- sprintf(outbuf.c_no_write,"%d",send_buffer->c_no_write);
- sprintf(outbuf.c_file_lock,"%d",send_buffer->c_file_lock);
- sprintf(outbuf.c_rec_lock,"%d",send_buffer->c_rec_lock);
- sprintf(outbuf.c_Kplus_readers,"%d",send_buffer->c_Kplus_readers);
- sprintf(outbuf.c_multiplier,"%d",send_buffer->c_multiplier);
- sprintf(outbuf.c_share_file,"%d",send_buffer->c_share_file);
- sprintf(outbuf.c_pattern,"%d",send_buffer->c_pattern);
- sprintf(outbuf.c_version,"%d",send_buffer->c_version);
- sprintf(outbuf.c_base_time,"%d",send_buffer->c_base_time);
- sprintf(outbuf.c_num_child,"%d",send_buffer->c_num_child);
- sprintf(outbuf.c_pct_read,"%d",send_buffer->c_pct_read);
- sprintf(outbuf.c_advise_op,"%d",send_buffer->c_advise_op);
- sprintf(outbuf.c_advise_flag,"%d",send_buffer->c_advise_flag);
- sprintf(outbuf.c_restf,"%d",send_buffer->c_restf);
- sprintf(outbuf.c_mygen,"%d",send_buffer->c_mygen);
-#ifdef NO_PRINT_LLD
- sprintf(outbuf.c_stride,"%ld",send_buffer->c_stride);
- sprintf(outbuf.c_rest_val,"%ld",send_buffer->c_rest_val);
- sprintf(outbuf.c_delay,"%ld",send_buffer->c_delay);
- sprintf(outbuf.c_purge,"%ld",send_buffer->c_purge);
- sprintf(outbuf.c_fetchon,"%ld",send_buffer->c_fetchon);
- sprintf(outbuf.c_numrecs64,"%ld",send_buffer->c_numrecs64);
- sprintf(outbuf.c_reclen,"%ld",send_buffer->c_reclen);
- sprintf(outbuf.c_child_flag,"%ld",send_buffer->c_child_flag);
- sprintf(outbuf.c_delay_start,"%ld",send_buffer->c_delay_start);
- sprintf(outbuf.c_depth,"%ld",send_buffer->c_depth);
-#else
- sprintf(outbuf.c_delay,"%lld",send_buffer->c_delay);
- sprintf(outbuf.c_stride,"%lld",send_buffer->c_stride);
- sprintf(outbuf.c_rest_val,"%lld",send_buffer->c_rest_val);
- sprintf(outbuf.c_purge,"%lld",send_buffer->c_purge);
- sprintf(outbuf.c_fetchon,"%lld",send_buffer->c_fetchon);
- sprintf(outbuf.c_numrecs64,"%lld",send_buffer->c_numrecs64);
- sprintf(outbuf.c_reclen,"%lld",send_buffer->c_reclen);
- sprintf(outbuf.c_child_flag,"%lld",send_buffer->c_child_flag);
- sprintf(outbuf.c_delay_start,"%lld",send_buffer->c_delay_start);
- sprintf(outbuf.c_depth,"%lld",send_buffer->c_depth);
-#endif
- sprintf(outbuf.c_stop_flag,"%d",send_buffer->c_stop_flag);
- sprintf(outbuf.c_compute_time,"%f",send_buffer->c_compute_time);
-
- if(mdebug >= 1)
- printf("Master sending message to %s \n",host_name);
- /*rc = send(child_socket_val, (char *)&outbuf, sizeof(struct client_neutral_command), 0);*/
- rc = write(child_socket_val, (char *)&outbuf, sizeof(struct client_neutral_command));
- if (rc < 0)
- {
- perror("write failed\n");
- exit(26);
- }
-}
-
-/*
- * Close the childs listening port for messages from the master.
- */
-#ifdef HAVE_ANSIC_C
-void
-stop_child_listen(int child_socket_val)
-#else
-void
-stop_child_listen(child_socket_val)
-int child_socket_val;
-#endif
-{
- close(child_socket_val);
-}
-
-/*
- * Close the childs channel for sending messages to the master.
- */
-#ifdef HAVE_ANSIC_C
-void
-O_stop_child_send(int child_socket_val)
-#else
-void
-O_stop_child_send(child_socket_val)
-int child_socket_val;
-#endif
-{
- close(child_socket_val);
-}
-
-/*
- * Close the masters listening channel for all clients messages.
- */
-#ifdef HAVE_ANSIC_C
-void
-stop_master_listen(int master_socket_val)
-#else
-void
-stop_master_listen(master_socket_val)
-int master_socket_val;
-#endif
-{
- if(mdebug)
- printf("Stop master listen\n");
-/*
- shutdown(master_socket_val,SHUT_RDWR);
-*/
- close(master_socket_val);
- master_socket_val = 0;
-}
-
-/*
- * Close the masters send channel a particular child.
- */
-#ifdef HAVE_ANSIC_C
-void
-stop_master_send(int child_socket_val)
-#else
-void
-stop_master_send(child_socket_val)
-int child_socket_val;
-#endif
-{
- close(child_socket_val);
-}
-
-/*
- * Start the childs listening service for messages from the master.
- */
-#ifdef HAVE_ANSIC_C
-int
-start_child_listen(int size_of_message)
-#else
-int
-start_child_listen(size_of_message)
-int size_of_message;
-#endif
-{
- int tsize;
- int s;
- int rc;
- int xx;
- int tmp_port;
- int sockerr;
- int recv_buf_size=65536;
- int optval=1;
- struct linger dummy={1,0};
- xx = 0;
- tsize=size_of_message; /* Number of messages to receive */
- s = socket(AF_INET, SOCK_STREAM, 0);
- if (s < 0)
- {
- perror("socket failed:");
- exit(19);
- }
- sockerr = setsockopt (s, SOL_SOCKET, SO_RCVBUF, (char *)
- &recv_buf_size, sizeof(int));
- if ( sockerr == -1 ) {
- perror("Error in setsockopt 3\n");
- }
- sockerr = setsockopt (s, SOL_SOCKET, SO_REUSEADDR, (char *)
- &optval, sizeof(int));
- if ( sockerr == -1 ) {
- perror("Error in setsockopt 4\n");
- }
- sockerr = setsockopt (s, SOL_SOCKET, SO_LINGER, (char *)
- &dummy, sizeof(struct linger));
- if ( sockerr == -1 ) {
- perror("Error in setsockopt 4\n");
- }
- bzero(&child_sync_sock, sizeof(struct sockaddr_in));
- tmp_port=CHILD_LIST_PORT+chid;
- child_sync_sock.sin_port = htons(tmp_port);
- child_sync_sock.sin_family = AF_INET;
- child_sync_sock.sin_addr.s_addr = INADDR_ANY;
- rc = -1;
- while (rc < 0)
- {
- rc = bind(s, (struct sockaddr *)&child_sync_sock,
- sizeof(struct sockaddr_in));
- if(rc < 0)
- {
- tmp_port++;
- child_sync_sock.sin_port=htons(tmp_port);
- continue;
- }
- }
- child_port = ntohs(child_sync_sock.sin_port);
- if(cdebug ==1)
- {
- fprintf(newstdout,"Child %d: Listen: Bound at port %d\n",(int)chid, tmp_port);
- fflush(newstdout);
- }
- if(rc < 0)
- {
- fprintf(newstdout,"Child bind failed. Errno %d\n",errno);
- fflush(newstdout);
- exit(20);
- }
- return(s);
-}
-#ifdef HAVE_ANSIC_C
-int
-child_attach(int s, int flag)
-#else
-int
-child_attach(s, flag)
-int s,flag;
-#endif
-{
- unsigned int me;
- int ns;
- struct sockaddr_in *addr;
- if(flag)
- {
- addr=&child_async_sock;
- if(cdebug)
- {
- fprintf(newstdout,"Child %d attach async\n",(int)chid);
- fflush(newstdout);
- }
- }
- else
- {
- addr=&child_sync_sock;
- if(cdebug)
- {
- fprintf(newstdout,"Child %d attach sync\n",(int)chid);
- fflush(newstdout);
- }
- }
- me=sizeof(struct sockaddr_in);
- if(cdebug)
- {
- printf("Child %d enters listen\n",(int)chid);
- fflush(stdout);
- }
- listen(s,10);
- if(cdebug)
- {
- fprintf(newstdout,"Child %d enters accept\n",(int)chid);
- fflush(newstdout);
- }
- ns=accept(s,(void *)addr,&me);
- if(cdebug)
- {
- fprintf(newstdout,"Child %d attached for receive. Sock %d %d\n",
- (int)chid, ns,errno);
- fflush(newstdout);
- }
- return(ns);
-}
-
-
-/*
- * The clients use this to block waiting for a message from
- * the master.
- */
-#ifdef HAVE_ANSIC_C
-void
-child_listen(int sock, int size_of_message)
-#else
-void
-child_listen(sock, size_of_message)
-int sock, size_of_message;
-#endif
-{
- int tsize;
- int rcvd;
- int s;
- int rc;
- char *cnc;
-
- cnc = (char *)&child_rcv_buf[0];
- bzero(cnc, sizeof(child_rcv_buf));
- s = sock;
- tsize=size_of_message; /* Number of messages to receive */
- rcvd = 0;
- while(rcvd < tsize)
- {
- if(cdebug ==1)
- {
- fprintf(newstdout,"Child %d In recieve \n",(int)chid);
- fflush(newstdout);
- }
- rc=read(s,cnc,size_of_message);
- if(rc < 0)
- {
- fprintf(newstdout,"Read failed. Errno %d \n",errno);
- fflush(newstdout);
- exit(21);
- }
- if(cdebug >= 1)
- {
- fprintf(newstdout,"Child %d: Got %d bytes\n",(int)chid, rc);
- fflush(newstdout);
- }
- rcvd+=rc;
- cnc+=rc;
- }
- if(cdebug >= 1)
- {
- fprintf(newstdout,"Child %d: return from listen\n",(int)chid);
- fflush(newstdout);
- }
-}
-/*
- * Start the childs async listening service for messages from the master.
- */
-#ifdef HAVE_ANSIC_C
-int
-start_child_listen_async(int size_of_message)
-#else
-int
-start_child_listen_async(size_of_message)
-int size_of_message;
-#endif
-{
- int tsize;
- int s;
- int rc;
- int xx;
- int tmp_port;
- int sockerr;
- int recv_buf_size=65536;
- int optval=1;
- xx = 0;
- tsize=size_of_message; /* Number of messages to receive */
- s = socket(AF_INET, SOCK_STREAM, 0);
- if (s < 0)
- {
- perror("socket failed:");
- exit(19);
- }
- sockerr = setsockopt (s, SOL_SOCKET, SO_RCVBUF, (char *)
- &recv_buf_size, sizeof(int));
- if ( sockerr == -1 ) {
- perror("Error in setsockopt 5\n");
- }
- sockerr = setsockopt (s, SOL_SOCKET, SO_REUSEADDR, (char *)
- &optval, sizeof(int));
- if ( sockerr == -1 ) {
- perror("Error in setsockopt 6\n");
- }
- bzero(&child_async_sock, sizeof(struct sockaddr_in));
- tmp_port=CHILD_ALIST_PORT;
- child_async_sock.sin_port = htons(tmp_port);
- child_async_sock.sin_family = AF_INET;
- child_async_sock.sin_addr.s_addr = INADDR_ANY;
- rc = -1;
- while (rc < 0)
- {
- rc = bind(s, (struct sockaddr *)&child_async_sock,
- sizeof(struct sockaddr_in));
- if(rc < 0)
- {
- tmp_port++;
- child_async_sock.sin_port=htons(tmp_port);
- continue;
- }
- }
- child_async_port = ntohs(child_async_sock.sin_port);
- if(cdebug ==1)
- {
- fprintf(newstdout,"Child %d: Async Listen: Bound at port %d\n",
- (int)chid,tmp_port);
- fflush(newstdout);
- }
- if(rc < 0)
- {
- fprintf(newstdout,"bind failed. Errno %d \n",errno);
- fflush(newstdout);
- exit(20);
- }
- return(s);
-}
-/*
- * The clients use this to block waiting for an async message from
- * the master.
- */
-#ifdef HAVE_ANSIC_C
-void
-child_listen_async(int sock, int size_of_message)
-#else
-void
-child_listen_async(sock, size_of_message)
-int sock, size_of_message;
-#endif
-{
- int tsize;
- int rcvd;
- int s;
- int rc;
- char *cnc;
-
- cnc = &child_async_rcv_buf[0];
- s = sock;
- tsize=size_of_message; /* Number of messages to receive */
- rcvd = 0;
- while(rcvd < tsize)
- {
- if(cdebug ==1)
- {
- fprintf(newstdout,"Child %d In async recieve \n",(int)chid);
- fflush(newstdout);
- }
- rc=read(s,cnc,size_of_message);
- if(rc < 0)
- {
- fprintf(newstdout,"Read failed. Errno %d \n",errno);
- fflush(newstdout);
- exit(21);
- }
- /* Special case. If master gets final results, it can
- exit, and close the connection to the async child
- too quickly. When this happens the child gets a
- read() that returns 0. It just needs to exit here.
- */
- if(rc==0)
- exit(0);
- if(cdebug >= 1)
- {
- fprintf(newstdout,"Child %d: Got %d bytes (async) \n",(int)chid,rc);
- fflush(newstdout);
- }
- rcvd+=rc;
- cnc+=rc;
- }
- if(cdebug >= 1)
- {
- fprintf(newstdout,"Child %d: return from async listen\n",(int)chid);
- fflush(newstdout);
- }
-}
-
-/*
- * Start the channel for the master to send a message to
- * a particular child on a particular port that the child
- * has created for the parent to use to communicate.
- */
-#ifdef HAVE_ANSIC_C
-int
-start_master_send(char *child_host_name, int child_port, struct in_addr *my_s_addr)
-#else
-int
-start_master_send(child_host_name, child_port, my_s_addr)
-char *child_host_name;
-int child_port;
-struct in_addr *my_s_addr;
-#endif
-{
- int rc,master_socket_val;
- struct sockaddr_in addr,raddr;
- struct hostent *he;
- int port,tmp_port;
- int ecount = 0;
- struct in_addr *ip;
- struct timespec req,rem;
-
- req.tv_sec = 0;
- req.tv_nsec = 10000000;
- rem.tv_sec = 0;
- rem.tv_nsec = 10000000;
-
- he = gethostbyname(child_host_name);
- if (he == NULL)
- {
- printf("Master: Bad hostname >%s<\n",child_host_name);
- fflush(stdout);
- exit(22);
- }
- if(mdebug ==1)
- {
- printf("Master: start master send: %s\n", he->h_name);
- fflush(stdout);
- }
- ip = (struct in_addr *)he->h_addr_list[0];
-#ifndef UWIN
- if(mdebug ==1)
- {
- printf("Master: child name: %s\n", (char *)inet_ntoa(*ip));
- printf("Master: child Port: %d\n", child_port);
- fflush(stdout);
- }
-#endif
-
- port=child_port;
- my_s_addr->s_addr = ip->s_addr;
- /*port=CHILD_LIST_PORT;*/
-
- raddr.sin_family = AF_INET;
- raddr.sin_port = htons(port);
- raddr.sin_addr.s_addr = ip->s_addr;
- master_socket_val = socket(AF_INET, SOCK_STREAM, 0);
- if (master_socket_val < 0)
- {
- perror("Master: socket failed:");
- exit(23);
- }
- bzero(&addr, sizeof(struct sockaddr_in));
- tmp_port=HOST_ESEND_PORT;
- addr.sin_port = htons(tmp_port);
- addr.sin_family = AF_INET;
- addr.sin_addr.s_addr = INADDR_ANY;
- rc = -1;
- while (rc < 0)
- {
- rc = bind(master_socket_val, (struct sockaddr *)&addr,
- sizeof(struct sockaddr_in));
- if(rc < 0)
- {
- tmp_port++;
- addr.sin_port=htons(tmp_port);
- continue;
- }
- }
- if(mdebug ==1)
- {
- printf("Master: Bound port\n");
- fflush(stdout);
- }
- if (rc < 0)
- {
- perror("Master: bind failed for sync channel to child.\n");
- exit(24);
- }
- nanosleep(&req,&rem);
-again:
- rc = connect(master_socket_val, (struct sockaddr *)&raddr,
- sizeof(struct sockaddr_in));
- if (rc < 0)
- {
- if(ecount++ < 300)
- {
- nanosleep(&req,&rem);
- /*sleep(1);*/
- goto again;
- }
- perror("Master: connect failed\n");
- printf("Error %d\n",errno);
- exit(25);
- }
- if(mdebug ==1)
- {
- printf("Master Connected\n");
- fflush(stdout);
- }
- return (master_socket_val);
-}
-/*
- * Start the channel for the master to send a message to
- * a particular child on a particular port that the child
- * has created for the parent to use to communicate.
- */
-#ifdef HAVE_ANSIC_C
-int
-start_master_send_async(char *child_host_name, int child_port, struct in_addr my_s_addr)
-#else
-int
-start_master_send_async(child_host_name, child_port, my_s_addr)
-char *child_host_name;
-int child_port;
-struct in_addr my_s_addr;
-#endif
-{
- int rc,master_socket_val;
- struct sockaddr_in addr,raddr;
- int port,tmp_port;
- int ecount = 0;
- struct timespec req,rem;
-
- req.tv_sec = 0;
- req.tv_nsec = 10000000;
- rem.tv_sec = 0;
- rem.tv_nsec = 10000000;
-
-
- port=child_port;
- nanosleep(&req,&rem);
-
-over:
- raddr.sin_family = AF_INET;
- raddr.sin_port = htons(port);
- raddr.sin_addr.s_addr = my_s_addr.s_addr;
- master_socket_val = socket(AF_INET, SOCK_STREAM, 0);
- if (master_socket_val < 0)
- {
- perror("Master: async socket failed:");
- exit(23);
- }
- bzero(&addr, sizeof(struct sockaddr_in));
- tmp_port=HOST_ASEND_PORT;
- addr.sin_port = htons(tmp_port);
- addr.sin_family = AF_INET;
- addr.sin_addr.s_addr = INADDR_ANY;
- rc = -1;
- while (rc < 0)
- {
- rc = bind(master_socket_val, (struct sockaddr *)&addr,
- sizeof(struct sockaddr_in));
- if(rc < 0)
- {
- tmp_port++;
- addr.sin_port=htons(tmp_port);
- continue;
- }
- }
- if(mdebug ==1)
- {
- printf("Master: Bound async port\n");
- fflush(stdout);
- }
- if (rc < 0)
- {
- perror("Master: bind async failed\n");
- exit(24);
- }
-again:
-
- rc = connect(master_socket_val, (struct sockaddr *)&raddr,
- sizeof(struct sockaddr_in));
- if (rc < 0)
- {
- if(ecount++ < 300)
- {
- /* Really need this sleep for Windows */
-#if defined (Windows)
- sleep(1);
-#else
- nanosleep(&req,&rem);
-#endif
- goto again;
- }
- perror("Master: async connect failed\n");
- close(master_socket_val);
-#if defined (Windows)
- sleep(1);
-#else
- nanosleep(&req,&rem);
-#endif
- /*sleep(1);*/
- ecount=0;
- goto over;
- }
- if(mdebug ==1)
- {
- printf("Master async Connected\n");
- fflush(stdout);
- }
- return (master_socket_val);
-}
-
-/*
- * If not "distributed" then call fork. The "distributed"
- * will start iozone on a remote node.
- */
-#ifdef HAVE_ANSIC_C
-long long
-start_child_proc(int testnum,long long numrecs64, long long reclen)
-#else
-long long
-start_child_proc(testnum, numrecs64, reclen)
-int testnum;
-long long numrecs64, reclen;
-#endif
-{
- long long x;
- if(distributed && master_iozone)
- {
- x=(long long)pick_client(testnum,numrecs64, reclen);
- }
- else
- {
- x=(long long)fork();
- }
- if(mdebug)
- printf("Starting proc %d\n",(int)x);
- return(x);
-}
-
-/*
- * This function picks a client from the list of clients and
- * starts it running on the remote machine. It also waits for
- * the remote process to join and then sends the client
- * the state information it needs to begin to run the
- * test. The client will initialize its state space,
- * begin the test and block as the barrier waiting
- * for the master to say go.
- */
-#ifdef HAVE_ANSIC_C
-int
-pick_client(int testnum,long long numrecs64, long long reclen)
-#else
-int
-pick_client(testnum, numrecs64, reclen)
-int testnum;
-long long numrecs64, reclen;
-#endif
-{
- int x;
- int c_command,child_index;
- struct client_command cc;
- struct master_command mc;
- struct master_neutral_command *mnc;
- char command[512];
- struct in_addr my_s_addr;
- char my_port_num[10];
-
-
- bzero(&cc,sizeof(struct client_command));
- for(x=0;x<512;x++)
- command[x]=0;
-
- current_client_number++; /* Need to start with 1 */
- x=current_client_number;
-
- child_idents[x-1].state = C_STATE_ZERO;
- /* Step 1. Now start client going on remote node. */
-
- find_remote_shell(remote_shell);
- sprintf(command,"%s ",remote_shell);
- strcat(command,child_idents[x-1].child_name);
- strcat(command," -n '");
- strcat(command,child_idents[x-1].execute_path);
- strcat(command," -+s -t 1 -r 4 -s 4 -+c ");
- strcat(command,controlling_host_name);
- if (master_listen_port != HOST_LIST_PORT)
- {
- sprintf(my_port_num," -+i %d",master_listen_port);
- strcat(command,my_port_num);
- }
- strcat(command," '");
- junk=system(command);
-/*
- system("remsh rsnperf '/home/capps/niozone/iozone -+s -t 1 -r 4 -s 8 -+c rsnperf'");
-
-*/
- if(mdebug)
- printf("%s",command);
- /* Format example: */
- /* */
- /* system("remsh rsnperf '/home/capps/niozone/iozone */
- /* -+s -t 1 -r 4 -s 8 -+c rsnperf'"); */
- /* */
-
- /* Step 2. Wait for join from new client. */
-
- child_idents[x-1].state = C_STATE_WAIT_WHO;
-
- if(mdebug>=1)
- printf("\nMaster listening for child to send join message.\n");
- master_listen(master_listen_socket,sizeof(struct master_neutral_command));
- mnc = (struct master_neutral_command *)&master_rcv_buf[0];
-
- /*
- * Convert from string format back to internal representation
- */
- sscanf(mnc->m_child_port,"%d",&mc.m_child_port);
- sscanf(mnc->m_child_async_port,"%d",&mc.m_child_async_port);
- sscanf(mnc->m_command,"%d",&mc.m_command);
- sscanf(mnc->m_version,"%d",&mc.m_version);
- if(mc.m_version != proto_version)
- {
- printf("Client > %s < is not running the same version of Iozone !! C%d M%d\n", child_idents[x-1].child_name, mc.m_version, proto_version);
- }
-
- c_port = mc.m_child_port;
- a_port = mc.m_child_async_port;
- c_command = mc.m_command;
- if(mdebug>=1)
- {
- printf("Master back from listen child Joined.\n");
- printf("Master: Command %d\n",c_command);
- }
- /* Step 3. Then start_master_send() for this client. */
-
- if(mdebug>=1)
- printf("Starting master send channel\n");
- master_send_sockets[x-1]= start_master_send(child_idents[x-1].child_name,c_port,
- &my_s_addr);
- if(mdebug>=1)
- printf("Starting master send async channel\n");
- master_send_async_sockets[x-1]= start_master_send_async(child_idents[x-1].child_name,a_port,
- my_s_addr);
-
- child_idents[x-1].master_socket_num = master_send_sockets[x-1];
- child_idents[x-1].master_async_socket_num = master_send_async_sockets[x-1];
- child_idents[x-1].child_number = x-1;
- child_idents[x-1].child_port = c_port;
- child_idents[x-1].child_async_port = a_port;
-
- /* */
- /* Step 4. Send message to client telling him his name, number, */
- /* rsize, fsize, and test to run. */
- strcpy(cc.c_host_name ,controlling_host_name);
- strcpy(cc.c_pit_hostname ,pit_hostname);
- strcpy(cc.c_pit_service ,pit_service);
- strcpy(cc.c_client_name ,child_idents[x-1].child_name);
- strcpy(cc.c_working_dir ,child_idents[x-1].workdir);
- strcpy(cc.c_file_name ,child_idents[x-1].file_name);
- strcpy(cc.c_write_traj_filename ,write_traj_filename);
- strcpy(cc.c_read_traj_filename ,read_traj_filename);
- cc.c_command = R_JOIN_ACK;
- cc.c_client_number = x-1;
- cc.c_testnum = testnum;
- cc.c_numrecs64 = numrecs64;
- cc.c_reclen = reclen;
- cc.c_oflag = oflag;
- cc.c_mfflag = mfflag;
- cc.c_unbuffered = unbuffered;
- cc.c_noretest = noretest;
- cc.c_notruncate = notruncate;
- cc.c_read_sync = read_sync;
- cc.c_jflag = jflag;
- cc.c_direct_flag = direct_flag;
- cc.c_cpuutilflag = cpuutilflag;
- cc.c_seq_mix = seq_mix;
- cc.c_async_flag = async_flag;
- cc.c_k_flag = k_flag;
- cc.c_h_flag = h_flag;
- cc.c_mflag = mflag;
- cc.c_pflag = pflag;
- cc.c_stride_flag = stride_flag;
- cc.c_fetchon = fetchon;
- cc.c_verify = verify;
- cc.c_sverify = sverify;
- cc.c_odsync = odsync;
- cc.c_diag_v = diag_v;
- cc.c_dedup = dedup;
- cc.c_dedup_interior = dedup_interior;
- cc.c_dedup_compress = dedup_compress;
- cc.c_dedup_mseed = dedup_mseed;
- cc.c_hist_summary = hist_summary;
- cc.c_op_rate = op_rate;
- cc.c_op_rate_flag = op_rate_flag;
- cc.c_file_lock = file_lock;
- cc.c_rec_lock = rlocking;
- cc.c_Kplus_readers = Kplus_readers;
- cc.c_multiplier = multiplier;
- cc.c_share_file = share_file;
- cc.c_pattern = pattern;
- cc.c_version = proto_version;
- cc.c_base_time = base_time;
- cc.c_num_child = (int)num_child;
- cc.c_pct_read = pct_read;
- cc.c_advise_op = advise_op;
- cc.c_advise_flag = advise_flag;
- cc.c_restf = restf;
- cc.c_mygen = mygen;
- cc.c_Q_flag = Q_flag;
- cc.c_L_flag = L_flag;
- cc.c_xflag = xflag;
- cc.c_w_traj_flag = w_traj_flag;
- cc.c_r_traj_flag = r_traj_flag;
- cc.c_include_flush = include_flush;
- cc.c_OPS_flag = OPS_flag;
- cc.c_purge = purge;
- cc.c_mmapflag = mmapflag;
- cc.c_mmapasflag = mmapasflag;
- cc.c_mmapnsflag = mmapnsflag;
- cc.c_mmapssflag = mmapssflag;
- cc.c_no_copy_flag = no_copy_flag;
- cc.c_no_unlink = no_unlink;
- cc.c_no_write = no_write;
- cc.c_include_close = include_close;
- cc.c_disrupt_flag = disrupt_flag;
- cc.c_compute_flag = compute_flag;
- cc.c_delay = delay;
- cc.c_stride = stride;
- cc.c_rest_val = rest_val;
- cc.c_delay_start = delay_start;
- cc.c_compute_time = compute_time;
- cc.c_depth = depth;
- cc.c_MS_flag = MS_flag;
- cc.c_mmap_mix = mmap_mix;
- cc.c_Kplus_flag = Kplus_flag;
-
-
- if(mdebug)
- printf("Master sending client who he is\n");
- master_send(master_send_sockets[x-1],cc.c_client_name, &cc,sizeof(struct client_command));
-
- child_idents[x-1].state = C_STATE_WAIT_BARRIER;
-
- /* */
- /* Step 5. Wait until you receive message that the chile is at */
- /* the barrier. */
- if(mdebug>=1)
- printf("Master listening for child to send at barrier message.\n");
- master_listen(master_listen_socket,sizeof(struct master_neutral_command));
- mnc = (struct master_neutral_command *)&master_rcv_buf[0];
- /*
- * Convert from string back to arch specific
- */
- sscanf(mnc->m_client_number,"%d",&mc.m_client_number);
-#ifdef NO_PRINT_LLD
- sscanf(mnc->m_child_flag,"%ld",&mc.m_child_flag);
-#else
- sscanf(mnc->m_child_flag,"%lld",&mc.m_child_flag);
-#endif
-
- child_index = mc.m_client_number;
- child_stat = (struct child_stats *)&shmaddr[child_index];
- child_stat->flag = (long long)(mc.m_child_flag);
- if(mdebug>=1)
- printf("Master sees child %d at barrier message.\n",child_index);
-
- return(x); /* Tell code above that it is the parent returning */
-}
-
-/****************************************************************************************/
-/* This is the code that the client will use when it */
-/* gets started via remote shell. It is activated by the -+c controller_name option. */
-/* */
-/* The steps to this process are: */
-/* 1. Start client receive channel */
-/* 2. Start client send channel */
-/* 3. Send message to controller saying I'm joining. */
-/* 4. Go into a loop and get all instructions from */
-/* 5. Get state information from the master */
-/* 6. Change to the working directory */
-/* 7. Run the test */
-/* 8. Release the listen and send sockets to the master */
-/* */
-/****************************************************************************************/
-#ifdef HAVE_ANSIC_C
-void
-become_client(void)
-#else
-void
-become_client()
-#endif
-{
- int x,testnum;
- struct master_command mc;
- struct client_command cc;
- struct client_neutral_command *cnc;
- char client_name[100];
- char *workdir;
-
- bzero(&mc,sizeof(struct master_command));
- x=fork(); /* Become a daemon so that remote shell will return. */
- if(x != 0)
- exit(0);
- /*
- * I am the child
- */
- (void)gethostname(client_name,100);
-
- fflush(stdout);
- fflush(stderr);
- if(cdebug)
- {
- newstdin=freopen("/tmp/don_in","r+",stdin);
- newstdout=freopen("/tmp/don_out","a+",stdout);
- newstderr=freopen("/tmp/don_err","a+",stderr);
- }
- else
- {
- fclose(stdin);
- fclose(stdout);
- fclose(stderr);
- }
- if(cdebug>=1)
- {
- fprintf(newstdout,"My name = %s, Controller's name = %s\n",client_name, controlling_host_name);
- fflush(newstdout);
- }
-
- /* 1. Start client receive channel */
-
- l_sock = start_child_listen(sizeof(struct client_neutral_command));
- l_async_sock = start_child_listen_async(sizeof(struct client_neutral_command));
-
- /* 2. Send message to controller saying I'm joining. */
-
- strcpy(mc.m_host_name,controlling_host_name);
- strcpy(mc.m_client_name,client_name);
- mc.m_child_port = child_port;
- mc.m_child_async_port = child_async_port;
- mc.m_command = R_CHILD_JOIN;
- mc.m_version = proto_version;
-
- if(cdebug)
- {
- fprintf(newstdout,"Child %s sends JOIN to master %s Host Port %d\n",
- client_name,controlling_host_name,controlling_host_port);
- fflush(newstdout);
- }
- child_send(controlling_host_name,(struct master_command *)&mc, sizeof(struct master_command));
-
- l_sock=child_attach(l_sock,0);
- l_async_sock=child_attach(l_async_sock,1);
-
- /* 4. Go into a loop and get all instructions from */
- /* the controlling process. */
-
- if(cdebug>=1)
- {
- fprintf(newstdout,"Child %s waiting for who am I\n",client_name);
- fflush(newstdout);
- }
- child_listen(l_sock,sizeof(struct client_neutral_command));
- cnc = (struct client_neutral_command *)&child_rcv_buf;
- bzero(&cc, sizeof(struct client_command));
-
- /* Convert from string format to arch format */
- sscanf(cnc->c_command,"%d",&cc.c_command);
- sscanf(cnc->c_client_name,"%s",cc.c_client_name);
- sscanf(cnc->c_client_number,"%d",&cc.c_client_number);
- sscanf(cnc->c_host_name,"%s",cc.c_host_name);
- sscanf(cnc->c_pit_hostname,"%s",cc.c_pit_hostname);
-
- if(cc.c_command == R_TERMINATE || cc.c_command==R_DEATH)
- {
- if(cdebug)
- {
- fprintf(newstdout,"Child %d received terminate on sync channel !!\n",(int)chid);
- fflush(newstdout);
- }
- exit(1);
- }
-
- if(cdebug)
- {
- fprintf(newstdout,"Child sees: \n Client name %s \n Client_num # %d \n Host_name %s\n"
- ,cc.c_client_name,cc.c_client_number,cc.c_host_name);
- fflush(newstdout);
- }
-
- /*
- * Now import all of the values of the flags that the child on this
- * machine needs to be able to run the test requested.
- */
-
- /* 5. Get state information from the master */
-
-#ifdef NO_PRINT_LLD
- sscanf(cnc->c_numrecs64,"%ld",&cc.c_numrecs64);
- sscanf(cnc->c_reclen,"%ld",&cc.c_reclen);
- sscanf(cnc->c_fetchon,"%ld",&cc.c_fetchon);
- sscanf(cnc->c_purge,"%ld",&cc.c_purge);
- sscanf(cnc->c_delay,"%ld",&cc.c_delay);
- sscanf(cnc->c_stride,"%ld",&cc.c_stride);
- sscanf(cnc->c_rest_val,"%ld",&cc.c_rest_val);
- sscanf(cnc->c_delay_start,"%ld",&cc.c_delay_start);
- sscanf(cnc->c_depth,"%ld",&cc.c_depth);
-#else
- sscanf(cnc->c_numrecs64,"%lld",&cc.c_numrecs64);
- sscanf(cnc->c_reclen,"%lld",&cc.c_reclen);
- sscanf(cnc->c_fetchon,"%lld",&cc.c_fetchon);
- sscanf(cnc->c_purge,"%lld",&cc.c_purge);
- sscanf(cnc->c_delay,"%lld",&cc.c_delay);
- sscanf(cnc->c_stride,"%lld",&cc.c_stride);
- sscanf(cnc->c_rest_val,"%lld",&cc.c_rest_val);
- sscanf(cnc->c_delay_start,"%lld",&cc.c_delay_start);
- sscanf(cnc->c_depth,"%lld",&cc.c_depth);
-#endif
- sscanf(cnc->c_pit_hostname,"%s",cc.c_pit_hostname);
- sscanf(cnc->c_pit_service,"%s",cc.c_pit_service);
- sscanf(cnc->c_testnum,"%d",&cc.c_testnum);
- sscanf(cnc->c_client_number,"%d",&cc.c_client_number);
- sscanf(cnc->c_working_dir,"%s",cc.c_working_dir);
- sscanf(cnc->c_file_name,"%s",cc.c_file_name);
- sscanf(cnc->c_write_traj_filename,"%s",cc.c_write_traj_filename);
- sscanf(cnc->c_read_traj_filename,"%s",cc.c_read_traj_filename);
- sscanf(cnc->c_noretest,"%d",&cc.c_noretest);
- sscanf(cnc->c_notruncate,"%d",&cc.c_notruncate);
- sscanf(cnc->c_read_sync,"%d",&cc.c_read_sync);
- sscanf(cnc->c_jflag,"%d",&cc.c_jflag);
- sscanf(cnc->c_direct_flag,"%d",&cc.c_direct_flag);
- sscanf(cnc->c_cpuutilflag,"%d",&cc.c_cpuutilflag);
- sscanf(cnc->c_seq_mix,"%d",&cc.c_seq_mix);
- sscanf(cnc->c_async_flag,"%d",&cc.c_async_flag);
- sscanf(cnc->c_k_flag,"%d",&cc.c_k_flag);
- sscanf(cnc->c_h_flag,"%d",&cc.c_h_flag);
- sscanf(cnc->c_mflag,"%d",&cc.c_mflag);
- sscanf(cnc->c_pflag,"%d",&cc.c_pflag);
- sscanf(cnc->c_stride_flag,"%d",&cc.c_stride_flag);
- sscanf(cnc->c_verify,"%d",&cc.c_verify);
- sscanf(cnc->c_sverify,"%d",&cc.c_sverify);
- sscanf(cnc->c_odsync,"%d",&cc.c_odsync);
- sscanf(cnc->c_diag_v,"%d",&cc.c_diag_v);
- sscanf(cnc->c_dedup,"%d",&cc.c_dedup);
- sscanf(cnc->c_dedup_interior,"%d",&cc.c_dedup_interior);
- sscanf(cnc->c_dedup_compress,"%d",&cc.c_dedup_compress);
- sscanf(cnc->c_dedup_mseed,"%d",&cc.c_dedup_mseed);
- sscanf(cnc->c_hist_summary,"%d",&cc.c_hist_summary);
- sscanf(cnc->c_op_rate,"%d",&cc.c_op_rate);
- sscanf(cnc->c_op_rate_flag,"%d",&cc.c_op_rate_flag);
- sscanf(cnc->c_file_lock,"%d",&cc.c_file_lock);
- sscanf(cnc->c_rec_lock,"%d",&cc.c_rec_lock);
- sscanf(cnc->c_Kplus_readers,"%d",&cc.c_Kplus_readers);
- sscanf(cnc->c_multiplier,"%d",&cc.c_multiplier);
- sscanf(cnc->c_share_file,"%d",&cc.c_share_file);
- sscanf(cnc->c_pattern,"%d",&cc.c_pattern);
- sscanf(cnc->c_version,"%d",&cc.c_version);
- sscanf(cnc->c_base_time,"%d",&cc.c_base_time);
- sscanf(cnc->c_num_child,"%d",&cc.c_num_child);
- sscanf(cnc->c_pct_read,"%d",&cc.c_pct_read);
- sscanf(cnc->c_advise_op,"%d",&cc.c_advise_op);
- sscanf(cnc->c_advise_flag,"%d",&cc.c_advise_flag);
- sscanf(cnc->c_restf,"%d",&cc.c_restf);
- sscanf(cnc->c_mygen,"%d",&cc.c_mygen);
- sscanf(cnc->c_oflag,"%d",&cc.c_oflag);
- sscanf(cnc->c_mfflag,"%d",&cc.c_mfflag);
- sscanf(cnc->c_unbuffered,"%d",&cc.c_unbuffered);
- sscanf(cnc->c_Q_flag,"%d",&cc.c_Q_flag);
- sscanf(cnc->c_L_flag,"%d",&cc.c_L_flag);
- sscanf(cnc->c_xflag,"%d",&cc.c_xflag);
- sscanf(cnc->c_include_flush,"%d",&cc.c_include_flush);
- sscanf(cnc->c_OPS_flag,"%d",&cc.c_OPS_flag);
- sscanf(cnc->c_mmapflag,"%d",&cc.c_mmapflag);
- sscanf(cnc->c_mmapasflag,"%d",&cc.c_mmapasflag);
- sscanf(cnc->c_mmapnsflag,"%d",&cc.c_mmapnsflag);
- sscanf(cnc->c_mmapssflag,"%d",&cc.c_mmapssflag);
- sscanf(cnc->c_no_copy_flag,"%d",&cc.c_no_copy_flag);
- sscanf(cnc->c_w_traj_flag,"%d",&cc.c_w_traj_flag);
- sscanf(cnc->c_r_traj_flag,"%d",&cc.c_r_traj_flag);
- sscanf(cnc->c_no_unlink,"%d",&cc.c_no_unlink);
- sscanf(cnc->c_no_write,"%d",&cc.c_no_write);
- sscanf(cnc->c_include_close,"%d",&cc.c_include_close);
- sscanf(cnc->c_disrupt_flag,"%d",&cc.c_disrupt_flag);
- sscanf(cnc->c_compute_flag,"%d",&cc.c_compute_flag);
- sscanf(cnc->c_MS_flag,"%d",&cc.c_MS_flag);
- sscanf(cnc->c_mmap_mix,"%d",&cc.c_mmap_mix);
- sscanf(cnc->c_Kplus_flag,"%d",&cc.c_Kplus_flag);
- sscanf(cnc->c_compute_time,"%f",&cc.c_compute_time);
-
- strcpy(write_traj_filename,cc.c_write_traj_filename);
- strcpy(read_traj_filename,cc.c_read_traj_filename);
- numrecs64 = cc.c_numrecs64;
- strcpy(pit_hostname,cc.c_pit_hostname);
- strcpy(pit_service,cc.c_pit_service);
- reclen = cc.c_reclen;
- testnum = cc.c_testnum;
- chid = cc.c_client_number;
- workdir=cc.c_working_dir;
- oflag = cc.c_oflag;
- /* Child's absolute filename to use is provided */
- mfflag = cc.c_mfflag;
- if(mfflag)
- strcpy(filearray[chid],cc.c_file_name);
- if(cdebug)
- {
- fprintf(newstdout,"File name given %s\n",cc.c_file_name);
- fflush(newstdout);
- }
- unbuffered = cc.c_unbuffered;
- noretest = cc.c_noretest;
- notruncate = cc.c_notruncate;
- read_sync = cc.c_read_sync;
- jflag = cc.c_jflag;
- direct_flag = cc.c_direct_flag;
- cpuutilflag = cc.c_cpuutilflag;
- seq_mix = cc.c_seq_mix;
- async_flag = cc.c_async_flag;
- k_flag = cc.c_k_flag;
- h_flag = cc.c_h_flag;
- mflag = cc.c_mflag;
- pflag = cc.c_pflag;
- stride_flag = cc.c_stride_flag;
- fetchon = cc.c_fetchon;
- verify = cc.c_verify;
- diag_v = cc.c_diag_v;
- dedup = cc.c_dedup;
- dedup_interior = cc.c_dedup_interior;
- dedup_compress = cc.c_dedup_compress;
- dedup_mseed = cc.c_dedup_mseed;
- hist_summary = cc.c_hist_summary;
- op_rate = cc.c_op_rate;
- op_rate_flag = cc.c_op_rate_flag;
- if(diag_v)
- sverify = 0;
- else
- sverify = cc.c_sverify;
- file_lock = cc.c_file_lock;
- rlocking = cc.c_rec_lock;
- Kplus_readers = cc.c_Kplus_readers;
- multiplier = cc.c_multiplier;
- share_file = cc.c_share_file;
- pattern = cc.c_pattern;
- /* proto_version = cc.c_version; Don't copy it back. */
- base_time=cc.c_base_time;
- num_child=(long long)cc.c_num_child;
- pct_read=cc.c_pct_read;
- advise_op=cc.c_advise_op;
- advise_flag=cc.c_advise_flag;
- restf=cc.c_restf;
- mygen=cc.c_mygen;
- Q_flag = cc.c_Q_flag;
- L_flag = cc.c_L_flag;
- xflag = cc.c_xflag;
- w_traj_flag = cc.c_w_traj_flag;
- r_traj_flag = cc.c_r_traj_flag;
- include_flush = cc.c_include_flush;
- OPS_flag = cc.c_OPS_flag;
- purge = cc.c_purge;
- mmapflag = cc.c_mmapflag;
- mmapasflag = cc.c_mmapasflag;
- mmapnsflag = cc.c_mmapnsflag;
- mmapssflag = cc.c_mmapssflag;
- no_copy_flag = cc.c_no_copy_flag;
- no_unlink = cc.c_no_unlink;
- no_write = cc.c_no_write;
- include_close = cc.c_include_close;
- disrupt_flag = cc.c_disrupt_flag;
- compute_flag = cc.c_compute_flag;
- MS_flag = cc.c_MS_flag;
- mmap_mix = cc.c_mmap_mix;
- Kplus_flag = cc.c_Kplus_flag;
- delay = cc.c_delay;
- stride = cc.c_stride;
- rest_val = cc.c_rest_val;
- depth = cc.c_depth;
- delay_start = cc.c_delay_start;
- compute_time = cc.c_compute_time;
- if(cdebug)
- {
- fprintf(newstdout,"Child %d change directory to %s\n",(int)chid,workdir);
- fflush(newstdout);
- }
- if(purge)
- alloc_pbuf();
-
- /* 6. Change to the working directory */
-
- if(chdir(workdir)<0)
- client_error=errno;
- start_child_listen_loop(); /* The async channel listener */
-
- /* Need to start this after getting into the correct directory */
- if(w_traj_flag)
- w_traj_size();
- if(r_traj_flag)
- r_traj_size();
-
- get_resolution(); /* Get my clock resolution */
- if(hist_summary)
- {
- printf("Child got HISTORY flag\n");
- }
-
- /* 7. Run the test */
- switch(testnum) {
-
- case THREAD_WRITE_TEST :
- if(cdebug>=1)
- {
- fprintf(newstdout,"Child %d running thread_write_test\n",(int)chid);
- fflush(newstdout);
- }
- thread_write_test((long)0);
- break;
-#ifdef HAVE_PREAD
- case THREAD_PWRITE_TEST :
- if(cdebug>=1)
- {
- fprintf(newstdout,"Child %d running thread_pwrite_test\n",(int)chid);
- fflush(newstdout);
- }
- thread_pwrite_test((long)0);
- break;
-#endif
- case THREAD_REWRITE_TEST :
- if(cdebug>=1)
- {
- fprintf(newstdout,"Child %d running thread_rewrite_test\n",(int)chid);
- fflush(newstdout);
- }
- thread_rwrite_test((long)0);
- break;
- case THREAD_READ_TEST :
- if(cdebug>=1)
- {
- fprintf(newstdout,"Child %d running thread_read_test\n",(int)chid);
- fflush(newstdout);
- }
- thread_read_test((long)0);
- break;
-#ifdef HAVE_PREAD
- case THREAD_PREAD_TEST :
- if(cdebug>=1)
- {
- fprintf(newstdout,"Child %d running thread_read_test\n",(int)chid);
- fflush(newstdout);
- }
- thread_pread_test((long)0);
- break;
-#endif
- case THREAD_REREAD_TEST :
- if(cdebug>=1)
- {
- fprintf(newstdout,"Child %d running thread_reread_test\n",(int)chid);
- fflush(newstdout);
- }
- thread_rread_test((long)0);
- break;
- case THREAD_STRIDE_TEST :
- if(cdebug>=1)
- {
- fprintf(newstdout,"Child %d running thread_stride_read_test\n",(int)chid);
- fflush(newstdout);
- }
- thread_stride_read_test((long)0);
- break;
- case THREAD_RANDOM_READ_TEST :
- if(cdebug>=1)
- {
- fprintf(newstdout,"Child %d running random read test\n",(int)chid);
- fflush(newstdout);
- }
- thread_ranread_test((long)0);
- break;
- case THREAD_RANDOM_WRITE_TEST :
- if(cdebug>=1)
- {
- fprintf(newstdout,"Child %d running random write test\n",(int)chid);
- fflush(newstdout);
- }
- thread_ranwrite_test((long)0);
- break;
- case THREAD_REVERSE_READ_TEST :
- if(cdebug>=1)
- {
- fprintf(newstdout,"Child %d running reverse read test\n",(int)chid);
- fflush(newstdout);
- }
- thread_reverse_read_test((long)0);
- break;
- case THREAD_RANDOM_MIX_TEST :
- if(cdebug>=1)
- {
- fprintf(newstdout,"Child %d running mixed workload test\n",(int)chid);
- fflush(newstdout);
- }
- thread_mix_test((long)0);
- break;
- case THREAD_FWRITE_TEST :
- if(cdebug>=1)
- {
- fprintf(newstdout,"Child %d running thread_fwrite_test\n",(int)chid);
- fflush(newstdout);
- }
- thread_fwrite_test((long)0);
- break;
- case THREAD_FREAD_TEST :
- if(cdebug>=1)
- {
- fprintf(newstdout,"Child %d running thread_fread_test\n",(int)chid);
- fflush(newstdout);
- }
- thread_fread_test((long)0);
- break;
- case THREAD_CLEANUP_TEST :
- if(cdebug>=1)
- {
- fprintf(newstdout,"Child %d running cleanup\n",(int)chid);
- fflush(newstdout);
- }
- thread_cleanup_test((long)0);
- break;
- };
- if(cdebug>=1)
- {
- fprintf(newstdout,"Child %d finished running test.\n",(int)chid);
- fflush(newstdout);
- }
-
- /* 8. Release the listen and send sockets to the master */
- stop_child_listen(l_sock);
-
- exit(0);
-}
-
-/*
- * Clients tell the master their statistics, set the stopped flag, and set shared memory
- * child_flag to tell the master they are finished. Also each client report all statistics.
- */
-#ifdef HAVE_ANSIC_C
-void
-tell_master_stats(testnum , chid, throughput, actual,
- cpu_time, wall_time, stop_flag, child_flag)
-int testnum;
-long long chid;
-double throughput, actual, wall_time;
-float cpu_time;
-char stop_flag;
-long long child_flag;
-/*
-void
-tell_master_stats(int testnum , long long chid, double tthroughput,
- double actual, float cpu_time, float wall_time,
- char stop_flag, long long child_flag)
-*/
-#else
-void
-tell_master_stats(testnum , chid, throughput, actual, cpu_time,
- wall_time, stop_flag, child_flag)
-int testnum;
-long long chid;
-double throughput, actual, wall_time;
-char stop_flag;
-float cpu_time;
-long long child_flag;
-#endif
-{
- struct master_command mc;
- bzero(&mc,sizeof(struct master_command));
- mc.m_client_number = (int) chid;
- mc.m_client_error = (int) client_error;
- mc.m_throughput= throughput;
- mc.m_testnum = testnum;
- mc.m_actual = actual;
- mc.m_cputime = cpu_time;
- mc.m_walltime = wall_time;
- mc.m_stop_flag = stop_flag;
- mc.m_child_flag = child_flag;
- mc.m_command = R_STAT_DATA;
- mc.m_mygen = mygen;
- mc.m_version = proto_version;
- if(cdebug>=1)
- {
- fprintf(newstdout,"Child %d: Tell master stats and terminate\n",(int)chid);
- fflush(newstdout);
- }
- child_send(controlling_host_name,(struct master_command *)&mc, sizeof(struct master_command));
-}
-
-/*
- * Stop the master listener loop service.
- * Currently this is not used. The master_join_count
- * variable is used to terminate the loop service.
- */
-#ifdef HAVE_ANSIC_C
-void
-stop_master_listen_loop(void)
-#else
-void
-stop_master_listen_loop()
-#endif
-{
- if(mdebug>=1)
- printf("Stopping Master listen loop");
- kill(master_listen_pid,SIGKILL);
-}
-
-
-/*
- * Clients tell the master that I am at the barrier and ready
- * for the message to start work.
- */
-#ifdef HAVE_ANSIC_C
-void
-tell_master_ready(long long chid)
-#else
-void
-tell_master_ready(chid)
-long long chid;
-#endif
-{
- struct master_command mc;
- bzero(&mc,sizeof(struct master_command));
- if(cdebug>=1)
- {
- fprintf(newstdout,"Child %d: Tell master to go\n",(int)chid);
- fflush(newstdout);
- }
- mc.m_command = R_FLAG_DATA;
- mc.m_mygen = mygen;
- mc.m_version = proto_version;
- mc.m_child_flag = CHILD_STATE_READY;
- mc.m_client_number = (int)chid;
- mc.m_client_error = client_error;
- child_send(controlling_host_name,(struct master_command *)&mc, sizeof(struct master_command));
-}
-
-/*
- * Clients wait at a barrier for the master to tell them
- * to begin work. This is the function where they wait.
- */
-#ifdef HAVE_ANSIC_C
-void
-wait_for_master_go(long long chid)
-#else
-void
-wait_for_master_go(chid)
-long long chid;
-#endif
-{
- struct client_neutral_command *cnc;
- struct client_command cc;
- bzero(&cc,sizeof(struct client_command));
- child_listen(l_sock,sizeof(struct client_neutral_command));
- cnc = (struct client_neutral_command *)child_rcv_buf;
- sscanf(cnc->c_command,"%d",&cc.c_command);
- if(cc.c_command == R_TERMINATE || cc.c_command==R_DEATH)
- {
- if(cdebug)
- {
- fprintf(newstdout,"Child %d received terminate on sync channel at barrier !!\n",(int)chid);
- fflush(newstdout);
- }
- exit(1);
- }
- if(cdebug>=1)
- {
- fprintf(newstdout,"Child %d return from wait_for_master_go\n",(int)chid);
- fflush(newstdout);
- }
-}
-
-/*
- * Create a master listener for receiving data from the
- * many children. As the children finish they will send
- * their statistics and terminate. When the master_join_count
- * goes to zero then it is time to stop this service.
- * When this service exits then the parent will know
- * that all of the children are done.
- */
-#ifdef HAVE_ANSIC_C
-void
-start_master_listen_loop(int num)
-#else
-void
-start_master_listen_loop(num)
-int num;
-#endif
-{
- int i;
- struct child_stats *child_stat;
- struct master_neutral_command *mnc;
- struct master_command mc;
- int temp;
- struct timespec req,rem;
-
- req.tv_sec = 0;
- req.tv_nsec = 10000000;
- rem.tv_sec = 0;
- rem.tv_nsec = 10000000;
-
-
- master_join_count=num;
- master_listen_pid=fork();
- if(master_listen_pid!=0)
- return;
- if(mdebug>=1)
- printf("Starting Master listen loop m %d c %d count %d\n",master_iozone,
- client_iozone,num);
-
- while(master_join_count)
- {
- master_listen(master_listen_socket,sizeof(struct master_neutral_command));
- mnc=(struct master_neutral_command *)&master_rcv_buf[0];
-
- /*
- * Convert from string format to arch format
- */
- sscanf(mnc->m_command,"%d",&mc.m_command);
- sscanf(mnc->m_client_number,"%d",&mc.m_client_number);
- sscanf(mnc->m_client_error,"%d",&mc.m_client_error);
- sscanf(mnc->m_mygen,"%d",&mc.m_mygen);
- sscanf(mnc->m_version,"%d",&mc.m_version);
- if(mc.m_version != proto_version)
- {
- printf("Client # %d is not running the same version of Iozone !\n",
- mc.m_client_number);
- }
- if(mc.m_client_error != 0)
- {
- printf("\nClient # %d reporting an error %s !\n",
- mc.m_client_number,strerror(mc.m_client_error));
- }
-#ifdef NO_PRINT_LLD
- sscanf(mnc->m_child_flag,"%ld",&mc.m_child_flag);
-#else
- sscanf(mnc->m_child_flag,"%lld",&mc.m_child_flag);
-#endif
- sscanf(mnc->m_actual,"%f",&mc.m_actual);
- sscanf(mnc->m_throughput,"%f",&mc.m_throughput);
- sscanf(mnc->m_cputime,"%f",&mc.m_cputime);
- sscanf(mnc->m_walltime,"%f",&mc.m_walltime);
- sscanf(mnc->m_stop_flag,"%d",&temp);
- mc.m_stop_flag = temp;
-
- switch(mc.m_command) {
- case R_STAT_DATA:
- if(mc.m_mygen != mygen)
- {
- /*
- * >>> You are NOT one of my children !!! <<<
- * Probably children left behind from another run !!!
- * Ignore their messages, and go on without them.
- */
- printf("*** Unknown Iozone children responding !!! ***\n");
- continue;
- }
- i = mc.m_client_number;
- if(mdebug)
- printf("loop: R_STAT_DATA for client %d\n",i);
- child_stat = (struct child_stats *)&shmaddr[i];
- child_stat->flag = mc.m_child_flag;
- child_stat->actual = mc.m_actual;
- child_stat->throughput = mc.m_throughput;
- child_stat->cputime = mc.m_cputime;
- child_stat->walltime = mc.m_walltime;
- *stop_flag = mc.m_stop_flag;
- master_join_count--;
- break;
- case R_FLAG_DATA:
- if(mc.m_mygen != mygen)
- {
- /* You are NOT one of my children !!! */
- printf("*** Unknown Iozone children responding !!! ***\n");
- continue;
- }
- if(mdebug)
- printf("loop: R_FLAG_DATA: Client %d flag %d \n",
- (int)mc.m_client_number,
- (int)mc.m_child_flag);
- i = mc.m_client_number;
- child_stat = (struct child_stats *)&shmaddr[i];
- child_stat->flag = (long long)(mc.m_child_flag);
- break;
- case R_STOP_FLAG:
- if(mc.m_mygen != mygen)
- {
- /* You are NOT one of my children !!! */
- printf("*** Unknown Iozone children responding !!! ***\n");
- continue;
- }
- if(mdebug)
- printf("Master loop: R_STOP_FLAG: Client %d STOP_FLAG \n",
- (int)mc.m_client_number);
- *stop_flag=1;
- distribute_stop();
- break;
- }
-
- }
- /* Let the clients report results before exiting.
- Also, exiting too quickly can close the async
- socket to the child, and cause it to become ill.
- On Solaris, it gets stuck in a 0=read() loop. */
-
-#if defined(Windows)
- sleep(1);
-#else
- nanosleep(&req,&rem);
-#endif
-
- exit(0);
-}
-/*
- * Create a client listener for receiving async data from the
- * the master.
- */
-#ifdef HAVE_ANSIC_C
-void
-start_child_listen_loop(void)
-#else
-void
-start_child_listen_loop()
-#endif
-{
- int i;
- struct child_stats *child_stat;
- struct client_command cc;
- struct client_neutral_command *cnc;
-
- client_listen_pid=fork();
- if(client_listen_pid!=0)
- return;
- if(cdebug>=1)
- {
- fprintf(newstdout,"Child %d starting client listen loop\n",(int)chid);
- fflush(newstdout);
- }
- while(1)
- {
- bzero(&cc,sizeof(struct client_command));
- child_listen_async(l_async_sock,sizeof(struct client_neutral_command));
- cnc=(struct client_neutral_command *)&child_async_rcv_buf;
- /*
- * Convert from string format to arch format
- */
- sscanf(cnc->c_command,"%d",&cc.c_command);
- sscanf(cnc->c_client_number,"%d",&cc.c_client_number);
- sscanf(cnc->c_stop_flag,"%d",&cc.c_stop_flag);
-
- switch(cc.c_command) {
- case R_STOP_FLAG:
- i = cc.c_client_number;
- if(cdebug)
- {
- fprintf(newstdout,"child loop: R_STOP_FLAG for client %d\n",i);
- fflush(newstdout);
- }
- child_stat = (struct child_stats *)&shmaddr[i];
- *stop_flag = cc.c_stop_flag; /* In shared memory with other copy */
- sent_stop=1;
- break;
- case R_TERMINATE:
- if(cdebug)
- {
- fprintf(newstdout,"Child loop: R_TERMINATE: Client %d \n",
- (int)cc.c_client_number);
- fflush(newstdout);
- }
- sleep(2);
- /* Aync listener goes away */
- stop_child_listen(l_async_sock);
- exit(0);
- case R_DEATH:
- if(cdebug)
- {
- fprintf(newstdout,"Child loop: R_DEATH: Client %d \n",
- (int)cc.c_client_number);
- fflush(newstdout);
- }
- i = cc.c_client_number;
- child_remove_files(i);
- sleep(2);
- /* Aync listener goes away */
- stop_child_listen(l_async_sock);
- exit(0);
- }
-
- }
-}
-
-/*
- * The controlling process "master" tells the children to begin.
- */
-
-#ifdef HAVE_ANSIC_C
-void
-tell_children_begin(long long childnum)
-#else
-void
-tell_children_begin(childnum)
-long long childnum;
-#endif
-{
- struct client_command cc;
- int x;
- bzero(&cc,sizeof(struct client_command));
- x = (int) childnum;
- if(mdebug>=1)
- printf("Master: Tell child %d to begin\n",x);
- cc.c_command = R_FLAG_DATA;
- cc.c_child_flag = CHILD_STATE_BEGIN;
- cc.c_client_number = (int)childnum;
- master_send(master_send_sockets[x],child_idents[x].child_name, &cc,sizeof(struct client_command));
-}
-
-/*
- * The master waits here for all of the the children to terminate.
- * When the children are done the the master_join_count will be at zero
- * and the master_listen_loop will exit. This function waits for this to happen.
- */
-#ifdef HAVE_ANSIC_C
-void
-wait_dist_join(void)
-#else
-void
-wait_dist_join()
-#endif
-{
- wait(0);
- if(mdebug)
- printf("Master: All children have finished. Sending terminate\n");
- terminate_child_async(); /* All children are done, so terminate their async channel */
- current_client_number=0; /* start again */
-}
-
-
-/*
- * This function reads a file that contains client information.
- * The information is:
- * client name (DNS usable name)
- * client working directory (where to run the test)
- * client directory that contains the Iozone executable.
- *
- * If the first character in a line is a # then it is a comment.
- * The maximum number of clients is MAXSTREAMS.
- */
-#ifdef HAVE_ANSIC_C
-int
-get_client_info(void)
-#else
-int
-get_client_info()
-#endif
-{
- FILE *fd;
- char *ret1;
- int count;
- char buffer[200];
- count=0;
- fd=fopen(client_filename,"r");
- if(fd == (FILE *)NULL)
- {
- printf("Unable to open client file \"%s\"\n",
- client_filename);
- exit(176);
- }
- while(1)
- {
- if (count > MAXSTREAMS) {
- printf("Too many lines in client file - max of %d supported\n",
- MAXSTREAMS);
- exit(7);
- }
- ret1=fgets(buffer,200,fd);
- if(ret1== (char *)NULL)
- break;
- count+=parse_client_line(buffer,count);
- }
- fclose(fd);
- return(count);
-}
-
-
-/*
- * This function parses a line from the client file. It is
- * looking for:
- * Client name (DNS usable)
- * Client working directory (where to run the test )
- * Client path to Iozone executable.
- *
- * Lines that start with # are comments.
- */
-
-#ifdef HAVE_ANSIC_C
-int
-parse_client_line(char *buffer,int line_num)
-#else
-int
-parse_client_line(buffer, line_num)
-char *buffer;
-int line_num;
-#endif
-{
- int num;
- /* Format is clientname, workdir, execute_path */
- /* If column #1 contains a # symbol then skip this line */
-
- if(buffer[0]=='#')
- return(0);
- num=sscanf(buffer,"%s %s %s %s\n",
- child_idents[line_num].child_name,
- child_idents[line_num].workdir,
- child_idents[line_num].execute_path,
- child_idents[line_num].file_name);
- if((num > 0) && (num !=3) && (num !=4))
- {
- printf("Bad Client Identity at entry %d\n",line_num);
- printf("Client: -> %s Workdir: -> %s Execute_path: -> %s \n",
- child_idents[line_num].child_name,
- child_idents[line_num].workdir,
- child_idents[line_num].execute_path);
- exit(203);
- }
- if(num == 4)
- mfflag++;
-
- return(1);
-}
-
-/*
- * This is a mechanism that the child uses to remove all
- * of its temporary files. Only used at terminate time.
- */
-#ifdef HAVE_ANSIC_C
-void
-child_remove_files(int i)
-#else
-void
-child_remove_files(i)
-int i;
-#endif
-{
-
- char *dummyfile[MAXSTREAMS]; /* name of dummy file */
- dummyfile[i]=(char *)malloc((size_t)MAXNAMESIZE);
- if(mfflag)
- {
- sprintf(dummyfile[i],"%s",filearray[i]);
- }
- else
- {
- sprintf(dummyfile[i],"%s.DUMMY.%d",filearray[i],i);
- }
- if(cdebug)
- {
- fprintf(newstdout,"Child %d remove: %s \n",(int)chid, dummyfile[i]);
- fflush(newstdout);
- }
- if(check_filename(dummyfile[i]))
- unlink(dummyfile[i]);
-}
-
-
-/*
- * The master tells the child async listener that it is time
- * to terminate its services.
- */
-#ifdef HAVE_ANSIC_C
-void
-terminate_child_async(void)
-#else
-void
-terminate_child_async()
-#endif
-{
- int i;
- struct client_command cc;
- bzero(&cc,sizeof(struct client_command));
- cc.c_command = R_TERMINATE;
- for(i=0;i<num_child;i++)
- {
- child_idents[i].state = C_STATE_ZERO;
- cc.c_client_number = (int)i;
- if(mdebug)
- printf("Master terminating async channels to children.\n");
- master_send(master_send_async_sockets[i],child_idents[i].child_name, &cc,sizeof(struct client_command));
- }
-}
-
-/*
- * The master has received an update to the stop flag and is
- * now distributing this to all of the clients.
- */
-#ifdef HAVE_ANSIC_C
-void
-distribute_stop(void)
-#else
-void
-distribute_stop()
-#endif
-{
- int i;
- struct client_command cc;
-
- /*
- * Only send one stop to the clients. Each client will
- * send stop to the master, but the master only needs
- * to distribute the first stop. Without this, the
- * master may distribute too many stops and overflow
- * the socket buffer on the client.
- */
- if(sent_stop)
- {
- if(mdebug)
- {
- s_count++;
- printf("Master not send stop %d\n",s_count);
- }
- return;
- }
- bzero(&cc,sizeof(struct client_command));
- cc.c_command = R_STOP_FLAG;
- cc.c_stop_flag = 1;
- for(i=0;i<num_child;i++)
- {
- cc.c_client_number = (int)i;
- if(mdebug)
- printf("Master distributing stop flag to child %d\n",i);
- master_send(master_send_async_sockets[i],child_idents[i].child_name, &cc,sizeof(struct client_command));
- }
- sent_stop=1;
-}
-
-/*
- * Child is sending its stop flag to the master.
- */
-#ifdef HAVE_ANSIC_C
-void
-send_stop(void)
-#else
-void
-send_stop()
-#endif
-{
- struct master_command mc;
-
- bzero(&mc, sizeof(struct master_command));
- mc.m_command = R_STOP_FLAG;
- mc.m_mygen = mygen;
- mc.m_version = proto_version;
- mc.m_client_number = chid;
- mc.m_client_error = client_error;
- if(cdebug)
- {
- fprintf(newstdout,"Child %d sending stop flag to master\n",(int)chid);
- fflush(newstdout);
- }
- child_send(controlling_host_name,(struct master_command *)&mc, sizeof(struct master_command));
- client_error=0; /* clear error, it has been delivered */
-}
-
-/*
- * This is very tricky stuff. There are points in time when
- * someone can hit control-c and cause the master to want to die.
- * Ok..now how does the master contact all the clients and tell
- * them to stop ? The clients may be in 3 different states.
- * Not started yet, Joined and waiting for the WHO information,
- * or at the barrier. If the client is not started... cool.
- * ignore it. If the client has joined and is waiting at WHO
- * then the client does not have an async listener yet. So
- * the master only needs to tell the client (sync) channel
- * to terminate. If the client is at the barrier then the
- * client has two processes. One at the barrier and another
- * that is providing the async services. So... the master
- * needs to terminate both of these processes.
- */
-#ifdef HAVE_ANSIC_C
-void
-cleanup_children(void)
-#else
-void
-cleanup_children()
-#endif
-{
- int i;
- struct client_command cc;
- bzero(&cc,sizeof(struct client_command));
- cc.c_command = R_DEATH;
- for(i=0;i<num_child;i++)
- {
- cc.c_client_number = (int)i;
- /* Child not started yet */
- if(child_idents[i].state == C_STATE_ZERO)
- ;
- /* Child is waiting for who info */
- if(child_idents[i].state == C_STATE_WAIT_WHO)
- {
- if(mdebug)
- printf("Master sending signaled death to child !!\n");
- master_send(master_send_sockets[i],child_idents[i].child_name, &cc,sizeof(struct client_command));
- }
- /* Child is waiting at the barrier */
- if(child_idents[i].state == C_STATE_WAIT_BARRIER)
- {
- if(mdebug)
- printf("Master sending signaled death to child !!\n");
- master_send(master_send_sockets[i],child_idents[i].child_name, &cc,sizeof(struct client_command));
- if(mdebug)
- printf("Master sending signaled death to child async !!\n");
- master_send(master_send_async_sockets[i],child_idents[i].child_name, &cc,sizeof(struct client_command));
- }
-
- }
-}
-
-/*
- * This closes the file descriptors that were created for the master send and async send
- * at the end of each phase of the throughput testing.
- */
-#ifdef HAVE_ANSIC_C
-void
-cleanup_comm(void)
-#else
-void
-cleanup_comm()
-#endif
-{
- int i;
- for(i=0;i<num_child;i++)
- {
- close(master_send_sockets[i]);
- close(master_send_async_sockets[i]);
- }
-}
-
-#ifdef HAVE_ANSIC_C
-void
-find_remote_shell(char *shell)
-#else
-void
-find_remote_shell(shell)
-char *shell;
-#endif
-{
- char *value;
- value=(char *)getenv("RSH");
- if(value)
- {
- strcpy(shell,value);
- return;
- }
-#ifdef _HPUX_SOURCE
- strcpy(shell,"remsh");
-#else
- strcpy(shell,"rsh");
-#endif
- return;
-}
-#ifdef HAVE_ANSIC_C
-void
-find_external_mon(char * imon_start, char * imon_stop)
-#else
-void
-find_external_mon(imon_start,imon_stop)
-char *imon_start,*imon_stop;
-#endif
-{
- char *start,*stop,*sync;
- imon_start[0]=(char)0;
- imon_stop[0]=(char)0;
- start=(char *)getenv("IMON_START");
- if(start)
- {
- strcpy(imon_start,start);
- }
- stop=(char *)getenv("IMON_STOP");
- if(stop)
- {
- strcpy(imon_stop,stop);
- }
- sync=(char *)getenv("IMON_SYNC");
- if(sync)
- {
- imon_sync=1;
- }
-
- return;
-}
-
-/*
- * This test is only valid in throughput mode.
- */
-
-#ifdef HAVE_ANSIC_C
-void
-mix_perf_test(off64_t kilo64,long long reclen,long long *data1,long long *data2)
-#else
-void
-mix_perf_test(kilo64,reclen,data1,data2)
-off64_t kilo64;
-long long reclen;
-long long *data1,*data2;
-#endif
-{
- return;
-/*
- printf("\nMix mode test only valid in throughput mode.\n");
- signal_handler();
- exit(180);
-*/
-}
-
-/*
- * Speed check code
- */
-char *sp_dest; /* Name of destination for messages */
-
-int sp_child_listen_port = SP_CHILD_LISTEN_PORT;
-int sp_child_esend_port = SP_CHILD_ESEND_PORT;
-
-int sp_master_listen_port = SP_MASTER_LISTEN_PORT;
-int sp_master_esend_port = SP_MASTER_ESEND_PORT;
-
-int sp_master_results_port = SP_MASTER_RESULTS_PORT;
-
-struct in_addr sp_my_cs_addr;
-struct in_addr sp_my_ms_addr;
-struct sockaddr_in sp_child_sync_sock, sp_child_async_sock;
-struct sockaddr_in sp_master_sync_sock, sp_master_async_sock;
-char *sp_buf;
-char sp_command[1024];
-char sp_remote_shell[100];
-int sp_child_mode;
-int sp_count,sp_msize,sp_once;
-int sp_tcount;
-double sp_start_time,sp_finish_time;
-void sp_send_result(int, int, float );
-void sp_get_result(int , int );
-void sp_do_child_t(void);
-void sp_do_master_t(void);
-void speed_main(char *, char *, long long ,long long , int);
-int sp_cret;
-char sp_remote_host[256];
-char sp_master_host[256];
-char sp_location[256];
-
-
-/*
- * This is the front end for the speed check code
- */
-#ifdef HAVE_ANSIC_C
-void
-speed_main(char *client_name, char *e_path, long long reclen,
- long long kilos, int client_flag)
-#else
-void
-speed_main(client_name, e_path, reclen, kilos, client_flag)
-char *client_name;
-char *e_path;
-long long reclen;
-long long kilos;
-int client_flag;
-#endif
-{
- int x;
-
-
- strcpy(sp_master_host,controlling_host_name);
- sp_msize=(int)reclen;
- sp_count=((int)kilos*1024)/(int)reclen;
- if(!client_flag)
- {
- printf("\n");
- strcpy(sp_remote_host,client_name);
- strcpy(sp_location,e_path);
- }
-
- if(client_flag)
- sp_child_mode=1;
- sp_buf=(char *)malloc(sp_msize);
- bzero(sp_buf,sp_msize); /* get page faults out of the way */
-
- if(sp_child_mode)
- {
- close(0);
- close(1);
- close(2);
- if(cdebug)
- {
- newstdin=freopen("/tmp/don_in","r+",stdin);
- newstdout=freopen("/tmp/don_out","a+",stdout);
- newstderr=freopen("/tmp/don_err","a+",stderr);
- }
- sp_dest=sp_master_host;
- sp_do_child_t();
- free(sp_buf);
- exit(0);
- }
- x=fork();
- if(x==0)
- {
- find_remote_shell(sp_remote_shell);
- sprintf(sp_command,"%s %s %s -+s -t 1 -r %d -s %d -+c %s -+t ",
- sp_remote_shell, sp_remote_host,
- sp_location, (int)reclen/1024,
- (int)kilos,sp_master_host);
- /*printf("%s\n",sp_command);*/
- junk=system(sp_command);
- exit(0);
- }
- else
- {
- if(!sp_once)
- {
- printf("***************************************************\n");
- printf("* >>>>> Client Network Speed check <<<<< *\n");
- printf("***************************************************\n\n");
- printf("Master: %s\n",sp_master_host);
- printf("Transfer size %d bytes \n",sp_msize);
- printf("Count %d\n",sp_count);
- printf("Total size %d kbytes \n\n",
- (sp_msize*sp_count)/1024);
- sp_once=1;
- }
- sp_dest=sp_remote_host;
- sleep(1);
- sp_do_master_t();
- free(sp_buf);
- }
-}
-
-/*
- * Get results back from the client.
- */
-#ifdef HAVE_ANSIC_C
-void
-sp_get_result(int port,int flag)
-#else
-void
-sp_get_result(port,flag)
-int port,flag;
-#endif
-{
- int tcfd;
- float throughput;
- int count;
- char mybuf[1024];
- int sp_offset,xx;
-
- tcfd=sp_start_master_listen(port, 1024);
- sp_offset=0;
- while(sp_offset < 1024)
- {
- xx=read(tcfd,&mybuf[sp_offset],1024);
- sp_offset+=xx;
- }
- sscanf(mybuf,"%d %f",&count,&throughput);
- if(!flag)
- printf("%-20s received %10d Kbytes @ %10.2f Kbytes/sec \n",
- sp_remote_host,count,throughput);
- else
- printf("%-20s sent %10d Kbytes @ %10.2f Kbytes/sec \n",
- sp_remote_host,count,throughput);
- close(tcfd);
-}
-
-/*
- * Send results to the master.
- */
-#ifdef HAVE_ANSIC_C
-void
-sp_send_result(int port, int count, float throughput)
-#else
-void
-sp_send_result(port, count, throughput)
-int port,count;
-float throughput;
-#endif
-{
- int msfd;
- char mybuf[1024];
- sprintf(mybuf,"%d %f",count, throughput);
- msfd=sp_start_child_send(sp_dest, port, &sp_my_cs_addr);
- junk=write(msfd,mybuf,1024);
- if(cdebug)
- {
- fprintf(newstdout,"Sending result\n");
- fflush(newstdout);
- }
- close(msfd);
-}
-
-/*
- * Start the channel for the master to send a message to
- * a child on a port that the child
- * has created for the parent to use to communicate.
- */
-#ifdef HAVE_ANSIC_C
-int
-sp_start_master_send(char *sp_child_host_name, int sp_child_listen_port, struct in_addr *sp_my_ms_addr)
-#else
-int
-sp_start_master_send(sp_child_host_name, sp_child_listen_port, sp_my_ms_addr)
-char *sp_child_host_name;
-int sp_child_listen_port;
-struct in_addr *sp_my_ms_addr;
-#endif
-{
- int rc,master_socket_val;
- struct sockaddr_in addr,raddr;
- struct hostent *he;
- int port,tmp_port;
- int ecount=0;
- struct in_addr *ip;
- struct timespec req,rem;
-
- req.tv_sec = 0;
- req.tv_nsec = 10000000;
- rem.tv_sec = 0;
- rem.tv_nsec = 10000000;
-
- he = gethostbyname(sp_child_host_name);
- if (he == NULL)
- {
- printf("Master: Bad hostname >%s<\n",sp_child_host_name);
- fflush(stdout);
- exit(22);
- }
- if(mdebug ==1)
- {
- printf("Master: start master send: %s\n", he->h_name);
- fflush(stdout);
- }
- ip = (struct in_addr *)he->h_addr_list[0];
-#ifndef UWIN
- if(mdebug ==1)
- {
- printf("Master: child name: %s\n", (char *)inet_ntoa(*ip));
- printf("Master: child Port: %d\n", sp_child_listen_port);
- fflush(stdout);
- }
-#endif
-
- port=sp_child_listen_port;
- sp_my_ms_addr->s_addr = ip->s_addr;
- /*port=CHILD_LIST_PORT;*/
-
- raddr.sin_family = AF_INET;
- raddr.sin_port = htons(port);
- raddr.sin_addr.s_addr = ip->s_addr;
- master_socket_val = socket(AF_INET, SOCK_STREAM, 0);
- if (master_socket_val < 0)
- {
- perror("Master: socket failed:");
- exit(23);
- }
- bzero(&addr, sizeof(struct sockaddr_in));
- tmp_port=sp_master_esend_port;
- addr.sin_port = htons(tmp_port);
- addr.sin_family = AF_INET;
- addr.sin_addr.s_addr = INADDR_ANY;
- rc = -1;
- while (rc < 0)
- {
- rc = bind(master_socket_val, (struct sockaddr *)&addr,
- sizeof(struct sockaddr_in));
- if(rc < 0)
- {
- tmp_port++;
- addr.sin_port=htons(tmp_port);
- continue;
- }
- }
- if(mdebug ==1)
- {
- printf("Master: Bound port\n");
- fflush(stdout);
- }
- if (rc < 0)
- {
- perror("Master: bind failed for sync channel to child.\n");
- exit(24);
- }
-#if defined(Windows)
- sleep(1);
-#else
- nanosleep(&req,&rem);
-#endif
-
-again:
- rc = connect(master_socket_val, (struct sockaddr *)&raddr,
- sizeof(struct sockaddr_in));
- if (rc < 0)
- {
- if(ecount++ < 300)
- {
-#if defined(Windows)
- sleep(1);
-#else
- nanosleep(&req,&rem);
-#endif
- /*sleep(1);*/
- goto again;
- }
- perror("Master: connect failed\n");
- printf("Error %d\n",errno);
- exit(25);
- }
- if(mdebug ==1)
- {
- printf("Master Connected\n");
- fflush(stdout);
- }
- return (master_socket_val);
-}
-
-/*
- * Start the childs listening service for messages from the master.
- */
-#ifdef HAVE_ANSIC_C
-int
-sp_start_child_listen(int listen_port, int size_of_message)
-#else
-int
-sp_start_child_listen(listen_port, size_of_message)
-int listen_port;
-int size_of_message;
-#endif
-{
- int tsize;
- int s,ns;
- unsigned int me;
- int rc;
- int xx;
- int tmp_port;
- struct sockaddr_in *addr;
- int sockerr;
- int recv_buf_size=65536;
- int optval=1;
- xx = 0;
- me=sizeof(struct sockaddr_in);
- tsize=size_of_message; /* Number of messages to receive */
- s = socket(AF_INET, SOCK_STREAM, 0);
- if (s < 0)
- {
- perror("socket failed:");
- exit(19);
- }
- sockerr = setsockopt (s, SOL_SOCKET, SO_RCVBUF, (char *)
- &recv_buf_size, sizeof(int));
- if ( sockerr == -1 ) {
- perror("Error in setsockopt 7\n");
- }
- sockerr = setsockopt (s, SOL_SOCKET, SO_REUSEADDR, (char *)
- &optval, sizeof(int));
- if ( sockerr == -1 ) {
- perror("Error in setsockopt 8\n");
- }
- bzero(&sp_child_sync_sock, sizeof(struct sockaddr_in));
- tmp_port=sp_child_listen_port;
- sp_child_sync_sock.sin_port = htons(tmp_port);
- sp_child_sync_sock.sin_family = AF_INET;
- sp_child_sync_sock.sin_addr.s_addr = INADDR_ANY;
- rc = -1;
- while (rc < 0)
- {
- rc = bind(s, (struct sockaddr *)&sp_child_sync_sock,
- sizeof(struct sockaddr_in));
- if(rc < 0)
- {
- tmp_port++;
- sp_child_sync_sock.sin_port=htons(tmp_port);
- continue;
- }
- }
- sp_child_listen_port = ntohs(sp_child_sync_sock.sin_port);
- if(cdebug ==1)
- {
- fprintf(newstdout,"Child: Listen: Bound at port %d\n", tmp_port);
- fflush(newstdout);
- }
- if(rc < 0)
- {
- if(cdebug ==1)
- {
- fprintf(newstdout,"bind failed. Errno %d\n", errno);
- fflush(newstdout);
- }
- exit(20);
- }
-
- addr=&sp_child_async_sock;
- listen(s,10);
- if(cdebug)
- {
- fprintf(newstdout,"Child enters accept\n");
- fflush(newstdout);
- }
- ns=accept(s,(void *)addr,&me);
- if(cdebug)
- {
- fprintf(newstdout,"Child attached for receive. Sock %d %d\n", ns,errno);
- fflush(newstdout);
- }
- close(s);
- return(ns);
-}
-
-
-/*
- * The client runs this code
- */
-#ifdef HAVE_ANSIC_C
-void
-sp_do_child_t(void)
-#else
-void
-sp_do_child_t()
-#endif
-{
- int i,y;
- int offset;
- int sp_tcount=0;
- /* child */
- /*
- * Child reads from master
- */
- sp_crfd=sp_start_child_listen(sp_child_listen_port, sp_msize);
- sp_start_time=time_so_far();
- for(i=0;i<sp_count;i++)
- {
- offset=0;
- while(offset<sp_msize)
- {
- y=read(sp_crfd,&sp_buf[offset],sp_msize-offset);
- if(y < 0)
- {
- if(cdebug)
- {
- fprintf(newstdout,"Child error %d offset %d\n",
- errno,offset);
- fflush(newstdout);
- }
- exit(1);
- }
- offset+=y;
- if(cdebug)
- {
- fprintf(newstdout,"Child offset %d read %d\n",offset,y);
- fflush(newstdout);
- }
- }
- sp_tcount+=offset;
- }
- sp_finish_time=time_so_far();
-
- close(sp_crfd);
- sleep(1); /* Wait for master to get into sp_get_result */
- sp_send_result(sp_master_results_port, sp_tcount/1024,
- (float)(sp_tcount/1024)/(sp_finish_time-sp_start_time));
-
- sleep(1);
- /*
- * Child writes to master
- */
- sp_csfd=sp_start_child_send(sp_dest, sp_master_listen_port,
- &sp_my_cs_addr);
- sp_tcount=0;
- offset=0;
- sp_start_time=time_so_far();
- for(i=0;i<sp_count;i++)
- {
- y=write(sp_csfd,sp_buf,sp_msize);
- sp_tcount+=y;
- }
- sp_finish_time=time_so_far();
- close(sp_csfd);
- sleep(1);
- sp_send_result(sp_master_results_port, sp_tcount/1024,
- (float)(sp_tcount/1024)/(sp_finish_time-sp_start_time));
- if(cdebug)
- {
- fprintf(newstdout,"child exits\n");
- fflush(newstdout);
- }
-}
-
-/*
- * The master runs this code.
- */
-#ifdef HAVE_ANSIC_C
-void
-sp_do_master_t(void)
-#else
-void
-sp_do_master_t()
-#endif
-{
- int i,y,sp_offset;
- int sp_tcount = 0;
-
-
- /*
- * Master writes to child
- */
- sp_msfd=sp_start_master_send(sp_dest, sp_child_listen_port,
- &sp_my_ms_addr);
- sp_start_time=time_so_far();
- for(i=0;i<sp_count;i++)
- {
- y=write(sp_msfd,sp_buf,sp_msize);
- sp_tcount+=y;
- }
- sp_finish_time=time_so_far();
- close(sp_msfd);
- sp_msfd=0;
- sp_get_result(sp_master_results_port,0);
- printf("%-20s sent %10d kbytes @ %10.2f Kbytes/sec \n",
- sp_master_host,sp_tcount/1024,
- (float)(sp_tcount/1024)/(sp_finish_time-sp_start_time));
-
- /* printf("\n"); */
- /*
- * Master reads from child
- */
- sp_mrfd=sp_start_master_listen(sp_master_listen_port, sp_msize);
- sp_offset=0;
- sp_start_time=time_so_far();
- sp_tcount=0;
- for(i=0;i<sp_count;i++)
- {
- sp_offset=0;
- while(sp_offset<sp_msize)
- {
- y=read(sp_mrfd,&sp_buf[sp_offset],sp_msize-sp_offset);
- if(y < 0)
- {
- printf("Master error %d offset %d\n",errno,
- sp_offset);
- exit(1);
- }
- sp_offset+=y;
- /* printf("Master offset %d read %d\n",offset,y);*/
- }
- sp_tcount+=sp_offset;
- }
- sp_finish_time=time_so_far();
- sp_get_result(sp_master_results_port,1);
- printf("%-20s received %10d kbytes @ %10.2f Kbytes/sec \n",
- sp_master_host,sp_tcount/1024,
- (float)(sp_tcount/1024)/(sp_finish_time-sp_start_time));
- printf("\n");
- wait(NULL);
- close(sp_mrfd);
- sp_mrfd=0;
-}
-
-/*
- * Start the master listening service for messages from the child.
- */
-#ifdef HAVE_ANSIC_C
-int
-sp_start_master_listen(int sp_master_listen_port, int sp_size_of_message)
-#else
-int
-sp_start_master_listen(sp_master_listen_port, sp_size_of_message)
-int sp_size_of_message;
-int sp_master_listen_port;
-#endif
-{
- int tsize;
- int s,ns;
- unsigned int me;
- int rc;
- int xx;
- int tmp_port;
- struct sockaddr_in *addr;
- int sockerr;
- int recv_buf_size=65536;
- int optval=1;
- xx = 0;
- me=sizeof(struct sockaddr_in);
- tsize=sp_size_of_message; /* Number of messages to receive */
- s = socket(AF_INET, SOCK_STREAM, 0);
- if (s < 0)
- {
- perror("socket failed:");
- exit(19);
- }
- sockerr = setsockopt (s, SOL_SOCKET, SO_RCVBUF, (char *)
- &recv_buf_size, sizeof(int));
- if ( sockerr == -1 ) {
- perror("Error in setsockopt 9\n");
- }
- sockerr = setsockopt (s, SOL_SOCKET, SO_REUSEADDR, (char *)
- &optval, sizeof(int));
- if ( sockerr == -1 ) {
- perror("Error in setsockopt 10\n");
- }
- bzero(&sp_master_sync_sock, sizeof(struct sockaddr_in));
- tmp_port=sp_master_listen_port;
- sp_master_sync_sock.sin_port = htons(tmp_port);
- sp_master_sync_sock.sin_family = AF_INET;
- sp_master_sync_sock.sin_addr.s_addr = INADDR_ANY;
- rc = -1;
- while (rc < 0)
- {
- rc = bind(s, (struct sockaddr *)&sp_master_sync_sock,
- sizeof(struct sockaddr_in));
- if(rc < 0)
- {
- tmp_port++;
- sp_master_sync_sock.sin_port=htons(tmp_port);
- continue;
- }
- }
- sp_master_listen_port = ntohs(sp_master_sync_sock.sin_port);
- if(mdebug ==1)
- {
- printf("Master: Listen: Bound at port %d\n", tmp_port);
- fflush(stdout);
- }
- if(rc < 0)
- {
- perror("bind failed\n");
- exit(20);
- }
-
- addr=&sp_master_async_sock;
- listen(s,10);
- if(mdebug)
- {
- printf("Master enters accept\n");
- fflush(stdout);
- }
- ns=accept(s,(void *)addr,&me);
- if(mdebug)
- {
- printf("Master attached for receive. Sock %d %d\n", ns,errno);
- fflush(stdout);
- }
- close(s);
- return(ns);
-}
-
-/*
- * Start the channel for the child to send a message to
- * the master.
- */
-#ifdef HAVE_ANSIC_C
-int
-sp_start_child_send(char *sp_master_host_name, int sp_master_listen_port, struct in_addr *sp_my_cs_addr)
-#else
-int
-sp_start_child_send(sp_master_host_name, sp_master_listen_port, sp_my_cs_addr)
-char *sp_master_host_name;
-int sp_master_listen_port;
-struct in_addr *sp_my_cs_addr;
-#endif
-{
- int rc,sp_child_socket_val;
- struct sockaddr_in addr,raddr;
- struct hostent *he;
- int port,tmp_port;
- struct in_addr *ip;
- int ecount=0;
- struct timespec req,rem;
-
- req.tv_sec = 0;
- req.tv_nsec = 10000000;
- rem.tv_sec = 0;
- rem.tv_nsec = 10000000;
-
- he = gethostbyname(sp_master_host_name);
- if (he == NULL)
- {
- printf("Child: Bad hostname >%s<\n",sp_master_host_name);
- fflush(stdout);
- exit(22);
- }
- if(cdebug ==1)
- {
- fprintf(newstdout,"Child: start child send: %s\n", he->h_name);
- fprintf(newstdout,"To: %s at port %d\n",sp_master_host_name,
- sp_master_listen_port);
- fflush(newstdout);
- }
- ip = (struct in_addr *)he->h_addr_list[0];
-
- port=sp_master_listen_port;
- sp_my_cs_addr->s_addr = ip->s_addr;
-
- raddr.sin_family = AF_INET;
- raddr.sin_port = htons(port);
- raddr.sin_addr.s_addr = ip->s_addr;
- sp_child_socket_val = socket(AF_INET, SOCK_STREAM, 0);
- if (sp_child_socket_val < 0)
- {
- perror("child: socket failed:");
- exit(23);
- }
- bzero(&addr, sizeof(struct sockaddr_in));
- tmp_port=sp_child_esend_port;
- addr.sin_port = htons(tmp_port);
- addr.sin_family = AF_INET;
- addr.sin_addr.s_addr = INADDR_ANY;
- rc = -1;
- while (rc < 0)
- {
- rc = bind(sp_child_socket_val, (struct sockaddr *)&addr,
- sizeof(struct sockaddr_in));
- if(rc < 0)
- {
- tmp_port++;
- addr.sin_port=htons(tmp_port);
- continue;
- }
- }
- if(cdebug ==1)
- {
- fprintf(newstdout,"Child: Bound port %d\n",tmp_port);
- fflush(newstdout);
- }
- if (rc < 0)
- {
- perror("Child: bind failed for sync channel to child.\n");
- exit(24);
- }
-#if defined(Windows)
- sleep(1);
-#else
- nanosleep(&req,&rem);
-#endif
-again:
- rc = connect(sp_child_socket_val, (struct sockaddr *)&raddr,
- sizeof(struct sockaddr_in));
- if (rc < 0)
- {
- if(ecount++<300)
- {
-#if defined(Windows)
- sleep(1);
-#else
- nanosleep(&req,&rem);
-#endif
- goto again;
- }
-
- fprintf(newstdout,"child: connect failed. Errno %d \n",errno);
- fflush(newstdout);
- exit(25);
- }
- if(cdebug ==1)
- {
- fprintf(newstdout,"child Connected\n");
- fflush(newstdout);
- }
- return (sp_child_socket_val);
-}
-
-#ifdef HAVE_ANSIC_C
-void
-do_speed_check(int client_flag)
-#else
-void
-do_speed_check(client_flag)
-int client_flag;
-#endif
-{
- int i;
- if(client_flag)
- {
- speed_main(" "," ",reclen,kilobytes64,client_flag);
- }
- else
- {
- printf("Checking %d clients\n",clients_found);
- for(i=0;i<clients_found;i++)
- {
- speed_main(child_idents[i].child_name,
- child_idents[i].execute_path,
- reclen, kilobytes64,client_flag);
- }
- }
-}
-
-#ifdef HAVE_ANSIC_C
-void
-get_date(char *where)
-#else
-get_date(where)
-char *where;
-#endif
-{
- time_t t;
- char *value;
- t=time(0);
- value=(char *)ctime(&t);
- strcpy(where,value);
-}
-
-/* Richard Sharpe decided to hack up Samba and
- * have it detect Iozone running, and then
- * produce the data without doing any actual
- * I/O. This was a HIGHLY questionable thing to
- * be doing (my opinion). It may have been a lab
- * experiment that was accidentally released into
- * the wild, but now that it is, no choice but
- * to prevent its use. So... the pattern
- * that he was locking on to, is now random,
- * and will change with every release of Iozone.
- * See: http://lists.samba.org/archive/samba-technical/2005-April/040541.html
- */
-
-#ifdef HAVE_ANSIC_C
-int
-get_pattern(void)
-#else
-get_pattern(void)
-#endif
-{
- int i,x,y;
- char cp[100],*ptr;
- int pat;
- unsigned char inp_pat;
- unsigned int temp;
-
- y=0;
- ptr=&cp[0];
- strcpy(cp,THISVERSION);
- x=strlen(THISVERSION);
- for(i=0;i<x;i++)
- y+=*ptr++;
- srand(y);
- pat=(rand()& 0xff);
- /* For compatibility with old 0xa5 data sets. */
- if(Z_flag)
- pat=0xa5;
- /* Lock pattern to 0xBB, for filesystem short circuit debug */
- if(X_flag)
- pat=PATTERN1;
- /* Set global pattern */
- inp_pat = pat;
- temp =((inp_pat << 24) | (inp_pat << 16) | (inp_pat << 8) | inp_pat);
- return(pat);
-}
-
-/*
- * Allocate the buffer for purge.
-*/
-#ifdef HAVE_ANSIC_C
-void
-alloc_pbuf(void)
-#else
-alloc_pbuf(void)
-#endif
-{
- pbuffer = (char *) alloc_mem((long long)(3 * cache_size),(int)0);
- if(pbuffer == 0) {
- perror("Memory allocation failed:");
- exit(9);
- }
-#ifdef _64BIT_ARCH_
- pbuffer = (char *)
- (((unsigned long long)pbuffer + cache_size )
- & ~(cache_size-1));
-#else
- pbuffer = (char *)
- (((long)pbuffer + (long)cache_size )
- & ~((long)cache_size-1));
-#endif
-}
-
-/*
- * Check to see if the file descriptor points at a file
- * or a device.
- */
-#ifdef HAVE_ANSIC_C
-int
-check_filename(char *name)
-#else
-check_filename(name)
-char *name;
-#endif
-{
-#ifdef _LARGEFILE64_SOURCE
- struct stat64 mystat;
-#else
- struct stat mystat;
-#endif
- int x;
- if(strlen(name)==0)
- return(0);
- /* Lets try stat first.. may get an error if file is too big */
- x=I_STAT(name,&mystat);
- if(x<0)
- {
- return(0);
- /* printf("Stat failed %d\n",x); */
- }
- if(mystat.st_mode & S_IFREG)
- {
- /*printf("Is a regular file\n");*/
- return(1);
- }
- return(0);
-}
-
-#ifdef HAVE_ANSIC_C
-void
-start_monitor(char *test)
-#else
-start_monitor(test)
-char *test;
-#endif
-{
- char command_line[256];
- if(strlen(imon_start)!=0)
- {
- if(imon_sync)
- sprintf(command_line,"%s %s",imon_start,test);
- else
- sprintf(command_line,"%s %s&",imon_start,test);
- junk=system(command_line);
- }
-}
-#ifdef HAVE_ANSIC_C
-void
-stop_monitor(char *test)
-#else
-stop_monitor(test)
-char *test;
-#endif
-{
- char command_line[256];
- if(strlen(imon_stop)!=0)
- {
- if(imon_sync)
- sprintf(command_line,"%s %s",imon_stop,test);
- else
- sprintf(command_line,"%s %s &",imon_stop,test);
- junk=system(command_line);
- }
-}
-
-/*
- * As quickly as possible, generate a new buffer that
- * can not be easily compressed, or de-duped. Also
- * permit specified percentage of buffer to be updated.
- *
- * ibuf ... input buffer
- * obuf ... output buffer
- * seed ... Seed to use for srand, rand -> xor ops
- * Seed composed from: blocknumber
- (do not include childnum as you want duplicates)
- * size ... size of buffers. (in bytes)
- * percent. Percent of buffer to modify.
- * percent_interior. Percent of buffer that is dedupable within
- * and across files
- * percent_compress. Percent of buffer that is dedupable within
- * but not across files
- *
- * Returns 0 (zero) for success, and -1 (minus one) for failure.
- */
-int
-gen_new_buf(char *ibuf, char *obuf, long seed, int size, int percent,
- int percent_interior, int percent_compress, int all)
-{
- register long *ip, *op; /* Register for speed */
- register long iseed; /* Register for speed */
- register long isize; /* Register for speed */
- register long cseed; /* seed for dedupable for within & ! across */
- register int x,w; /* Register for speed */
- register int value; /* Register for speed */
- register int interior_size; /* size of interior dedup region */
- register int compress_size; /* size of compression dedup region */
- if(ibuf == NULL) /* no input buf */
- return(-1);
- if(obuf == NULL) /* no output buf */
- return(-1);
- if((percent > 100) || (percent < 0)) /* percent check */
- return(-1);
- if(size == 0) /* size check */
- return(-1);
- srand(seed+1+(((int)numrecs64)*dedup_mseed)); /* set random seed */
- iseed = rand(); /* generate random value */
- isize = (size * percent)/100; /* percent that is dedupable */
- interior_size = ((isize * percent_interior)/100);/* /sizeof(long) */
- compress_size =((interior_size * percent_compress)/100);
- ip = (long *)ibuf; /* pointer to input buf */
- op = (long *)obuf; /* pointer to output buf */
- if(all == 0) /* Special case for verify only */
- isize = sizeof(long);
- /* interior_size = dedup_within + dedup_across */
- for(w=0;w<interior_size;w+=sizeof(long))
- {
- *op=0xdeadbeef+dedup_mseed;
- *ip=0xdeadbeef+dedup_mseed;
- op++;
- ip++;
- }
- /* Prepare for dedup within but not across */
- w=interior_size - compress_size;
- op=(long *)&obuf[w];
- ip=(long *)&ibuf[w];
- srand(chid+1+dedup_mseed); /* set randdom seed */
- cseed = rand(); /* generate random value */
- for(w=(interior_size-compress_size);w<interior_size;w+=sizeof(long))
- {
- *op=*ip ^ cseed; /* do the xor op */
- op++;
- ip++;
- }
- /* isize = dedup across only */
- for(x=interior_size;x<isize;x+=sizeof(long)) /* tight loop for transformation */
- {
- *op=*ip ^ iseed; /* do the xor op */
- op++;
- ip++;
- }
- if(all == 0) /* Special case for verify only */
- return(0);
- /* make the rest of the buffer non-dedupable */
- if(100-percent > 0)
- {
- srand(1+seed+((chid+1)*(int)numrecs64)*dedup_mseed);
- value=rand();
-/* printf("Non-dedup value %x seed %x\n",value,seed);*/
- for( ; x<size;x+=sizeof(long))
- *op++=(*ip++)^value; /* randomize the remainder */
- }
- return(0);
-}
-/*
- * Used to touch all of the buffers so that the CPU data
- * cache is hot, and not part of the measurement.
- */
-void
-touch_dedup(char *i, int size)
-{
- register int x;
- register long *ip;
- ip = (long *)i;
- srand(DEDUPSEED);
- for(x=0;x<size/sizeof(long);x++)
- {
- *ip=rand(); /* fill initial buffer */
- ip++;
- }
-}
-
-/*
- A C-program for MT19937-64 (2004/9/29 version).
- Coded by Takuji Nishimura and Makoto Matsumoto.
-
- This is a 64-bit version of Mersenne Twister pseudorandom number
- generator.
-
- Before using, initialize the state by using init_genrand64(seed)
- or init_by_array64(init_key, key_length).
-
- Copyright (C) 2004, Makoto Matsumoto and Takuji Nishimura,
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions
- are met:
-
- 1. Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright
- notice, this list of conditions and the following disclaimer in the
- documentation and/or other materials provided with the distribution.
-
- 3. The names of its contributors may not be used to endorse or promote
- products derived from this software without specific prior written
- permission.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
- References:
- T. Nishimura, ``Tables of 64-bit Mersenne Twisters''
- ACM Transactions on Modeling and
- Computer Simulation 10. (2000) 348--357.
- M. Matsumoto and T. Nishimura,
- ``Mersenne Twister: a 623-dimensionally equidistributed
- uniform pseudorandom number generator''
- ACM Transactions on Modeling and
- Computer Simulation 8. (Jan. 1998) 3--30.
-
- Any feedback is very welcome.
- http://www.math.hiroshima-u.ac.jp/~m-mat/MT/emt.html
- email: m-mat @ math.sci.hiroshima-u.ac.jp (remove spaces)
-*/
-
-
-
-#define NN 312
-#define MM 156
-#define MATRIX_A 0xB5026F5AA96619E9ULL
-#define UM 0xFFFFFFFF80000000ULL /* Most significant 33 bits */
-#define LM 0x7FFFFFFFULL /* Least significant 31 bits */
-
-
-/* The array for the state vector */
-static unsigned long long mt[NN];
-/* mti==NN+1 means mt[NN] is not initialized */
-static int mti=NN+1;
-
-/* initializes mt[NN] with a seed */
-void init_genrand64(unsigned long long seed)
-{
- mt[0] = seed;
- for (mti=1; mti<NN; mti++)
- mt[mti] = (6364136223846793005ULL * (mt[mti-1] ^ (mt[mti-1] >> 62)) + mti);
-}
-
-/* initialize by an array with array-length */
-/* init_key is the array for initializing keys */
-/* key_length is its length */
-void init_by_array64(unsigned long long init_key[],
- unsigned long long key_length)
-{
- unsigned long long i, j, k;
- init_genrand64(19650218ULL);
- i=1; j=0;
- k = (NN>key_length ? NN : key_length);
- for (; k; k--) {
- mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 62)) * 3935559000370003845ULL))
- + init_key[j] + j; /* non linear */
- i++; j++;
- if (i>=NN) { mt[0] = mt[NN-1]; i=1; }
- if (j>=key_length) j=0;
- }
- for (k=NN-1; k; k--) {
- mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 62)) * 2862933555777941757ULL))
- - i; /* non linear */
- i++;
- if (i>=NN) { mt[0] = mt[NN-1]; i=1; }
- }
-
- mt[0] = 1ULL << 63; /* MSB is 1; assuring non-zero initial array */
-}
-
-/* generates a random number on [0, 2^64-1]-interval */
-unsigned long long genrand64_int64(void)
-{
- int i;
- unsigned long long x;
- static unsigned long long mag01[2]={0ULL, MATRIX_A};
-
- if (mti >= NN) { /* generate NN words at one time */
-
- /* if init_genrand64() has not been called, */
- /* a default initial seed is used */
- if (mti == NN+1)
- init_genrand64(5489ULL);
-
- for (i=0;i<NN-MM;i++) {
- x = (mt[i]&UM)|(mt[i+1]&LM);
- mt[i] = mt[i+MM] ^ (x>>1) ^ mag01[(int)(x&1ULL)];
- }
- for (;i<NN-1;i++) {
- x = (mt[i]&UM)|(mt[i+1]&LM);
- mt[i] = mt[i+(MM-NN)] ^ (x>>1) ^ mag01[(int)(x&1ULL)];
- }
- x = (mt[NN-1]&UM)|(mt[0]&LM);
- mt[NN-1] = mt[MM-1] ^ (x>>1) ^ mag01[(int)(x&1ULL)];
-
- mti = 0;
- }
-
- x = mt[mti++];
-
- x ^= (x >> 29) & 0x5555555555555555ULL;
- x ^= (x << 17) & 0x71D67FFFEDA60000ULL;
- x ^= (x << 37) & 0xFFF7EEE000000000ULL;
- x ^= (x >> 43);
-
- return x;
-}
-
-/* generates a random number on [0, 2^63-1]-interval */
-long long genrand64_int63(void)
-{
- return (long long)(genrand64_int64() >> 1);
-}
-
-/* generates a random number on [0,1]-real-interval */
-double genrand64_real1(void)
-{
- return (genrand64_int64() >> 11) * (1.0/9007199254740991.0);
-}
-
-/* generates a random number on [0,1)-real-interval */
-double genrand64_real2(void)
-{
- return (genrand64_int64() >> 11) * (1.0/9007199254740992.0);
-}
-
-/* generates a random number on (0,1)-real-interval */
-double genrand64_real3(void)
-{
- return ((genrand64_int64() >> 12) + 0.5) * (1.0/4503599627370496.0);
-}
-
-#ifdef MT_TEST
-
-int main(void)
-{
- int i;
- unsigned long long init[4]={0x12345ULL, 0x23456ULL, 0x34567ULL, 0x45678ULL}, length=4;
- init_by_array64(init, length);
- printf("1000 outputs of genrand64_int64()\n");
- for (i=0; i<1000; i++) {
- printf("%20llu ", genrand64_int64());
- if (i%5==4) printf("\n");
- }
- printf("\n1000 outputs of genrand64_real2()\n");
- for (i=0; i<1000; i++) {
- printf("%10.8f ", genrand64_real2());
- if (i%5==4) printf("\n");
- }
- return 0;
-}
-#endif
-
-/*----------------------------------------------------------------------*/
-/* */
-/* The PIT Programmable Interdimensional Timer */
-/* */
-/* This is used to measure time, when you know something odd is going */
-/* to be happening with your wrist watch. For example, you have entered */
-/* a temporal distortion field where time its-self is not moving */
-/* as it does in your normal universe. ( thing either intense */
-/* gravitational fields bending space-time, or virtual machines playing */
-/* with time ) */
-/* So.. you need to measure time, but with respect to a normal */
-/* space-time. So.. we deal with this by calling for time from another */
-/* machine, but do so with a very similar interface to that of */
-/* gettimeofday(). */
-/* To activate this, one only needs to set an environmental variable. */
-/* Example: setenv IOZ_PIT hostname_of_PIT_server */
-/* The environmental variable tells this client where to go to get */
-/* correct timeofday time stamps, with the usual gettimeofday() */
-/* resolution. (microsecond resolution) */
-/*----------------------------------------------------------------------*/
-
-/*----------------------------------------------------------------------*/
-/* The PIT client: Adapted from source found on the web for someone's */
-/* daytime client code. (Used in many examples for network programming */
-/* Reads PIT info over a socket from a PIT server. */
-/* The PIT server sends its raw microsecond version of gettimeofday */
-/* The PIT client converts this back into timeval structure format. */
-/* Written by: Don Capps. [ capps@iozone.org ] */
-/*----------------------------------------------------------------------*/
-
-/*>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
-/* >>>> DON'T forget, you must put a definition for PIT <<<<<<<<<< */
-/* >>>> in /etc/services <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
-/*>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
-#define DFLT_SERVICE "PIT" /* Default service name. */
-#define INVALID_DESC -1 /* Invalid file (socket) descriptor. */
-#define MAXBFRSIZE 256 /* Max bfr sz to read remote TOD. */
-
-/*
-** Type definitions (for convenience).
-*/
-#if defined(Windows)
-int false = 0;
-int true = 1;
-#else
-typedef enum { false = 0, true } boolean;
-#endif
-typedef struct sockaddr_in sockaddr_in_t;
-typedef struct sockaddr_in6 sockaddr_in6_t;
-
-/*
- * Routine to mimic gettimeofday() using a remote PIT server
- */
-#if defined(_SUA_)
-struct timezone {
- int tz_minuteswest;
- int tz_dsttime;
-};
-#endif
-
-int
-pit_gettimeofday( struct timeval *tp, struct timezone *foo,
- char *pit_hostname, char *pit_service)
-{
- int sckt; /* socket descriptor */
- unsigned scopeId = 0;
-
- /* See if the interdimensional rift is active */
-
- if(pit_hostname[0] == 0)
- {
- return gettimeofday(tp,foo);
- }
-
- if ( ( sckt = openSckt( pit_hostname,
- pit_service,
- scopeId ) ) == INVALID_DESC )
- {
- fprintf( stderr,
- "Sorry... a connectionless socket could "
- "not be set up.\n");
- return -1;
- }
- /*
- ** Get the remote PIT.
- */
- pit( sckt ,tp );
- close(sckt);
- return 0;
-}
-
-/*
- * Opens a socket for the PIT to use to get the time
- * from a remote time server ( A PIT server )
- */
-static int openSckt( const char *host,
- const char *service,
- unsigned int scopeId )
-{
- struct addrinfo *ai;
- int aiErr;
- struct addrinfo *aiHead;
- struct addrinfo hints;
- sockaddr_in6_t *pSadrIn6;
- int sckt;
- /*
- * Initialize the 'hints' structure for getaddrinfo(3).
- */
- memset( &hints, 0, sizeof( hints ) );
- hints.ai_family = PF_UNSPEC; /* IPv4 or IPv6 records */
- hints.ai_socktype = SOCK_STREAM; /* Connection oriented communication.*/
- hints.ai_protocol = IPPROTO_TCP; /* TCP transport layer protocol only. */
- /*
- ** Look up the host/service information.
- */
- if ( ( aiErr = getaddrinfo( host,
- service,
- &hints,
- &aiHead ) ) != 0 )
- {
- fprintf( stderr, "(line %d): ERROR - %s.\n", __LINE__,
- gai_strerror( aiErr ) );
- return INVALID_DESC;
- }
- /*
- ** Go through the list and try to open a connection. Continue until either
- ** a connection is established or the entire list is exhausted.
- */
- for ( ai = aiHead, sckt = INVALID_DESC;
- ( ai != NULL ) && ( sckt == INVALID_DESC );
- ai = ai->ai_next )
- {
- /*
- ** IPv6 kluge. Make sure the scope ID is set.
- */
- if ( ai->ai_family == PF_INET6 )
- {
- pSadrIn6 = (sockaddr_in6_t*) ai->ai_addr;
- if ( pSadrIn6->sin6_scope_id == 0 )
- {
- pSadrIn6->sin6_scope_id = scopeId;
- } /* End IF the scope ID wasn't set. */
- } /* End IPv6 kluge. */
- /*
- ** Create a socket.
- */
- sckt = socket( ai->ai_family, ai->ai_socktype, ai->ai_protocol );
- if(sckt == -1)
- {
- sckt = INVALID_DESC;
- continue; /* Try the next address record in the list. */
- }
- /*
- ** Set the target destination for the remote host on this socket. That
- ** is, this socket only communicates with the specified host.
- */
- if (connect( sckt, ai->ai_addr, ai->ai_addrlen ) )
- {
- (void) close( sckt ); /* Could use system call again here,
- but why? */
- sckt = INVALID_DESC;
- continue; /* Try the next address record in the list. */
- }
- } /* End FOR each address record returned by getaddrinfo(3). */
- /*
- ** Clean up & return.
- */
- freeaddrinfo( aiHead );
- return sckt;
-} /* End openSckt() */
-
-/*
- * Read the PIT, and convert this back into timeval
- * info, and store it in the timeval structure that was
- * passed in.
- */
-static void pit( int sckt, struct timeval *tp)
-{
- char bfr[ MAXBFRSIZE+1 ];
- int inBytes;
- long long value;
- /*
- ** Send a datagram to the server to wake it up. The content isn't
- ** important, but something must be sent to let it know we want the TOD.
- */
- junk=write( sckt, "Are you there?", 14 );
- /*
- ** Read the PIT from the remote host.
- */
- inBytes = read( sckt, bfr, MAXBFRSIZE );
- bfr[ inBytes ] = '\0'; /* Null-terminate the received string. */
- /*
- * Convert result to timeval structure format
- */
- sscanf(bfr,"%llu\n",&value);
- tp->tv_sec = (long)(value / 1000000);
- tp->tv_usec = (long)(value % 1000000);
-}
-
-/* sync does not exist in SUA */
-#if defined(_SUA_)
-sync()
-{
-}
-#endif
-
-
-#define BUCKETS 40
-long long buckets[BUCKETS];
-long long bucket_val[BUCKETS] =
- { 20,40,60,80,100,
- 200,400,600,800,1000,
- 2000,4000,6000,8000,10000,
- 12000,14000,16000,18000,20000,
- 40000,60000,80000,100000,
- 200000,400000,600000,800000,1000000,
- 2000000,4000000,6000000,8000000,10000000,
- 20000000,30000000,60000000,90000000,120000000,120000001};
-/*
- * Buckets: (Based on a Netapp internal consensus)
- * 0 1 2 3 4
- * <=20us <=40us <=60us <=80us <=100us
- *
- * 5 6 7 8 9
- * <=200us <=400us <=600us <=88us <=1ms
- *
- * 10 11 12 13 14
- * <=2ms <=4ms <=6ms <=8ms <=10ms
- *
- * 15 16 17 18 19
- * <=12ms <=14ms <=16ms <=18ms <=20ms
- *
- * 20 21 22 23 24
- * <=20ms <=40ms <=60ms <=80ms <=100ms
- *
- * 25 26 27 28 29
- * <=200ms <=400ms <=600ms <=800ms <=1s
- *
- * 30 31 32 33 34
- * <=2s <=4s <=6s <=8s <=10s
- *
- * 35 36 37 38 39
- * <=20s <=30s <=60 <=90s >90
- */
-
-/*
- fp=fopen("/tmp/iozone_latency_summary.txt","a");
- dump_hist(fp);
-*/
-
-void
-hist_insert(double my_value)
-{
- int k;
- long long value;
-
- /* Convert to micro-seconds */
- value = (long long)(my_value * 1000000);
- for(k=0;k<BUCKETS;k++)
- {
- if(k < (BUCKETS-1))
- {
- if(value <= bucket_val[k])
- {
- buckets[k]++;
- break;
- }
- }
- else
- {
- if(value > bucket_val[k])
- {
- buckets[k]++;
- break;
- }
- }
- }
-}
-
-void
-dump_hist(char *what,int id)
-{
- FILE *fp;
-
- char name[256];
-
- sprintf(name,"%s_child_%d.txt","Iozone_histogram",id);
-
- fp = fopen(name,"a");
-
-#ifndef NO_PRINT_LLD
- fprintf(fp,"Child: %d Op: %s\n",id,what);
- fprintf(fp,"Band 1: ");
- fprintf(fp," 20us:%-7.1lld ",buckets[0]);
- fprintf(fp," 40us:%-7.1lld ",buckets[1]);
- fprintf(fp," 60us:%-7.1lld ",buckets[2]);
- fprintf(fp," 80us:%-7.1lld ",buckets[3]);
- fprintf(fp,"100us:%-7.1lld \n",buckets[4]);
-
- fprintf(fp,"Band 2: ");
- fprintf(fp,"200us:%-7.1lld ",buckets[5]);
- fprintf(fp,"400us:%-7.1lld ",buckets[6]);
- fprintf(fp,"600us:%-7.1lld ",buckets[7]);
- fprintf(fp,"800us:%-7.1lld ",buckets[8]);
- fprintf(fp," 1ms:%-7.1lld \n",buckets[9]);
-
- fprintf(fp,"Band 3: ");
- fprintf(fp," 2ms:%-7.1lld ",buckets[10]);
- fprintf(fp," 4ms:%-7.1lld ",buckets[11]);
- fprintf(fp," 6ms:%-7.1lld ",buckets[12]);
- fprintf(fp," 8ms:%-7.1lld ",buckets[13]);
- fprintf(fp," 10ms:%-7.1lld \n",buckets[14]);
-
- fprintf(fp,"Band 4: ");
- fprintf(fp," 12ms:%-7.1lld ",buckets[15]);
- fprintf(fp," 14ms:%-7.1lld ",buckets[16]);
- fprintf(fp," 16ms:%-7.1lld ",buckets[17]);
- fprintf(fp," 18ms:%-7.1lld ",buckets[18]);
- fprintf(fp," 20ms:%-7.1lld \n",buckets[19]);
-
- fprintf(fp,"Band 5: ");
- fprintf(fp," 40ms:%-7.1lld ",buckets[20]);
- fprintf(fp," 60ms:%-7.1lld ",buckets[21]);
- fprintf(fp," 80ms:%-7.1lld ",buckets[22]);
- fprintf(fp,"100ms:%-7.1lld \n",buckets[23]);
-
- fprintf(fp,"Band 6: ");
- fprintf(fp,"200ms:%-7.1lld ",buckets[24]);
- fprintf(fp,"400ms:%-7.1lld ",buckets[25]);
- fprintf(fp,"600ms:%-7.1lld ",buckets[26]);
- fprintf(fp,"800ms:%-7.1lld ",buckets[27]);
- fprintf(fp," 1s:%-7.1lld \n",buckets[28]);
-
- fprintf(fp,"Band 7: ");
- fprintf(fp," 2s:%-7.1lld ",buckets[29]);
- fprintf(fp," 4s:%-7.1lld ",buckets[30]);
- fprintf(fp," 6s:%-7.1lld ",buckets[31]);
- fprintf(fp," 8s:%-7.1lld ",buckets[32]);
- fprintf(fp," 10s:%-7.1lld \n",buckets[33]);
-
- fprintf(fp,"Band 8: ");
- fprintf(fp," 20s:%-7.1lld ",buckets[34]);
- fprintf(fp," 40s:%-7.1lld ",buckets[35]);
- fprintf(fp," 60s:%-7.1lld ",buckets[36]);
- fprintf(fp," 80s:%-7.1lld ",buckets[37]);
- fprintf(fp," 120s:%-7.1lld \n",buckets[38]);
-
- fprintf(fp,"Band 9: ");
- fprintf(fp,"120+s:%-7.1lld \n\n",buckets[39]);
-#else
- fprintf(fp,"Child: %d Op: %s\n",id,what);
- fprintf(fp,"Band 1: ");
- fprintf(fp," 20us:%-7.1ld ",buckets[0]);
- fprintf(fp," 40us:%-7.1ld ",buckets[1]);
- fprintf(fp," 60us:%-7.1ld ",buckets[2]);
- fprintf(fp," 80us:%-7.1ld ",buckets[3]);
- fprintf(fp,"100us:%-7.1ld \n",buckets[4]);
-
- fprintf(fp,"Band 2: ");
- fprintf(fp,"200us:%-7.1ld ",buckets[5]);
- fprintf(fp,"400us:%-7.1ld ",buckets[6]);
- fprintf(fp,"600us:%-7.1ld ",buckets[7]);
- fprintf(fp,"800us:%-7.1ld ",buckets[8]);
- fprintf(fp," 1ms:%-7.1ld \n",buckets[9]);
-
- fprintf(fp,"Band 3: ");
- fprintf(fp," 2ms:%-7.1ld ",buckets[10]);
- fprintf(fp," 4ms:%-7.1ld ",buckets[11]);
- fprintf(fp," 6ms:%-7.1ld ",buckets[12]);
- fprintf(fp," 8ms:%-7.1ld ",buckets[13]);
- fprintf(fp," 10ms:%-7.1ld \n",buckets[14]);
-
- fprintf(fp,"Band 4: ");
- fprintf(fp," 12ms:%-7.1ld ",buckets[15]);
- fprintf(fp," 14ms:%-7.1ld ",buckets[16]);
- fprintf(fp," 16ms:%-7.1ld ",buckets[17]);
- fprintf(fp," 18ms:%-7.1ld ",buckets[18]);
- fprintf(fp," 20ms:%-7.1ld \n",buckets[19]);
-
- fprintf(fp,"Band 5: ");
- fprintf(fp," 40ms:%-7.1ld ",buckets[20]);
- fprintf(fp," 60ms:%-7.1ld ",buckets[21]);
- fprintf(fp," 80ms:%-7.1ld ",buckets[22]);
- fprintf(fp,"100ms:%-7.1ld \n",buckets[23]);
-
- fprintf(fp,"Band 6: ");
- fprintf(fp,"200ms:%-7.1ld ",buckets[24]);
- fprintf(fp,"400ms:%-7.1ld ",buckets[25]);
- fprintf(fp,"600ms:%-7.1ld ",buckets[26]);
- fprintf(fp,"800ms:%-7.1ld ",buckets[27]);
- fprintf(fp," 1s:%-7.1ld \n",buckets[28]);
-
- fprintf(fp,"Band 7: ");
- fprintf(fp," 2s:%-7.1ld ",buckets[29]);
- fprintf(fp," 4s:%-7.1ld ",buckets[30]);
- fprintf(fp," 6s:%-7.1ld ",buckets[31]);
- fprintf(fp," 8s:%-7.1ld ",buckets[32]);
- fprintf(fp," 10s:%-7.1ld \n",buckets[33]);
-
- fprintf(fp,"Band 8: ");
- fprintf(fp," 20s:%-7.1ld ",buckets[34]);
- fprintf(fp," 40s:%-7.1ld ",buckets[35]);
- fprintf(fp," 60s:%-7.1ld ",buckets[36]);
- fprintf(fp," 80s:%-7.1ld ",buckets[37]);
- fprintf(fp," 120s:%-7.1ld \n",buckets[38]);
-
- fprintf(fp,"Band 9: ");
- fprintf(fp,"120+s:%-7.1ld \n\n",buckets[39]);
-#endif
- fclose(fp);
-}
-
-#ifdef HAVE_ANSIC_C
-void * thread_fwrite_test(void *x)
-#else
-void * thread_fwrite_test( x)
-#endif
-{
-
- struct child_stats *child_stat;
- double starttime1 = 0;
- double temp_time;
- double hist_time;
- double desired_op_rate_time;
- double actual_rate;
- double walltime, cputime;
- double compute_val = (double)0;
- float delay = (float)0;
- double thread_qtime_stop,thread_qtime_start;
- off64_t traj_offset;
- long long w_traj_bytes_completed;
- long long w_traj_ops_completed;
- FILE *w_traj_fd;
- int fd;
- long long recs_per_buffer;
- long long stopped,i;
- off64_t written_so_far, read_so_far, re_written_so_far,re_read_so_far;
- long long xx,xx2;
- char *dummyfile [MAXSTREAMS]; /* name of dummy file */
- char *nbuff;
- char *maddr;
- char *wmaddr,*free_addr;
- char now_string[30];
- int anwser,bind_cpu,wval;
-#if defined(VXFS) || defined(solaris)
- int test_foo = 0;
-#endif
- off64_t filebytes64;
- char tmpname[256];
- FILE *thread_wqfd;
- FILE *thread_Lwqfd;
- char *filename;
-
- char *stdio_buf;
- char *how;
- long long Index = 0;
- FILE *stream = NULL;
- static int First_Run = 1;
-
- if(compute_flag)
- delay=compute_time;
- nbuff=maddr=wmaddr=free_addr=0;
- thread_qtime_stop=thread_qtime_start=0;
- thread_wqfd=w_traj_fd=thread_Lwqfd=(FILE *)0;
- traj_offset=walltime=cputime=0;
- anwser=bind_cpu=0;
-
- if(w_traj_flag)
- {
- filebytes64 = w_traj_fsize;
- numrecs64=w_traj_ops;
- }
- else
- {
- filebytes64 = numrecs64*reclen;
- }
- written_so_far=read_so_far=re_written_so_far=re_read_so_far=0;
- w_traj_bytes_completed=w_traj_ops_completed=0;
- recs_per_buffer = cache_size/reclen ;
-#ifdef NO_THREADS
- xx=chid;
-#else
- if(use_thread)
- {
- xx = (long long)((long)x);
- }
- else
- {
- xx=chid;
- }
-#endif
-#ifndef NO_THREADS
-#ifdef _HPUX_SOURCE
- if(ioz_processor_bind)
- {
- bind_cpu=(begin_proc+(int)xx)%num_processors;
- pthread_processor_bind_np(PTHREAD_BIND_FORCED_NP,
- (pthread_spu_t *)&anwser, (pthread_spu_t)bind_cpu, pthread_self());
- my_nap(40); /* Switch to new cpu */
- }
-#endif
-#endif
- if(use_thread)
- nbuff=barray[xx];
- else
- nbuff=buffer;
- if(debug1 )
- {
- if(use_thread)
-#ifdef NO_PRINT_LLD
- printf("\nStarting child %ld\n",xx);
-#else
- printf("\nStarting child %lld\n",xx);
-#endif
- else
-#ifdef NO_PRINT_LLD
- printf("\nStarting process %d slot %ld\n",getpid(),xx);
-#else
- printf("\nStarting process %d slot %lld\n",getpid(),xx);
-#endif
-
- }
- dummyfile[xx]=(char *)malloc((size_t)MAXNAMESIZE);
- xx2=xx;
- if(share_file)
- xx2=(long long)0;
- if(mfflag)
- {
-#ifdef NO_PRINT_LLD
- sprintf(dummyfile[xx],"%s",filearray[xx2]);
-#else
- sprintf(dummyfile[xx],"%s",filearray[xx2]);
-#endif
- }
- else
- {
-#ifdef NO_PRINT_LLD
- sprintf(dummyfile[xx],"%s.DUMMY.%ld",filearray[xx2],xx2);
-#else
- sprintf(dummyfile[xx],"%s.DUMMY.%lld",filearray[xx2],xx2);
-#endif
- }
- filename=dummyfile[xx];
-
- if(mmapflag || async_flag)
- return(0);
-
- stdio_buf=(char *)malloc((size_t)reclen);
-
- if(Uflag) /* Unmount and re-mount the mountpoint */
- {
- purge_buffer_cache();
- }
-
- if(First_Run==1)
- {
- First_Run=0;
- if(check_filename(filename))
- how="r+"; /* file exists, don't create and zero a new one. */
- else
- how="w+"; /* file doesn't exist. create it. */
- }
- else
- how="r+"; /* re-tests should error out if file does not exist. */
-
-#ifdef IRIX64
- if((stream=(FILE *)fopen(filename,how)) == 0)
- {
- printf("\nCan not fdopen temp file: %s %lld\n",
- filename,errno);
- perror("fdopen");
- exit(48);
- }
-#else
- if((stream=(FILE *)I_FOPEN(filename,how)) == 0)
- {
-#ifdef NO_PRINT_LLD
- printf("\nCan not fdopen temp file: %s %d\n",
- filename,errno);
-#else
- printf("\nCan not fdopen temp file: %s %d\n",
- filename,errno);
-#endif
- perror("fdopen");
- exit(49);
- }
-#endif
- fd=fileno(stream);
- fsync(fd);
- if(direct_flag)
- setvbuf(stream,stdio_buf,_IONBF,reclen);
- else
- setvbuf(stream,stdio_buf,_IOFBF,reclen);
-
- buffer=mainbuffer;
- if(fetchon)
- fetchit(buffer,reclen);
- if(verify || dedup || dedup_interior)
- fill_buffer(buffer,reclen,(long long)pattern,sverify,(long long)0);
-
- compute_val=(double)0;
-
- /*******************************************************************/
-
- child_stat = (struct child_stats *)&shmaddr[xx];
- child_stat->throughput = 0;
- child_stat->actual = 0;
- child_stat->flag=CHILD_STATE_READY; /* Tell parent child is ready to go */
-
- if(distributed && client_iozone)
- tell_master_ready(chid);
- if(distributed && client_iozone)
- {
- if(cdebug)
- {
- printf("Child %d waiting for go from master\n",(int)xx);
- fflush(stdout);
- }
- wait_for_master_go(chid);
- if(cdebug)
- {
- printf("Child %d received go from master\n",(int)xx);
- fflush(stdout);
- }
- }
- else
- {
- while(child_stat->flag!=CHILD_STATE_BEGIN) /* Wait for signal from parent */
- Poll((long long)1);
- }
-
- written_so_far=0;
- child_stat = (struct child_stats *)&shmaddr[xx];
- child_stat->actual = 0;
- child_stat->throughput = 0;
- stopped=0;
- if(Q_flag)
- {
- sprintf(tmpname,"Child_%d_fwol.dat",(int)xx);
- thread_wqfd=fopen(tmpname,"a");
- if(thread_wqfd==0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- printf("Unable to open %s\n",tmpname);
- exit(40);
- }
- fprintf(thread_wqfd,"Offset in Kbytes Latency in microseconds Transfer size in bytes\n");
- }
- if(L_flag)
- {
- sprintf(tmpname,"Child_%d.log",(int)xx);
- thread_Lwqfd=fopen(tmpname,"a");
- if(thread_Lwqfd==0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- printf("Unable to open %s\n",tmpname);
- exit(40);
- }
- get_date(now_string);
- fprintf(thread_Lwqfd,"%-25s %s","fwrite test start: ",now_string);
- }
- starttime1 = time_so_far();
- if(cpuutilflag)
- {
- walltime = starttime1;
- cputime = cputime_so_far();
- }
- /*******************************************************************/
- for(i=0; i<numrecs64; i++){
- if(compute_flag)
- compute_val+=do_compute(compute_time);
- if(multi_buffer)
- {
- Index +=reclen;
- if(Index > (MAXBUFFERSIZE-reclen))
- Index=0;
- buffer = mbuffer + Index;
- }
- if((verify & diag_v) || dedup || dedup_interior)
- fill_buffer(buffer,reclen,(long long)pattern,sverify,i);
- if(purge)
- purgeit(buffer,reclen);
- if(Q_flag || hist_summary || op_rate_flag)
- {
- thread_qtime_start=time_so_far();
- }
- if(fwrite(buffer, (size_t) reclen, 1, stream) != 1)
- {
-#ifdef NO_PRINT_LLD
- printf("\nError fwriting block %ld, fd= %d\n", i,
- fd);
-#else
- printf("\nError fwriting block %lld, fd= %d\n", i,
- fd);
-#endif
- perror("fwrite");
- signal_handler();
- }
- if(hist_summary)
- {
- thread_qtime_stop=time_so_far();
- hist_time =(thread_qtime_stop-thread_qtime_start);
- hist_insert(hist_time);
- }
- if(op_rate_flag)
- {
- thread_qtime_stop=time_so_far();
- desired_op_rate_time = ((double)1.0/(double)op_rate);
- actual_rate = (double)(thread_qtime_stop-thread_qtime_start);
- if( actual_rate < desired_op_rate_time)
- my_unap((unsigned long long)((desired_op_rate_time-actual_rate)*1000000.0 ));
- }
- if(Q_flag)
- {
- thread_qtime_stop=time_so_far();
-#ifdef NO_PRINT_LLD
- fprintf(thread_wqfd,"%10.1ld %10.0f %10.1ld\n",(traj_offset)/1024,((thread_qtime_stop-thread_qtime_start-time_res))*1000000,reclen);
-#else
- fprintf(thread_wqfd,"%10.1lld %10.0f %10.1lld\n",(traj_offset)/1024,((thread_qtime_stop-thread_qtime_start-time_res))*1000000,reclen);
-#endif
- }
- w_traj_ops_completed++;
- w_traj_bytes_completed+=reclen;
- written_so_far+=reclen/1024;
- }
- if(include_flush)
- {
- fflush(stream);
- wval=fsync(fd);
- if(wval==-1){
- perror("fsync");
- signal_handler();
- }
- }
- if(include_close)
- {
- wval=fclose(stream);
- if(wval==-1){
- perror("fclose");
- signal_handler();
- }
- }
- /*******************************************************************/
- if(!stopped){
- temp_time = time_so_far();
- child_stat->throughput = ((temp_time - starttime1)-time_res)
- -compute_val;
- if(child_stat->throughput < (double).000001)
- {
- child_stat->throughput= time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-
- if(OPS_flag){
- /*written_so_far=(written_so_far*1024)/reclen;*/
- written_so_far=w_traj_ops_completed;
- }
- child_stat->throughput =
- (double)written_so_far/child_stat->throughput;
- child_stat->actual = (double)written_so_far;
- }
- if(cdebug)
- {
- printf("Child %d: throughput %f actual %f \n",(int)chid, child_stat->throughput,
- child_stat->actual);
- fflush(stdout);
- }
- if(cpuutilflag)
- {
- cputime = cputime_so_far() - cputime;
- if (cputime < cputime_res)
- cputime = 0.0;
- child_stat->cputime = cputime;
- walltime = time_so_far() - walltime;
- child_stat->walltime = walltime;
- }
- if(distributed && client_iozone)
- tell_master_stats(THREAD_FWRITE_TEST, chid, child_stat->throughput,
- child_stat->actual,
- child_stat->cputime, child_stat->walltime,
- (char)*stop_flag,
- (long long)CHILD_STATE_HOLD);
-
- if (debug1) {
- printf(" child/slot: %lld, wall-cpu: %8.3f %8.3fC" " -> %6.2f%%\n",
- xx, walltime, cputime,
- cpu_util(cputime, walltime));
- }
- child_stat->flag = CHILD_STATE_HOLD; /* Tell parent I'm done */
- stopped=0;
-
- /*******************************************************************/
- /* End fwrite performance test. *************************************/
- /*******************************************************************/
-
- if(debug1)
-#ifdef NO_PRINT_LLD
- printf("\nChild finished %ld\n",xx);
-#else
- printf("\nChild finished %lld\n",xx);
-#endif
- if(Q_flag && (thread_wqfd !=0) )
- fclose(thread_wqfd);
- free(dummyfile[xx]);
- if(w_traj_flag)
- fclose(w_traj_fd);
-
- if(L_flag)
- {
- get_date(now_string);
- fprintf(thread_Lwqfd,"%-25s %s","Fwrite test finished: ",now_string);
- fclose(thread_Lwqfd);
- }
- /*******************************************************************/
- if(!include_close)
- {
- wval=fflush(stream);
- if(wval==-1){
- perror("fflush");
- signal_handler();
- }
- wval=fsync(fd);
- if(wval==-1){
- perror("fsync");
- signal_handler();
- }
- wval=fclose(stream);
- if(wval==-1){
- perror("fclose");
- signal_handler();
- }
- }
-
- if(restf)
- sleep((int)(int)rest_val);
-
- free(stdio_buf);
- if(OPS_flag || MS_flag){
- filebytes64=filebytes64/reclen;
- }
- /*******************************************************************/
- if(hist_summary)
- dump_hist("Fwrite",(int)xx);
- if(distributed && client_iozone)
- return(0);
-#ifdef NO_THREADS
- exit(0);
-#else
- if(use_thread)
- thread_exit();
- else
- exit(0);
-#endif
-
-return(0);
-}
-
-
-#ifdef HAVE_ANSIC_C
-void * thread_fread_test(void *x)
-#else
-void * thread_fread_test( x)
-#endif
-{
- struct child_stats *child_stat;
- double starttime1 = 0;
- double temp_time;
- double hist_time;
- double desired_op_rate_time;
- double actual_rate;
- double walltime, cputime;
- double compute_val = (double)0;
- float delay = (float)0;
- double thread_qtime_stop,thread_qtime_start;
- off64_t traj_offset;
- long long w_traj_bytes_completed;
- long long w_traj_ops_completed;
- FILE *w_traj_fd;
- int fd;
- long long recs_per_buffer;
- long long stopped,i;
- off64_t written_so_far, read_so_far, re_written_so_far,re_read_so_far;
- long long xx,xx2;
- char *dummyfile [MAXSTREAMS]; /* name of dummy file */
- char *nbuff;
- char *maddr;
- char *wmaddr,*free_addr;
- char now_string[30];
- int anwser,bind_cpu;
-#if defined(VXFS) || defined(solaris)
- int test_foo = 0;
-#endif
- off64_t filebytes64;
- char tmpname[256];
- FILE *thread_wqfd;
- FILE *thread_Lwqfd;
-
- if(compute_flag)
- delay=compute_time;
- nbuff=maddr=wmaddr=free_addr=0;
- thread_qtime_stop=thread_qtime_start=0;
- thread_wqfd=w_traj_fd=thread_Lwqfd=(FILE *)0;
- traj_offset=walltime=cputime=0;
- anwser=bind_cpu=0;
- char *stdio_buf;
- long long Index = 0;
- FILE *stream = NULL;
- char *filename;
-
- if(w_traj_flag)
- {
- filebytes64 = w_traj_fsize;
- numrecs64=w_traj_ops;
- }
- else
- {
- filebytes64 = numrecs64*reclen;
- }
- written_so_far=read_so_far=re_written_so_far=re_read_so_far=0;
- w_traj_bytes_completed=w_traj_ops_completed=0;
- recs_per_buffer = cache_size/reclen ;
-#ifdef NO_THREADS
- xx=chid;
-#else
- if(use_thread)
- {
- xx = (long long)((long)x);
- }
- else
- {
- xx=chid;
- }
-#endif
-#ifndef NO_THREADS
-#ifdef _HPUX_SOURCE
- if(ioz_processor_bind)
- {
- bind_cpu=(begin_proc+(int)xx)%num_processors;
- pthread_processor_bind_np(PTHREAD_BIND_FORCED_NP,
- (pthread_spu_t *)&anwser, (pthread_spu_t)bind_cpu, pthread_self());
- my_nap(40); /* Switch to new cpu */
- }
-#endif
-#endif
- if(use_thread)
- nbuff=barray[xx];
- else
- nbuff=buffer;
- if(debug1 )
- {
- if(use_thread)
-#ifdef NO_PRINT_LLD
- printf("\nStarting child %ld\n",xx);
-#else
- printf("\nStarting child %lld\n",xx);
-#endif
- else
-#ifdef NO_PRINT_LLD
- printf("\nStarting process %d slot %ld\n",getpid(),xx);
-#else
- printf("\nStarting process %d slot %lld\n",getpid(),xx);
-#endif
-
- }
- dummyfile[xx]=(char *)malloc((size_t)MAXNAMESIZE);
- xx2=xx;
- if(share_file)
- xx2=(long long)0;
- if(mfflag)
- {
-#ifdef NO_PRINT_LLD
- sprintf(dummyfile[xx],"%s",filearray[xx2]);
-#else
- sprintf(dummyfile[xx],"%s",filearray[xx2]);
-#endif
- }
- else
- {
-#ifdef NO_PRINT_LLD
- sprintf(dummyfile[xx],"%s.DUMMY.%ld",filearray[xx2],xx2);
-#else
- sprintf(dummyfile[xx],"%s.DUMMY.%lld",filearray[xx2],xx2);
-#endif
- }
-
- filename=dummyfile[xx];
-
- if(mmapflag || async_flag)
- return(0);
-
- stdio_buf=(char *)malloc((size_t)reclen);
-
- if(Uflag) /* Unmount and re-mount the mountpoint */
- {
- purge_buffer_cache();
- }
-#ifdef IRIX64
- if((stream=(FILE *)fopen(filename,"r")) == 0)
- {
- printf("\nCan not fdopen temp file: %s\n",
- filename);
- perror("fdopen");
- exit(51);
- }
-#else
- if((stream=(FILE *)I_FOPEN(filename,"r")) == 0)
- {
- printf("\nCan not fdopen temp file: %s\n",
- filename);
- perror("fdopen");
- exit(52);
- }
-#endif
- fd=I_OPEN(filename,O_RDONLY,0);
- fsync(fd);
- close(fd);
- if(direct_flag)
- setvbuf(stream,stdio_buf,_IONBF,reclen);
- else
- setvbuf(stream,stdio_buf,_IOFBF,reclen);
-
- buffer=mainbuffer;
- if(fetchon)
- fetchit(buffer,reclen);
- compute_val=(double)0;
-
- /*******************************************************************/
- /*******************************************************************/
-
- child_stat = (struct child_stats *)&shmaddr[xx];
- child_stat->throughput = 0;
- child_stat->actual = 0;
- child_stat->flag=CHILD_STATE_READY; /* Tell parent child is ready to go */
-
- if(distributed && client_iozone)
- tell_master_ready(chid);
- if(distributed && client_iozone)
- {
- if(cdebug)
- {
- printf("Child %d waiting for go from master\n",(int)xx);
- fflush(stdout);
- }
- wait_for_master_go(chid);
- if(cdebug)
- {
- printf("Child %d received go from master\n",(int)xx);
- fflush(stdout);
- }
- }
- else
- {
- while(child_stat->flag!=CHILD_STATE_BEGIN) /* Wait for signal from parent */
- Poll((long long)1);
- }
-
- written_so_far=0;
- child_stat = (struct child_stats *)&shmaddr[xx];
- child_stat->actual = 0;
- child_stat->throughput = 0;
- stopped=0;
- if(Q_flag)
- {
- sprintf(tmpname,"Child_%d_frol.dat",(int)xx);
- thread_wqfd=fopen(tmpname,"a");
- if(thread_wqfd==0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- printf("Unable to open %s\n",tmpname);
- exit(40);
- }
- fprintf(thread_wqfd,"Offset in Kbytes Latency in microseconds Transfer size in bytes\n");
- }
- if(L_flag)
- {
- sprintf(tmpname,"Child_%d.log",(int)xx);
- thread_Lwqfd=fopen(tmpname,"a");
- if(thread_Lwqfd==0)
- {
- client_error=errno;
- if(distributed && client_iozone)
- send_stop();
- printf("Unable to open %s\n",tmpname);
- exit(40);
- }
- get_date(now_string);
- fprintf(thread_Lwqfd,"%-25s %s","fread test start: ",now_string);
- }
- starttime1 = time_so_far();
- if(cpuutilflag)
- {
- walltime = starttime1;
- cputime = cputime_so_far();
- }
-
-
-
- /*******************************************************************/
-
- for(i=0; i<numrecs64; i++)
- {
- if(compute_flag)
- compute_val+=do_compute(compute_time);
- if(multi_buffer)
- {
- Index +=reclen;
- if(Index > (MAXBUFFERSIZE-reclen))
- Index=0;
- buffer = mbuffer + Index;
- }
- if(purge)
- purgeit(buffer,reclen);
- if(Q_flag || hist_summary || op_rate_flag)
- {
- thread_qtime_start=time_so_far();
- }
- if(fread(buffer, (size_t) reclen,1, stream) != 1)
- {
-#ifdef _64BIT_ARCH_
-#ifdef NO_PRINT_LLD
- printf("\nError freading block %ld %x\n", i,
- (unsigned long)buffer);
-#else
- printf("\nError freading block %lld %llx\n", i,
- (unsigned long long)buffer);
-#endif
-#else
-#ifdef NO_PRINT_LLD
- printf("\nError freading block %ld %lx\n", i,
- (long)buffer);
-#else
- printf("\nError freading block %lld %lx\n", i,
- (long)buffer);
-#endif
-#endif
- perror("read");
- exit(54);
- }
- if(verify){
- if(verify_buffer(buffer,reclen,(off64_t)i,reclen,(long long)pattern,sverify)){
- exit(55);
- }
- }
- if(hist_summary)
- {
- thread_qtime_stop=time_so_far();
- hist_time =(thread_qtime_stop-thread_qtime_start);
- hist_insert(hist_time);
- }
- if(op_rate_flag)
- {
- thread_qtime_stop=time_so_far();
- desired_op_rate_time = ((double)1.0/(double)op_rate);
- actual_rate = (double)(thread_qtime_stop-thread_qtime_start);
- if( actual_rate < desired_op_rate_time)
- my_unap((unsigned long long)((desired_op_rate_time-actual_rate)*1000000.0 ));
- }
- if(Q_flag)
- {
- thread_qtime_stop=time_so_far();
-#ifdef NO_PRINT_LLD
- fprintf(thread_wqfd,"%10.1ld %10.0f %10.1ld\n",(traj_offset)/1024,((thread_qtime_stop-thread_qtime_start-time_res))*1000000,reclen);
-#else
- fprintf(thread_wqfd,"%10.1lld %10.0f %10.1lld\n",(traj_offset)/1024,((thread_qtime_stop-thread_qtime_start-time_res))*1000000,reclen);
-#endif
- }
- w_traj_ops_completed++;
- w_traj_bytes_completed+=reclen;
- written_so_far+=reclen/1024;
-
- }
- if(include_flush)
- fflush(stream);
- if(include_close)
- {
- fclose(stream);
- }
-
- /*******************************************************************/
-
- if(!stopped){
- temp_time = time_so_far();
- child_stat->throughput = ((temp_time - starttime1)-time_res)
- -compute_val;
- if(child_stat->throughput < (double).000001)
- {
- child_stat->throughput= time_res;
- if(rec_prob < reclen)
- rec_prob = reclen;
- res_prob=1;
- }
-
- if(OPS_flag){
- /*written_so_far=(written_so_far*1024)/reclen;*/
- written_so_far=w_traj_ops_completed;
- }
- child_stat->throughput =
- (double)written_so_far/child_stat->throughput;
- child_stat->actual = (double)written_so_far;
- }
- if(cdebug)
- {
- printf("Child %d: throughput %f actual %f \n",(int)chid, child_stat->throughput,
- child_stat->actual);
- fflush(stdout);
- }
- if(cpuutilflag)
- {
- cputime = cputime_so_far() - cputime;
- if (cputime < cputime_res)
- cputime = 0.0;
- child_stat->cputime = cputime;
- walltime = time_so_far() - walltime;
- child_stat->walltime = walltime;
- }
- if(distributed && client_iozone)
- tell_master_stats(THREAD_FREAD_TEST, chid, child_stat->throughput,
- child_stat->actual,
- child_stat->cputime, child_stat->walltime,
- (char)*stop_flag,
- (long long)CHILD_STATE_HOLD);
-
- if (debug1) {
- printf(" child/slot: %lld, wall-cpu: %8.3f %8.3fC" " -> %6.2f%%\n",
- xx, walltime, cputime,
- cpu_util(cputime, walltime));
- }
- child_stat->flag = CHILD_STATE_HOLD; /* Tell parent I'm done */
- stopped=0;
-
- /*******************************************************************/
- /* End fead performance test. *************************************/
- /*******************************************************************/
-
- if(debug1)
-#ifdef NO_PRINT_LLD
- printf("\nChild finished %ld\n",xx);
-#else
- printf("\nChild finished %lld\n",xx);
-#endif
- if(Q_flag && (thread_wqfd !=0) )
- fclose(thread_wqfd);
- free(dummyfile[xx]);
- if(w_traj_flag)
- fclose(w_traj_fd);
-
- if(L_flag)
- {
- get_date(now_string);
- fprintf(thread_Lwqfd,"%-25s %s","Fread test finished: ",now_string);
- fclose(thread_Lwqfd);
- }
-
- /*******************************************************************/
-
- if(!include_close)
- {
- fflush(stream);
- fclose(stream);
- }
- stream = NULL;
-
- if(restf)
- sleep((int)(int)rest_val);
-
- free(stdio_buf);
- if(OPS_flag || MS_flag){
- filebytes64=filebytes64/reclen;
- }
-
- /*******************************************************************/
- if(hist_summary)
- dump_hist("Fread",(int)xx);
- if(distributed && client_iozone)
- return(0);
-#ifdef NO_THREADS
- exit(0);
-#else
- if(use_thread)
- thread_exit();
- else
- exit(0);
-#endif
-
-return(0);
-}
diff --git a/src/components/appio/tests/iozone/iozone_visualizer.pl b/src/components/appio/tests/iozone/iozone_visualizer.pl
deleted file mode 100755
index a7c6b1360..000000000
--- a/src/components/appio/tests/iozone/iozone_visualizer.pl
+++ /dev/null
@@ -1,262 +0,0 @@
-#!/usr/bin/perl
-
-use warnings;
-use strict;
-
-# arguments: one of more report files
-#
-# Christian Mautner <christian * mautner . ca>, 2005-10-31
-# Marc Schoechlin <ms * 256bit.org>, 2007-12-02
-#
-# This script is just a hack :-)
-#
-# This script is based loosely on the Generate_Graph set
-# of scripts that come with iozone, but is a complete re-write
-#
-# The main reason to write this was the need to compare the behaviour of
-# two or more different setups, for tuning filesystems or
-# comparing different pieces of hardware.
-#
-# This script is in the public domain, too short and too trivial
-# to deserve a copyright.
-#
-# Simply run iozone like, for example, ./iozone -a -g 4G > config1.out (if your machine has 4GB)
-#
-# and then run perl report.pl config1.out
-# or get another report from another box into config2.out and run
-# perl report.pl config1.out config2.out
-# the look in the report_* directory for .png
-#
-# If you don't like png or the graphic size, search for "set terminal" in this file and put whatever gnuplot
-# terminal you want. Note I've also noticed that gnuplot switched the set terminal png syntax
-# a while back, you might need "set terminal png small size 900,700"
-#
-use Getopt::Long;
-
-my $column;
-my %columns;
-my $datafile;
-my @datafiles;
-my $outdir;
-my $report;
-my $nooffset=0;
-my @Reports;
-my @split;
-my $size3d; my $size2d;
-
-# evaluate options
-GetOptions(
- '3d=s' => \$size3d,
- '2d=s' => \$size2d,
- 'nooffset' => \$nooffset
-);
-
-$size3d = "900,700" unless defined $size3d;
-$size2d = "800,500" unless defined $size2d;
-
-
-my $xoffset = "offset -7";
-my $yoffset = "offset -3";
-
-if ($nooffset == 1){
- $xoffset = ""; $yoffset = "";
-}
-
-print "\niozone_visualizer.pl : this script is distributed as public domain\n";
-print "Christian Mautner <christian * mautner . ca>, 2005-10-31\n";
-print "Marc Schoechlin <ms * 256bit.org>, 2007-12-02\n";
-
-
-@Reports=@ARGV;
-
-die "usage: $0 --3d=x,y -2d=x,y <iozone.out> [<iozone2.out>...]\n" if not @Reports or grep (m|^-|, @Reports);
-
-die "report files must be in current directory" if grep (m|/|, @Reports);
-
-print "Configured xtics-offset '$xoffset', configured ytics-offfset '$yoffset' (disable with --nooffset)\n";
-print "Size 3d graphs : ".$size3d." (modify with '--3d=x,y')\n";
-print "Size 2d graphs : ".$size2d." (modify with '--2d=x,y')\n";
-
-#KB reclen write rewrite read reread read write read rewrite read fwrite frewrite fread freread
-%columns=(
- 'KB' =>1,
- 'reclen' =>2,
- 'write' =>3,
- 'rewrite' =>4,
- 'read' =>5,
- 'reread' =>6,
- 'randread' =>7,
- 'randwrite' =>8,
- 'bkwdread' =>9,
- 'recrewrite'=>10,
- 'strideread'=>11,
- 'fwrite' =>12,
- 'frewrite' =>13,
- 'fread' =>14,
- 'freread' =>15,
- );
-
-#
-# create output directory. the name is the concatenation
-# of all report file names (minus the file extension, plus
-# prefix report_)
-#
-$outdir="report_".join("_",map{/([^\.]+)(\..*)?/ && $1}(@Reports));
-
-print STDERR "Output directory: $outdir ";
-
-if ( -d $outdir )
-{
- print STDERR "(removing old directory) ";
- system "rm -rf $outdir";
-}
-
-mkdir $outdir or die "cannot make directory $outdir";
-
-print STDERR "done.\nPreparing data files...";
-
-foreach $report (@Reports)
-{
- open(I, $report) or die "cannot open $report for reading";
- $report=~/^([^\.]+)/;
- $datafile="$1.dat";
- push @datafiles, $datafile;
- open(O, ">$outdir/$datafile") or die "cannot open $outdir/$datafile for writing";
- open(O2, ">$outdir/2d-$datafile") or die "cannot open $outdir/$datafile for writing";
-
- my @sorted = sort { $columns{$a} <=> $columns{$b} } keys %columns;
- print O "# ".join(" ",@sorted)."\n";
- print O2 "# ".join(" ",@sorted)."\n";
-
- while(<I>)
- {
- next unless ( /^[\s\d]+$/ );
- @split = split();
- next unless ( @split == 15 );
- print O;
- print O2 if $split[1] == 16384 or $split[0] == $split[1];
- }
- close(I);
- close(O);
- close(O2);
-}
-
-print STDERR "done.\nGenerating graphs:";
-
-
-open(HTML, ">$outdir/index.html") or die "cannot open $outdir/index.html for writing";
-
-print HTML qq{<?xml version="1.0" encoding="iso-8859-1"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
-<head>
-<title>IOZone Statistics</title>
- <STYLE type="text/css">
-.headline \{ font-family: Arial, Helvetica, sans-serif; font-size: 18px; color: 003300 ; font-weight: bold; text-decoration: none\}
- </STYLE>
-</head>
-<body>
-<a name="top"></a>
-<h1>IOZone Statistics</h1>
-<table width="100%" summary="iozone stats">
-<tr>
-<td>
-};
-
-# Generate Menu
-print HTML "<u><b>## Overview</b></u>\n<ul>\n";
-foreach $column (keys %columns){
- print HTML '<li><b>'.uc($column).'</b> : '.
- '<a href="#'.$column."\">3d</a>\n".
- '<a href="#s2d-'.$column."\">2d</a></li>\n";
-}
-print HTML "</ul></td></tr>\n";
-# Genereate 3d plots
-foreach $column (keys %columns)
-{
- print STDERR " $column";
-
- open(G, ">$outdir/$column.do") or die "cannot open $outdir/$column.do for writing";
-
-
-
- print G qq{
-set title "Iozone performance: $column"
-set grid lt 2 lw 1
-set surface
-set parametric
-set xtics $xoffset
-set ytics $yoffset
-set logscale x 2
-set logscale y 2
-set autoscale z
-#set xrange [2.**5:2.**24]
-set xlabel "File size in KBytes" -2
-set ylabel "Record size in Kbytes" 2
-set zlabel "Kbytes/sec" 4,8
-set style data lines
-set dgrid3d 80,80,3
-#set terminal png small picsize 900 700
-set terminal png small size $size3d nocrop
-set output "$column.png"
-};
-
- print HTML qq{
- <tr>
- <td align="center">
- <h2><a name="$column"></a>3d-$column</h2><a href="#top">[top]</a><BR/>
- <img src="$column.png" alt="3d-$column"/><BR/>
- </td>
- </tr>
- };
-
- print G "splot ". join(", ", map{qq{"$_" using 1:2:$columns{$column} title "$_"}}(@datafiles));
-
- print G "\n";
-
- close G;
-
- open(G, ">$outdir/2d-$column.do") or die "cannot open $outdir/$column.do for writing";
- print G qq{
-set title "Iozone performance: $column"
-#set terminal png small picsize 450 350
-set terminal png medium size $size2d nocrop
-set logscale x
-set xlabel "File size in KBytes"
-set ylabel "Kbytes/sec"
-set output "2d-$column.png"
-};
-
- print HTML qq{
- <tr>
- <td align="center">
- <h2><a name="s2d-$column"></a>2d-$column</h2><a href="#top">[top]</a><BR/>
- <img src="2d-$column.png" alt="2d-$column"/><BR/>
- </td>
- </tr>
- };
-
-
-
- print G "plot ". join(", ", map{qq{"2d-$_" using 1:$columns{$column} title "$_" with lines}}(@datafiles));
-
- print G "\n";
-
- close G;
-
- if ( system("cd $outdir && gnuplot $column.do && gnuplot 2d-$column.do") )
- {
- print STDERR "(failed) ";
- }
- else
- {
- print STDERR "(ok) ";
- }
-}
-
-print HTML qq{
-</table>
-</body>
-</html>
-};
-print STDERR "done.\n";
diff --git a/src/components/appio/tests/iozone/libasync.c b/src/components/appio/tests/iozone/libasync.c
deleted file mode 100644
index 4548a2cbe..000000000
--- a/src/components/appio/tests/iozone/libasync.c
+++ /dev/null
@@ -1,1604 +0,0 @@
-
-
-/*
- * Library for Posix async read operations with hints.
- * Author: Don Capps
- * Company: Iozone
- * Date: 4/24/1998
- *
- * Two models are supported. First model is a replacement for read() where the async
- * operations are performed and the requested data is bcopy()-ed back into the users
- * buffer. The second model is a new version of read() where the caller does not
- * supply the address of the buffer but instead is returned an address to the
- * location of the data. The second model eliminates a bcopy from the path.
- *
- * To use model #1:
- * 1. Call async_init(&pointer_on_stack,fd,direct_flag);
- * The fd is the file descriptor for the async operations.
- * The direct_flag sets VX_DIRECT
- *
- * 2. Call async_read(gc, fd, ubuffer, offset, size, stride, max, depth)
- * Where:
- * gc ............ is the pointer on the stack
- * fd ............ is the file descriptor
- * ubuffer ....... is the address of the user buffer.
- * offset ........ is the offset in the file to begin reading
- * size .......... is the size of the transfer.
- * stride ........ is the distance, in size units, to space the async reads.
- * max ........... is the max size of the file to be read.
- * depth ......... is the number of async operations to perform.
- *
- * 3. Call end_async(gc) when finished.
- * Where:
- * gc ............ is the pointer on the stack.
- *
- * To use model #2:
- * 1. Call async_init(&pointer_on_stack,fd,direct_flag);
- * The fd is the file descriptor for the async operations.
- * The direct_flag sets VX_DIRECT
- * 2. Call async_read(gc, fd, &ubuffer, offset, size, stride, max, depth)
- * Where:
- * gc ............ is the pointer on the stack
- * fd ............ is the file descriptor
- * ubuffer ....... is the address of a pointer that will be filled in
- * by the async library.
- * offset ........ is the offset in the file to begin reading
- * size .......... is the size of the transfer.
- * stride ........ is the distance, in size units, to space the async reads.
- * max ........... is the max size of the file to be read.
- * depth ......... is the number of async operations to perform.
- *
- * 3. Call async_release(gc) when finished with the data that was returned.
- * This allows the async library to reuse the memory that was filled in
- * and returned to the user.
- *
- * 4. Call end_async(gc) when finished.
- * Where:
- * gc ............ is the pointer on the stack.
- *
- * To use model #1: (WRITES)
- * 1. Call async_init(&pointer_on_stack,fd,direct_flag);
- * The fd is the file descriptor for the async operations.
- *
- * 2. Call async_write(gc, fd, ubuffer, size, offset, depth)
- * Where:
- * gc ............ is the pointer on the stack
- * fd ............ is the file descriptor
- * ubuffer ....... is the address of the user buffer.
- * size .......... is the size of the transfer.
- * offset ........ is the offset in the file to begin reading
- * depth ......... is the number of async operations to perform.
- *
- * 4. Call end_async(gc) when finished.
- * Where:
- * gc ............ is the pointer on the stack.
- *
- * Notes:
- * The intended use is to replace calls to read() with calls to
- * async_read() and allow the user to make suggestions on
- * what kind of async read-ahead would be nice to have.
- * The first transfer requested is guarenteed to be complete
- * before returning to the caller. The async operations will
- * be started and will also be guarenteed to have completed
- * if the next call specifies its first request to be one
- * that was previously performed with an async operation.
- *
- * The async_read_no_copy() function allows the async operations
- * to return the data to the user and not have to perform
- * a bcopy of the data back into the user specified buffer
- * location. This model is faster but assumes that the user
- * application has been modified to work with this model.
- *
- * The async_write() is intended to enhance the performance of
- * initial writes to a file. This is the slowest case in the write
- * path as it must perform meta-data allocations and wait.
- */
-
-#include <sys/types.h>
-#include <aio.h>
-#if defined(solaris) || defined(linux) || defined(SCO_Unixware_gcc)
-#else
-#include <sys/timers.h>
-#endif
-#include <sys/errno.h>
-#include <unistd.h>
-#ifndef bsd4_4
-#include <malloc.h>
-#endif
-#ifdef VXFS
-#include <sys/fs/vx_ioctl.h>
-#endif
-
-#if defined(OSFV5) || defined(linux)
-#include <string.h>
-#endif
-
-#if defined(linux)
-#include <unistd.h>
-#include <stdio.h>
-#include <stdlib.h>
-#endif
-
-#if (defined(solaris) && defined(__LP64__)) || defined(__s390x__) || defined(FreeBSD)
-/* If we are building for 64-bit Solaris, all functions that return pointers
- * must be declared before they are used; otherwise the compiler will assume
- * that they return ints and the top 32 bits of the pointer will be lost,
- * causing segmentation faults. The following includes take care of this.
- * It should be safe to add these for all other OSs too, but we're only
- * doing it for Solaris now in case another OS turns out to be a special case.
- */
-#include <stdio.h>
-#include <stdlib.h>
-#include <strings.h> /* For the BSD string functions */
-#endif
-
-void mbcopy(char *source, char *dest, size_t len);
-
-
-#if !defined(solaris) && !defined(off64_t) && !defined(_OFF64_T) && !defined(__off64_t_defined) && !defined(SCO_Unixware_gcc)
-typedef long long off64_t;
-#endif
-#if defined(OSFV5)
-#include <string.h>
-#endif
-
-
-extern long long page_size;
-extern int one;
-/*
- * Internal cache entrys. Each entry on the global
- * cache, pointed to by async_init(gc) will be of
- * this structure type.
- */
-char version[] = "Libasync Version $Revision$";
-struct cache_ent {
- struct aiocb myaiocb; /* For use in small file mode */
-#ifdef _LARGEFILE64_SOURCE
-#if defined(__CrayX1__)
- aiocb64_t myaiocb64; /* For use in large file mode */
-#else
- struct aiocb64 myaiocb64; /* For use in large file mode */
-#endif
-#endif
- long long fd; /* File descriptor */
- long long size; /* Size of the transfer */
- struct cache_ent *forward; /* link to next element on cache list */
- struct cache_ent *back; /* link to previous element on the cache list */
- long long direct; /* flag to indicate if the buffer should be */
- /* de-allocated by library */
- char *real_address; /* Real address to free */
-
- volatile void *oldbuf; /* Used for firewall to prevent in flight */
- /* accidents */
- int oldfd; /* Used for firewall to prevent in flight */
- /* accidents */
- size_t oldsize; /* Used for firewall to prevent in flight */
- /* accidents */
-};
-
-/*
- * Head of the cache list
- */
-struct cache {
- struct cache_ent *head; /* Head of cache list */
- struct cache_ent *tail; /* tail of cache list */
- struct cache_ent *inuse_head; /* head of in-use list */
- long long count; /* How many elements on the cache list */
- struct cache_ent *w_head; /* Head of cache list */
- struct cache_ent *w_tail; /* tail of cache list */
- long long w_count; /* How many elements on the write list */
- };
-
-long long max_depth;
-extern int errno;
-struct cache_ent *alloc_cache();
-struct cache_ent *incache();
-void async_init();
-void end_async();
-int async_suspend();
-int async_read();
-void takeoff_cache();
-void del_cache();
-void async_release();
-void putoninuse();
-void takeoffinuse();
-struct cache_ent *allocate_write_buffer();
-size_t async_write();
-void async_wait_for_write();
-void async_put_on_write_queue();
-void async_write_finish();
-
-/* On Solaris _LP64 will be defined by <sys/types.h> if we're compiling
- * as a 64-bit binary. Make sure that __LP64__ gets defined in this case,
- * too -- it should be defined on the compiler command line, but let's
- * not rely on this.
- */
-#if defined(_LP64)
-#if !defined(__LP64__)
-#define __LP64__
-#endif
-#endif
-
-
-/***********************************************/
-/* Initialization routine to setup the library */
-/***********************************************/
-void
-async_init(gc,fd,flag)
-struct cache **gc;
-int fd;
-int flag;
-{
-#ifdef VXFS
- if(flag)
- ioctl(fd,VX_SETCACHE,VX_DIRECT);
-#endif
- if(*gc)
- {
- printf("Warning calling async_init two times ?\n");
- return;
- }
- *gc=(struct cache *)malloc((size_t)sizeof(struct cache));
- if(*gc == 0)
- {
- printf("Malloc failed\n");
- exit(174);
- }
- bzero(*gc,sizeof(struct cache));
-#if defined(__AIX__) || defined(SCO_Unixware_gcc)
- max_depth=500;
-#else
- max_depth=sysconf(_SC_AIO_MAX);
-#endif
-}
-
-/***********************************************/
-/* Tear down routine to shutdown the library */
-/***********************************************/
-void
-end_async(gc)
-struct cache *gc;
-{
- del_cache(gc);
- async_write_finish(gc);
- free((void *)gc);
-}
-
-/***********************************************/
-/* Wait for a request to finish */
-/***********************************************/
-int
-async_suspend(struct cache_ent *ce)
-{
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- const struct aiocb * const cblist[1] = {&ce->myaiocb};
-#else
- const struct aiocb64 * const cblist[1] = {&ce->myaiocb64};
-#endif
-#else
- const struct aiocb * const cblist[1] = {&ce->myaiocb};
-#endif
-
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- return aio_suspend(cblist, 1, NULL);
-#else
- return aio_suspend64(cblist, 1, NULL);
-#endif
-#else
- return aio_suspend(cblist, 1, NULL);
-#endif
-}
-
-/*************************************************************************
- * This routine is a generic async reader assist function. It takes
- * the same calling parameters as read() but also extends the
- * interface to include:
- * stride ..... For the async reads, what is the distance, in size units,
- * to space the reads. Note: Stride of 0 indicates that
- * you do not want any read-ahead.
- * max ..... What is the maximum file offset for this operation.
- * depth ..... How much read-ahead do you want.
- *
- * The calls to this will guarentee to complete the read() operation
- * before returning to the caller. The completion may occur in two
- * ways. First the operation may be completed by calling aio_read()
- * and then waiting for it to complete. Second the operation may be
- * completed by copying the data from a cache of previously completed
- * async operations.
- * In the event the read to be satisfied is not in the cache then a
- * series of async operations will be scheduled and then the first
- * async read will be completed. In the event that the read() can be
- * satisfied from the cache then the data is copied back to the
- * user buffer and a series of async reads will be initiated. If a
- * read is issued and the cache contains data and the read can not
- * be satisfied from the cache, then the cache is discarded, and
- * a new cache is constructed.
- * Note: All operations are aio_read(). The series will be issued
- * as asyncs in the order requested. After all are in flight
- * then the code will wait for the manditory first read.
- *************************************************************************/
-
-int
-async_read(gc, fd, ubuffer, offset, size, stride, max, depth)
-struct cache *gc;
-long long fd;
-char *ubuffer;
-off64_t offset;
-long long size;
-long long stride;
-off64_t max;
-long long depth;
-{
- off64_t a_offset,r_offset;
- long long a_size;
- struct cache_ent *ce,*first_ce=0;
- long long i;
- ssize_t retval=0;
- ssize_t ret;
- long long start = 0;
- long long del_read=0;
-
- a_offset=offset;
- a_size = size;
- /*
- * Check to see if it can be completed from the cache
- */
- if((ce=(struct cache_ent *)incache(gc,fd,offset,size)))
- {
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- while((ret=aio_error(&ce->myaiocb))== EINPROGRESS)
- {
- async_suspend(ce);
- }
-#else
- while((ret=aio_error64(&ce->myaiocb64))== EINPROGRESS)
- {
- async_suspend(ce);
- }
-#endif
-#else
- while((ret=aio_error(&ce->myaiocb))== EINPROGRESS)
- {
- async_suspend(ce);
- }
-#endif
- if(ret)
- {
- printf("aio_error 1: ret %d %d\n",ret,errno);
- }
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- retval=aio_return(&ce->myaiocb);
-#else
-#if defined(__CrayX1__)
- retval=aio_return64((aiocb64_t *)&ce->myaiocb64);
-#else
- retval=aio_return64((struct aiocb64 *)&ce->myaiocb64);
-#endif
-
-#endif
-#else
- retval=aio_return(&ce->myaiocb);
-#endif
- if(retval > 0)
- {
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- mbcopy((char *)ce->myaiocb.aio_buf,(char *)ubuffer,(size_t)retval);
-#else
- mbcopy((char *)ce->myaiocb64.aio_buf,(char *)ubuffer,(size_t)retval);
-#endif
-#else
- mbcopy((char *)ce->myaiocb.aio_buf,(char *)ubuffer,(size_t)retval);
-#endif
- }
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- if(retval < ce->myaiocb.aio_nbytes)
-#else
- if(retval < ce->myaiocb64.aio_nbytes)
-#endif
-#else
- if(retval < ce->myaiocb.aio_nbytes)
-#endif
- {
- printf("aio_return error1: ret %d %d\n",retval,errno);
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- printf("aio_return error1: fd %d offset %ld buffer %lx size %d Opcode %d\n",
- ce->myaiocb.aio_fildes,
- ce->myaiocb.aio_offset,
- (long)(ce->myaiocb.aio_buf),
- ce->myaiocb.aio_nbytes,
- ce->myaiocb.aio_lio_opcode
-#else
- printf("aio_return error1: fd %d offset %lld buffer %lx size %d Opcode %d\n",
- ce->myaiocb64.aio_fildes,
- ce->myaiocb64.aio_offset,
- (long)(ce->myaiocb64.aio_buf),
- ce->myaiocb64.aio_nbytes,
- ce->myaiocb64.aio_lio_opcode
-#endif
-#else
- printf("aio_return error1: fd %d offset %d buffer %lx size %d Opcode %d\n",
- ce->myaiocb.aio_fildes,
- ce->myaiocb.aio_offset,
- (long)(ce->myaiocb.aio_buf),
- ce->myaiocb.aio_nbytes,
- ce->myaiocb.aio_lio_opcode
-#endif
- );
- }
- ce->direct=0;
- takeoff_cache(gc,ce);
- }else
- {
- /*
- * Clear the cache and issue the first request async()
- */
- del_cache(gc);
- del_read++;
- first_ce=alloc_cache(gc,fd,offset,size,(long long)LIO_READ);
-again:
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- ret=aio_read(&first_ce->myaiocb);
-#else
- ret=aio_read64(&first_ce->myaiocb64);
-#endif
-#else
- ret=aio_read(&first_ce->myaiocb);
-#endif
- if(ret!=0)
- {
- if(errno==EAGAIN)
- goto again;
- else
- printf("error returned from aio_read(). Ret %d errno %d\n",ret,errno);
- }
- }
- if(stride==0) /* User does not want read-ahead */
- goto out;
- if(a_offset<0) /* Before beginning of file */
- goto out;
- if(a_offset+size>max) /* After end of file */
- goto out;
- if(depth >=(max_depth-1))
- depth=max_depth-1;
- if(depth==0)
- goto out;
- if(gc->count > 1)
- start=depth-1;
- for(i=start;i<depth;i++) /* Issue read-aheads for the depth specified */
- {
- r_offset=a_offset+((i+1)*(stride*a_size));
- if(r_offset<0)
- continue;
- if(r_offset+size > max)
- continue;
- if((ce=incache(gc,fd,r_offset,a_size)))
- continue;
- ce=alloc_cache(gc,fd,r_offset,a_size,(long long)LIO_READ);
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- ret=aio_read(&ce->myaiocb);
-#else
- ret=aio_read64(&ce->myaiocb64);
-#endif
-#else
- ret=aio_read(&ce->myaiocb);
-#endif
- if(ret!=0)
- {
- takeoff_cache(gc,ce);
- break;
- }
- }
-out:
- if(del_read) /* Wait for the first read to complete */
- {
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- while((ret=aio_error(&first_ce->myaiocb))== EINPROGRESS)
- {
- async_suspend(first_ce);
- }
-#else
- while((ret=aio_error64(&first_ce->myaiocb64))== EINPROGRESS)
- {
- async_suspend(first_ce);
- }
-#endif
-#else
- while((ret=aio_error(&first_ce->myaiocb))== EINPROGRESS)
- {
- async_suspend(first_ce);
- }
-#endif
- if(ret)
- printf("aio_error 2: ret %d %d\n",ret,errno);
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- retval=aio_return(&first_ce->myaiocb);
-#else
- retval=aio_return64(&first_ce->myaiocb64);
-#endif
-#else
- retval=aio_return(&first_ce->myaiocb);
-#endif
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- if(retval < first_ce->myaiocb.aio_nbytes)
-#else
- if(retval < first_ce->myaiocb64.aio_nbytes)
-#endif
-#else
- if(retval < first_ce->myaiocb.aio_nbytes)
-#endif
- {
- printf("aio_return error2: ret %d %d\n",retval,errno);
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- printf("aio_return error2: fd %d offset %lld buffer %lx size %d Opcode %d\n",
- first_ce->myaiocb.aio_fildes,
- first_ce->myaiocb.aio_offset,
- (long)(first_ce->myaiocb.aio_buf),
- first_ce->myaiocb.aio_nbytes,
- first_ce->myaiocb.aio_lio_opcode
-#else
- printf("aio_return error2: fd %d offset %lld buffer %lx size %d Opcode %d\n",
- first_ce->myaiocb64.aio_fildes,
- first_ce->myaiocb64.aio_offset,
- (long)(first_ce->myaiocb64.aio_buf),
- first_ce->myaiocb64.aio_nbytes,
- first_ce->myaiocb64.aio_lio_opcode
-#endif
-#else
- printf("aio_return error2: fd %d offset %d buffer %lx size %d Opcode %d\n",
- first_ce->myaiocb.aio_fildes,
- first_ce->myaiocb.aio_offset,
- (long)(first_ce->myaiocb.aio_buf),
- first_ce->myaiocb.aio_nbytes,
- first_ce->myaiocb.aio_lio_opcode
-#endif
- );
- }
- if(retval > 0)
- {
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- mbcopy((char *)first_ce->myaiocb.aio_buf,(char *)ubuffer,(size_t)retval);
-#else
- mbcopy((char *)first_ce->myaiocb64.aio_buf,(char *)ubuffer,(size_t)retval);
-#endif
-#else
- mbcopy((char *)first_ce->myaiocb.aio_buf,(char *)ubuffer,(size_t)retval);
-#endif
- }
- first_ce->direct=0;
- takeoff_cache(gc,first_ce);
- }
- return((int)retval);
-}
-
-/************************************************************************
- * This routine allocates a cache_entry. It contains the
- * aiocb block as well as linkage for use in the cache mechanism.
- * The space allocated here will be released after the cache entry
- * has been consumed. The routine takeoff_cache() will be called
- * after the data has been copied to user buffer or when the
- * cache is purged. The routine takeoff_cache() will also release
- * all memory associated with this cache entry.
- ************************************************************************/
-
-struct cache_ent *
-alloc_cache(gc,fd,offset,size,op)
-struct cache *gc;
-long long fd,size,op;
-off64_t offset;
-{
- struct cache_ent *ce;
- long temp;
- ce=(struct cache_ent *)malloc((size_t)sizeof(struct cache_ent));
- if(ce == (struct cache_ent *)0)
- {
- printf("Malloc failed\n");
- exit(175);
- }
- bzero(ce,sizeof(struct cache_ent));
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- ce->myaiocb.aio_fildes=(int)fd;
- ce->myaiocb.aio_offset=(off64_t)offset;
- ce->real_address = (char *)malloc((size_t)(size+page_size));
- temp=(long)ce->real_address;
- temp = (temp+page_size) & ~(page_size-1);
- ce->myaiocb.aio_buf=(volatile void *)temp;
- if(ce->myaiocb.aio_buf == 0)
-#else
- ce->myaiocb64.aio_fildes=(int)fd;
- ce->myaiocb64.aio_offset=(off64_t)offset;
- ce->real_address = (char *)malloc((size_t)(size+page_size));
- temp=(long)ce->real_address;
- temp = (temp+page_size) & ~(page_size-1);
- ce->myaiocb64.aio_buf=(volatile void *)temp;
- if(ce->myaiocb64.aio_buf == 0)
-#endif
-#else
- ce->myaiocb.aio_fildes=(int)fd;
- ce->myaiocb.aio_offset=(off_t)offset;
- ce->real_address = (char *)malloc((size_t)(size+page_size));
- temp=(long)ce->real_address;
- temp = (temp+page_size) & ~(page_size-1);
- ce->myaiocb.aio_buf=(volatile void *)temp;
- if(ce->myaiocb.aio_buf == 0)
-#endif
- {
- printf("Malloc failed\n");
- exit(176);
- }
- /*bzero(ce->myaiocb.aio_buf,(size_t)size);*/
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- ce->myaiocb.aio_reqprio=0;
- ce->myaiocb.aio_nbytes=(size_t)size;
- ce->myaiocb.aio_sigevent.sigev_notify=SIGEV_NONE;
- ce->myaiocb.aio_lio_opcode=(int)op;
-#else
- ce->myaiocb64.aio_reqprio=0;
- ce->myaiocb64.aio_nbytes=(size_t)size;
- ce->myaiocb64.aio_sigevent.sigev_notify=SIGEV_NONE;
- ce->myaiocb64.aio_lio_opcode=(int)op;
-#endif
-#else
- ce->myaiocb.aio_reqprio=0;
- ce->myaiocb.aio_nbytes=(size_t)size;
- ce->myaiocb.aio_sigevent.sigev_notify=SIGEV_NONE;
- ce->myaiocb.aio_lio_opcode=(int)op;
-#endif
- ce->fd=(int)fd;
- ce->forward=0;
- ce->back=gc->tail;
- if(gc->tail)
- gc->tail->forward = ce;
- gc->tail= ce;
- if(!gc->head)
- gc->head=ce;
- gc->count++;
- return(ce);
-}
-
-/************************************************************************
- * This routine checks to see if the requested data is in the
- * cache.
-*************************************************************************/
-struct cache_ent *
-incache(gc,fd,offset,size)
-struct cache *gc;
-long long fd,size;
-off64_t offset;
-{
- struct cache_ent *move;
- if(gc->head==0)
- {
- return(0);
- }
- move=gc->head;
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- while(move)
- {
- if((move->fd == fd) && (move->myaiocb.aio_offset==(off64_t)offset) &&
- ((size_t)size==move->myaiocb.aio_nbytes))
- {
- return(move);
- }
- move=move->forward;
- }
-#else
- while(move)
- {
- if((move->fd == fd) && (move->myaiocb64.aio_offset==(off64_t)offset) &&
- ((size_t)size==move->myaiocb64.aio_nbytes))
- {
- return(move);
- }
- move=move->forward;
- }
-#endif
-#else
- while(move)
- {
- if((move->fd == fd) && (move->myaiocb.aio_offset==(off_t)offset) &&
- ((size_t)size==move->myaiocb.aio_nbytes))
- {
- return(move);
- }
- move=move->forward;
- }
-#endif
- return(0);
-}
-
-/************************************************************************
- * This routine removes a specific cache entry from the cache, and
- * releases all memory associated witht the cache entry (if not direct).
-*************************************************************************/
-
-void
-takeoff_cache(gc,ce)
-struct cache *gc;
-struct cache_ent *ce;
-{
- struct cache_ent *move;
- long long found;
- move=gc->head;
- if(move==ce) /* Head of list */
- {
-
- gc->head=ce->forward;
- if(gc->head)
- gc->head->back=0;
- else
- gc->tail = 0;
- if(!ce->direct)
- {
- free((void *)(ce->real_address));
- free((void *)ce);
- }
- gc->count--;
- return;
- }
- found=0;
- while(move)
- {
- if(move==ce)
- {
- if(move->forward)
- {
- move->forward->back=move->back;
- }
- if(move->back)
- {
- move->back->forward=move->forward;
- }
- found=1;
- break;
- }
- else
- {
- move=move->forward;
- }
- }
- if(gc->head == ce)
- gc->tail = ce;
- if(!found)
- printf("Internal Error in takeoff cache\n");
- move=gc->head;
- if(!ce->direct)
- {
- free((void *)(ce->real_address));
- free((void *)ce);
- }
- gc->count--;
-}
-
-/************************************************************************
- * This routine is used to purge the entire cache. This is called when
- * the cache contains data but the incomming read was not able to
- * be satisfied from the cache. This indicates that the previous
- * async read-ahead was not correct and a new pattern is emerging.
- ************************************************************************/
-void
-del_cache(gc)
-struct cache *gc;
-{
- struct cache_ent *ce;
- ssize_t ret;
- ce=gc->head;
- while(1)
- {
- ce=gc->head;
- if(ce==0)
- return;
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- while((ret = aio_cancel(0,&ce->myaiocb))==AIO_NOTCANCELED)
-#else
- while((ret = aio_cancel64(0,&ce->myaiocb64))==AIO_NOTCANCELED)
-#endif
-#else
- while((ret = aio_cancel(0,&ce->myaiocb))==AIO_NOTCANCELED)
-#endif
- ;
-
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- ret = aio_return(&ce->myaiocb);
-#else
- ret = aio_return64(&ce->myaiocb64);
-#endif
-#else
- ret = aio_return(&ce->myaiocb);
-#endif
- ce->direct=0;
- takeoff_cache(gc,ce); /* remove from cache */
- }
-}
-
-/************************************************************************
- * Like its sister async_read() this function performs async I/O for
- * all buffers but it differs in that it expects the caller to
- * request a pointer to the data to be returned instead of handing
- * the function a location to put the data. This will allow the
- * async I/O to be performed and does not require any bcopy to be
- * done to put the data back into the location specified by the caller.
- ************************************************************************/
-int
-async_read_no_copy(gc, fd, ubuffer, offset, size, stride, max, depth)
-struct cache *gc;
-long long fd;
-char **ubuffer;
-off64_t offset;
-long long size;
-long long stride;
-off64_t max;
-long long depth;
-{
- off64_t a_offset,r_offset;
- long long a_size;
- struct cache_ent *ce,*first_ce=0;
- long long i;
- ssize_t retval=0;
- ssize_t ret;
- long long del_read=0;
- long long start=0;
-
- a_offset=offset;
- a_size = size;
- /*
- * Check to see if it can be completed from the cache
- */
- if((ce=(struct cache_ent *)incache(gc,fd,offset,size)))
- {
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- while((ret=aio_error(&ce->myaiocb))== EINPROGRESS)
- {
- async_suspend(ce);
- }
-#else
- while((ret=aio_error64(&ce->myaiocb64))== EINPROGRESS)
- {
- async_suspend(ce);
- }
-#endif
-#else
- while((ret=aio_error(&ce->myaiocb))== EINPROGRESS)
- {
- async_suspend(ce);
- }
-#endif
- if(ret)
- printf("aio_error 3: ret %d %d\n",ret,errno);
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- if(ce->oldbuf != ce->myaiocb.aio_buf ||
- ce->oldfd != ce->myaiocb.aio_fildes ||
- ce->oldsize != ce->myaiocb.aio_nbytes)
-#else
- if(ce->oldbuf != ce->myaiocb64.aio_buf ||
- ce->oldfd != ce->myaiocb64.aio_fildes ||
- ce->oldsize != ce->myaiocb64.aio_nbytes)
-#endif
-#else
- if(ce->oldbuf != ce->myaiocb.aio_buf ||
- ce->oldfd != ce->myaiocb.aio_fildes ||
- ce->oldsize != ce->myaiocb.aio_nbytes)
-#endif
- printf("It changed in flight\n");
-
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- retval=aio_return(&ce->myaiocb);
-#else
- retval=aio_return64(&ce->myaiocb64);
-#endif
-#else
- retval=aio_return(&ce->myaiocb);
-#endif
- if(retval > 0)
- {
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- *ubuffer=(char *)ce->myaiocb.aio_buf;
-#else
- *ubuffer=(char *)ce->myaiocb64.aio_buf;
-#endif
-#else
- *ubuffer=(char *)ce->myaiocb.aio_buf;
-#endif
- }else
- *ubuffer=0;
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- if(retval < ce->myaiocb.aio_nbytes)
-#else
- if(retval < ce->myaiocb64.aio_nbytes)
-#endif
-#else
- if(retval < ce->myaiocb.aio_nbytes)
-#endif
- {
- printf("aio_return error4: ret %d %d\n",retval,errno);
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- printf("aio_return error4: fd %d offset %lld buffer %lx size %d Opcode %d\n",
- ce->myaiocb.aio_fildes,
- ce->myaiocb.aio_offset,
- (long)(ce->myaiocb.aio_buf),
- ce->myaiocb.aio_nbytes,
- ce->myaiocb.aio_lio_opcode
-#else
- printf("aio_return error4: fd %d offset %lld buffer %lx size %d Opcode %d\n",
- ce->myaiocb64.aio_fildes,
- ce->myaiocb64.aio_offset,
- (long)(ce->myaiocb64.aio_buf),
- ce->myaiocb64.aio_nbytes,
- ce->myaiocb64.aio_lio_opcode
-#endif
-#else
- printf("aio_return error4: fd %d offset %d buffer %lx size %d Opcode %d\n",
- ce->myaiocb.aio_fildes,
- ce->myaiocb.aio_offset,
- (long)(ce->myaiocb.aio_buf),
- ce->myaiocb.aio_nbytes,
- ce->myaiocb.aio_lio_opcode
-#endif
- );
- }
- ce->direct=1;
- takeoff_cache(gc,ce); /* do not delete buffer*/
- putoninuse(gc,ce);
- }else
- {
- /*
- * Clear the cache and issue the first request async()
- */
- del_cache(gc);
- del_read++;
- first_ce=alloc_cache(gc,fd,offset,size,(long long)LIO_READ); /* allocate buffer */
- /*printf("allocated buffer/read %x offset %d\n",first_ce->myaiocb.aio_buf,offset);*/
-again:
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- first_ce->oldbuf=first_ce->myaiocb.aio_buf;
- first_ce->oldfd=first_ce->myaiocb.aio_fildes;
- first_ce->oldsize=first_ce->myaiocb.aio_nbytes;
- ret=aio_read(&first_ce->myaiocb);
-#else
- first_ce->oldbuf=first_ce->myaiocb64.aio_buf;
- first_ce->oldfd=first_ce->myaiocb64.aio_fildes;
- first_ce->oldsize=first_ce->myaiocb64.aio_nbytes;
- ret=aio_read64(&first_ce->myaiocb64);
-#endif
-#else
- first_ce->oldbuf=first_ce->myaiocb.aio_buf;
- first_ce->oldfd=first_ce->myaiocb.aio_fildes;
- first_ce->oldsize=first_ce->myaiocb.aio_nbytes;
- ret=aio_read(&first_ce->myaiocb);
-#endif
- if(ret!=0)
- {
- if(errno==EAGAIN)
- goto again;
- else
- printf("error returned from aio_read(). Ret %d errno %d\n",ret,errno);
- }
- }
- if(stride==0) /* User does not want read-ahead */
- goto out;
- if(a_offset<0) /* Before beginning of file */
- goto out;
- if(a_offset+size>max) /* After end of file */
- goto out;
- if(depth >=(max_depth-1))
- depth=max_depth-1;
- if(depth==0)
- goto out;
- if(gc->count > 1)
- start=depth-1;
- for(i=start;i<depth;i++) /* Issue read-aheads for the depth specified */
- {
- r_offset=a_offset+((i+1)*(stride*a_size));
- if(r_offset<0)
- continue;
- if(r_offset+size > max)
- continue;
- if((ce=incache(gc,fd,r_offset,a_size)))
- continue;
- ce=alloc_cache(gc,fd,r_offset,a_size,(long long)LIO_READ);
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- ce->oldbuf=ce->myaiocb.aio_buf;
- ce->oldfd=ce->myaiocb.aio_fildes;
- ce->oldsize=ce->myaiocb.aio_nbytes;
- ret=aio_read(&ce->myaiocb);
-#else
- ce->oldbuf=ce->myaiocb64.aio_buf;
- ce->oldfd=ce->myaiocb64.aio_fildes;
- ce->oldsize=ce->myaiocb64.aio_nbytes;
- ret=aio_read64(&ce->myaiocb64);
-#endif
-#else
- ce->oldbuf=ce->myaiocb.aio_buf;
- ce->oldfd=ce->myaiocb.aio_fildes;
- ce->oldsize=ce->myaiocb.aio_nbytes;
- ret=aio_read(&ce->myaiocb);
-#endif
- if(ret!=0)
- {
- takeoff_cache(gc,ce);
- break;
- }
- }
-out:
- if(del_read) /* Wait for the first read to complete */
- {
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- while((ret=aio_error(&first_ce->myaiocb))== EINPROGRESS)
- {
- async_suspend(first_ce);
- }
-#else
- while((ret=aio_error64(&first_ce->myaiocb64))== EINPROGRESS)
- {
- async_suspend(first_ce);
- }
-#endif
-#else
- while((ret=aio_error(&first_ce->myaiocb))== EINPROGRESS)
- {
- async_suspend(first_ce);
- }
-#endif
- if(ret)
- printf("aio_error 4: ret %d %d\n",ret,errno);
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- if(first_ce->oldbuf != first_ce->myaiocb.aio_buf ||
- first_ce->oldfd != first_ce->myaiocb.aio_fildes ||
- first_ce->oldsize != first_ce->myaiocb.aio_nbytes)
- printf("It changed in flight2\n");
- retval=aio_return(&first_ce->myaiocb);
-#else
- if(first_ce->oldbuf != first_ce->myaiocb64.aio_buf ||
- first_ce->oldfd != first_ce->myaiocb64.aio_fildes ||
- first_ce->oldsize != first_ce->myaiocb64.aio_nbytes)
- printf("It changed in flight2\n");
- retval=aio_return64(&first_ce->myaiocb64);
-#endif
-#else
- if(first_ce->oldbuf != first_ce->myaiocb.aio_buf ||
- first_ce->oldfd != first_ce->myaiocb.aio_fildes ||
- first_ce->oldsize != first_ce->myaiocb.aio_nbytes)
- printf("It changed in flight2\n");
- retval=aio_return(&first_ce->myaiocb);
-#endif
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- if(retval < first_ce->myaiocb.aio_nbytes)
-#else
- if(retval < first_ce->myaiocb64.aio_nbytes)
-#endif
-#else
- if(retval < first_ce->myaiocb.aio_nbytes)
-#endif
- {
- printf("aio_return error5: ret %d %d\n",retval,errno);
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- printf("aio_return error5: fd %d offset %lld buffer %lx size %d Opcode %d\n",
- first_ce->myaiocb.aio_fildes,
- first_ce->myaiocb.aio_offset,
- (long)(first_ce->myaiocb.aio_buf),
- first_ce->myaiocb.aio_nbytes,
- first_ce->myaiocb.aio_lio_opcode
-#else
- printf("aio_return error5: fd %d offset %lld buffer %lx size %d Opcode %d\n",
- first_ce->myaiocb64.aio_fildes,
- first_ce->myaiocb64.aio_offset,
- (long)(first_ce->myaiocb64.aio_buf),
- first_ce->myaiocb64.aio_nbytes,
- first_ce->myaiocb64.aio_lio_opcode
-#endif
-#else
- printf("aio_return error5: fd %d offset %ld buffer %lx size %d Opcode %d\n",
- first_ce->myaiocb.aio_fildes,
- first_ce->myaiocb.aio_offset,
- (long)(first_ce->myaiocb.aio_buf),
- first_ce->myaiocb.aio_nbytes,
- first_ce->myaiocb.aio_lio_opcode
-#endif
- );
- }
- if(retval > 0)
- {
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- *ubuffer=(char *)first_ce->myaiocb.aio_buf;
-#else
- *ubuffer=(char *)first_ce->myaiocb64.aio_buf;
-#endif
-#else
- *ubuffer=(char *)first_ce->myaiocb.aio_buf;
-#endif
- }else
- *ubuffer=(char *)0;
- first_ce->direct=1; /* do not delete the buffer */
- takeoff_cache(gc,first_ce);
- putoninuse(gc,first_ce);
- }
- return((int)retval);
-}
-
-/************************************************************************
- * The caller is now finished with the data that was provided so
- * the library is now free to return the memory to the pool for later
- * reuse.
- ************************************************************************/
-void
-async_release(gc)
-struct cache *gc;
-{
- takeoffinuse(gc);
-}
-
-
-/************************************************************************
- * Put the buffer on the inuse list. When the user is finished with
- * the buffer it will call back into async_release and the items on the
- * inuse list will be deallocated.
- ************************************************************************/
-void
-putoninuse(gc,entry)
-struct cache *gc;
-struct cache_ent *entry;
-{
- if(gc->inuse_head)
- entry->forward=gc->inuse_head;
- else
- entry->forward=0;
- gc->inuse_head=entry;
-}
-
-/************************************************************************
- * This is called when the application is finished with the data that
- * was provided. The memory may now be returned to the pool.
- ************************************************************************/
-void
-takeoffinuse(gc)
-struct cache *gc;
-{
- struct cache_ent *ce;
- if(gc->inuse_head==0)
- printf("Takeoffinuse error\n");
- ce=gc->inuse_head;
- gc->inuse_head=gc->inuse_head->forward;
-
- if(gc->inuse_head !=0)
- printf("Error in take off inuse\n");
- free((void*)(ce->real_address));
- free(ce);
-}
-
-/*************************************************************************
- * This routine is a generic async writer assist function. It takes
- * the same calling parameters as write() but also extends the
- * interface to include:
- *
- * offset ..... offset in the file.
- * depth ..... How much read-ahead do you want.
- *
- *************************************************************************/
-size_t
-async_write(gc,fd,buffer,size,offset,depth)
-struct cache *gc;
-long long fd,size;
-char *buffer;
-off64_t offset;
-long long depth;
-{
- struct cache_ent *ce;
- size_t ret;
- ce=allocate_write_buffer(gc,fd,offset,size,(long long)LIO_WRITE,depth,0LL,(char *)0,(char *)0);
- ce->direct=0; /* not direct. Lib supplies buffer and must free it */
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- mbcopy(buffer,(char *)(ce->myaiocb.aio_buf),(size_t)size);
-#else
- mbcopy(buffer,(char *)(ce->myaiocb64.aio_buf),(size_t)size);
-#endif
-#else
- mbcopy(buffer,(char *)(ce->myaiocb.aio_buf),(size_t)size);
-#endif
- async_put_on_write_queue(gc,ce);
- /*
- printf("asw: fd %d offset %lld, size %d\n",ce->myaiocb64.aio_fildes,
- ce->myaiocb64.aio_offset,
- ce->myaiocb64.aio_nbytes);
- */
-
-again:
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- ret=aio_write(&ce->myaiocb);
-#else
- ret=aio_write64(&ce->myaiocb64);
-#endif
-#else
- ret=aio_write(&ce->myaiocb);
-#endif
- if(ret==-1)
- {
- if(errno==EAGAIN)
- {
- async_wait_for_write(gc);
- goto again;
- }
- if(errno==0)
- {
- /* Compensate for bug in async library */
- async_wait_for_write(gc);
- goto again;
- }
- else
- {
- printf("Error in aio_write: ret %d errno %d count %lld\n",ret,errno,gc->w_count);
- /*
- printf("aio_write_no_copy: fd %d buffer %x offset %lld size %d\n",
- ce->myaiocb64.aio_fildes,
- ce->myaiocb64.aio_buf,
- ce->myaiocb64.aio_offset,
- ce->myaiocb64.aio_nbytes);
- */
- exit(177);
- }
- }
- return((ssize_t)size);
-}
-
-/*************************************************************************
- * Allocate a write aiocb and write buffer of the size specified. Also
- * put some extra buffer padding so that VX_DIRECT can do its job when
- * needed.
- *************************************************************************/
-
-struct cache_ent *
-allocate_write_buffer(gc,fd,offset,size,op,w_depth,direct,buffer,free_addr)
-struct cache *gc;
-long long fd,size,op;
-off64_t offset;
-long long w_depth;
-long long direct;
-char *buffer,*free_addr;
-{
- struct cache_ent *ce;
- long temp;
- if(fd==0LL)
- {
- printf("Setting up write buffer insane\n");
- exit(178);
- }
- if(gc->w_count > w_depth)
- async_wait_for_write(gc);
- ce=(struct cache_ent *)malloc((size_t)sizeof(struct cache_ent));
- if(ce == (struct cache_ent *)0)
- {
- printf("Malloc failed 1\n");
- exit(179);
- }
- bzero(ce,sizeof(struct cache_ent));
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- ce->myaiocb.aio_fildes=(int)fd;
- ce->myaiocb.aio_offset=(off64_t)offset;
- if(!direct)
- {
- ce->real_address = (char *)malloc((size_t)(size+page_size));
- temp=(long)ce->real_address;
- temp = (temp+page_size) & ~(page_size-1);
- ce->myaiocb.aio_buf=(volatile void *)temp;
- }else
- {
- ce->myaiocb.aio_buf=(volatile void *)buffer;
- ce->real_address=(char *)free_addr;
- }
- if(ce->myaiocb.aio_buf == 0)
-#else
- ce->myaiocb64.aio_fildes=(int)fd;
- ce->myaiocb64.aio_offset=(off64_t)offset;
- if(!direct)
- {
- ce->real_address = (char *)malloc((size_t)(size+page_size));
- temp=(long)ce->real_address;
- temp = (temp+page_size) & ~(page_size-1);
- ce->myaiocb64.aio_buf=(volatile void *)temp;
- }
- else
- {
- ce->myaiocb64.aio_buf=(volatile void *)buffer;
- ce->real_address=(char *)free_addr;
- }
- if(ce->myaiocb64.aio_buf == 0)
-#endif
-#else
- ce->myaiocb.aio_fildes=(int)fd;
- ce->myaiocb.aio_offset=(off_t)offset;
- if(!direct)
- {
- ce->real_address = (char *)malloc((size_t)(size+page_size));
- temp=(long)ce->real_address;
- temp = (temp+page_size) & ~(page_size-1);
- ce->myaiocb.aio_buf=(volatile void *)temp;
- }
- else
- {
- ce->myaiocb.aio_buf=(volatile void *)buffer;
- ce->real_address=(char *)free_addr;
- }
- if(ce->myaiocb.aio_buf == 0)
-#endif
- {
- printf("Malloc failed 2\n");
- exit(180);
- }
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- ce->myaiocb.aio_reqprio=0;
- ce->myaiocb.aio_nbytes=(size_t)size;
- ce->myaiocb.aio_sigevent.sigev_notify=SIGEV_NONE;
- ce->myaiocb.aio_lio_opcode=(int)op;
-#else
- ce->myaiocb64.aio_reqprio=0;
- ce->myaiocb64.aio_nbytes=(size_t)size;
- ce->myaiocb64.aio_sigevent.sigev_notify=SIGEV_NONE;
- ce->myaiocb64.aio_lio_opcode=(int)op;
-#endif
-#else
- ce->myaiocb.aio_reqprio=0;
- ce->myaiocb.aio_nbytes=(size_t)size;
- ce->myaiocb.aio_sigevent.sigev_notify=SIGEV_NONE;
- ce->myaiocb.aio_lio_opcode=(int)op;
-#endif
- ce->fd=(int)fd;
- return(ce);
-}
-
-/*************************************************************************
- * Put it on the outbound queue.
- *************************************************************************/
-
-void
-async_put_on_write_queue(gc,ce)
-struct cache *gc;
-struct cache_ent *ce;
-{
- ce->forward=0;
- ce->back=gc->w_tail;
- if(gc->w_tail)
- gc->w_tail->forward = ce;
- gc->w_tail= ce;
- if(!gc->w_head)
- gc->w_head=ce;
- gc->w_count++;
- return;
-}
-
-/*************************************************************************
- * Cleanup all outstanding writes
- *************************************************************************/
-void
-async_write_finish(gc)
-struct cache *gc;
-{
- while(gc->w_head)
- {
- /*printf("async_write_finish: Waiting for buffer %x to finish\n",gc->w_head->myaiocb64.aio_buf);*/
- async_wait_for_write(gc);
- }
-}
-
-/*************************************************************************
- * Wait for an I/O to finish
- *************************************************************************/
-
-void
-async_wait_for_write(gc)
-struct cache *gc;
-{
- struct cache_ent *ce;
- size_t ret,retval;
- if(gc->w_head==0)
- return;
- ce=gc->w_head;
- gc->w_head=ce->forward;
- gc->w_count--;
- ce->forward=0;
- if(ce==gc->w_tail)
- gc->w_tail=0;
- /*printf("Wait for buffer %x offset %lld size %d to finish\n",
- ce->myaiocb64.aio_buf,
- ce->myaiocb64.aio_offset,
- ce->myaiocb64.aio_nbytes);
- printf("write count %lld \n",gc->w_count);
- */
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- while((ret=aio_error(&ce->myaiocb))== EINPROGRESS)
- {
- async_suspend(ce);
- }
-#else
- while((ret=aio_error64(&ce->myaiocb64))== EINPROGRESS)
- {
- async_suspend(ce);
- }
-#endif
-#else
- while((ret=aio_error(&ce->myaiocb))== EINPROGRESS)
- {
- async_suspend(ce);
- }
-#endif
- if(ret)
- {
- printf("aio_error 5: ret %d %d\n",ret,errno);
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- printf("fd %d offset %lld size %d\n",
- ce->myaiocb.aio_fildes,
- ce->myaiocb.aio_offset,
- ce->myaiocb.aio_nbytes);
-#else
- printf("fd %d offset %lld size %d\n",
- ce->myaiocb64.aio_fildes,
- ce->myaiocb64.aio_offset,
- ce->myaiocb64.aio_nbytes);
-#endif
-#else
- printf("fd %d offset %lld size %d\n",
- ce->myaiocb.aio_fildes,
- ce->myaiocb.aio_offset,
- ce->myaiocb.aio_nbytes);
-#endif
- exit(181);
- }
-
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- retval=aio_return(&ce->myaiocb);
-#else
-#if defined(__CrayX1__)
- retval=aio_return64((aiocb64_t *)&ce->myaiocb64);
-#else
- retval=aio_return64((struct aiocb64 *)&ce->myaiocb64);
-#endif
-
-#endif
-#else
- retval=aio_return(&ce->myaiocb);
-#endif
- if((int)retval < 0)
- {
- printf("aio_return error: %d\n",errno);
- }
-
- if(!ce->direct)
- {
- /* printf("Freeing buffer %x\n",ce->real_address);*/
- free((void *)(ce->real_address));
- free((void *)ce);
- }
-
-}
-
-/*************************************************************************
- * This routine is a generic async writer assist function. It takes
- * the same calling parameters as write() but also extends the
- * interface to include:
- *
- * offset ..... offset in the file.
- * depth ..... How much read-ahead do you want.
- * free_addr .. address of memory to free after write is completed.
- *
- *************************************************************************/
-size_t
-async_write_no_copy(gc,fd,buffer,size,offset,depth,free_addr)
-struct cache *gc;
-long long fd,size;
-char *buffer;
-off64_t offset;
-long long depth;
-char *free_addr;
-{
- struct cache_ent *ce;
- size_t ret;
- long long direct = 1;
- ce=allocate_write_buffer(gc,fd,offset,size,(long long)LIO_WRITE,depth,direct,buffer,free_addr);
- ce->direct=0; /* have library de-allocate the buffer */
- async_put_on_write_queue(gc,ce);
- /*
- printf("awnc: fd %d offset %lld, size %d\n",ce->myaiocb64.aio_fildes,
- ce->myaiocb64.aio_offset,
- ce->myaiocb64.aio_nbytes);
- */
-
-again:
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- ret=aio_write(&ce->myaiocb);
-#else
- ret=aio_write64(&ce->myaiocb64);
-#endif
-#else
- ret=aio_write(&ce->myaiocb);
-#endif
- if(ret==-1)
- {
- if(errno==EAGAIN)
- {
- async_wait_for_write(gc);
- goto again;
- }
- if(errno==0)
- {
- /* Compensate for bug in async library */
- async_wait_for_write(gc);
- goto again;
- }
- else
- {
- printf("Error in aio_write: ret %d errno %d\n",ret,errno);
-#ifdef _LARGEFILE64_SOURCE
-#ifdef __LP64__
- printf("aio_write_no_copy: fd %d buffer %lx offset %lld size %d\n",
- ce->myaiocb.aio_fildes,
- (long)(ce->myaiocb.aio_buf),
- ce->myaiocb.aio_offset,
- ce->myaiocb.aio_nbytes);
-#else
- printf("aio_write_no_copy: fd %d buffer %lx offset %lld size %d\n",
- ce->myaiocb64.aio_fildes,
- (long)(ce->myaiocb64.aio_buf),
- ce->myaiocb64.aio_offset,
- ce->myaiocb64.aio_nbytes);
-#endif
-#else
- printf("aio_write_no_copy: fd %d buffer %lx offset %ld size %d\n",
- ce->myaiocb.aio_fildes,
- (long)(ce->myaiocb.aio_buf),
- ce->myaiocb.aio_offset,
- ce->myaiocb.aio_nbytes);
-#endif
- exit(182);
- }
- }
- else
- {
- return((ssize_t)size);
- }
-}
-
-void mbcopy(source, dest, len)
-char *source,*dest;
-size_t len;
-{
- int i;
- for(i=0;i<len;i++)
- *dest++=*source++;
-}
diff --git a/src/components/appio/tests/iozone/libbif.c b/src/components/appio/tests/iozone/libbif.c
deleted file mode 100644
index a69475d31..000000000
--- a/src/components/appio/tests/iozone/libbif.c
+++ /dev/null
@@ -1,452 +0,0 @@
-/*
- * Here is a very simple set of routines to write an Excel worksheet
- * Microsoft BIFF format. The Excel version is set to 2.0 so that it
- * will work with all versions of Excel.
- *
- * Author: Don Capps
- */
-
-/*
- * Note: rows and colums should not exceed 255 or this code will
- * act poorly
- */
-
-#ifdef Windows
-#include <Windows.h>
-#endif
-#include <sys/types.h>
-#include <stdio.h>
-#include <sys/file.h>
-#if defined(__AIX__) || defined(__FreeBSD__) || defined(__DragonFly__)
-#include <fcntl.h>
-#else
-#include <sys/fcntl.h>
-#endif
-
-#if defined(OSV5) || defined(linux) || defined (__FreeBSD__) || defined(__OpenBSD__) || defined(__bsdi__) || defined(__APPLE__) || defined(__DragonFly__)
-#include <string.h>
-#endif
-
-#if defined(linux) || defined(__DragonFly__) || defined(macosx)
-#include <unistd.h>
-#include <stdlib.h>
-#endif
-
-#if (defined(solaris) && defined( __LP64__ )) || defined(__s390x__) || defined(FreeBSD)
-/* If we are building for 64-bit Solaris, all functions that return pointers
- * must be declared before they are used; otherwise the compiler will assume
- * that they return ints and the top 32 bits of the pointer will be lost,
- * causing segmentation faults. The following includes take care of this.
- * It should be safe to add these for all other OSs too, but we're only
- * doing it for Solaris now in case another OS turns out to be a special case.
- */
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <string.h>
-#endif
-/* Little Endian */
-#define ENDIAN_1 1
-/* Big Endian */
-#define ENDIAN_2 2
-/* Middle Endian */
-#define ENDIAN_3 3
-/* Middle Endian */
-#define ENDIAN_4 4
-
-int junk, *junkp;
-
-
-#ifdef HAVE_ANSIC_C
-/************************************************************************/
-/* Here is the API... Enjoy */
-/************************************************************************/
-/* Create worksheet */
-int create_xls(char *);
-/* Args: Filename */
-/* */
-/* Close worksheet */
-void close_xls(int);
-/* Args: file descriptor */
-/* */
-/* Put a 16 bit integer in worksheet */
-void do_int(int,int,int,int);
-/* Args: file descriptor, */
-/* value, */
-/* row, */
-/* column */
-
-/* Put a double in 8 byte float */
-void do_float(int,double,int,int);
-/* Args: file descriptor, */
-/* value, */
-/* row, */
-/* column */
-/* Put a string in worksheet */
-void do_label(int,char *,int,int);
-/* Args: file descriptor, */
-/* string, */
-/* row, */
-/* column */
-/************************************************************************/
-
-char libbif_version[] = "Libbif Version $Revision$";
-void do_eof(int ); /* Used internally */
-void do_header(int ); /* Used internally */
-int endian(void);
-#endif
-
-#define BOF 0x9
-#define INTEGER 0x2
-#define FLOAT 0x3
-#define LABEL 0x4
-#define EXCEL_VERS 0x2
-#define WORKSHEET 0x10
-
-struct bof_record{ /* Beginning of file */
- char hi_opcode;
- char lo_opcode;
- char hi_length;
- char lo_length;
- char hi_version; /* Excel version */
- char lo_version;
- char hi_filetype;
- char lo_filetype;
- };
-struct int_record {
- char hi_opcode; /* Type 2 of record */
- char lo_opcode;
- char hi_length;
- char lo_length;
- char hi_row;
- char lo_row;
- char hi_column;
- char lo_column;
- char rgbhi;
- char rgbmed;
- char rgblo;
- char hi_data;
- char lo_data;
- };
-struct label_record {
- char hi_opcode; /* Type 4 of record */
- char lo_opcode;
- char hi_length;
- char lo_length;
- char hi_row;
- char lo_row;
- char hi_column;
- char lo_column;
- char rgbhi;
- char rgbmed;
- char rgblo;
- char string_length;
- char str_array[256];
- };
-struct float_record { /* Type 3 record */
- char hi_opcode;
- char lo_opcode;
- char hi_length;
- char lo_length;
- char hi_row;
- char lo_row;
- char hi_column;
- char lo_column;
- char rgbhi;
- char rgbmed;
- char rgblo;
- double data;
- };
-/*
- * Write the EOF and close the file
- */
-#ifdef HAVE_ANSIC_C
-void
-close_xls(int fd)
-{
-#else
-close_xls(fd)
-int fd;
-{
-#endif
- do_eof(fd);
- close(fd);
-}
-
-/*
- * Create xls worksheet. Create file and put the BOF record in it.
- */
-#ifdef HAVE_ANSIC_C
-int
-create_xls(char *name)
-{
-#else
-create_xls(name)
-char *name;
-{
-#endif
- int fd;
- unlink(name);
-#ifdef Windows
- fd=open(name,O_BINARY|O_CREAT|O_RDWR,0666);
-#else
- fd=open(name,O_CREAT|O_RDWR,0666);
-#endif
- if(fd<0)
- {
- printf("Error opening file %s\n",name);
- exit(-1);
- }
- do_header(fd);
- return(fd);
-}
-
-#ifdef HAVE_ANSIC_C
-void
-do_header(int fd) /* Stick the BOF at the beginning of the file */
-{
-#else
-do_header(fd)
-int fd;
-{
-#endif
- struct bof_record bof;
- bof.hi_opcode=BOF;
- bof.lo_opcode = 0x0;
- bof.hi_length=0x4;
- bof.lo_length=0x0;
- bof.hi_version=EXCEL_VERS;
- bof.lo_version=0x0;
- bof.hi_filetype=WORKSHEET;
- bof.lo_filetype=0x0;
- junk=write(fd,&bof,sizeof(struct bof_record));
-}
-
-/*
- * Put an integer (16 bit) in the worksheet
- */
-#ifdef HAVE_ANSIC_C
-void
-do_int(int fd,int val, int row, int column)
-{
-#else
-do_int(fd,val,row,column)
-int fd,val,row,column;
-{
-#endif
- struct int_record intrec;
- short s_row,s_column;
- s_row=(short)row;
- s_column=(short)column;
- intrec.hi_opcode=INTEGER;
- intrec.lo_opcode=0x00;
- intrec.hi_length=0x09;
- intrec.lo_length=0x00;
- intrec.rgbhi=0x0;
- intrec.rgbmed=0x0;
- intrec.rgblo=0x0;
- intrec.hi_row=(char)s_row&0xff;
- intrec.lo_row=(char)(s_row>>8)&0xff;
- intrec.hi_column=(char)(s_column&0xff);
- intrec.lo_column=(char)(s_column>>8)&0xff;
- intrec.hi_data=(val & 0xff);
- intrec.lo_data=(val & 0xff00)>>8;
- junk=write(fd,&intrec,13);
-}
-
-/* Note: This routine converts Big Endian to Little Endian
- * and writes the record out.
- */
-
-/*
- * Put a double in the worksheet as 8 byte float in IEEE format.
- */
-#ifdef HAVE_ANSIC_C
-void
-do_float(int fd, double value, int row, int column)
-{
-#else
-do_float(fd, value, row, column)
-int fd;
-double value;
-int row,column;
-{
-#endif
- struct float_record floatrec;
- short s_row,s_column;
- unsigned char *sptr,*dptr;
- s_row=(short)row;
- s_column=(short)column;
- floatrec.hi_opcode=FLOAT;
- floatrec.lo_opcode=0x00;
- floatrec.hi_length=0xf;
- floatrec.lo_length=0x00;
- floatrec.rgbhi=0x0;
- floatrec.rgbmed=0x0;
- floatrec.rgblo=0x0;
- floatrec.hi_row=(char)(s_row&0xff);
- floatrec.lo_row=(char)((s_row>>8)&0xff);
- floatrec.hi_column=(char)(s_column&0xff);
- floatrec.lo_column=(char)((s_column>>8)&0xff);
- sptr =(unsigned char *) &value;
- dptr =(unsigned char *) &floatrec.data;
-
- if(endian()==ENDIAN_2) /* Big Endian */
- {
- dptr[0]=sptr[7]; /* Convert to Little Endian */
- dptr[1]=sptr[6];
- dptr[2]=sptr[5];
- dptr[3]=sptr[4];
- dptr[4]=sptr[3];
- dptr[5]=sptr[2];
- dptr[6]=sptr[1];
- dptr[7]=sptr[0];
- }
- if(endian()==ENDIAN_3) /* Middle Endian */
- {
- dptr[0]=sptr[4]; /* 16 bit swapped ARM */
- dptr[1]=sptr[5];
- dptr[2]=sptr[6];
- dptr[3]=sptr[7];
- dptr[4]=sptr[0];
- dptr[5]=sptr[1];
- dptr[6]=sptr[2];
- dptr[7]=sptr[3];
- }
-
- if(endian()==ENDIAN_1) /* Little Endian */
- {
- dptr[0]=sptr[0]; /* Do not convert to Little Endian */
- dptr[1]=sptr[1];
- dptr[2]=sptr[2];
- dptr[3]=sptr[3];
- dptr[4]=sptr[4];
- dptr[5]=sptr[5];
- dptr[6]=sptr[6];
- dptr[7]=sptr[7];
- }
- if(endian()==-1) /* Unsupported architecture */
- {
- dptr[0]=0;
- dptr[1]=0;
- dptr[2]=0;
- dptr[3]=0;
- dptr[4]=0;
- dptr[5]=0;
- dptr[6]=0;
- dptr[7]=0;
- printf("Excel output not supported on this architecture.\n");
- }
- junk=write(fd,&floatrec,11); /* Don't write floatrec. Padding problems */
- junk=write(fd,&floatrec.data,8); /* Write value seperately */
-}
-
-/*
- * Put a string as a label in the worksheet.
- */
-#ifdef HAVE_ANSIC_C
-void
-do_label(int fd, char *string, int row, int column)
-{
-#else
-do_label(fd, string, row, column)
-int fd;
-char *string;
-int row,column;
-{
-#endif
- struct label_record labelrec;
- short s_row,s_column;
- int i;
- for(i=0;i<255;i++)
- labelrec.str_array[i]=0;
- s_row=(short)row;
- s_column=(short)column;
- i=strlen(string);
- labelrec.hi_opcode=LABEL;
- labelrec.lo_opcode=0x00;
- labelrec.hi_length=0x08; /* 264 total bytes */
- labelrec.lo_length=0x01;
- labelrec.rgblo=0x0;
- labelrec.rgbmed=0x0;
- labelrec.rgbhi=0x0;
- labelrec.hi_row=(char)(s_row&0xff);
- labelrec.lo_row=(char)((s_row>>8)&0xff);
- labelrec.hi_column=(char)(s_column&0xff);
- labelrec.lo_column=(char)((s_column>>8)&0xff);
- labelrec.string_length=i;
- if(i > 255) /* If too long then terminate it early */
- string[254]=0;
- i=strlen(string);
- strcpy(labelrec.str_array,string);
-
- junk=write(fd,&labelrec,sizeof(struct label_record));
-
-}
-
-/*
- * Write the EOF in the file
- */
-#ifdef HAVE_ANSIC_C
-void
-do_eof(int fd)
-{
-#else
-do_eof(fd)
-int fd;
-{
-#endif
- char buf[]={0x0a,0x00,0x00,0x00};
- junk=write(fd,buf,4);
-}
-
-/*
- * Routine to determine the Endian-ness of the system. This
- * is needed for Iozone to convert doubles (floats) into
- * Little-endian format. This is needed for Excel to be
- * able to interpret the file
- */
-int
-endian(void)
-{
- long long foo = 0x0102030405060708LL;
- long foo1 = 0x012345678;
- unsigned char *c,c1,c2,c3,c4,c5,c6,c7,c8;
- c=(unsigned char *)&foo;
- c1=*c++;
- c2=*c++;
- c3=*c++;
- c4=*c++;
- c5=*c++;
- c6=*c++;
- c7=*c++;
- c8=*c;
-
- /*--------------------------------------------------------------*/
- /* printf("%x %x %x %x %x %x %x %x\n",c1,c2,c3,c4,c5,c6,c7,c8); */
- /*--------------------------------------------------------------*/
-
- /* Little Endian format ? ( Intel ) */
- if( (c1==0x08) && (c2==0x07) && (c3==0x06) && (c4==0x05) &&
- (c5==0x04) && (c6==0x03) && (c7==0x02) && (c8==0x01) )
- return(ENDIAN_1);
- /* Big Endian format ? ( Sparc, Risc... */
- if( (c1==0x01) && (c2==0x02) && (c3==0x03) && (c4==0x04) &&
- (c5==0x05) && (c6==0x06) && (c7==0x07) && (c8==0x08) )
- return(ENDIAN_2);
- /* Middle Endian format ? ( ARM ... ) */
- if( (c1==0x04) && (c2==0x03) && (c3==0x02) && (c4==0x01) &&
- (c5==0x08) && (c6==0x07) && (c7==0x06) && (c8==0x05) )
- return(ENDIAN_3);
- c=(unsigned char *)&foo1;
- c1=*c++;
- c2=*c++;
- c3=*c++;
- c4=*c++;
- /* Another middle endian format ? ( PDP-11 ... ) */
- if( (c1==0x34) && (c2==0x12) && (c3==0x78) && (c4==0x56))
- return(ENDIAN_4);
-
- return(-1);
-}
diff --git a/src/components/appio/tests/iozone/makefile b/src/components/appio/tests/iozone/makefile
deleted file mode 100644
index f7db172a6..000000000
--- a/src/components/appio/tests/iozone/makefile
+++ /dev/null
@@ -1,1461 +0,0 @@
-#
-# Version $Revision$
-#
-# The makefile for building all versions of iozone for all supported
-# platforms
-#
-# Supports: hpux, hpux_no_ansi, hpux-10.1, hpux_no_ansi-10.1,
-# sppux, sppux-10.1, ghpux, sppux,
-# convex, FreeBSD, OpenBSD, OSFV3, OSFV4, OSFV5, SCO
-# SCO_Unixware_gcc,NetBSD,TRU64, Mac OS X
-
-CC = cc
-C89 = c89
-GCC = gcc
-CCS = /usr/ccs/bin/cc
-NACC = /opt/ansic/bin/cc
-CFLAGS =
-S10GCCFLAGS = -m64
-S10CCFLAGS = -m64
-FLAG64BIT = -m64
-
-# If your Linux kernel supports preadv and pwritev system calls
-# and you want iozone to use them, add -DHAVE_PREADV -DHAVE_PWRITEV
-# to CFLAGS
-
-all:
- @echo ""
- @echo "You must specify the target. "
- @echo " -> AIX (32bit) <-"
- @echo " -> AIX-LF (32bit) <-"
- @echo " -> AIX64 (32bit) <-"
- @echo " -> AIX64-LF (32bit) <-"
- @echo " -> bsdi (32bit) <-"
- @echo " -> convex (32bit) <-"
- @echo " -> CrayX1 (32bit) <-"
- @echo " -> dragonfly (32bit) <-"
- @echo " -> freebsd (32bit) <-"
- @echo " -> generic (32bit) <-"
- @echo " -> ghpux (32bit) <-"
- @echo " -> hpuxs-11.0 (simple) (32bit) <-"
- @echo " -> hpux-11.0w (64bit) <-"
- @echo " -> hpuxs-11.0w (64bit) <-"
- @echo " -> hpux-11.0 (32bit) <-"
- @echo " -> hpux-10.1 (32bit) <-"
- @echo " -> hpux-10.20 (32bit) <-"
- @echo " -> hpux (32bit) <-"
- @echo " -> hpux_no_ansi (32bit) <-"
- @echo " -> hpux_no_ansi-10.1 (32bit) <-"
- @echo " -> IRIX (32bit) <-"
- @echo " -> IRIX64 (64bit) <-"
- @echo " -> linux (32bit) <-"
- @echo " -> linux-arm (32bit) <-"
- @echo " -> linux-AMD64 (64bit) <-"
- @echo " -> linux-ia64 (64bit) <-"
- @echo " -> linux-powerpc (32bit) <-"
- @echo " -> linux-powerpc64 (64bit) <-"
- @echo " -> linux-sparc (32bit) <-"
- @echo " -> macosx (32bit) <-"
- @echo " -> netbsd (32bit) <-"
- @echo " -> openbsd (32bit) <-"
- @echo " -> openbsd-threads (32bit) <-"
- @echo " -> OSFV3 (64bit) <-"
- @echo " -> OSFV4 (64bit) <-"
- @echo " -> OSFV5 (64bit) <-"
- @echo " -> linux-S390 (32bit) <-"
- @echo " -> linux-S390X (64bit) <-"
- @echo " -> SCO (32bit) <-"
- @echo " -> SCO_Unixware_gcc (32bit) <-"
- @echo " -> Solaris (32bit) <-"
- @echo " -> Solaris-2.6 (32bit) <-"
- @echo " -> Solaris7gcc (32bit) <-"
- @echo " -> Solaris8-64 (64bit) <-"
- @echo " -> Solaris8-64-VXFS (64bit) <-"
- @echo " -> Solaris10 (32bit) <-"
- @echo " -> Solaris10cc (64bit) <-"
- @echo " -> Solaris10gcc (32bit) <-"
- @echo " -> Solaris10gcc-64 (64bit) <-"
- @echo " -> sppux (32bit) <-"
- @echo " -> sppux-10.1 (32bit) <-"
- @echo " -> sppux_no_ansi-10.1 (32bit) <-"
- @echo " -> SUA (32bit) <-"
- @echo " -> TRU64 (64bit) <-"
- @echo " -> UWIN (32bit) <-"
- @echo " -> Windows (95/98/NT) (32bit) <-"
- @echo ""
-
-clean:
- rm -f *.o iozone fileop pit_server
-
-rpm:
- cp ../../iozone*.tar /usr/src/red*/SO*
- rpmbuild -ba spec.in
-
-
-#
-# Turn on the optimizer, largefiles, Posix async I/O and threads.
-#
-hpux-11.0: iozone_hpux-11.0.o libasync.o libbif.o
- $(CC) +O3 +Oparallel $(LDFLAGS) iozone_hpux-11.0.o libasync.o \
- libbif.o -lpthread -lrt -o iozone
-
-#
-# Turn on wide-mode, the optimizer, largefiles, Posix async I/O and threads.
-#
-hpux-11.0w: iozone_hpux-11.0w.o libasyncw.o libbif.o
- $(CC) +DD64 +O3 $(LDFLAGS) iozone_hpux-11.0w.o libasyncw.o \
- libbif.o -lpthread -lrt -o iozone
-
-
-#
-# Simple build with largefiles, Posix threads and Posix async I/O
-#
-hpuxs-11.0: iozone_hpuxs-11.0.o libasync.o libbif.o fileop_hpuxs-11.0.o pit_server.o
- $(CC) -O $(LDFLAGS) iozone_hpuxs-11.0.o \
- libasync.o libbif.o -lpthread -lrt -o iozone
- $(CC) -O $(LDFLAGS) fileop_hpuxs-11.0.o -o fileop
- $(CC) -O $(LDFLAGS) pit_server.o -o pit_server
-
-#
-# Simple build with wide-mode, largefiles, Posix threads and Posix async I/O
-#
-hpuxs-11.0w: iozone_hpuxs-11.0w.o libasyncw.o libbif.o
- $(CC) -O +DD64 $(LDFLAGS) iozone_hpuxs-11.0w.o \
- libasyncw.o libbif.o -lpthread -lrt -o iozone
-
-#
-# Simple 10.1 build with no threads, no largefiles, no async I/O
-#
-hpux-10.1: iozone_hpux-10.1.o libbif.o
- $(C89) +e -O $(LDFLAGS) iozone_hpux-10.1.o libbif.o -o iozone
-
-hpux-10.20: iozone_hpux-10.20.o libbif.o
- $(C89) +e -O $(LDFLAGS) iozone_hpux-10.20.o libbif.o -o iozone
-
-#
-# Simple generic HP build with no threads, no largefiles, no async I/O
-#
-hpux: iozone_hpux.o
- $(C89) +e -O $(LDFLAGS) iozone_hpux.o libbif.o -o iozone
-
-#
-# GNU HP build with no threads, no largefiles, no async I/O
-#
-ghpux: iozone_ghpux.o libbif.o
- $(GCC) -O $(LDFLAGS) iozone_ghpux.o libbif.o -static -o iozone
-
-#
-# GNU Generic build with no threads, no largefiles, no async I/O
-#
-generic: iozone_generic.o libbif.o
- $(CC) -O $(LDFLAGS) iozone_generic.o libbif.o -o iozone
-
-#
-# No ansii 'C' compiler HP build with no threads, no largefiles, no async I/O
-#
-hpux_no_ansi-10.1: iozone_hpux_no-10.1.o libbif.o
- $(NACC) -O $(LDFLAGS) iozone_hpux_no-10.1.o libbif.o -o iozone
-
-#
-# No ansii 'C' compiler HP build with no threads, no largefiles, no async I/O
-#
-hpux_no_ansi: iozone_hpux_no.o libbif.o
- $(C89) -O $(LDFLAGS) iozone_hpux_no.o libbif.o -o iozone
-
-#
-# GNU 'C' compiler Linux build with threads, largefiles, async I/O
-#
-linux: iozone_linux.o libasync.o libbif.o fileop_linux.o pit_server.o
- $(CC) -O3 $(LDFLAGS) iozone_linux.o libasync.o libbif.o -lpthread \
- -lrt -o iozone
- $(CC) -O3 -Dlinux fileop_linux.o -o fileop
- $(CC) -O3 -Dlinux pit_server.o -o pit_server
-
-#
-# GNU 'C' compiler Linux build for powerpc chip with threads, largefiles, async I/O
-#
-linux-powerpc: iozone_linux-powerpc.o libbif.o libasync.o fileop_linux-ppc.o pit_server.o
- $(CC) -O3 $(LDFLAGS) iozone_linux-powerpc.o libasync.o \
- libbif.o -lpthread -lrt -o iozone
- $(CC) -O3 -Dlinux fileop_linux-ppc.o -o fileop
- $(CC) -O3 -Dlinux pit_server.o -o pit_server
-#
-# GNU 'C' compiler Linux build for sparc chip with threads, largefiles, async I/O
-#
-linux-sparc: iozone_linux-sparc.o libbif.o libasync.o fileop_linux.o pit_server.o
- $(CC) -O3 $(LDFLAGS) iozone_linux-sparc.o libasync.o libbif.o \
- -lpthread -lrt -o iozone
- $(CC) -O3 -Dlinux fileop_linux.o -o fileop
- $(CC) -O3 -Dlinux pit_server.o -o pit_server
-
-#
-# GNU 'C' compiler Linux build with threads, largefiles, async I/O
-#
-linux-ia64: iozone_linux-ia64.o libbif.o libasync.o fileop_linux-ia64.o pit_server.o
- $(CC) -O3 $(LDFLAGS) iozone_linux-ia64.o libbif.o libasync.o \
- -lrt -lpthread -o iozone
- $(CC) -O3 -Dlinux fileop_linux-ia64.o -o fileop
- $(CC) -O3 -Dlinux pit_server.o -o pit_server
-
-#
-# GNU 'C' compiler Linux build for powerpc chip with threads, largefiles, async I/O
-#
-linux-powerpc64: iozone_linux-powerpc64.o libbif.o libasync.o fileop_linux-ppc64.o pit_server-linux-powerpc64.o
- $(CC) -O3 -Dunix -DHAVE_ANSIC_C -DSHARED_MEM -DASYNC_IO \
- -D_LARGEFILE64_SOURCE -Dlinux \
- iozone_linux-powerpc64.o libasync.o libbif.o -lpthread \
- -lrt $(FLAG64BIT) -o iozone
- $(CC) -O3 -Dlinux fileop_linux-ppc64.o $(FLAG64BIT) -o fileop
- $(CC) -O3 -Dlinux pit_server-linux-powerpc64.o $(FLAG64BIT) -o pit_server
-
-#
-# GNU 'C' compiler Linux build with threads, largefiles, async I/O
-#
-linux-arm: iozone_linux-arm.o libbif.o libasync.o fileop_linux-arm.o pit_server.o
- $(CC) -O3 $(LDFLAGS) iozone_linux-arm.o libbif.o libasync.o \
- -lrt -lpthread -o iozone
- $(CC) -O3 -Dlinux fileop_linux-arm.o -o fileop
- $(CC) -O3 -Dlinux pit_server.o -o pit_server
-
-#
-# GNU 'C' compiler Linux build with threads, largefiles, async I/O
-#
-linux-AMD64: iozone_linux-AMD64.o libbif.o libasync.o fileop_linux-AMD64.o pit_server.o
- $(CC) -O3 $(LDFLAGS) iozone_linux-AMD64.o libbif.o libasync.o \
- -lrt -lpthread -o iozone
- $(CC) -O3 -Dlinux fileop_linux-AMD64.o -o fileop
- $(CC) -O3 -Dlinux pit_server.o -o pit_server
-
-#
-# GNU 'C' compiler Linux build with S/390, threads, largfiles, async I/O
-#
-linux-S390: iozone_linux-s390.o libbif.o libasync.o fileop_linux-s390.o pit_server.o
- $(CC) -O2 $(LDFLAGS) -lpthread -lrt iozone_linux-s390.o \
- libbif.o libasync.o -o iozone
- $(CC) -O3 -Dlinux fileop_linux-s390.o -o fileop
- $(CC) -O3 -Dlinux pit_server.o -o pit_server
-
-#
-# GNU 'C' compiler Linux build with S/390, threads, largfiles, async I/O
-#
-linux-S390X: iozone_linux-s390x.o libbif.o libasync.o fileop_linux-s390x.o pit_server.o
- $(CC) -O2 $(LDFLAGS) -lpthread -lrt iozone_linux-s390x.o \
- libbif.o libasync.o -o iozone
- $(CC) -O3 -Dlinux fileop_linux-s390x.o -o fileop
- $(CC) -O3 -Dlinux pit_server.o -o pit_server
-
-
-#
-# AIX
-# I would have built with ASYNC_IO but the AIX machine does not have
-# POSIX 1003.1b compliant async I/O header files. Has threads, no
-# largefile support.
-#
-AIX: iozone_AIX.o libbif.o fileop_AIX.o
- $(CC) -O $(LDFLAGS) iozone_AIX.o libbif.o \
- -lpthreads -o iozone
- $(CC) -O -Dlinux fileop_AIX.o -o fileop
-
-#
-# AIX-LF
-# I would have built with ASYNC_IO but the AIX machine does not have
-# POSIX 1003.1b compliant async I/O header files. Has threads, and
-# largefile support.
-#
-AIX-LF: iozone_AIX-LF.o libbif.o fileop_AIX-LF.o pit_server.o
- $(CC) -O $(LDFLAGS) iozone_AIX-LF.o libbif.o \
- -lpthreads -o iozone
- $(CC) -O fileop_AIX-LF.o -o fileop
- $(CC) -O pit_server.o -o pit_server
-
-# AIX64
-# This version uses the 64 bit interfaces and is compiled as 64 bit code.
-# Has threads, async I/O but no largefile support.
-#
-AIX64: iozone_AIX64.o libbif.o fileop_AIX64.o libasync.o pit_server.o
- $(GCC) -maix64 -O3 $(LDFLAGS) iozone_AIX64.o libasync.o \
- libbif.o -lpthreads -o iozone
- $(GCC) -maix64 -O3 $(LDFLAGS) -Dlinux fileop_AIX64.o -o fileop
- $(GCC) -maix32 -O3 $(LDFLAGS) pit_server.o -o pit_server
-
-#
-# AIX64-LF
-# This version uses the 64 bit interfaces and is compiled as 64 bit code.
-# Has threads, async I/O and largefile support.
-#
-AIX64-LF: iozone_AIX64-LF.o libbif.o fileop_AIX64-LF.o libasync.o pit_server.o
- $(GCC) -maix64 -O3 $(LDFLAGS) iozone_AIX64-LF.o libasync.o \
- libbif.o -lpthreads -o iozone
- $(GCC) -maix64 -O3 $(LDFLAGS) -Dlinux fileop_AIX64-LF.o -o fileop
- $(GCC) -maix32 -O3 $(LDFLAGS) pit_server.o -o pit_server
-
-#
-# IRIX 32 bit build with threads, largefiles, async I/O
-# This would like to be in 64 bit mode but it hangs whenever in 64 bit mode.
-# This version uses the 64 bit interfaces but is compiled as 32 bit code
-#
-IRIX64: iozone_IRIX64.o libasyncw.o libbif.o
- $(CC) -32 -O $(LDFLAGS) iozone_IRIX64.o libbif.o \
- -lpthread libasyncw.o -o iozone
-
-#
-# IRIX 32 bit build with threads, No largefiles, and async I/O
-# This version uses the 32 bit interfaces and is compiled as 32 bit code
-#
-IRIX: iozone_IRIX.o libasync.o libbif.o
- $(CC) -O -32 $(LDFLAGS) iozone_IRIX.o libbif.o -lpthread \
- libasync.o -o iozone
-
-#
-# CrayX1: 32 bit build with threads, No largefiles, and async I/O
-# This version uses the 32 bit interfaces and is compiled as 32 bit code
-#
-CrayX1: iozone_CrayX1.o libasync.o libbif.o
- $(CC) -O $(LDFLAGS) iozone_CrayX1.o libbif.o \
- -lpthread libasyncw.o -o iozone
-
-#
-# SPP-UX 32 bit build with threads, No largefiles, and No async I/O,
-# pread extensions
-# For older SPP-UX machines with 9.05 compatibility
-#
-sppux: iozone_sppux.o libbif.o
- $(NACC) -O $(LDFLAGS) iozone_sppux.o libbif.o \
- -Wl,+parallel -lcnx_syscall -lpthread -lail -o iozone
-
-#
-# SPP-UX 32 bit build with threads, No largefiles, and No async I/O, pread
-# extensions
-# For Newer SPP-UX machines with 10.01 compatibility
-#
-sppux-10.1: iozone_sppux-10.1.o libbif.o
- $(NACC) -O $(LDFLAGS) iozone_sppux-10.1.o libbif.o \
- -lcnx_syscall -Wl,+parallel -lpthread -lail -o iozone
-
-#
-# SPP-UX 32 bit build with threads, No largefiles, and No async I/O, pread
-# extensions
-# For Newer SPP-UX machines with 10.01 compatibility, and no ansi 'C' compiler.
-#
-sppux_no_ansi-10.1: iozone_sppux_no-10.1.o libbif.o
- $(CCS) -O $(LDFLAGS) iozone_sppux_no-10.1.o libbif.o \
- -Wl,+parallel -lcnx_syscall \
- -lpthread -lail -o iozone
-
-#
-# Convex 'C' series 32 bit build with No threads, No largefiles, and No async I/O
-#
-convex: iozone_convex.o libbif.o
- $(CC) -O $(LDFLAGS)iozone_convex.o libbif.o -o iozone
-
-#
-# Solaris 32 bit build with threads, largefiles, and async I/O
-#
-Solaris: iozone_solaris.o libasync.o libbif.o fileop_Solaris.o pit_server.o
- $(CC) -O $(LDFLAGS) iozone_solaris.o libasync.o libbif.o \
- -lthread -lpthread -lposix4 -lnsl -laio -lsocket \
- -o iozone
- $(CC) -O fileop_Solaris.o -o fileop
- $(CC) -O pit_server.o -lthread -lpthread -lposix4 -lnsl -laio \
- -lsocket -o pit_server
-
-#
-# Solaris 32 bit build with threads, largefiles, and async I/O
-#
-Solaris7gcc: iozone_solaris7gcc.o libasync7.o libbif7.o
- $(GCC) -O $(LDFLAGS) iozone_solaris7gcc.o libasync7.o libbif7.o \
- -lthread -lpthread -lposix4 -lnsl -laio \
- -lsocket -o iozone
-#
-# Solaris 32 bit build with threads, largefiles, and async I/O
-#
-Solaris10: iozone_solaris10.o libasync10.o libbif10.o fileop_Solaris10.o pit_server.o
- $(CC) -O $(LDFLAGS) iozone_solaris10.o libasync10.o libbif10.o \
- -lthread -lpthread -lposix4 -lnsl -laio \
- -lsocket -o iozone
- $(CC) -O fileop_Solaris10.o -o fileop
- $(CC) -O pit_server.o -lthread -lpthread -lposix4 -lnsl -laio \
- -lsocket -o pit_server
-
-#
-# Solaris 32 bit build with threads, largefiles, and async I/O
-#
-Solaris10cc: iozone_solaris10cc.o libasync10cc.o libbif10cc.o fileop_Solaris10cc.o pit_server.o
- $(CC) -O $(LDFLAGS) iozone_solaris10cc.o libasync10cc.o libbif10cc.o \
- -lthread -lpthread -lposix4 -lnsl -laio \
- -lsocket -o iozone
- $(CC) -O fileop_Solaris10cc.o -o fileop
- $(CC) -O pit_server.o -lthread -lpthread -lposix4 -lnsl -laio \
- -lsocket -o pit_server
-
-#
-# Solaris 32 bit build with threads, largefiles, and async I/O
-#
-Solaris10gcc: iozone_solaris10gcc.o libasync10.o libbif10.o fileop_Solaris10gcc.o pit_server_solaris10gcc.o
- $(GCC) -O $(LDFLAGS) iozone_solaris10gcc.o libasync10.o libbif10.o \
- -lthread -lpthread -lposix4 -lnsl -laio \
- -lsocket -o iozone
- $(GCC) -O fileop_Solaris10gcc.o -o fileop
- $(GCC) -O pit_server_solaris10gcc.o -lthread -lpthread -lposix4 -lnsl -laio \
- -lsocket -o pit_server
-
-#
-# Solaris 64 bit build with threads, largefiles, and async I/O
-#
-Solaris10gcc-64: iozone_solaris10gcc-64.o libasync10-64.o libbif10-64.o fileop_Solaris10gcc-64.o pit_server_solaris10gcc-64.o
- $(GCC) -O $(LDFLAGS) $(S10GCCFLAGS) iozone_solaris10gcc-64.o libasync10-64.o libbif10-64.o \
- -lthread -lpthread -lposix4 -lnsl -laio \
- -lsocket -o iozone
- $(GCC) -O $(S10GCCFLAGS) fileop_Solaris10gcc-64.o -o fileop
- $(GCC) -O $(S10GCCFLAGS) pit_server_solaris10gcc-64.o -lthread -lpthread -lposix4 \
- -lnsl -laio -lsocket -o pit_server
-
-
-#
-# Solaris 64 bit build with threads, largefiles, and async I/O
-#
-Solaris10cc-64: iozone_solaris10cc-64.o libasync10-64.o libbif10-64.o fileop_Solaris10cc-64.o pit_server.o
- $(CC) -O $(LDFLAGS) $(S10CCFLAGS) iozone_solaris10cc-64.o libasync10-64.o libbif10-64.o \
- -lthread -lpthread -lposix4 -lnsl -laio \
- -lsocket -o iozone
- $(CC) -O $(S10CCFLAGS) fileop_Solaris10cc-64.o -o fileop
- $(CC) -O $(S10CCFLAGS) pit_server.o -lthread -lpthread -lposix4 \
- -lnsl -laio -lsocket -o pit_server
-
-
-
-#
-# Solaris 2.6 (32 bit) build with no threads, no largefiles, and no async I/O
-#
-Solaris-2.6: iozone_solaris-2.6.o libbif.o
- $(CC) -O $(LDFLAGS) iozone_solaris-2.6.o libbif.o \
- -lnsl -laio -lsocket -o iozone
-
-#
-# Solaris 64 bit build with threads, largefiles, and async I/O
-#
-Solaris8-64: iozone_solaris8-64.o libasync.o libbif.o
- $(CC) $(LDFLAGS) -fast -xtarget=generic64 -v iozone_solaris8-64.o \
- libasync.o libbif.o -lthread -lpthread -lposix4 -lnsl -laio \
- -lsocket -o iozone
-
-#
-# Solaris 64 bit build with threads, largefiles, async I/O, and Vxfs
-#
-Solaris8-64-VXFS: iozone_solaris8-64-VXFS.o libasync.o libbif.o
- $(CC) $(LDFLAGS) -fast -xtarget=generic64 -v -I/opt/VRTSvxfs/include/
- iozone_solaris8-64-VXFS.o libasync.o libbif.o \
- -lthread -lpthread -lposix4 -lnsl -laio \
- -lsocket -o iozone
-
-#
-# Windows build requires Cygwin development environment. You
-# can get this from www.cygwin.com
-# No largefiles, No async I/O
-#
-Windows: iozone_windows.o libbif.o fileop_windows.o pit_server_win.o
- $(GCC) -O $(LDFLAGS) iozone_windows.o libbif.o -o iozone
- $(GCC) -O $(LDFLAGS) fileop_windows.o -o fileop
- $(GCC) -O $(LDFLAGS) pit_server_win.o -o pit_server
-
-#
-# Windows build requires SUA development environment. You
-# can get this from Microsoft
-# No largefiles, No async I/O
-#
-SUA: iozone_sua.o libbif.o fileop_sua.o pit_server_sua.o
- $(GCC) -O $(LDFLAGS) iozone_sua.o libbif.o -o iozone
- $(GCC) -O $(LDFLAGS) fileop_sua.o -o fileop
- $(GCC) -O $(LDFLAGS) pit_server_sua.o -o pit_server
-
-#
-# Uwin build requires UWIN development environment.
-# No threads, No largefiles, No async I/O
-#
-UWIN: iozone_uwin.o libbif.o
- $(GCC) -O $(LDFLAGS) iozone_uwin.o libbif.o -o iozone
-
-#
-# GNU C compiler BSD/OS build with threads, largefiles, no async I/O
-#
-
-bsdi: iozone_bsdi.o libbif.o fileop_bsdi.o pit_server.o
- $(CC) -O $(LDFLAGS) iozone_bsdi.o libbif.o -o iozone
- $(CC) -O fileop_bsdi.o -o fileop
- $(CC) -O pit_server.o -o pit_server
-
-#
-# GNU C compiler FreeBSD build with no threads, no largefiles, no async I/O
-#
-
-freebsd: iozone_freebsd.o libbif.o fileop_freebsd.o libasync.o pit_server.o
- $(CC) $(LDFLAGS) iozone_freebsd.o libbif.o -lpthread libasync.o \
- -o iozone
- $(CC) -O fileop_freebsd.o -o fileop
- $(CC) -O pit_server.o -o pit_server
-
-#
-# GNU C compiler DragonFly build with no threads, no largefiles
-#
-dragonfly: iozone_dragonfly.o libbif.o fileop_dragonfly.o pit_server.o
- $(CC) $(LDFLAGS) iozone_dragonfly.o libbif.o -o iozone
- $(CC) -O fileop_dragonfly.o -o fileop
- $(CC) -O pit_server.o -o pit_server
-
-#
-# GNU C compiler MacosX build with no threads, no largefiles, no async I/O
-#
-
-macosx: iozone_macosx.o fileop_macosx.o pit_server.o
- $(CC) -O $(LDFLAGS) iozone_macosx.o libbif.o -o iozone
- $(CC) -O $(LDFLAGS) fileop_macosx.o -o fileop
- $(CC) -O $(LDFLAGS) pit_server.o -o pit_server
-#
-#
-# GNU C compiler OpenBSD build with no threads, no largefiles, no async I/O
-#
-
-openbsd: iozone_openbsd.o libbif.o fileop_openbsd.o pit_server.o
- $(CC) -O $(LDFLAGS) iozone_openbsd.o libbif.o -o iozone
- $(CC) -O fileop_openbsd.o -o fileop
- $(CC) -O pit_server.o -o pit_server
-
-#
-# GNU C compiler OpenBSD build with threads, no largefiles, no async I/O
-#
-
-openbsd-threads: iozone_openbsd-threads.o libbif.o
- $(CC) -O $(LDFLAGS) -pthread iozone_openbsd-threads.o \
- libbif.o -o iozone
-
-#
-# GNU C compiler OSFV3 build
-# Has threads and async I/O but no largefiles.
-#
-
-OSFV3: iozone_OSFV3.o libbif.o libasync.o
- $(CC) -O $(LDFLAGS) iozone_OSFV3.o libbif.o \
- -lpthreads libasync.o -laio -o iozone
-
-#
-# GNU C compiler OSFV4 build
-# Has threads and async I/O but no largefiles.
-#
-
-OSFV4: iozone_OSFV4.o libbif.o libasync.o
- $(CC) -O $(LDFLAGS) iozone_OSFV4.o libbif.o -lpthread \
- libasync.o -laio -o iozone
-
-#
-# GNU C compiler OSFV5 build
-# Has threads and async I/O but no largefiles.
-#
-
-OSFV5: iozone_OSFV5.o libbif.o libasync.o
- $(CC) -O $(LDFLAGS) iozone_OSFV5.o libbif.o -lpthread \
- libasync.o -laio -o iozone
-
-#
-# GNU C compiler TRU64 build
-# Has threads and async I/O but no largefiles.
-#
-
-TRU64: iozone_TRU64.o libbif.o libasync.o
- $(CC) -O $(LDFLAGS) iozone_TRU64.o libbif.o -lpthread \
- libasync.o -laio -o iozone
-
-#
-# GNU Generic build with no threads, no largefiles, no async I/O
-# for SCO
-# Note: Be sure you have the latest patches for SCO's Openserver
-# or you will get warnings about timer problems.
-#
-
-SCO: iozone_SCO.o libbif.o
- $(GCC) -O $(LDFLAGS) iozone_SCO.o -lsocket -s libbif.o -o iozone
-
-
-#
-# GNU build with threads, largefiles, async I/O
-# for SCO Unixware 5 7.1.1 i386 x86at SCO UNIX SVR5
-# Note: Be sure you have the latest patches for SCO's Openserver
-# or you will get warnings about timer problems.
-#
-
-SCO_Unixware_gcc: iozone_SCO_Unixware_gcc.o libbif.o libasync.o
- $(GCC) -O $(LDFLAGS) iozone_SCO_Unixware_gcc.o libbif.o libasync.o \
- -lsocket -lthread -o iozone
-
-#
-# GNU C compiler NetBSD build with no threads, no largefiles, no async I/O
-#
-
-netbsd: iozone_netbsd.o libbif.o fileop_netbsd.o pit_server.o
- $(CC) -O $(LDFLAGS) iozone_netbsd.o libbif.o -o iozone
- $(CC) -O fileop_netbsd.o -o fileop
- $(CC) -O pit_server.o -o pit_server
-
-#
-#
-# Now for the machine specific stuff
-#
-
-iozone_hpux.o: iozone.c libbif.c
- @echo ""
- @echo "Building iozone for HP-UX (9.05)"
- @echo ""
- $(C89) +e -c -O -Dunix -D_HPUX_SOURCE -DHAVE_ANSIC_C -DNO_THREADS \
- -DNAME='"hpux"' $(CFLAGS) iozone.c -o iozone_hpux.o
- $(C89) +e -c -O -Dunix -D_HPUX_SOURCE -DHAVE_ANSIC_C -DNO_THREADS \
- $(CFLAGS) libbif.c -o libbif.o
-
-iozone_hpux-11.0.o: iozone.c libasync.c libbif.c
- @echo ""
- @echo "Building iozone for HP-UX (11.0)"
- @echo ""
- $(CC) -c +O3 +Oparallel -Dunix -D_LARGEFILE64_SOURCE -D_HPUX_SOURCE \
- -DNAME='"hpux-11.0"' -DHAVE_ANSIC_C -DASYNC_IO -DVXFS $(CFLAGS) \
- iozone.c -o iozone_hpux-11.0.o
- $(CC) -c +O3 +Oparallel -Dunix -D_LARGEFILE64_SOURCE -D_HPUX_SOURCE \
- -DHAVE_ANSIC_C -DASYNC_IO -DVXFS $(CFLAGS) libasync.c -o libasync.o
- $(CC) -c +O3 +Oparallel -Dunix -D_LARGEFILE64_SOURCE -D_HPUX_SOURCE \
- -DHAVE_ANSIC_C -DASYNC_IO -DVXFS $(CFLAGS) libbif.c -o libbif.o
-
-iozone_hpux-11.0w.o: iozone.c libasync.c libbif.c
- @echo ""
- @echo "Building iozone for HP-UX (11.0w)"
- @echo ""
- $(CC) -c +DD64 +O3 -Dunix -D_LARGEFILE64_SOURCE -D_HPUX_SOURCE \
- -DNAME='"hpux-11.0w"' -DHAVE_ANSIC_C -DASYNC_IO -DVXFS $(CFLAGS) iozone.c \
- -o iozone_hpux-11.0w.o
- $(CC) -c +DD64 +O3 -Dunix -D_LARGEFILE64_SOURCE -D_HPUX_SOURCE \
- -DHAVE_ANSIC_C -DASYNC_IO -DVXFS $(CFLAGS) libasync.c -o libasyncw.o
- $(CC) -c +DD64 +O3 -Dunix -D_LARGEFILE64_SOURCE -D_HPUX_SOURCE \
- -DHAVE_ANSIC_C -DASYNC_IO -DVXFS $(CFLAGS) libbif.c -o libbif.o
-
-iozone_hpuxs-11.0.o: iozone.c libasync.c libbif.c
- @echo ""
- @echo "Building simple iozone for HP-UX (11.0)"
- @echo ""
- $(CC) -c -Dunix -D_LARGEFILE64_SOURCE -D_HPUX_SOURCE -DHAVE_ANSIC_C \
- -DNAME='"hpuxs-11.0"' -DASYNC_IO -DVXFS -DHAVE_PREAD $(CFLAGS) iozone.c \
- -o iozone_hpuxs-11.0.o
- $(CC) -c -Dunix -D_LARGEFILE64_SOURCE -D_HPUX_SOURCE -DHAVE_ANSIC_C \
- -DASYNC_IO -DVXFS $(CFLAGS) libasync.c -o libasync.o
- $(CC) -c -Dunix -D_LARGEFILE64_SOURCE -D_HPUX_SOURCE -DHAVE_ANSIC_C \
- -DASYNC_IO -DVXFS $(CFLAGS) libbif.c -o libbif.o
-
-fileop_hpuxs-11.0.o: fileop.c
- @echo ""
- @echo "Building simple fileop for HP-UX (11.0)"
- @echo ""
- $(CC) -c $(CFLAGS) fileop.c -o fileop_hpuxs-11.0.o
-
-pit_server_solaris10gcc-64.o: pit_server.c
- @echo ""
- @echo "Building the pit_server"
- @echo ""
- $(CC) -c $(CFLAGS) $(S10GCCFLAGS) pit_server.c -o pit_server_solaris10gcc-64.o
-
-pit_server.o: pit_server.c
- @echo ""
- @echo "Building the pit_server"
- @echo ""
- $(CC) -c $(CFLAGS) pit_server.c -o pit_server.o
-
-pit_server-linux-powerpc64.o: pit_server.c
- @echo ""
- @echo "Building the pit_server"
- @echo ""
- $(CC) -c $(CFLAGS) $(FLAG64BIT) pit_server.c -o pit_server-linux-powerpc64.o
-
-pit_server_solaris10gcc.o: pit_server.c
- @echo ""
- @echo "Building the pit_server"
- @echo ""
- $(GCC) -c $(CFLAGS) pit_server.c -o pit_server_solaris10gcc.o
-
-
-pit_server_win.o: pit_server.c
- @echo ""
- @echo "Building the pit_server for Windows"
- @echo ""
- $(GCC) -c $(CFLAGS) -DWindows pit_server.c -o pit_server_win.o
-
-pit_server_sua.o: pit_server.c
- @echo ""
- @echo "Building the pit_server for Windows SUA"
- @echo ""
- $(GCC) -c $(CFLAGS) -D_SUA_ pit_server.c -o pit_server_sua.o
-
-iozone_hpuxs-11.0w.o: iozone.c libasync.c libbif.c
- @echo ""
- @echo "Building simple iozone for HP-UX (11.0w)"
- @echo ""
- $(CC) -c +DD64 -Dunix -D_LARGEFILE64_SOURCE -D_HPUX_SOURCE \
- -DNAME='"hpuxs-11.0w"' -DHAVE_ANSIC_C -DASYNC_IO -DVXFS \
- -DHAVE_PREAD $(CFLAGS) iozone.c -o iozone_hpuxs-11.0w.o
- $(CC) -c +DD64 -Dunix -D_LARGEFILE64_SOURCE -D_HPUX_SOURCE \
- -DHAVE_ANSIC_C -DASYNC_IO -DVXFS $(CFLAGS) libasync.c -o libasyncw.o
- $(CC) -c +DD64 -Dunix -D_LARGEFILE64_SOURCE -D_HPUX_SOURCE \
- -DHAVE_ANSIC_C -DASYNC_IO -DVXFS $(CFLAGS) libbif.c -o libbif.o
-
-iozone_hpux-10.1.o: iozone.c libbif.c
- @echo ""
- @echo "Building iozone for HP-UX (10.1)"
- @echo ""
- $(C89) +e -c -O -Dunix -D_HPUX_SOURCE -DHAVE_ANSIC_C -DNO_THREADS \
- -DNAME='"hpux-10.1"' $(CFLAGS) iozone.c -o iozone_hpux-10.1.o
- $(C89) +e -c -O -Dunix -D_HPUX_SOURCE -DHAVE_ANSIC_C -DNO_THREADS \
- $(CFLAGS) libbif.c -o libbif.o
-
-iozone_hpux-10.20.o: iozone.c libbif.c
- @echo ""
- @echo "Building iozone for HP-UX (10.20)"
- @echo ""
- $(C89) +e -c -O -Dunix -D_HPUX_SOURCE -DHAVE_ANSIC_C -DNO_THREADS \
- -DNAME='"hpux-10.20"' $(CFLAGS) iozone.c -o iozone_hpux-10.20.o
- $(C89) +e -c -O -Dunix -D_HPUX_SOURCE -DHAVE_ANSIC_C -DNO_THREADS \
- $(CFLAGS) libbif.c -o libbif.o
-
-iozone_ghpux.o: iozone.c libbif.c
- @echo ""
- @echo "Building iozone for GCC HP-UX (9.05) "
- @echo ""
- $(GCC) -c -O -Dunix -D_HPUX_SOURCE -DHAVE_ANSIC_C -DNO_THREADS $(CFLAGS) iozone.c \
- -DNAME='"h=ghpux"' -o iozone_ghpux.o
- $(GCC) -c -O -Dunix -D_HPUX_SOURCE -DHAVE_ANSIC_C -DNO_THREADS \
- $(CFLAGS) libbif.c -o libbif.o
-
-iozone_generic.o: iozone.c libbif.c
- @echo ""
- @echo "Building iozone Generic "
- @echo ""
- $(CC) -c -O -Dgeneric -Dunix -DHAVE_ANSIC_C -DNO_THREADS \
- -DNAME='"Generic"' $(CFLAGS) iozone.c -o iozone_generic.o
- $(CC) -c -O -Dgeneric -Dunix -DHAVE_ANSIC_C -DNO_THREADS \
- $(CFLAGS) libbif.c -o libbif.o
-
-iozone_hpux_no.o: iozone.c libbif.c
- @echo ""
- @echo "Building iozone for HP-UX (9.05) without ansi compiler"
- @echo ""
- $(NACC) -c -O -Dunix -D_HPUX_SOURCE -DNO_THREADS iozone.c \
- -DNAME='"hpux_no_ansi"' -o iozone_hpux_no.o
- $(NACC) -c -O -Dunix -D_HPUX_SOURCE -DNO_THREADS \
- libbif.c -o libbif.o
-
-iozone_hpux_no-10.1.o: iozone.c
- @echo ""
- @echo "Building iozone for HP-UX (10.1) without ansi compiler"
- @echo ""
- $(NACC) -c -O -Dunix -D_HPUX_SOURCE -DNO_THREADS iozone.c \
- -DNAME='"hpux_no_ansi_10.1"' -o iozone_hpux_no-10.1.o
- $(NACC) -c -O -Dunix -D_HPUX_SOURCE -DNO_THREADS \
- libbif.c -o libbif.o
-
-iozone_linux-powerpc.o: iozone.c libbif.c libasync.c
- @echo ""
- @echo "Building iozone for Linux PowerPC"
- @echo ""
- $(CC) -c -O3 -Dunix -DHAVE_ANSIC_C -DASYNC_IO -DDONT_HAVE_O_DIRECT \
- -DSHARED_MEM -Dlinux -D_LARGEFILE64_SOURCE $(CFLAGS) iozone.c \
- -DNAME='"linux-powerpc"' -o iozone_linux-powerpc.o
- $(CC) -c -O3 -Dunix -DHAVE_ANSIC_C -DASYNC_IO -D_LARGEFILE64_SOURCE \
- -DSHARED_MEM -Dlinux $(CFLAGS) libbif.c -o libbif.o
- $(CC) -c -O3 -Dunix -Dlinux -DHAVE_ANSIC_C -DASYNC_IO \
- -D_LARGEFILE64_SOURCE $(CFLAGS) libasync.c -o libasync.o
-
-iozone_linux-powerpc64.o: iozone.c libbif.c libasync.c
- @echo ""
- @echo "Building iozone for Linux PowerPC64"
- @echo ""
- $(CC) -c -O3 -Dunix -DHAVE_ANSIC_C -DASYNC_IO -DNAME='"linux-powerpc64"' \
- -DSHARED_MEM -Dlinux -D_LARGEFILE64_SOURCE $(CFLAGS) iozone.c \
- $(FLAG64BIT) -o iozone_linux-powerpc64.o
- $(CC) -c -O3 -Dunix -DHAVE_ANSIC_C -DASYNC_IO -D_LARGEFILE64_SOURCE \
- -DSHARED_MEM -Dlinux $(CFLAGS) libbif.c $(FLAG64BIT) -o libbif.o
- $(CC) -c -O3 -Dunix -Dlinux -DHAVE_ANSIC_C -DASYNC_IO \
- -D_LARGEFILE64_SOURCE $(CFLAGS) libasync.c $(FLAG64BIT) -o libasync.o
-
-
-iozone_linux-sparc.o: iozone.c libbif.c libasync.c
- @echo ""
- @echo "Building iozone for Linux Sparc"
- @echo ""
- $(CC) -c -O3 -Dunix -DHAVE_ANSIC_C -DASYNC_IO -DDONT_HAVE_O_DIRECT \
- -DSHARED_MEM -Dlinux -D_LARGEFILE64_SOURCE $(CFLAGS) iozone.c \
- -DNAME='"linux-sparc"' -o iozone_linux-sparc.o
- $(CC) -c -O3 -Dunix -DHAVE_ANSIC_C -DASYNC_IO -D_LARGEFILE64_SOURCE \
- -DSHARED_MEM -Dlinux $(CFLAGS) libbif.c -o libbif.o
- $(CC) -c -O3 -Dunix -Dlinux -DHAVE_ANSIC_C -DASYNC_IO \
- -D_LARGEFILE64_SOURCE $(CFLAGS) libasync.c -o libasync.o
-
-iozone_linux.o: iozone.c libbif.c libasync.c
- @echo ""
- @echo "Building iozone for Linux"
- @echo ""
- $(CC) -Wall -c -O3 -Dunix -DHAVE_ANSIC_C -DASYNC_IO -DHAVE_PREAD \
- -DSHARED_MEM -Dlinux -D_LARGEFILE64_SOURCE $(CFLAGS) iozone.c \
- -DNAME='"linux"' -o iozone_linux.o
- $(CC) -Wall -c -O3 -Dunix -DHAVE_ANSIC_C -DASYNC_IO -D_LARGEFILE64_SOURCE \
- -DSHARED_MEM -Dlinux $(CFLAGS) libbif.c -o libbif.o
- $(CC) -Wall -c -O3 -Dunix -Dlinux -DHAVE_ANSIC_C -DASYNC_IO \
- -D_LARGEFILE64_SOURCE $(CFLAGS) libasync.c -o libasync.o
-
-fileop_AIX.o: fileop.c
- @echo ""
- @echo "Building fileop for AIX"
- @echo ""
- $(CC) -c -O $(CFLAGS) fileop.c -o fileop_AIX.o
-
-fileop_AIX-LF.o: fileop.c
- @echo ""
- @echo "Building fileop for AIX-LF"
- @echo ""
- $(CC) -c -O $(CFLAGS) fileop.c -o fileop_AIX-LF.o
-
-fileop_AIX64.o: fileop.c
- @echo ""
- @echo "Building fileop for AIX64"
- @echo ""
- $(GCC) -maix64 -c -O3 $(CFLAGS) fileop.c -o fileop_AIX64.o
-
-fileop_AIX64-LF.o: fileop.c
- @echo ""
- @echo "Building fileop for AIX64-LF"
- @echo ""
- $(GCC) -maix64 -c -O3 $(CFLAGS) fileop.c -o fileop_AIX64-LF.o
-
-fileop_bsdi.o: fileop.c
- @echo ""
- @echo "Building fileop for BSDi"
- @echo ""
- $(CC) -c -O $(CFLAGS) fileop.c -o fileop_bsdi.o
-
-fileop_freebsd.o: fileop.c
- @echo ""
- @echo "Building fileop for FreeBSD"
- @echo ""
- $(CC) -c -O $(CFLAGS) fileop.c -o fileop_freebsd.o
-
-fileop_netbsd.o: fileop.c
- @echo ""
- @echo "Building fileop for NetBSD"
- @echo ""
- $(CC) -c -O $(CFLAGS) fileop.c -o fileop_netbsd.o
-
-fileop_Solaris.o: fileop.c
- @echo ""
- @echo "Building fileop for Solaris"
- @echo ""
- $(CC) -c -O $(CFLAGS) fileop.c -o fileop_Solaris.o
-
-fileop_Solaris10.o: fileop.c
- @echo ""
- @echo "Building fileop for Solaris10"
- @echo ""
- $(CC) -c -O $(CFLAGS) fileop.c -o fileop_Solaris10.o
-
-fileop_Solaris10cc.o: fileop.c
- @echo ""
- @echo "Building fileop for Solaris10cc"
- @echo ""
- $(CC) -c -O $(CFLAGS) fileop.c -o fileop_Solaris10cc.o
-
-
-fileop_Solaris10gcc.o: fileop.c
- @echo ""
- @echo "Building fileop for Solaris10gcc"
- @echo ""
- $(GCC) -c -O $(CFLAGS) fileop.c -o fileop_Solaris10gcc.o
-
-fileop_Solaris10gcc-64.o: fileop.c
- @echo ""
- @echo "Building fileop for Solaris10gcc-64"
- @echo ""
- $(GCC) -c -O $(CFLAGS) $(S10GCCFLAGS) fileop.c -o fileop_Solaris10gcc-64.o
-
-fileop_Solaris10cc-64.o: fileop.c
- @echo ""
- @echo "Building fileop for Solaris10cc-64"
- @echo ""
- $(CC) -c -O $(CFLAGS) $(S10CCFLAGS) fileop.c -o fileop_Solaris10cc-64.o
-
-
-fileop_linux.o: fileop.c
- @echo ""
- @echo "Building fileop for Linux"
- @echo ""
- $(CC) -Wall -c -O3 $(CFLAGS) fileop.c -o fileop_linux.o
-
-fileop_openbsd.o: fileop.c
- @echo ""
- @echo "Building fileop for OpenBSD"
- @echo ""
- $(CC) -Wall -c -O $(CFLAGS) fileop.c -o fileop_openbsd.o
-
-fileop_macosx.o: fileop.c
- @echo ""
- @echo "Building fileop for MAC OS X"
- @echo ""
- $(CC) -Wall -c -O -Dmacosx $(CFLAGS) fileop.c -o fileop_macosx.o
-
-fileop_linux-ia64.o: fileop.c
- @echo ""
- @echo "Building fileop for Linux-ia64"
- @echo ""
- $(CC) -Wall -c -O3 $(CFLAGS) fileop.c -o fileop_linux-ia64.o
-
-fileop_linux-ppc.o: fileop.c
- @echo ""
- @echo "Building fileop for Linux-powerpc"
- @echo ""
- $(CC) -Wall -c -O3 $(CFLAGS) fileop.c -o fileop_linux-ppc.o
-
-fileop_linux-ppc64.o: fileop.c
- @echo ""
- @echo "Building fileop for Linux-powerpc64"
- @echo ""
- $(CC) -Wall -c -O3 $(CFLAGS) $(FLAG64BIT) fileop.c -o fileop_linux-ppc64.o
-
-fileop_linux-AMD64.o: fileop.c
- @echo ""
- @echo "Building fileop for Linux-AMD64"
- @echo ""
- $(CC) -Wall -c -O3 $(CFLAGS) fileop.c -o fileop_linux-AMD64.o
-
-fileop_linux-arm.o: fileop.c
- @echo ""
- @echo "Building fileop for Linux-arm"
- @echo ""
- $(GCC) -Wall -c -O3 $(CFLAGS) fileop.c -o fileop_linux-arm.o
-
-fileop_linux-s390.o: fileop.c
- @echo ""
- @echo "Building fileop for Linux-S390"
- @echo ""
- $(GCC) -Wall -c -O3 $(CFLAGS) fileop.c -o fileop_linux-s390.o
-
-fileop_linux-s390x.o: fileop.c
- @echo ""
- @echo "Building fileop for Linux-s390x"
- @echo ""
- $(GCC) -Wall -c -O3 $(CFLAGS) fileop.c -o fileop_linux-s390x.o
-
-fileop_windows.o: fileop.c
- @echo ""
- @echo "Building fileop for Windows"
- @echo ""
- $(GCC) -Wall -c -O3 $(CFLAGS) -DWindows fileop.c -o fileop_windows.o
-
-fileop_sua.o: fileop.c
- @echo ""
- @echo "Building fileop for Windows SUA"
- @echo ""
- $(GCC) -Wall -c -O3 $(CFLAGS) -D_SUA_ fileop.c -o fileop_sua.o
-
-iozone_linux-ia64.o: iozone.c libbif.c libasync.c
- @echo ""
- @echo "Building iozone for Linux-ia64"
- @echo ""
- $(CC) -c -O3 -Dunix -DHAVE_ANSIC_C -DASYNC_IO -DNAME='"linux-ia64"' \
- -DSHARED_MEM -Dlinux -D_LARGEFILE64_SOURCE $(CFLAGS) iozone.c \
- -o iozone_linux-ia64.o
- $(CC) -c -O3 -Dunix -DHAVE_ANSIC_C -DASYNC_IO -D_LARGEFILE64_SOURCE \
- -DSHARED_MEM -Dlinux $(CFLAGS) libbif.c -o libbif.o
- $(CC) -c -O3 -Dunix -Dlinux -DHAVE_ANSIC_C -DASYNC_IO \
- -D_LARGEFILE64_SOURCE $(CFLAGS) libasync.c -o libasync.o
-
-iozone_linux-arm.o: iozone.c libbif.c libasync.c
- @echo ""
- @echo "Building iozone for Linux-arm"
- @echo ""
- $(CC) -c -O3 -Dunix -DHAVE_ANSIC_C -DASYNC_IO -DHAVE_PREAD \
- -DNAME='"linux-arm"' -DLINUX_ARM -DSHARED_MEM \
- -Dlinux -D_LARGEFILE64_SOURCE $(CFLAGS) iozone.c \
- -o iozone_linux-arm.o
- $(CC) -c -O3 -Dunix -DHAVE_ANSIC_C -DASYNC_IO -D_LARGEFILE64_SOURCE \
- -DSHARED_MEM -Dlinux $(CFLAGS) libbif.c -o libbif.o
- $(CC) -c -O3 -Dunix -Dlinux -DHAVE_ANSIC_C -DASYNC_IO \
- -D_LARGEFILE64_SOURCE $(CFLAGS) libasync.c -o libasync.o
-
-iozone_linux-AMD64.o: iozone.c libbif.c libasync.c
- @echo ""
- @echo "Building iozone for Linux-AMD64"
- @echo ""
- $(CC) -c -O3 -Dunix -DHAVE_ANSIC_C -DASYNC_IO -DNAME='"linux-AMD64"' \
- -D__AMD64__ -DSHARED_MEM -Dlinux -D_LARGEFILE64_SOURCE \
- -DHAVE_PREAD $(CFLAGS) iozone.c -o iozone_linux-AMD64.o
- $(CC) -c -O3 -Dunix -DHAVE_ANSIC_C -DASYNC_IO -D_LARGEFILE64_SOURCE \
- -DSHARED_MEM -Dlinux $(CFLAGS) libbif.c -o libbif.o
- $(CC) -c -O3 -Dunix -Dlinux -DHAVE_ANSIC_C -DASYNC_IO \
- -D_LARGEFILE64_SOURCE $(CFLAGS) libasync.c -o libasync.o
-
-iozone_linux-s390.o: iozone.c libbif.c libasync.c
- @echo ""
- @echo "Building iozone for Linux-s390"
- @echo ""
- $(CC) -c -O3 -Dunix -DHAVE_ANSIC_C -DASYNC_IO -DHAVE_PREAD \
- -DSHARED_MEM -Dlinux -D_LARGEFILE64_SOURCE $(CFLAGS) iozone.c \
- -DNAME='"linux-s390"' -o iozone_linux-s390.o
- $(CC) -c -O3 -Dunix -DHAVE_ANSIC_C -DSHARED_MEM -Dlinux \
- -D_LARGEFILE64_SOURCE $(CFLAGS) libbif.c -o libbif.o
- $(CC) -c -O3 -Dunix -Dlinux -DHAVE_ANSIC_C -DASYNC_IO \
- -D_LARGEFILE64_SOURCE $(CFLAGS) libasync.c -o libasync.o
-
-iozone_linux-s390x.o: iozone.c libbif.c libasync.c
- @echo ""
- @echo "Building iozone for Linux-s390x"
- @echo ""
- $(CC) -c -O3 -Dunix -DHAVE_ANSIC_C -DASYNC_IO -DHAVE_PREAD \
- -DSHARED_MEM -Dlinux -D_LARGEFILE64_SOURCE $(CFLAGS) iozone.c \
- -DNAME='"linux-s390x"' -o iozone_linux-s390x.o
- $(CC) -c -O3 -Dunix -DHAVE_ANSIC_C -DSHARED_MEM -Dlinux \
- -D_LARGEFILE64_SOURCE $(CFLAGS) libbif.c -o libbif.o
- $(CC) -c -O3 -Dunix -Dlinux -DHAVE_ANSIC_C -DASYNC_IO \
- -D_LARGEFILE64_SOURCE $(CFLAGS) libasync.c -o libasync.o
-
-
-iozone_AIX.o: iozone.c libbif.c
- @echo ""
- @echo "Building iozone for AIX"
- @echo ""
- $(CC) -c -O -D__AIX__ -D_NO_PROTO -Dunix -DHAVE_ANSIC_C \
- -DNAME='"AIX"' -DSHARED_MEM $(CFLAGS) iozone.c -o iozone_AIX.o
- $(CC) -c -O -D__AIX__ -D_NO_PROTO -Dunix -DHAVE_ANSIC_C \
- -DSHARED_MEM $(CFLAGS) libbif.c -o libbif.o
-
-iozone_AIX-LF.o: iozone.c libbif.c
- @echo ""
- @echo "Building iozone for AIX with Large files"
- @echo ""
- $(CC) -c -O -D__AIX__ -D_NO_PROTO -Dunix -DHAVE_ANSIC_C \
- -DSHARED_MEM -D_LARGEFILE64_SOURCE -D_LARGE_FILES \
- -DNAME='"AIX-LF"' $(CFLAGS) iozone.c -o iozone_AIX-LF.o
- $(CC) -c -O -D__AIX__ -D_NO_PROTO -Dunix -DHAVE_ANSIC_C \
- -DSHARED_MEM -D_LARGEFILE64_SOURCE -D_LARGE_FILES \
- $(CFLAGS) libbif.c -o libbif.o
-
-iozone_AIX64.o: iozone.c libbif.c libasync.c
- @echo ""
- @echo "Building iozone for AIX64"
- @echo ""
- $(GCC) -maix64 -c -O3 -D__AIX__ -D_NO_PROTO -Dunix -DHAVE_ANSIC_C \
- -DASYNC_IO -DNAME='"AIX64"' -DSHARED_MEM \
- $(CFLAGS) iozone.c -o iozone_AIX64.o
- $(GCC) -maix64 -c -O3 -D__AIX__ -D_NO_PROTO -Dunix -DHAVE_ANSIC_C \
- -DASYNC_IO -DSHARED_MEM $(CFLAGS) libbif.c -o libbif.o
- $(GCC) -maix64 -c -O3 -Dunix -Dlinux -DHAVE_ANSIC_C -DASYNC_IO \
- $(CFLAGS) libasync.c -o libasync.o
-
-iozone_AIX64-LF.o: iozone.c libbif.c libasync.c
- @echo ""
- @echo "Building iozone for AIX64 with Large files"
- @echo ""
- $(GCC) -maix64 -c -O3 -D__AIX__ -D_NO_PROTO -Dunix -DHAVE_ANSIC_C \
- -DASYNC_IO -DNAME='"AIX64-LF"' -DSHARED_MEM \
- -D_LARGEFILE64_SOURCE -D_LARGE_FILES \
- $(CFLAGS) iozone.c -o iozone_AIX64-LF.o
- $(GCC) -maix64 -c -O3 -D__AIX__ -D_NO_PROTO -Dunix -DHAVE_ANSIC_C \
- -DASYNC_IO -DSHARED_MEM -D_LARGEFILE64_SOURCE -D_LARGE_FILES \
- $(CFLAGS) libbif.c -o libbif.o
- $(GCC) -maix64 -c -O3 -Dunix -Dlinux -DHAVE_ANSIC_C -DASYNC_IO \
- -D_LARGEFILE64_SOURCE -D_LARGE_FILES \
- $(CFLAGS) libasync.c -o libasync.o
-
-iozone_solaris.o: iozone.c libasync.c libbif.c
- @echo ""
- @echo "Building iozone for Solaris"
- @echo ""
- $(CC) -c -O -Dunix -DHAVE_ANSIC_C -DASYNC_IO \
- -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -Dsolaris \
- -DNAME='"Solaris"' $(CFLAGS) iozone.c -o iozone_solaris.o
- $(CC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -D__LP64__ \
- -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -Dsolaris \
- $(CFLAGS) libasync.c -o libasync.o
- $(CC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -D__LP64__ \
- -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -Dsolaris \
- $(CFLAGS) libbif.c -o libbif.o
-
-iozone_solaris7gcc.o: iozone.c libasync.c libbif.c
- @echo ""
- @echo "Building iozone for Solaris7gcc"
- @echo ""
- $(GCC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -D__LP64__ \
- -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -Dsolaris \
- -DNAME='"Solaris7gcc"' $(CFLAGS) libasync.c -o libasync7.o
- $(GCC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -D__LP64__ \
- -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -Dsolaris \
- $(CFLAGS) libbif.c -o libbif7.o
- $(GCC) -c -O -Dunix -DHAVE_ANSIC_C -DASYNC_IO \
- -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -Dsolaris \
- -DNAME='"Solaris7gcc"' $(CFLAGS) iozone.c -o iozone_solaris7gcc.o
-
-iozone_solaris10.o: iozone.c libbif.c
- @echo ""
- @echo "Building iozone for Solaris10"
- @echo ""
- $(CC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -D__LP64__ \
- -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -Dsolaris \
- $(CFLAGS) libbif.c -o libbif10.o
- $(CC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -D__LP64__ \
- -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -Dsolaris \
- -DNAME='"Solaris10"' $(CFLAGS) libasync.c -o libasync10.o
- $(CC) -c -O -Dunix -DHAVE_ANSIC_C -DASYNC_IO -Dstudio11 \
- -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -Dsolaris \
- -DNAME='"Solaris10"' $(CFLAGS) iozone.c -o iozone_solaris10.o
-
-iozone_solaris10cc.o: iozone.c libbif.c
- @echo ""
- @echo "Building iozone for Solaris10cc"
- @echo ""
- $(CC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -D__LP64__ \
- -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -Dsolaris \
- $(CFLAGS) libbif.c -o libbif10cc.o
- $(CC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -D__LP64__ \
- -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -Dsolaris \
- -DNAME='"Solaris10"' $(CFLAGS) libasync.c -o libasync10cc.o
- $(CC) -c -O -Dunix -DHAVE_ANSIC_C -DASYNC_IO -Dstudio11 \
- -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -Dsolaris \
- -DNAME='"Solaris10"' $(CFLAGS) iozone.c -o iozone_solaris10cc.o
-
-iozone_solaris10gcc.o: iozone.c libbif.c
- @echo ""
- @echo "Building iozone for Solaris10gcc"
- @echo ""
- $(GCC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -D__LP64__ \
- -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -Dsolaris \
- $(CFLAGS) libbif.c -o libbif10.o
- $(GCC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -D__LP64__ \
- -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -Dsolaris \
- -DNAME='"Solaris10gcc"' $(CFLAGS) libasync.c -o libasync10.o
- $(GCC) -c -O -Dunix -DHAVE_ANSIC_C -DASYNC_IO \
- -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -Dsolaris \
- -DNAME='"Solaris10gcc"' $(CFLAGS) iozone.c -o iozone_solaris10gcc.o
-
-iozone_solaris10gcc-64.o: iozone.c libbif.c
- @echo ""
- @echo "Building iozone for Solaris10gcc-64"
- @echo ""
- $(GCC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -D__LP64__ \
- -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -Dsolaris \
- $(CFLAGS) $(S10GCCFLAGS) libbif.c -o libbif10-64.o
- $(GCC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -D__LP64__ \
- -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -Dsolaris \
- -DNAME='"Solaris10gcc-64"' $(CFLAGS) $(S10GCCFLAGS) libasync.c -o libasync10-64.o
- $(GCC) -c -O -Dunix -DHAVE_ANSIC_C -DASYNC_IO \
- -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -Dsolaris \
- -DNAME='"Solaris10gcc-64"' $(CFLAGS) $(S10GCCFLAGS) iozone.c -o iozone_solaris10gcc-64.o
-
-iozone_solaris10cc-64.o: iozone.c libbif.c
- @echo ""
- @echo "Building iozone for Solaris10cc-64"
- @echo ""
- $(CC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -D__LP64__ \
- -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -Dsolaris \
- $(CFLAGS) $(S10CCFLAGS) libbif.c -o libbif10-64.o
- $(CC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -D__LP64__ \
- -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -Dsolaris \
- -DNAME='"Solaris10cc-64"' $(CFLAGS) $(S10CCFLAGS) libasync.c -o libasync10-64.o
- $(CC) -c -O -Dunix -DHAVE_ANSIC_C -DASYNC_IO -Dstudio11 \
- -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -Dsolaris \
- -DNAME='"Solaris10cc-64"' $(CFLAGS) $(S10CCFLAGS) iozone.c -o iozone_solaris10cc-64.o
-
-
-#
-# -DSHARED_MEM -Dsolaris libasync.c -o libasync.o
-# -DSHARED_MEM -Dsolaris iozone.c -o iozone_solaris.o
-#
-
-iozone_solaris-2.6.o: iozone.c libbif.c
- @echo ""
- @echo "Building iozone for Solaris-2.6"
- @echo ""
- $(CC) -c -O -Dunix -DHAVE_ANSIC_C -DNO_THREADS \
- -DNAME='"Solaris-2.6"' -Dsolaris $(CFLAGS) iozone.c -o iozone_solaris-2.6.o
- $(CC) -O -c -Dunix -DHAVE_ANSIC_C \
- -Dsolaris $(CFLAGS) libbif.c -o libbif.o
-
-iozone_solaris8-64.o: iozone.c libasync.c libbif.c
- @echo ""
- @echo "Building iozone for Solaris8-64"
- @echo ""
- $(CC) -fast -xtarget=generic64 -v -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO \
- -D__LP64__ -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 \
- -DNAME='"Solaris8-64"' -Dsolaris -DHAVE_PREAD \
- $(CFLAGS) iozone.c -o iozone_solaris8-64.o
- $(CC) -fast -xtarget=generic64 -v -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO \
- -D__LP64__ -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 \
- -Dsolaris -DHAVE_PREAD $(CFLAGS) libasync.c -o libasync.o
- $(CC) -fast -xtarget=generic64 -v -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO \
- -D__LP64__ -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 \
- -Dsolaris -DHAVE_PREAD $(CFLAGS) libbif.c -o libbif.o
-
-iozone_solaris8-64-VXFS.o: iozone.c libasync.c libbif.c
- @echo ""
- @echo "Building iozone for Solaris8-64-VXFS"
- @echo ""
- $(CC) -fast -xtarget=generic64 -v -c -I/opt/VRTSvxfs/include/ -Dunix \
- -DVXFS -DHAVE_ANSIC_C -DASYNC_IO \
- -D__LP64__ -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 \
- -DNAME='"Solaris8-64"' -Dsolaris -DHAVE_PREAD \
- $(CFLAGS) iozone.c -o iozone_solaris8-64-VXFS.o
- $(CC) -fast -xtarget=generic64 -v -c -I/opt/VRTSvxfs/include/ -Dunix \
- -DVXFS -DHAVE_ANSIC_C -DASYNC_IO \
- -D__LP64__ -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 \
- -Dsolaris -DHAVE_PREAD $(CFLAGS) libasync.c -o libasync.o
- $(CC) -fast -xtarget=generic64 -v -c -I/opt/VRTSvxfs/include/ -Dunix \
- -DVXFS -DHAVE_ANSIC_C -DASYNC_IO \
- -D__LP64__ -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 \
- -Dsolaris -DHAVE_PREAD $(CFLAGS) libbif.c -o libbif.o
-
-iozone_windows.o: iozone.c libasync.c libbif.c fileop.c
- @echo ""
- @echo "Building iozone for Windows (No async I/O)"
- @echo ""
- $(GCC) -c -O -Dunix -DHAVE_ANSIC_C -DNO_MADVISE \
- -DWindows $(CFLAGS) -DDONT_HAVE_O_DIRECT iozone.c \
- -o iozone_windows.o
- $(GCC) -c -O -Dunix -DHAVE_ANSIC_C -DNO_MADVISE \
- -DWindows $(CFLAGS) libbif.c -o libbif.o
-
-
-# -D_SUA_ $(CFLAGS) -DDONT_HAVE_O_DIRECT iozone.c \
-
-iozone_sua.o: iozone.c libasync.c libbif.c fileop.c
- @echo ""
- @echo "Building iozone for Windows SUA (No async I/O)"
- @echo ""
- $(GCC) -c -O -Dunix -DHAVE_ANSIC_C -D_XOPEN_SOURCE -DNO_MADVISE \
- -D_SUA_ $(CFLAGS) iozone.c \
- -DNAME='"Windows SUA"' -o iozone_sua.o
- $(GCC) -c -O -Dunix -D_SUA_ -D_XOPEN_SOURCE -DHAVE_ANSIC_C \
- -DNO_MADVISE $(CFLAGS) libbif.c -o libbif.o
-
-iozone_uwin.o: iozone.c libbif.c
- @echo ""
- @echo "Building iozone for UWIN (No threads, No async I/O)"
- @echo ""
- $(GCC) -c -O -DUWIN -Dunix -DHAVE_ANSIC_C -DNO_THREADS -DNO_MADVISE \
- -DNAME='"UWIN"' -DSHARED_MEM -DWindows $(CFLAGS) iozone.c -o iozone_uwin.o
- $(GCC) -c -O -DUWIN -Dunix -DHAVE_ANSIC_C -DNO_THREADS -DNO_MADVISE \
- -DSHARED_MEM -DWindows $(CFLAGS) libbif.c -o libbif.o
-
-iozone_IRIX64.o: iozone.c libasync.c libbif.c
- @echo ""
- @echo "Building iozone for IRIX64"
- @echo ""
- $(CC) -32 -O -c -Dunix -DHAVE_ANSIC_C -D_LARGEFILE64_SOURCE -DASYNC_IO \
- -DNAME='"IRIX64"' -DIRIX64 -DSHARED_MEM $(CFLAGS) iozone.c -o iozone_IRIX64.o
- $(CC) -32 -O -c -Dunix -DHAVE_ANSIC_C -D_LARGEFILE64_SOURCE -DASYNC_IO \
- -DIRIX64 -DSHARED_MEM $(CFLAGS) libasync.c -o libasyncw.o
- $(CC) -32 -O -c -Dunix -DHAVE_ANSIC_C -D_LARGEFILE64_SOURCE -DASYNC_IO \
- -DIRIX64 -DSHARED_MEM $(CFLAGS) libbif.c -o libbif.o
-
-iozone_IRIX.o: iozone.c libasync.c libbif.c
- @echo ""
- @echo "Building iozone for IRIX"
- @echo ""
- $(CC) -O -32 -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO \
- -DNAME='"IRIX"' -DIRIX -DSHARED_MEM $(CFLAGS) iozone.c -o iozone_IRIX.o
- $(CC) -O -32 -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO \
- -DIRIX -DSHARED_MEM $(CFLAGS) libasync.c -o libasync.o
- $(CC) -O -32 -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO \
- -DIRIX -DSHARED_MEM $(CFLAGS) libbif.c -o libbif.o
-
-iozone_CrayX1.o: iozone.c libasync.c libbif.c
- @echo ""
- @echo "Building iozone for CrayX1"
- @echo ""
- $(CC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -D_LARGEFILE64_SOURCE \
- -DNAME='"CrayX1"' -DIRIX64 -DSHARED_MEM -D__CrayX1__ \
- $(CFLAGS) iozone.c -o iozone_CrayX1.o
- $(CC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -D_LARGEFILE64_SOURCE \
- -DIRIX64 -DSHARED_MEM -D__CrayX1__ \
- $(CFLAGS) libasync.c -o libasyncw.o
- $(CC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -D_LARGEFILE64_SOURCE \
- -DIRIX64 -DSHARED_MEM -D__CrayX1__ $(CFLAGS) libbif.c \
- -o libbif.o
-
-iozone_sppux.o: iozone.c libbif.c
- @echo ""
- @echo "Building iozone for SPP-UX using Convex compiler"
- @echo ""
- $(NACC) -c -O -Dunix -D_HPUX_SOURCE -D__convex_spp \
- -DNAME='"sppux"' -Wl,+parallel -DHAVE_ANSIC_C -DHAVE_PREAD \
- -DHAVE_PREADV $(CFLAGS) iozone.c -o iozone_sppux.o
- $(NACC) -O -Dunix -D_HPUX_SOURCE -D__convex_spp \
- -Wl,+parallel -DHAVE_ANSIC_C -DHAVE_PREAD -DHAVE_PREADV \
- $(CFLAGS) libbif.c -o libbif.o
-
-iozone_sppux-10.1.o: iozone.c libbif.c
- @echo ""
- @echo "Building iozone for SPP-UX using HP ansic compiler"
- @echo ""
- $(NACC) -c -O -Dunix -D_HPUX_SOURCE -D__convex_spp \
- -DHAVE_ANSIC_C -DHAVE_PREAD -DHAVE_PREADV $(CFLAGS) iozone.c \
- -DNAME='"sppux-10.1"' -Wl,+parallel -o iozone_sppux-10.1.o
- $(NACC) -c -O -Dunix -D_HPUX_SOURCE -D__convex_spp \
- -DHAVE_ANSIC_C -DHAVE_PREAD -DHAVE_PREADV \
- $(CFLAGS) libbif.c -Wl,+parallel -o libbif.o
-
-iozone_sppux_no-10.1.o: iozone.c libbif.c
- @echo ""
- @echo "Building iozone for SPP-UX no ANSI c compiler"
- @echo ""
- $(CCS) -c -O -Dunix -D_HPUX_SOURCE -D__convex_spp \
- -DNAME='"sppux_no_ansi_10.1"' -Wl,+parallel -DHAVE_PREAD \
- -DHAVE_PREADV $(CFLAGS) iozone.c -o iozone_sppux_no-10.1.o
- $(CCS) -c -O -Dunix -D_HPUX_SOURCE -D__convex_spp \
- -Wl,+parallel -DHAVE_PREAD -DHAVE_PREADV $(CFLAGS) \
- libbif.c -o libbif.o
-
-iozone_convex.o: iozone.c libbif.c
- @echo ""
- @echo "Building iozone for Convex 'C' series"
- @echo ""
- $(CC) -c -O -Dunix -DNO_THREADS -Dbsd4_2 $(CFLAGS) iozone.c \
- -DNAME='"Convex"' -o iozone_convex.o
- $(CC) -c -O -Dunix -DNO_THREADS -Dbsd4_2 \
- $(CFLAGS) libbif.c -o libbif.o
-
-iozone_bsdi.o: iozone.c libbif.c
- @echo ""
- @echo "Build iozone for BSD/OS"
- @echo ""
- $(CC) -c -O -Dunix -Dbsd4_4 -DHAVE_ANSIC_C \
- -DNAME='"bsdi"' $(CFLAGS) iozone.c -o iozone_bsdi.o
- $(CC) -c -O -Dunix -Dbsd4_4 -DHAVE_ANSIC_C \
- $(CFLAGS) libbif.c -o libbif.o
-
-iozone_freebsd.o: iozone.c libbif.c libasync.c
- @echo ""
- @echo "Build iozone for FreeBSD"
- @echo ""
- $(CC) -c ${CFLAGS} -DFreeBSD -Dunix -Dbsd4_4 -DHAVE_ANSIC_C -DASYNC_IO \
- -DHAVE_PREAD -DNAME='"freebsd"' -DSHARED_MEM \
- $(CFLAGS) iozone.c -o iozone_freebsd.o
- $(CC) -c ${CFLAGS} -DFreeBSD -Dunix -Dbsd4_4 -DHAVE_ANSIC_C -DASYNC_IO \
- -DSHARED_MEM -DHAVE_PREAD $(CFLAGS) libbif.c \
- -o libbif.o
- $(CC) -c ${CFLAGS} -DFreeBSD -Dunix -Dbsd4_4 -DHAVE_ANSIC_C -DASYNC_IO \
- -DSHARED_MEM -DHAVE_PREAD $(CFLAGS) libasync.c \
- -o libasync.o
-
-iozone_dragonfly.o: iozone.c libbif.c
- @echo ""
- @echo "Build iozone for DragonFly"
- @echo ""
- $(CC) -c ${CFLAGS} -D__DragonFly__ -Dunix -DHAVE_ANSIC_C -DNO_THREADS \
- -DNAME='"dragonfly"' -DSHARED_MEM -DHAVE_PREAD -DHAVE_PREADV \
- $(CFLAGS) iozone.c -o iozone_dragonfly.o
- $(CC) -c ${CFLAGS} -D__DragonFly__ -Dunix -DHAVE_ANSIC_C -DNO_THREADS \
- -DSHARED_MEM -DHAVE_PREAD -DHAVE_PREADV $(CFLAGS) libbif.c \
- -o libbif.o
-
-iozone_macosx.o: iozone.c libbif.c
- @echo ""
- @echo "Build iozone for MacOSX"
- @echo ""
- $(CC) -c -O -Dunix -Dbsd4_2 -Dmacosx -DHAVE_ANSIC_C -DNO_THREADS \
- -DNAME='"macosx"' -DSHARED_MEM $(CFLAGS) iozone.c -o iozone_macosx.o
- $(CC) -c -O -Dunix -Dbsd4_2 -Dmacosx -DHAVE_ANSIC_C -DNO_THREADS \
- -DSHARED_MEM $(CFLAGS) libbif.c -o libbif.o
-
-iozone_openbsd.o: iozone.c libbif.c
- @echo ""
- @echo "Build iozone for OpenBSD"
- @echo ""
- $(CC) -c -O -Dunix -Dbsd4_4 -DHAVE_ANSIC_C -DNO_THREADS \
- -DNAME='"openbsd"' -DSHARED_MEM $(CFLAGS) iozone.c -o iozone_openbsd.o
- $(CC) -c -O -Dunix -Dbsd4_4 -DHAVE_ANSIC_C -DNO_THREADS \
- -DSHARED_MEM $(CFLAGS) libbif.c -o libbif.o
-
-iozone_openbsd-threads.o: iozone.c libbif.c
- @echo ""
- @echo "Build iozone for OpenBSD with threads"
- @echo ""
- $(CC) -c -O -pthread -Dunix -Dbsd4_4 -DHAVE_ANSIC_C \
- -DNAME='"openbsd-threads"' $(CFLAGS) iozone.c \
- -o iozone_openbsd-threads.o
- $(CC) -c -O -pthread -Dunix -Dbsd4_4 -DHAVE_ANSIC_C \
- $(CFLAGS) libbif.c -o libbif.o
-
-iozone_OSFV3.o: iozone.c libbif.c
- @echo ""
- @echo "Build iozone for OSFV3"
- @echo ""
- $(CC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -DOSFV3 \
- -DNAME='"OSFV3"' -DNO_PRINT_LLD -DOSF_64 $(CFLAGS) iozone.c \
- -o iozone_OSFV3.o
- $(CC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -DOSFV3 \
- -DNO_PRINT_LLD -DOSF_64 $(CFLAGS) libbif.c -o libbif.o
- $(CC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -DOSFV3 \
- -DNO_PRINT_LLD -DOSF_64 $(CFLAGS) libasync.c -o libasync.o
-
-iozone_OSFV4.o: iozone.c libbif.c
- @echo ""
- @echo "Build iozone for OSFV4"
- @echo ""
- $(CC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -DOSFV4 \
- -DNAME='"OSFV4"' -DNO_PRINT_LLD -DOSF_64 $(CFLAGS) iozone.c \
- -o iozone_OSFV4.o
- $(CC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -DOSFV4 \
- -DNO_PRINT_LLD -DOSF_64 $(CFLAGS) libbif.c -o libbif.o
- $(CC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -DOSFV4 \
- -DNO_PRINT_LLD -DOSF_64 $(CFLAGS) libasync.c -o libasync.o
-
-iozone_OSFV5.o: iozone.c libbif.c
- @echo ""
- @echo "Build iozone for OSFV5"
- @echo ""
- $(CC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -DOSFV5 \
- -DNAME='"OSFV5"' -DNO_PRINT_LLD -DOSF_64 $(CFLAGS) iozone.c \
- -o iozone_OSFV5.o
- $(CC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -DOSFV5 \
- -DNO_PRINT_LLD -DOSF_64 $(CFLAGS) libbif.c -o libbif.o
- $(CC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -DOSFV5 \
- -DNO_PRINT_LLD -DOSF_64 $(CFLAGS) libasync.c -o libasync.o
-
-iozone_TRU64.o: iozone.c libbif.c
- @echo ""
- @echo "Build iozone for TRU64"
- @echo ""
- $(CC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -DOSFV5 -DTRU64 -DHAVE_PREAD \
- -DNAME='"TRU64"' -DNO_PRINT_LLD -DOSF_64 -pthread $(CFLAGS) iozone.c \
- -o iozone_TRU64.o
- $(CC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -DOSFV5 -DHAVE_PREAD \
- -DNO_PRINT_LLD -DOSF_64 $(CFLAGS) libbif.c -o libbif.o
- $(CC) -O -c -Dunix -DHAVE_ANSIC_C -DASYNC_IO -DOSFV5 -DHAVE_PREAD \
- -DNO_PRINT_LLD -DOSF_64 $(CFLAGS) libasync.c -o libasync.o
-
-iozone_SCO.o: iozone.c libbif.c
- @echo ""
- @echo "Building iozone SCO "
- @echo ""
- $(GCC) -c -O -DSCO -Dunix -DHAVE_ANSIC_C -DNO_THREADS -DNO_MADVISE \
- -DNAME='"SCO"' $(CFLAGS) iozone.c -o iozone_SCO.o
- $(GCC) -c -O -DSCO -Dunix -DHAVE_ANSIC_C -DNO_THREADS -DNO_MADVISE \
- $(CFLAGS) libbif.c -o libbif.o
-
-iozone_SCO_Unixware_gcc.o: iozone.c libbif.c libasync.c
- @echo ""
- @echo "Building iozone SCO_Unixware_gcc "
- @echo ""
- $(GCC) -c -O -DSCO_Unixware_gcc -Dunix -DHAVE_ANSIC_C \
- -DASYNC_IO -D_LARGEFILE64_SOURCE $(CFLAGS) iozone.c \
- -DNAME='"SCO_Unixware_gcc"' -o iozone_SCO_Unixware_gcc.o
- $(GCC) -c -O -DSCO_Unixware_gcc -Dunix -DHAVE_ANSIC_C \
- -DASYNC_IO -D_LARGEFILE64_SOURCE $(CFLAGS) libbif.c -o libbif.o
- $(GCC) -c -O -DSCO_Unixware_gcc -Dunix -DHAVE_ANSIC_C \
- -DASYNC_IO -D_LARGEFILE64_SOURCE $(CFLAGS) libasync.c -o libasync.o
-
-iozone_netbsd.o: iozone.c libbif.c
- @echo ""
- @echo "Building iozone NetBSD "
- @echo ""
- $(CC) -c -O -Dunix -Dbsd4_4 -DHAVE_ANSIC_C -DNO_THREADS \
- -DNAME='"netbsd"' -DSHARED_MEM $(CFLAGS) iozone.c -o iozone_netbsd.o
- $(CC) -c -O -Dunix -Dbsd4_4 -DHAVE_ANSIC_C -DNO_THREADS \
- -DSHARED_MEM $(CFLAGS) libbif.c -o libbif.o
diff --git a/src/components/appio/tests/iozone/pit_server.c b/src/components/appio/tests/iozone/pit_server.c
deleted file mode 100644
index 638e2f0d4..000000000
--- a/src/components/appio/tests/iozone/pit_server.c
+++ /dev/null
@@ -1,831 +0,0 @@
-/******************************************************************************
-* File: pit_server.c
-*
-* Description: Contains source code for an IPv6-capable 'PIT' server.
-* This is a derivative of the tod6 (time-of-day) server that was written
-* by John Wenker.
-* .......
-* Author of tod6: John Wenker, Sr. Software Engineer,
-* Performance Technologies, San Diego, USA
-* .......
-* The program tod6 was a time of day server. It has beeen modified
-* to provide a microsecond timestamp on request. Modified and adapted
-* for PIT purposes by Don Capps. [ capps@iozone.org ]
-*
-* This server sends the current value of gettimeofday() in
-* microseconds back to the client, as a numerical string.
-*
-* /etc/services should contain "PIT" with a specified port value.
-*
-******************************************************************************/
-/*
-** System header files.
-*/
-#include <errno.h> /* errno declaration & error codes. */
-#include <netdb.h> /* getaddrinfo(3) et al. */
-#include <netinet/in.h> /* sockaddr_in & sockaddr_in6 definition. */
-#include <stdio.h> /* printf(3) et al. */
-#include <stdlib.h> /* exit(2). */
-#include <string.h> /* String manipulation & memory functions. */
-#if defined(_SUA_)
-#include <poll.h> /* poll(2) and related definitions. */
-#else
-#include <sys/poll.h> /* poll(2) and related definitions. */
-#endif
-#include <sys/socket.h> /* Socket functions (socket(2), bind(2), etc). */
-#include <time.h> /* time(2) & ctime(3). */
-#include <sys/time.h> /* gettimeofday */
-#include <unistd.h> /* getopt(3), read(2), etc. */
-/* Include for Cygnus development environment for Windows */
-#if defined (Windows)
-#include <Windows.h>
-int errno;
-#endif
-
-#if defined(_SUA_)
-extern char *optarg, *opterr;
-#endif
-
-/*
-** Constants.
-**
-** Please remember to add PIT service to the /etc/services file.
-*/
-#define DFLT_SERVICE "PIT" /* Programmable Interdimensional Timer */
-
-#define INVALID_DESC -1 /* Invalid file descriptor. */
-#define MAXCONNQLEN 3 /* Max nbr of connection requests to queue. */
-#define MAXTCPSCKTS 2 /* One TCP socket for IPv4 & one for IPv6. */
-#define MAXUDPSCKTS 2 /* One UDP socket for IPv4 & one for IPv6. */
-#define VALIDOPTS "vh:p:" /* Valid command options. */
-/*
-** Simple boolean type definition.
-*/
-int false = 0;
-int true = 1;
-/*
-** Prototypes for internal helper functions.
-*/
-static int openSckt( const char *service,
- const char *protocol,
- int desc[ ],
- size_t *descSize );
-static void pit( int tSckt[ ],
- size_t tScktSize,
- int uSckt[ ],
- size_t uScktSize );
-/*
-** Global data objects.
-*/
-static char hostBfr[ NI_MAXHOST ]; /* For use w/getnameinfo(3). */
-static const char *pgmName; /* Program name w/o dir prefix. */
-static char servBfr[ NI_MAXSERV ]; /* For use w/getnameinfo(3). */
-static int verbose = 0; /* Verbose mode indication. */
-struct timeval tm; /* Timeval structure, used with gettimeofday() */
-char timeStr[40]; /* String for time in microseconds */
-char service_name[20];
-int need;
-/*
-** Usage macro for command syntax violations.
-*/
-#define USAGE \
- { \
- fprintf( stderr, \
- "Usage: %s [-v] -p service \n", \
- pgmName ); \
- exit( 127 ); \
- } /* End USAGE macro. */
-/*
-** Macro to terminate the program if a system call error occurs. The system
-** call must be one of the usual type that returns -1 on error.
-*/
-#define CHK(expr) \
- do \
- { \
- if ( (expr) == -1 ) \
- { \
- fprintf( stderr, \
- "%s (line %d): System call ERROR - %s.\n", \
- pgmName, \
- __LINE__, \
- strerror( errno ) ); \
- exit( 1 ); \
- } /* End IF system call failed. */ \
- } while ( false )
-/******************************************************************************
-* Function: main
-*
-* Description:
-* Set up a PIT server and handle network requests. This server
-* handles both TCP and UDP requests.
-*
-* Parameters:
-* The usual argc and argv parameters to a main() function.
-*
-* Return Value:
-* This is a daemon program and never returns. However, in the degenerate
-* case where no sockets are created, the function returns zero.
-******************************************************************************/
-int main( int argc,
- char *argv[ ] )
-{
- int opt;
- int tSckt[ MAXTCPSCKTS ]; /* Array of TCP socket descriptors. */
- size_t tScktSize = MAXTCPSCKTS; /* Size of uSckt (# of elements). */
- int uSckt[ MAXUDPSCKTS ]; /* Array of UDP socket descriptors. */
- size_t uScktSize = MAXUDPSCKTS; /* Size of uSckt (# of elements). */
-
- strcpy(service_name,DFLT_SERVICE);
- /*
- ** Set the program name (w/o directory prefix).
- */
- pgmName = strrchr( argv[ 0 ], '/' );
- pgmName = pgmName == NULL ? argv[ 0 ] : pgmName + 1;
- /*
- ** Process command options.
- */
- opterr = 0; /* Turns off "invalid option" error messages. */
- while ( ( opt = getopt( argc, argv, VALIDOPTS ) ) >= 0 )
- {
- switch ( opt )
- {
- case 'v': /* Verbose mode. */
- {
- verbose = true;
- break;
- }
- case 'p': /* Get the port number */
- {
- strcpy(service_name,optarg);
- need++;
- break;
- }
- default:
- {
- USAGE;
- }
- } /* End SWITCH on command option. */
- } /* End WHILE processing options. */
-
- if(need < 1)
- {
- USAGE;
- exit;
- }
- /*
- ** Open both a TCP and UDP socket, for both IPv4 & IPv6, on which to receive
- ** service requests.
- */
- if ( ( openSckt( service_name, "tcp", tSckt, &tScktSize ) < 0 ) ||
- ( openSckt( service_name, "udp", uSckt, &uScktSize ) < 0 ) )
- {
- exit( 1 );
- }
- /*
- ** Run the Programmable Interdimensional Timer server.
- */
- if ( ( tScktSize > 0 ) || ( uScktSize > 0 ) )
- {
- pit( tSckt, /* pit() never returns. */
- tScktSize,
- uSckt,
- uScktSize );
- }
- /*
- ** Since pit() never returns, execution only gets here if no sockets were
- ** created.
- */
- if ( verbose )
- {
- fprintf( stderr,
- "%s: No sockets opened... terminating.\n",
- pgmName );
- }
- return 0;
-} /* End main() */
-/******************************************************************************
-* Function: openSckt
-*
-* Description:
-* Open passive (server) sockets for the indicated inet service & protocol.
-* Notice in the last sentence that "sockets" is plural. During the interim
-* transition period while everyone is switching over to IPv6, the server
-* application has to open two sockets on which to listen for connections...
-* one for IPv4 traffic and one for IPv6 traffic.
-*
-* Parameters:
-* service - Pointer to a character string representing the well-known port
-* on which to listen (can be a service name or a decimal number).
-* protocol - Pointer to a character string representing the transport layer
-* protocol (only "tcp" or "udp" are valid).
-* desc - Pointer to an array into which the socket descriptors are
-* placed when opened.
-* descSize - This is a value-result parameter. On input, it contains the
-* max number of descriptors that can be put into 'desc' (i.e. the
-* number of elements in the array). Upon return, it will contain
-* the number of descriptors actually opened. Any unused slots in
-* 'desc' are set to INVALID_DESC.
-*
-* Return Value:
-* 0 on success, -1 on error.
-******************************************************************************/
-static int openSckt( const char *service,
- const char *protocol,
- int desc[ ],
- size_t *descSize )
-{
- struct addrinfo *ai;
- int aiErr;
- struct addrinfo *aiHead;
- struct addrinfo hints = { .ai_flags = AI_PASSIVE, /* Server mode. */
- .ai_family = PF_UNSPEC }; /* IPv4 or IPv6. */
- size_t maxDescs = *descSize;
- /*
- ** Initialize output parameters. When the loop completes, *descSize is 0.
- */
- while ( *descSize > 0 )
- {
- desc[ --( *descSize ) ] = INVALID_DESC;
- }
- /*
- ** Check which protocol is selected (only TCP and UDP are valid).
- */
- if ( strcmp( protocol, "tcp" ) == 0 ) /* TCP protocol. */
- {
- hints.ai_socktype = SOCK_STREAM;
- hints.ai_protocol = IPPROTO_TCP;
- }
- else if ( strcmp( protocol, "udp" ) == 0 ) /* UDP protocol. */
- {
- hints.ai_socktype = SOCK_DGRAM;
- hints.ai_protocol = IPPROTO_UDP;
- }
- else /* Invalid protocol. */
- {
- fprintf( stderr,
- "%s (line %d): ERROR - Unknown transport "
- "layer protocol \"%s\".\n",
- pgmName,
- __LINE__,
- protocol );
- return -1;
- }
- /*
- ** Look up the service's "well-known" port number. Notice that NULL is being
- ** passed for the 'node' parameter, and that the AI_PASSIVE flag is set in
- ** 'hints'. Thus, the program is requesting passive address information.
- ** The network address is initialized to :: (all zeros) for IPv6 records, or
- ** 0.0.0.0 for IPv4 records.
- */
- if ( ( aiErr = getaddrinfo( NULL,
- service,
- &hints,
- &aiHead ) ) != 0 )
- {
- fprintf( stderr,
- "%s (line %d): ERROR - %s.\n",
- pgmName,
- __LINE__,
- gai_strerror( aiErr ) );
- return -1;
- }
- /*
- ** For each of the address records returned, attempt to set up a passive
- ** socket.
- */
- for ( ai = aiHead;
- ( ai != NULL ) && ( *descSize < maxDescs );
- ai = ai->ai_next )
- {
- if ( verbose )
- {
- /*
- ** Display the current address info. Start with the protocol-
- ** independent fields first.
- */
- fprintf( stderr,
- "Setting up a passive socket based on the "
- "following address info:\n"
- " ai_flags = %#02X\n"
- " ai_family = %d (PF_INET = %d, PF_INET6 = %d)\n"
- " ai_socktype = %d (SOCK_STREAM = %d, SOCK_DGRAM = %d)\n"
- " ai_protocol = %d (IPPROTO_TCP = %d, IPPROTO_UDP = %d)\n"
- " ai_addrlen = %d (sockaddr_in = %lu, "
- "sockaddr_in6 = %lu)\n",
- ai->ai_flags,
- ai->ai_family,
- PF_INET,
- PF_INET6,
- ai->ai_socktype,
- SOCK_STREAM,
- SOCK_DGRAM,
- ai->ai_protocol,
- IPPROTO_TCP,
- IPPROTO_UDP,
- ai->ai_addrlen,
- sizeof( struct sockaddr_in ),
- sizeof( struct sockaddr_in6 ) );
- /*
- ** Now display the protocol-specific formatted socket address. Note
- ** that the program is requesting that getnameinfo(3) convert the
- ** host & service into numeric strings.
- */
- getnameinfo( ai->ai_addr,
- ai->ai_addrlen,
- hostBfr,
- sizeof( hostBfr ),
- servBfr,
- sizeof( servBfr ),
- NI_NUMERICHOST | NI_NUMERICSERV );
- switch ( ai->ai_family )
- {
- case PF_INET: /* IPv4 address record. */
- {
- struct sockaddr_in *p = (struct sockaddr_in*) ai->ai_addr;
- fprintf( stderr,
- " ai_addr = sin_family: %d (AF_INET = %d, "
- "AF_INET6 = %d)\n"
- " sin_addr: %s\n"
- " sin_port: %s\n",
- p->sin_family,
- AF_INET,
- AF_INET6,
- hostBfr,
- servBfr );
- break;
- } /* End CASE of IPv4. */
- case PF_INET6: /* IPv6 address record. */
- {
- struct sockaddr_in6 *p = (struct sockaddr_in6*) ai->ai_addr;
- fprintf( stderr,
- " ai_addr = sin6_family: %d (AF_INET = %d, "
- "AF_INET6 = %d)\n"
- " sin6_addr: %s\n"
- " sin6_port: %s\n"
- " sin6_flowinfo: %d\n"
- " sin6_scope_id: %d\n",
- p->sin6_family,
- AF_INET,
- AF_INET6,
- hostBfr,
- servBfr,
- p->sin6_flowinfo,
- p->sin6_scope_id );
- break;
- } /* End CASE of IPv6. */
- default: /* Can never get here, but just for completeness. */
- {
- fprintf( stderr,
- "%s (line %d): ERROR - Unknown protocol family (%d).\n",
- pgmName,
- __LINE__,
- ai->ai_family );
- freeaddrinfo( aiHead );
- return -1;
- } /* End DEFAULT case (unknown protocol family). */
- } /* End SWITCH on protocol family. */
- } /* End IF verbose mode. */
- /*
- ** Create a socket using the info in the addrinfo structure.
- */
- CHK( desc[ *descSize ] = socket( ai->ai_family,
- ai->ai_socktype,
- ai->ai_protocol ) );
- /*
- ** Here is the code that prevents "IPv4 mapped addresses", as discussed
- ** in Section 22.1.3.1. If an IPv6 socket was just created, then set the
- ** IPV6_V6ONLY socket option.
- */
- if ( ai->ai_family == PF_INET6 )
- {
-#if defined( IPV6_V6ONLY )
- /*
- ** Disable IPv4 mapped addresses.
- */
- int v6Only = 1;
- CHK( setsockopt( desc[ *descSize ],
- IPPROTO_IPV6,
- IPV6_V6ONLY,
- &v6Only,
- sizeof( v6Only ) ) );
-#else
- /*
- ** IPV6_V6ONLY is not defined, so the socket option can't be set and
- ** thus IPv4 mapped addresses can't be disabled. Print a warning
- ** message and close the socket. Design note: If the
- ** #if...#else...#endif construct were removed, then this program
- ** would not compile (because IPV6_V6ONLY isn't defined). That's an
- ** acceptable approach; IPv4 mapped addresses are certainly disabled
- ** if the program can't build! However, since this program is also
- ** designed to work for IPv4 sockets as well as IPv6, I decided to
- ** allow the program to compile when IPV6_V6ONLY is not defined, and
- ** turn it into a run-time warning rather than a compile-time error.
- ** IPv4 mapped addresses are still disabled because _all_ IPv6 traffic
- ** is disabled (all IPv6 sockets are closed here), but at least this
- ** way the server can still service IPv4 network traffic.
- */
- fprintf( stderr,
- "%s (line %d): WARNING - Cannot set IPV6_V6ONLY socket "
- "option. Closing IPv6 %s socket.\n",
- pgmName,
- __LINE__,
- ai->ai_protocol == IPPROTO_TCP ? "TCP" : "UDP" );
- CHK( close( desc[ *descSize ] ) );
- continue; /* Go to top of FOR loop w/o updating *descSize! */
-#endif /* IPV6_V6ONLY */
- } /* End IF this is an IPv6 socket. */
- /*
- ** Bind the socket. Again, the info from the addrinfo structure is used.
- */
- CHK( bind( desc[ *descSize ],
- ai->ai_addr,
- ai->ai_addrlen ) );
- /*
- ** If this is a TCP socket, put the socket into passive listening mode
- ** (listen is only valid on connection-oriented sockets).
- */
- if ( ai->ai_socktype == SOCK_STREAM )
- {
- CHK( listen( desc[ *descSize ],
- MAXCONNQLEN ) );
- }
- /*
- ** Socket set up okay. Bump index to next descriptor array element.
- */
- *descSize += 1;
- } /* End FOR each address info structure returned. */
- /*
- ** Dummy check for unused address records.
- */
- if ( verbose && ( ai != NULL ) )
- {
- fprintf( stderr,
- "%s (line %d): WARNING - Some address records were "
- "not processed due to insufficient array space.\n",
- pgmName,
- __LINE__ );
- } /* End IF verbose and some address records remain unprocessed. */
- /*
- ** Clean up.
- */
- freeaddrinfo( aiHead );
- return 0;
-} /* End openSckt() */
-/******************************************************************************
-* Function: pit
-*
-* Description:
-* Listen on a set of sockets and send the current microsecond counter
-* that was produced by gettimeofday(), to any clients. This function
-* never returns.
-*
-* Parameters:
-* tSckt - Array of TCP socket descriptors on which to listen.
-* tScktSize - Size of the tSckt array (nbr of elements).
-* uSckt - Array of UDP socket descriptors on which to listen.
-* uScktSize - Size of the uSckt array (nbr of elements).
-*
-* Return Value: None.
-******************************************************************************/
-static void pit( int tSckt[ ],
- size_t tScktSize,
- int uSckt[ ],
- size_t uScktSize )
-{
- char bfr[ 256 ];
- ssize_t count;
- struct pollfd *desc;
- size_t descSize = tScktSize + uScktSize;
- int idx;
- int newSckt;
- struct sockaddr *sadr;
- socklen_t sadrLen;
- struct sockaddr_storage sockStor;
- int status;
- size_t timeLen;
- time_t timeVal;
- ssize_t wBytes;
- unsigned long long secs;
- int ret;
- /*
- ** Allocate memory for the poll(2) array.
- */
- desc = malloc( descSize * sizeof( struct pollfd ) );
- if ( desc == NULL )
- {
- fprintf( stderr,
- "%s (line %d): ERROR - %s.\n",
- pgmName,
- __LINE__,
- strerror( ENOMEM ) );
- exit( 1 );
- }
- /*
- ** Initialize the poll(2) array.
- */
- for ( idx = 0; idx < descSize; idx++ )
- {
- desc[ idx ].fd = idx < tScktSize ? tSckt[ idx ]
- : uSckt[ idx - tScktSize ];
- desc[ idx ].events = POLLIN;
- desc[ idx ].revents = 0;
- }
- /*
- ** Main PIT server loop. Handles both TCP & UDP requests. This is
- ** an interative server, and all requests are handled directly within the
- ** main loop.
- */
- while ( true ) /* Do forever. */
- {
- /*
- ** Wait for activity on one of the sockets. The DO..WHILE construct is
- ** used to restart the system call in the event the process is
- ** interrupted by a signal.
- */
- do
- {
- status = poll( desc,
- descSize,
- -1 /* Wait indefinitely for input. */ );
- } while ( ( status < 0 ) && ( errno == EINTR ) );
- CHK( status ); /* Check for a bona fide system call error. */
- /*
- ** Get the current time.
- */
-#if defined(Windows)
- LARGE_INTEGER freq,counter;
- double wintime,bigcounter;
- /* For Windows the time_of_day() is useless. It increments in 55 milli
- * second increments. By using the Win32api one can get access to the
- * high performance measurement interfaces. With this one can get back
- * into the 8 to 9 microsecond resolution.
- */
- QueryPerformanceFrequency(&freq);
- QueryPerformanceCounter(&counter);
- bigcounter=(double)counter.HighPart *(double)0xffffffff +
- (double)counter.LowPart;
- wintime = (double)(bigcounter/(double)freq.LowPart);
- secs = (long long)(wintime * 1000000);
-#else
- ret = gettimeofday( &tm,0 );
- secs = ((unsigned long long)tm.tv_sec * 1000000)
- + (unsigned long long)tm.tv_usec;
-#endif
-
- ret = sprintf(timeStr,"%llu",secs);
- timeLen = strlen( timeStr );
- /*
- ** Process sockets with input available.
- */
- for ( idx = 0; idx < descSize; idx++ )
- {
- switch ( desc[ idx ].revents )
- {
- case 0: /* No activity on this socket; try the next. */
- continue;
- case POLLIN: /* Network activity. Go process it. */
- break;
- default: /* Invalid poll events. */
- {
- fprintf( stderr,
- "%s (line %d): ERROR - Invalid poll event (%#02X).\n",
- pgmName,
- __LINE__,
- desc[ idx ].revents );
- exit( 1 );
- }
- } /* End SWITCH on returned poll events. */
- /*
- ** Determine if this is a TCP request or UDP request.
- */
- if ( idx < tScktSize )
- {
- /*
- ** TCP connection requested. Accept it. Notice the use of
- ** the sockaddr_storage data type.
- */
- sadrLen = sizeof( sockStor );
- sadr = (struct sockaddr*) &sockStor;
- CHK( newSckt = accept( desc[ idx ].fd,
- sadr,
- &sadrLen ) );
- CHK( shutdown( newSckt, /* Server never recv's anything. */
- SHUT_RD ) );
- if ( verbose )
- {
- /*
- ** Display the socket address of the remote client. Begin with
- ** the address-independent fields.
- */
- fprintf( stderr,
- "Sockaddr info for new TCP client:\n"
- " sa_family = %d (AF_INET = %d, AF_INET6 = %d)\n"
- " addr len = %d (sockaddr_in = %lu, "
- "sockaddr_in6 = %lu)\n",
- sadr->sa_family,
- AF_INET,
- AF_INET6,
- sadrLen,
- sizeof( struct sockaddr_in ),
- sizeof( struct sockaddr_in6 ) );
- /*
- ** Display the address-specific fields.
- */
- getnameinfo( sadr,
- sadrLen,
- hostBfr,
- sizeof( hostBfr ),
- servBfr,
- sizeof( servBfr ),
- NI_NUMERICHOST | NI_NUMERICSERV );
- /*
- ** Notice that we're switching on an address family now, not a
- ** protocol family.
- */
- switch ( sadr->sa_family )
- {
- case AF_INET: /* IPv4 address. */
- {
- struct sockaddr_in *p = (struct sockaddr_in*) sadr;
- fprintf( stderr,
- " sin_addr = sin_family: %d\n"
- " sin_addr: %s\n"
- " sin_port: %s\n",
- p->sin_family,
- hostBfr,
- servBfr );
- break;
- } /* End CASE of IPv4. */
- case AF_INET6: /* IPv6 address. */
- {
- struct sockaddr_in6 *p = (struct sockaddr_in6*) sadr;
- fprintf( stderr,
- " sin6_addr = sin6_family: %d\n"
- " sin6_addr: %s\n"
- " sin6_port: %s\n"
- " sin6_flowinfo: %d\n"
- " sin6_scope_id: %d\n",
- p->sin6_family,
- hostBfr,
- servBfr,
- p->sin6_flowinfo,
- p->sin6_scope_id );
- break;
- } /* End CASE of IPv6. */
- default: /* Can never get here, but for completeness. */
- {
- fprintf( stderr,
- "%s (line %d): ERROR - Unknown address "
- "family (%d).\n",
- pgmName,
- __LINE__,
- sadr->sa_family );
- break;
- } /* End DEFAULT case (unknown address family). */
- } /* End SWITCH on address family. */
- } /* End IF verbose mode. */
- /*
- ** Send the PIT to the client.
- */
- wBytes = timeLen;
- while ( wBytes > 0 )
- {
- do
- {
- count = write( newSckt,
- timeStr,
- wBytes );
- } while ( ( count < 0 ) && ( errno == EINTR ) );
- CHK( count ); /* Check for an error. */
- wBytes -= count;
- } /* End WHILE there is data to send. */
- CHK( close( newSckt ) );
- } /* End IF this was a TCP connection request. */
- else
- {
- /*
- ** This is a UDP socket, and a datagram is available. The funny
- ** thing about UDP requests is that this server doesn't require any
- ** client input; but it can't send the PIT unless it knows a client
- ** wants the data, and the only way that can occur with UDP is if
- ** the server receives a datagram from the client. Thus, the
- ** server must receive _something_, but the content of the datagram
- ** is irrelevant. Read in the datagram. Again note the use of
- ** sockaddr_storage to receive the address.
- */
- sadrLen = sizeof( sockStor );
- sadr = (struct sockaddr*) &sockStor;
- CHK( count = recvfrom( desc[ idx ].fd,
- bfr,
- sizeof( bfr ),
- 0,
- sadr,
- &sadrLen ) );
- /*
- ** Display whatever was received on stdout.
- */
- if ( verbose )
- {
- ssize_t rBytes = count;
- fprintf( stderr,
- "%s: UDP datagram received (%ld bytes).\n",
- pgmName,
- count );
- while ( count > 0 )
- {
- fputc( bfr[ rBytes - count-- ],
- stdout );
- }
- if ( bfr[ rBytes-1 ] != '\n' )
- fputc( '\n', stdout ); /* Newline also flushes stdout. */
- /*
- ** Display the socket address of the remote client. Address-
- ** independent fields first.
- */
- fprintf( stderr,
- "Remote client's sockaddr info:\n"
- " sa_family = %d (AF_INET = %d, AF_INET6 = %d)\n"
- " addr len = %d (sockaddr_in = %lu, "
- "sockaddr_in6 = %lu)\n",
- sadr->sa_family,
- AF_INET,
- AF_INET6,
- sadrLen,
- sizeof( struct sockaddr_in ),
- sizeof( struct sockaddr_in6 ) );
- /*
- ** Display the address-specific information.
- */
- getnameinfo( sadr,
- sadrLen,
- hostBfr,
- sizeof( hostBfr ),
- servBfr,
- sizeof( servBfr ),
- NI_NUMERICHOST | NI_NUMERICSERV );
- switch ( sadr->sa_family )
- {
- case AF_INET: /* IPv4 address. */
- {
- struct sockaddr_in *p = (struct sockaddr_in*) sadr;
- fprintf( stderr,
- " sin_addr = sin_family: %d\n"
- " sin_addr: %s\n"
- " sin_port: %s\n",
- p->sin_family,
- hostBfr,
- servBfr );
- break;
- } /* End CASE of IPv4 address. */
- case AF_INET6: /* IPv6 address. */
- {
- struct sockaddr_in6 *p = (struct sockaddr_in6*) sadr;
- fprintf( stderr,
- " sin6_addr = sin6_family: %d\n"
- " sin6_addr: %s\n"
- " sin6_port: %s\n"
- " sin6_flowinfo: %d\n"
- " sin6_scope_id: %d\n",
- p->sin6_family,
- hostBfr,
- servBfr,
- p->sin6_flowinfo,
- p->sin6_scope_id );
- break;
- } /* End CASE of IPv6 address. */
- default: /* Can never get here, but for completeness. */
- {
- fprintf( stderr,
- "%s (line %d): ERROR - Unknown address "
- "family (%d).\n",
- pgmName,
- __LINE__,
- sadr->sa_family );
- break;
- } /* End DEFAULT case (unknown address family). */
- } /* End SWITCH on address family. */
- } /* End IF verbose mode. */
- /*
- ** Send the PIT to the client.
- */
- wBytes = timeLen;
- while ( wBytes > 0 )
- {
- do
- {
- count = sendto( desc[ idx ].fd,
- timeStr,
- wBytes,
- 0,
- sadr, /* Address & address length */
- sadrLen ); /* received in recvfrom(). */
- } while ( ( count < 0 ) && ( errno == EINTR ) );
- CHK( count ); /* Check for a bona fide error. */
- wBytes -= count;
- } /* End WHILE there is data to send. */
- } /* End ELSE a UDP datagram is available. */
- desc[ idx ].revents = 0; /* Clear the returned poll events. */
- } /* End FOR each socket descriptor. */
- } /* End WHILE forever. */
-} /* End pit() */
-
diff --git a/src/components/appio/tests/iozone/read_telemetry b/src/components/appio/tests/iozone/read_telemetry
deleted file mode 100644
index 1cfd2523c..000000000
--- a/src/components/appio/tests/iozone/read_telemetry
+++ /dev/null
@@ -1,29 +0,0 @@
-#
-#
-# The format is:
-#
-# All fields are space delimited.
-# A # symbol in column 1 indicates a comment.
-# First field: Byte offset within the file.
-# Second field: Size in bytes of the I/O operation.
-# Third field: Number of milliseconds to delay before I/O operation.
-#
-# This is an example of sequential 64k reader with 2 milliseconds
-# before each read.
-#
-0 65536 2
-65536 65536 2
-131072 65536 2
-196608 65536 2
-262144 65536 2
-327680 65536 2
-393216 65536 2
-458752 65536 2
-524288 65536 2
-589824 65536 2
-655360 65536 2
-720896 65536 2
-786432 65536 2
-851968 65536 2
-917504 65536 2
-983040 65536 2
diff --git a/src/components/appio/tests/iozone/report.pl b/src/components/appio/tests/iozone/report.pl
deleted file mode 100755
index f9b9b30ba..000000000
--- a/src/components/appio/tests/iozone/report.pl
+++ /dev/null
@@ -1,150 +0,0 @@
-#!/usr/bin/perl
-#
-# arguments: one of more report files
-#
-# Christian Mautner <christian * mautner . ca>, 2005-10-31
-#
-# This script is based loosely on the Generate_Graph set
-# of scripts that come with iozone, but is a complete re-write
-#
-# The main reason to write this was the need to compare the behaviour of
-# two or more different setups, for tuning filesystems or
-# comparing different pieces of hardware.
-#
-# This script is in the public domain, too short and too trivial
-# to deserve a copyright.
-#
-# Simply run iozone like, for example, ./iozone -a -g 4G > config1.out (if your machine has 4GB)
-# and then run perl report.pl config1.out
-# or get another report from another box into config2.out and run
-# perl report.pl config1.out config2.out
-# the look in the report_* directory for .png
-#
-# If you don't like png or the graphic size, search for "set terminal" in this file and put whatever gnuplot
-# terminal you want. Note I've also noticed that gnuplot switched the set terminal png syntax
-# a while back, you might need "set terminal png small size 900,700"
-#
-
-
-@Reports=@ARGV;
-
-die "usage: $0 <iozone.out> [<iozone2.out>...]\n" if not @Reports or grep (m|^-|, @Reports);
-
-die "report files must be in current directory" if grep (m|/|, @Reports);
-
-%columns=(
- 'write' =>3,
- 'read' =>5,
- 'rewrite' =>4,
- 'reread' =>6,
- 'randread' =>7,
- 'randwrite' =>8,
- 'bkwdread' =>9,
- 'recrewrite'=>10,
- 'strideread'=>11,
- 'fwrite' =>12,
- 'frewrite' =>13,
- 'fread' =>14,
- 'freread' =>15,
- );
-
-#
-# create output directory. the name is the concatenation
-# of all report file names (minus the file extension, plus
-# prefix report_)
-#
-$outdir="report_".join("_",map{/([^\.]+)(\..*)?/ && $1}(@Reports));
-
-print STDERR "Output directory: $outdir ";
-
-if ( -d $outdir )
-{
- print STDERR "(removing old directory) ";
- system "rm -rf $outdir";
-}
-
-mkdir $outdir or die "cannot make directory $outdir";
-
-print STDERR "done.\nPreparing data files...";
-
-foreach $report (@Reports)
-{
- open(I, $report) or die "cannot open $report for reading";
- $report=~/^([^\.]+)/;
- $datafile="$1.dat";
- push @datafiles, $datafile;
- open(O, ">$outdir/$datafile") or die "cannot open $outdir/$datafile for writing";
- open(O2, ">$outdir/2d-$datafile") or die "cannot open $outdir/$datafile for writing";
- while(<I>)
- {
- next unless ( /^[\s\d]+$/ );
- @split = split();
- next unless ( @split >= 8 );
- print O;
- print O2 if $split[1] == 16384 or $split[0] == $split[1];
- }
- close I, O, O2;
-}
-
-print STDERR "done.\nGenerating graphs:";
-
-foreach $column (keys %columns)
-{
- print STDERR " $column";
-
- open(G, ">$outdir/$column.do") or die "cannot open $outdir/$column.do for writing";
- print G qq{
-set title "Iozone performance: $column"
-set grid lt 2 lw 1
-set surface
-set parametric
-set xtics
-set ytics
-set logscale x 2
-set logscale y 2
-set autoscale z
-#set xrange [2.**5:2.**24]
-set xlabel "File size in KBytes"
-set ylabel "Record size in Kbytes"
-set zlabel "Kbytes/sec"
-set style data lines
-set dgrid3d 80,80,3
-#set terminal png small picsize 900 700
-set terminal png small size 900 700
-set output "$column.png"
-};
-
- print G "splot ". join(", ", map{qq{"$_" using 1:2:$columns{$column} title "$_"}}(@datafiles));
-
- print G "\n";
-
- close G;
-
- open(G, ">$outdir/2d-$column.do") or die "cannot open $outdir/$column.do for writing";
- print G qq{
-set title "Iozone performance: $column"
-#set terminal png small picsize 450 350
-set terminal png small size 450 350
-set logscale x
-set xlabel "File size in KBytes"
-set ylabel "Kbytes/sec"
-set output "2d-$column.png"
-};
-
- print G "plot ". join(", ", map{qq{"2d-$_" using 1:$columns{$column} title "$_" with lines}}(@datafiles));
-
- print G "\n";
-
- close G;
-
- if ( system("cd $outdir && gnuplot $column.do && gnuplot 2d-$column.do") )
- {
- print STDERR "(failed) ";
- }
- else
- {
- print STDERR "(ok) ";
- }
-}
-
-print STDERR "done.\n";
diff --git a/src/components/appio/tests/iozone/spec.in b/src/components/appio/tests/iozone/spec.in
deleted file mode 100644
index b385b5866..000000000
--- a/src/components/appio/tests/iozone/spec.in
+++ /dev/null
@@ -1,107 +0,0 @@
-Summary: Iozone Filesystem Benchmark
-Name: iozone
-Version: 3
-Release: 398
-License: Freeware
-Group: Applications/Engineering
-Source: %{name}%{version}_%{release}.tar
-Buildroot: /var/tmp/%{name}-buildroot
-
-%description
-IOzone is a filesystem benchmark tool. The benchmark generates and
-measures a variety of file operations. Iozone has been ported to many machines and runs under many operating systems.
-
-Iozone is useful for performing a broad filesystem analysis of a vendors
-computer platform. The benchmark tests file I/O performance for the following
-operations: Read, write, re-read, re-write, read backwards, read strided,
-fread, fwrite, random read, pread ,mmap, aio_read, aio_write.
-
-
-##
-## PREP
-##
-%prep
-
-##
-## SETUP and PATCH
-##
-%setup -n iozone3_398/src/current
-
-
-##
-## BUILD
-##
-##
-## BUILD
-##
-%build
-%ifarch %{ix86}
- make linux
-%else
- %ifarch x86_64
- make linux-AMD64
- %else
- %ifarch ia64
- make linux-ia64
- %else
- %ifarch ppc
- make linux-powerpc
- %else
- %ifarch ppc64
- make linux-powerpc64
- %else
- %ifarch s390
- make linux-S390
- %else
- %ifarch s390x
- make linux-S390X
- %else
- %ifarch %(arm)
- make linux-arm
- %else
- echo "No idea how to build for your arch..."
- exit 1
- %endif
- %endif
- %endif
- %endif
- %endif
- %endif
- %endif
-%endif
-
-##
-## INSTALL
-##
-%install
-mkdir -p $RPM_BUILD_ROOT/opt/iozone/bin
-cp $RPM_BUILD_DIR/iozone3_398/src/current/iozone $RPM_BUILD_ROOT/opt/iozone/bin/
-cp $RPM_BUILD_DIR/iozone3_398/src/current/fileop $RPM_BUILD_ROOT/opt/iozone/bin/
-cp $RPM_BUILD_DIR/iozone3_398/src/current/pit_server $RPM_BUILD_ROOT/opt/iozone/bin/
-cp $RPM_BUILD_DIR/iozone3_398/src/current/Generate_Graphs $RPM_BUILD_ROOT/opt/iozone/bin/
-cp $RPM_BUILD_DIR/iozone3_398/src/current/gengnuplot.sh $RPM_BUILD_ROOT/opt/iozone/bin/
-cp $RPM_BUILD_DIR/iozone3_398/src/current/gnu3d.dem $RPM_BUILD_ROOT/opt/iozone/bin/
-
-mkdir -p $RPM_BUILD_ROOT/opt/iozone/docs
-cp $RPM_BUILD_DIR/iozone3_398/docs/IOzone_msword_98.pdf $RPM_BUILD_ROOT/opt/iozone/docs/
-cp $RPM_BUILD_DIR/iozone3_398/docs/Run_rules.doc $RPM_BUILD_ROOT/opt/iozone/docs/
-cp $RPM_BUILD_DIR/iozone3_398/docs/IOzone_msword_98.doc $RPM_BUILD_ROOT/opt/iozone/docs/
-cp $RPM_BUILD_DIR/iozone3_398/docs/Iozone_ps.gz $RPM_BUILD_ROOT/opt/iozone/docs/
-cp $RPM_BUILD_DIR/iozone3_398/src/current/Gnuplot.txt $RPM_BUILD_ROOT/opt/iozone/docs/
-
-mkdir -p $RPM_BUILD_ROOT/opt/iozone/man/man1
-cp $RPM_BUILD_DIR/iozone3_398/docs/iozone.1 $RPM_BUILD_ROOT/opt/iozone/man/man1/
-
-
-##
-## FILES
-##
-%files
-%attr(755,root,root) /opt/
-
-
-##
-## CLEAN
-##
-%clean
-rm -rf $RPM_BUILD_ROOT
diff --git a/src/components/appio/tests/iozone/write_telemetry b/src/components/appio/tests/iozone/write_telemetry
deleted file mode 100644
index 8b789d168..000000000
--- a/src/components/appio/tests/iozone/write_telemetry
+++ /dev/null
@@ -1,29 +0,0 @@
-#
-#
-# The format is:
-#
-# All fields are space delimited.
-# A # symbol in column 1 indicates a comment.
-# First field: Byte offset within the file.
-# Second field: Size in bytes of the I/O operation.
-# Third field: Number of milliseconds to delay before I/O operation.
-#
-# This is an example of sequential 64k writer with 2 milliseconds
-# before each write.
-#
-0 65536 2
-65536 65536 2
-131072 65536 2
-196608 65536 2
-262144 65536 2
-327680 65536 2
-393216 65536 2
-458752 65536 2
-524288 65536 2
-589824 65536 2
-655360 65536 2
-720896 65536 2
-786432 65536 2
-851968 65536 2
-917504 65536 2
-983040 65536 2
--
2.26.2
Reference in New Issue View Git Blame Copy Permalink