IOperf

Now trying tests with IOperf

( http://nucwww.chem.sunysb.edu/htbin/software_list.cgi?package=ioperf )

THIS PAGE DOES NOT CONTAIN MEANINGFUL NUMERICAL RESULTS YET!!!  THERE ARE AT LEAST TWO PROBLEMS WITH THE IOPERF NUMBERS TO BE RESOLVED (as described below).  Once resolved, this page will likely be completely rewritten.

The original IOperf code would not compile:

[root@dh34 ioperf]# make
cc -lm -o Ioperf ioperf.c
ioperf.c: In function 'main':
ioperf.c:133: error: 'CLK_TCK' undeclared (first use in this function)
ioperf.c:133: error: (Each undeclared identifier is reported only once
ioperf.c:133: error: for each function it appears in.)
ioperf.c: In function 'get_timer':
ioperf.c:477: error: 'CLK_TCK' undeclared (first use in this function)
make: *** [Ioperf] Error 1

Comments in /usr/include/time.h and /usr/include/bits/time.h lead me to think that "CLK_TCK" is just an obsolete name for CLOCKS_PER_SEC, though this struck me odd, because ioperf code is also using CLOCKS_PER_SEC for CLK_SCALE.

I modified ioperf.h, changing

# define SCALE    CLK_TCK

to

# define SCALE    CLOCKS_PER_SEC

and it compiled, but there is clearly a problem with the real timing scale factor (perhaps simply off by 1 million?). 

So for now, these "real time" results are obviously not realistic numbers, BUT, they are would probably be correct in relative (ratio) terms -- twice as fast is twice as fast.  The CPU % is meaningless for the same reason.

Another limitation (and more important for our purposes) in the "stock" ioperf appears to be a 2GB file size limit.  To get around this, I added "-D_FILE_OFFSET_BITS=64" to the CFLAGS line in the makefile.  I was able to write a 39GB file after this, but there is an overflow at some point in one or more variables, because the printed filesize was -1989672960 in the standard output.  (Even at 8GB, the file size overflow appears).  While the html output has a different filesize that the standard output, it too appears to be incorrect above a certain point.  For instance, look at the third example below, in which the file size should be 8GB, but is instead only ~4GB.

 

With these two oddities (wrong real times and file sizes), I don't see much point in generating a lot of results at this time.

 

JUNE 27 update.  With some wanton changes of int, long int and size_t to 'long long int' in declarations and casting of the ioperf code, I was able to get correct file sizes everywhere (?) for a test with 8GB file size.  This still leaves the timing issue unresolved, so the actual rates are still not meaningful, I don't think, but now perhaps the results will at least be able to be contrasted amongst the different filesystems for relative differences.

 

On to some results:

Ioperf -l 5 -s 100 -n 100000 -html -w -m eastwood-hda:

  Block IO Character Random
fwrite fread putc getc seek
Machine KB KB/sec Real KB/sec CPU %CPU KB/sec Real KB/sec CPU %CPU KB/sec Real KB/sec CPU %CPU KB/sec Real KB/sec CPU %CPU KB/sec Real KB/sec CPU %CPU
eastwood-hda 400000 372786579.68 141342.76 263746.51 2325581395.35 232558.14 1000000.00 275292498.28 40444.89 680660.70 507614213.20 50697.08 1001269.04 23418764.99 2341.88 1000000.00
eastwood-hda 400000 376470588.24 141843.97 265428.39 2325581395.35 233236.15 997093.02 273130761.35 40120.36 680777.51 507292327.20 50664.98 1001268.23 23418764.99 2344.69 998800.96
eastwood-hda 400000 377477194.09 142180.09 265503.81 2325581395.35 233009.71 998062.02 273473108.48 40053.40 682775.59 502512562.81 50209.21 1000845.49 23344123.51 2336.27 999200.64
eastwood-hda 400000 377982518.31 142348.75 265541.52 2325581395.35 232558.14 1000000.00 273224043.72 40000.00 683062.62 500469189.87 50031.27 1000325.09 23320895.52 2332.09 999995.72
eastwood-hda 400000 377073906.49 142450.14 264720.80 2322880371.66 232558.14 998843.93 273410799.73 39952.06 684352.77 499625281.04 49975.01 999763.80 23306980.91 2329.59 1000472.76

 

Ioperf -l 5 -s 100 -n 100000 -html -w -m newman-hda:

  Block IO Character Random
fwrite fread putc getc seek
Machine KB KB/sec Real KB/sec CPU %CPU KB/sec Real KB/sec CPU %CPU KB/sec Real KB/sec CPU %CPU KB/sec Real KB/sec CPU %CPU KB/sec Real KB/sec CPU %CPU
newman-hda 400000 349650349.65 140350.88 249125.87 2325581395.35 232558.14 1000000.00 268456375.84 41025.64 654362.42 506970849.18 50697.08 1000000.00 23141291.47 2308.66 1002369.67
newman-hda 400000 351185250.22 141843.97 247578.81 2325581395.35 232558.14 1000000.00 263504611.33 40962.62 643481.34 506970849.18 50729.23 999366.29 23086583.92 2305.93 1001184.83
newman-hda 400000 355977454.76 141843.97 251054.37 2330097087.38 233009.71 1000000.00 259852750.11 41025.64 633791.60 507185122.57 50718.51 1000000.54 23086583.92 2308.66 1000001.87
newman-hda 400000 353904003.54 142095.91 249160.34 2325581395.35 232558.14 1000000.00 261865793.78 41025.64 638715.02 507292327.20 50729.23 1000000.40 23086583.92 2307.29 1000592.42
newman-hda 400000 354421407.05 142146.41 249417.40 2322880371.66 232288.04 1000000.00 263608804.53 41017.23 643131.80 507356671.74 50748.54 999746.51 23097504.73 2307.57 1000947.87

 

(All this shows is that the two machines perform almost identically, as expected,since they are the same hardware.)

Ioperf -l 5 -s 100 -n 2000000 -html -w -m eastwood-hda

 

  Block IO Character Random
fwrite fread putc getc seek
Machine KB KB/sec Real KB/sec CPU %CPU KB/sec Real KB/sec CPU %CPU KB/sec Real KB/sec CPU %CPU KB/sec Real KB/sec CPU %CPU KB/sec Real KB/sec CPU %CPU
eastwood-hda 3805696 185888536.12 64921.46 286328.33 193546050.96 103697.44 186644.97 177961000.70 19129.87 930278.23 195073863.35 23687.89 823517.35 11054431.89 1105.44 1000000.00
eastwood-hda 3805696 82291879.40 29158.53 282278.70 86875854.88 46547.99 186637.18 80702092.49 8594.50 939085.77 87483051.72 10636.85 822453.78 11054431.89 1105.31 1000118.98
eastwood-hda 3805696 48867732.72 17233.71 283610.19 51358024.69 27474.19 186932.21 47592167.71 5070.20 938725.47 51647935.60 6283.02 822025.09 11033428.33 1103.21 1000118.75
eastwood-hda 3805696 32029118.79 11267.06 284316.11 33571635.68 17943.67 187094.82 31230001.18 3316.26 941804.92 33758817.36 4104.79 822425.98 11039327.51 1103.87 1000059.31
eastwood-hda 3805696 21913097.65 7686.38 285134.41 22880094.31 12236.46 186983.55 21257190.34 2260.60 940410.63 23025180.52 2798.51 822765.06 11040245.73 1103.97 1000047.45

 No explanation why the Block IO and character results decreased so dramatically with each iteration...  (FWIW, according to the ioperf man page, each iteration is an average of the current result with all previous results, so it would seem that the first iteration was much faster than subsequent iterations for some reason...)  This may be a side effect of the incorrect filesize, since there is an overflowed variable going into the calculations.

 

June 27 update: at least the file sizes are now as expected with an 8GB file after some changes to make variables long long ints:

 

  Block IO Character Random
fwrite fread putc getc seek
MachineKB KB/sec RealKB/sec CPU%CPUKB/sec RealKB/sec CPU%CPUKB/sec RealKB/sec CPU%CPUKB/sec RealKB/sec CPU%CPUKB/sec RealKB/sec CPU%CPU
newman-hda8000000 389863547.76123057.99316812.87 516295579.22171710.67300677.64 367073506.4739414.69931311.37 409563303.1349200.49832437.41 171026707.5317102.671000000.00