diff --git a/papi-no-iozone.patch b/papi-no-iozone.patch new file mode 100644 index 0000000..3dd8e1e --- /dev/null +++ b/papi-no-iozone.patch @@ -0,0 +1,34628 @@ +From 08608fb6887b53e3bbd71dde8eeaf8f5f2ad6e29 Mon Sep 17 00:00:00 2001 +From: William Cohen +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 ] [-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 Specify starting directory. +- -U 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 +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +- +-#include +- +-#if defined(Windows) +-#include +-#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 stats[_STAT_DIR_CREATE].worst) +- stats[_STAT_DIR_CREATE].worst=stats[_STAT_DIR_CREATE].speed; +- junk=chdir(buf); +- for(j=0;j stats[_STAT_DIR_CREATE].worst) +- stats[_STAT_DIR_CREATE].worst=stats[_STAT_DIR_CREATE].speed; +- junk=chdir(buf); +- for(k=0;k 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 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 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 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 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 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 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 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 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 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 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 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 ] [-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 Specify starting directory.\n"); +- printf(" -U 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 " >> /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 " 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 +-#include +-#else +-#if defined(linux) || defined(solaris) || defined(macosx) || defined(__AIX__) || defined(FreeBSD) || defined(_HPUX_SOURCE) +-#include +-#else +-extern int errno; /* imported for errors */ +-extern int h_errno; /* imported for errors */ +-#endif +-#endif +- +- +-#include +-#include +-#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 +-#endif +- +-#if defined(HAVE_ANSIC_C) && defined(linux) +-#include +-#include +-#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 +- +-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 +-#include +-#include +-#include +- +-#include +-#if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__APPLE__) && !defined(__DragonFly__) +-#include +-#endif +-#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__APPLE__) || defined(__DragonFly__) +-#include +-#include +-#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 +-#include +-#include +-#include +-#include +- +-#endif +-#if ( defined(solaris) && defined(studio11) ) +-#include +-#include +-#endif +- +-#if defined(OSFV5) || defined(linux) +-#include +-#endif +- +-#if defined(linux) +-#include +-#include +-#include +-#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 +-#endif +- +-#ifdef VXFS +-#include +-#endif +- +-#ifdef unix +-#if defined (__APPLE__) || defined(__FreeBSD__) || defined(__DragonFly__) \ +- || defined(_SUA_) +-#include +-#endif +-#include +-#include +-#include +-#ifndef NULL +-#define NULL 0 +-#endif +- +-#ifndef nolimits +-#include +-#endif +-#endif +- +-#ifdef HAVE_ANSIC_C +-#define VOLATILE volatile +-#else +-#define VOLATILE +-#endif +- +-#include +- +-#ifdef SHARED_MEM +-#include +-#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 +-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 +-struct piovec piov[PVECMAX]; +-#else +-#include +-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 +-#endif +- +-#include +-#include +-#include +- +- +-/* +- * 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 +-#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 +-#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 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 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 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> %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 (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;xyzflag=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;xxflag==CHILD_STATE_HOLD) +- Poll((long long)1); +- } +- for(i=0;iflag=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;xyzthroughput; /* 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;xyzflag = 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;xyzactual, 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;iflag==CHILD_STATE_HOLD) +- Poll((long long)1); +- } +- for(i=0;iflag = 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;xyzthroughput; +- 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;xyzflag = 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;xyzactual, 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;iflag==CHILD_STATE_HOLD) +- Poll((long long)1); +- } +- for(i=0;iflag = 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;xyzthroughput; +- 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;xyzactual, 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;iflag==CHILD_STATE_HOLD) +- Poll((long long)1); +- } +- for(i=0;iflag = 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;xyzthroughput; +- 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;xyzactual, 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;iflag==CHILD_STATE_HOLD) +- Poll((long long)1); +- } +- for(i=0;iflag = 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;xyzthroughput; +- 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;xyzactual, 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;iflag==CHILD_STATE_HOLD) +- Poll((long long)1); +- } +- for(i=0;iflag = 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;xyzthroughput; +- 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;xyzactual, 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;iflag==CHILD_STATE_HOLD) +- Poll((long long)1); +- } +- for(i=0;iflag = 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;xyzthroughput; +- 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;xyzactual, 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;iflag==CHILD_STATE_HOLD) +- Poll((long long)1); +- } +- for(i=0;iflag = 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;xyzthroughput; +- 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;xyzactual, 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;iflag==CHILD_STATE_HOLD) +- Poll((long long)1); +- } +- for(i=0;iflag = 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;xyzthroughput; +- 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;xyzactual, 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;iflag==CHILD_STATE_HOLD) +- Poll((long long)1); +- } +- for(i=0;iflag = 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;xyzthroughput; +- 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;xyzactual, 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;iflag==CHILD_STATE_HOLD) +- Poll((long long)1); +- } +- for(i=0;iflag = 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;xyzthroughput; +- 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;xyzactual, 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;iflag==CHILD_STATE_HOLD) +- Poll((long long)1); +- } +- for(i=0;iflag = 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;xyzthroughput; +- 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;xyzactual, 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;iflag==CHILD_STATE_HOLD) +- Poll((long long)1); +- } +- for(i=0;iflag = 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;xyzthroughput; +- 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;xyzactual, 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;iflag==CHILD_STATE_HOLD) +- Poll((long long)1); +- } +- for(i=0;iflag = 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;xyzflag = 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>%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 (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>= 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 (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>= 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 (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>= 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 (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>= 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 (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 (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 (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>= 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 (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 (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 (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>= 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 (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>= 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>= 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>= 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; ithroughput = +- (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; ithroughput = +- (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; iflag = 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; iflag = 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; iflag = 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; iflag = 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; iflag = 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; iflag = 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; iflag = 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; ithroughput = +- (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 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>>>> 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%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 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 0) +- { +- srand(1+seed+((chid+1)*(int)numrecs64)*dedup_mseed); +- value=rand(); +-/* printf("Non-dedup value %x seed %x\n",value,seed);*/ +- for( ; x> 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>1) ^ mag01[(int)(x&1ULL)]; +- } +- for (;i>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 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 (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 (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 , 2005-10-31 +-# Marc Schoechlin , 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 , 2005-10-31\n"; +-print "Marc Schoechlin , 2007-12-02\n"; +- +- +-@Reports=@ARGV; +- +-die "usage: $0 --3d=x,y -2d=x,y [...]\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() +- { +- 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{ +- +- +- +-IOZone Statistics +- +- +- +- +-

IOZone Statistics

+- +- +-\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{ +- +- +- +- }; +- +- 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{ +- +- +- +- }; +- +- +- +- 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{ +-
+-}; +- +-# Generate Menu +-print HTML "## Overview\n
    \n"; +-foreach $column (keys %columns){ +- print HTML '
  • '.uc($column).' : '. +- '3d\n". +- '2d
    • \n"; +-} +-print HTML "
+-

3d-$column

[top]
+- 3d-$column
+-
+-

2d-$column

[top]
+- 2d-$column
+-
+- +- +-}; +-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 +-#include +-#if defined(solaris) || defined(linux) || defined(SCO_Unixware_gcc) +-#else +-#include +-#endif +-#include +-#include +-#ifndef bsd4_4 +-#include +-#endif +-#ifdef VXFS +-#include +-#endif +- +-#if defined(OSFV5) || defined(linux) +-#include +-#endif +- +-#if defined(linux) +-#include +-#include +-#include +-#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 +-#include +-#include /* 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 +-#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 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 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 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 +-#endif +-#include +-#include +-#include +-#if defined(__AIX__) || defined(__FreeBSD__) || defined(__DragonFly__) +-#include +-#else +-#include +-#endif +- +-#if defined(OSV5) || defined(linux) || defined (__FreeBSD__) || defined(__OpenBSD__) || defined(__bsdi__) || defined(__APPLE__) || defined(__DragonFly__) +-#include +-#endif +- +-#if defined(linux) || defined(__DragonFly__) || defined(macosx) +-#include +-#include +-#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 +-#include +-#include +-#include +-#include +-#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 declaration & error codes. */ +-#include /* getaddrinfo(3) et al. */ +-#include /* sockaddr_in & sockaddr_in6 definition. */ +-#include /* printf(3) et al. */ +-#include /* exit(2). */ +-#include /* String manipulation & memory functions. */ +-#if defined(_SUA_) +-#include /* poll(2) and related definitions. */ +-#else +-#include /* poll(2) and related definitions. */ +-#endif +-#include /* Socket functions (socket(2), bind(2), etc). */ +-#include /* time(2) & ctime(3). */ +-#include /* gettimeofday */ +-#include /* getopt(3), read(2), etc. */ +-/* Include for Cygnus development environment for Windows */ +-#if defined (Windows) +-#include +-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 , 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 [...]\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() +- { +- 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 + diff --git a/papi.spec b/papi.spec index 629bd6a..04adb5f 100644 --- a/papi.spec +++ b/papi.spec @@ -9,13 +9,14 @@ Summary: Performance Application Programming Interface Name: papi Version: 6.0.0 -Release: 4%{?dist} +Release: 5%{?dist} License: BSD Requires: papi-libs = %{version}-%{release} URL: http://icl.cs.utk.edu/papi/ Source0: http://icl.cs.utk.edu/projects/papi/downloads/%{name}-%{version}.tar.gz Patch1: papi-python3.patch Patch2: papi-a64fx.patch +Patch3: papi-no-iozone.patch BuildRequires: autoconf BuildRequires: doxygen BuildRequires: ncurses-devel @@ -80,6 +81,7 @@ the PAPI user-space libraries and interfaces. %setup -q %patch1 -p1 -b .python3 %patch2 -p1 -b .a64fx +%patch3 -p1 %build # This package fails to build with LTO due to undefined symbols. LTO @@ -168,6 +170,9 @@ chrpath --delete $RPM_BUILD_ROOT%{_libdir}/*.so* %{_libdir}/*.a %changelog +* Thu Dec 17 2020 William Cohen - 6.0.0-5 +- Remove iozone source code. (#1901077) + * Mon Nov 09 2020 William Cohen - 6.0.0-4 - Add Fujitsu A64FX presets.