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