Originally posted by _Elixia_
Nice work Jason! I know it can be done easily enough, but could you include %-age speed increase on each line, which is the result of using Win32 API over C-api?
I have re-done the same 3 tests above with the additional information. The %-ages are how fast the C runtime library is compared to the Win32 API. If it is < 100%, then C runtime is slower. If it is > 100%, then C runtime is faster.
Code:
SEQUENTIAL READ - 650 MB FILES INTO 1 MB BUFFER, 512 MB of RAM.
File access speed test - C runtime vs Win32 API - By: Jason Doucette
-----------------------------------------------------------------------------
type: C C C Win32 Win32 Win32 C spd C spd C spd
test: rb rbS rbR 0 SEQ RAND % of W % of W % of W
-----------------------------------------------------------------------------
# 1: 38583ms 29376ms 18299ms 29578ms 39269ms 16608ms 76% 133% 90%
# 2: 30448ms 18459ms 17768ms 62373ms 29583ms 16590ms 204% 160% 93%
# 3: 34691ms 29310ms 31884ms 33641ms 29441ms 15804ms 96% 100% 49%
# 4: 49692ms 42064ms 16355ms 28803ms 18037ms 36523ms 57% 42% 223%
# 5: 39686ms 29085ms 16147ms 46058ms 31446ms 15406ms 116% 108% 95%
# 6: 40074ms 28243ms 23231ms 35188ms 27918ms 15679ms 87% 98% 67%
# 7: 39540ms 24375ms 16226ms 38414ms 27980ms 15534ms 97% 114% 95%
# 8: 55819ms 29943ms 16088ms 34801ms 35100ms 16755ms 62% 117% 104%
# 9: 36575ms 28526ms 16047ms 49908ms 29157ms 16306ms 136% 102% 101%
#10: 34368ms 47799ms 16438ms 38339ms 27832ms 15498ms 111% 58% 94%
#11: 49350ms 19733ms 20685ms 34123ms 28871ms 35641ms 69% 146% 172%
#12: 34898ms 28836ms 16196ms 41028ms 21539ms 15863ms 117% 74% 97%
#13: 39051ms 29179ms 17150ms 55804ms 28790ms 15879ms 142% 98% 92%
#14: 38805ms 32995ms 17485ms 29575ms 28237ms 15763ms 76% 85% 90%
#15: 58967ms 17833ms 16267ms 37530ms 28987ms 15751ms 63% 162% 96%
#16: 58282ms 28926ms 16138ms 38386ms 29024ms 16112ms 65% 100% 99%
#17: 34709ms 28559ms 17299ms 50745ms 28190ms 16698ms 146% 98% 96%
#18: 33093ms 48236ms 18468ms 37536ms 28303ms 15559ms 113% 58% 84%
#19: 56813ms 17468ms 19634ms 31420ms 27828ms 34452ms 55% 159% 175%
#20: 34072ms 32461ms 17430ms 36229ms 26032ms 15845ms 106% 80% 90%
#21: 33015ms 28758ms 16505ms 65473ms 30023ms 16073ms 198% 104% 97%
#22: 35532ms 40782ms 16417ms 38223ms 28385ms 15736ms 107% 69% 95%
#23: 58790ms 20708ms 16484ms 35724ms 28163ms 15589ms 60% 136% 94%
#24: 50172ms 29342ms 17296ms 36213ms 36416ms 15823ms 72% 124% 91%
#25: 38030ms 29128ms 15938ms 48190ms 28296ms 16184ms 126% 97% 101%
#26: 34417ms 42479ms 16651ms 39396ms 28207ms 16306ms 114% 66% 97%
#27: 58497ms 30125ms 16363ms 33000ms 16539ms 35355ms 56% 54% 216%
#28: 37700ms 29349ms 16222ms 43848ms 21196ms 15645ms 116% 72% 96%
#29: 37676ms 19752ms 16026ms 47847ms 29190ms 15839ms 126% 147% 98%
#30: 32341ms 48445ms 16709ms 32402ms 19912ms 15987ms 100% 41% 95%
#31: 46864ms 29253ms 17534ms 34204ms 27690ms 15573ms 72% 94% 88%
#32: 56116ms 28876ms 16154ms 32780ms 34765ms 17129ms 58% 120% 106%
-----------------------------------------------------------------------------
avg: 42395ms 30262ms 17610ms 39899ms 28135ms 18422ms 94% 92% 104%
The above times are pretty erratic. The 650 MB files are certainly using up as much memory as possible on my 512 MB system, and it appears the prior tests effect future tests. Should they? I have no idea... There is no data being written back to disk, so I would think this memory used for cache would be available for use on the next file in an insignificantly small amount of time.
Code:
SEQUENTIAL READ - 65 MB FILES INTO 1 MB BUFFER, 512 MB of RAM.
File access speed test - C runtime vs Win32 API - By: Jason Doucette
-----------------------------------------------------------------------------
type: C C C Win32 Win32 Win32 C spd C spd C spd
test: rb rbS rbR 0 SEQ RAND % of W % of W % of W
-----------------------------------------------------------------------------
# 1: 3574ms 1635ms 1649ms 3666ms 2977ms 1777ms 102% 182% 107%
# 2: 289ms 3198ms 265ms 275ms 1820ms 261ms 95% 56% 98%
# 3: 293ms 2910ms 265ms 281ms 2842ms 263ms 95% 97% 99%
# 4: 295ms 3576ms 273ms 282ms 3964ms 265ms 95% 110% 97%
# 5: 296ms 3787ms 262ms 273ms 2809ms 261ms 92% 74% 99%
# 6: 299ms 1614ms 263ms 282ms 2722ms 261ms 94% 168% 99%
# 7: 290ms 3189ms 264ms 284ms 2931ms 261ms 97% 91% 98%
# 8: 292ms 1629ms 263ms 276ms 2910ms 262ms 94% 178% 99%
# 9: 293ms 1624ms 264ms 277ms 2697ms 263ms 94% 166% 99%
#10: 296ms 1618ms 263ms 278ms 2674ms 265ms 93% 165% 100%
#11: 302ms 1696ms 266ms 278ms 2619ms 266ms 92% 154% 100%
#12: 307ms 1633ms 263ms 278ms 2646ms 261ms 90% 162% 99%
#13: 304ms 3682ms 264ms 277ms 2797ms 265ms 91% 75% 100%
#14: 295ms 2850ms 263ms 278ms 2846ms 263ms 94% 99% 100%
#15: 295ms 3203ms 266ms 278ms 1913ms 261ms 94% 59% 98%
#16: 295ms 2866ms 265ms 276ms 1921ms 261ms 93% 67% 98%
#17: 292ms 1801ms 267ms 280ms 1945ms 262ms 95% 107% 98%
#18: 291ms 1956ms 266ms 283ms 1930ms 264ms 97% 98% 99%
#19: 295ms 1850ms 265ms 283ms 1637ms 262ms 95% 88% 98%
#20: 295ms 1840ms 264ms 275ms 1628ms 262ms 93% 88% 99%
#21: 295ms 1878ms 264ms 278ms 1646ms 262ms 94% 87% 99%
#22: 295ms 2914ms 264ms 280ms 2790ms 261ms 94% 95% 98%
#23: 299ms 2826ms 265ms 276ms 2752ms 264ms 92% 97% 99%
#24: 301ms 2781ms 263ms 278ms 2731ms 262ms 92% 98% 99%
#25: 293ms 1819ms 266ms 281ms 1657ms 261ms 95% 91% 98%
#26: 304ms 1793ms 264ms 275ms 1612ms 262ms 90% 89% 99%
#27: 295ms 1738ms 265ms 279ms 1564ms 264ms 94% 89% 99%
#28: 303ms 2819ms 266ms 279ms 2732ms 263ms 92% 96% 98%
#29: 294ms 2860ms 266ms 285ms 1556ms 262ms 96% 54% 98%
#30: 299ms 2835ms 266ms 278ms 2742ms 263ms 92% 96% 98%
#31: 300ms 1659ms 263ms 284ms 1565ms 262ms 94% 94% 99%
#32: 297ms 1700ms 265ms 278ms 1567ms 263ms 93% 92% 99%
-----------------------------------------------------------------------------
avg: 398ms 2368ms 308ms 384ms 2348ms 309ms 96% 99% 100%
Since all 6 files can be cached into memory on my 512 MB system, the only results that matter are those from the first test. Do prior tests effect future ones? I would assume no, as they access different files, and I have enough memory that the caching of one should not need any memory from another. Also, the settings for sequential read is not even as good as the settings for random access... This really makes no sense. Btw, I booted the system before every test, to ensure that no caching was done on the files for the first run. The Win32 API fails miserably here... why?
Code:
RANDOM ACCESS READ - 65 MB FILES INTO 1 MB BUFFER, 512 MB of RAM.
512 1-MB reads (from random location each time) per test
File access speed test - C runtime vs Win32 API - By: Jason Doucette
-----------------------------------------------------------------------------
type: C C C Win32 Win32 Win32 C spd C spd C spd
test: rb rbS rbR 0 SEQ RAND % of W % of W % of W
-----------------------------------------------------------------------------
# 1: 7647ms 4432ms 4215ms 4303ms 13581ms 4613ms 56% 306% 109%
# 2: 2369ms 15441ms 2045ms 2303ms 12262ms 1946ms 97% 79% 95%
# 3: 2385ms 10274ms 2035ms 2308ms 14884ms 1963ms 96% 144% 96%
# 4: 2385ms 11208ms 2060ms 2304ms 10151ms 1955ms 96% 90% 94%
# 5: 2376ms 9315ms 2047ms 2310ms 9579ms 1966ms 97% 102% 96%
# 6: 2379ms 10035ms 2043ms 2322ms 9921ms 1950ms 97% 98% 95%
# 7: 2376ms 9632ms 2039ms 2316ms 10328ms 1979ms 97% 107% 97%
# 8: 2478ms 11084ms 2048ms 2327ms 9489ms 1958ms 93% 85% 95%
# 9: 2382ms 9955ms 2096ms 2333ms 10075ms 1954ms 97% 101% 93%
#10: 2371ms 10073ms 2014ms 2307ms 9388ms 1954ms 97% 93% 97%
#11: 2384ms 11186ms 2053ms 2317ms 8955ms 1947ms 97% 80% 94%
#12: 2391ms 9666ms 2061ms 2307ms 10546ms 1961ms 96% 109% 95%
#13: 2375ms 10479ms 2060ms 2315ms 9506ms 1957ms 97% 90% 95%
#14: 2374ms 9187ms 2042ms 2320ms 11029ms 1977ms 97% 120% 96%
#15: 2386ms 8968ms 2042ms 2315ms 10454ms 1944ms 97% 116% 95%
#16: 2390ms 8891ms 2050ms 2313ms 10444ms 1973ms 96% 117% 96%
#17: 2389ms 9498ms 2043ms 2323ms 9858ms 1949ms 97% 103% 95%
#18: 2396ms 10038ms 2051ms 2314ms 9528ms 1959ms 96% 94% 95%
#19: 2379ms 9501ms 2046ms 2323ms 9004ms 1949ms 97% 94% 95%
#20: 2392ms 9305ms 2026ms 2333ms 10077ms 1961ms 97% 108% 96%
#21: 2471ms 12002ms 2039ms 2311ms 9947ms 1968ms 93% 82% 96%
#22: 2392ms 10027ms 2039ms 2318ms 9046ms 1957ms 96% 90% 95%
#23: 2384ms 10629ms 2035ms 2319ms 9454ms 1951ms 97% 88% 95%
#24: 2397ms 10559ms 2034ms 2323ms 9919ms 1960ms 96% 93% 96%
#25: 2391ms 9462ms 2088ms 2383ms 11285ms 1957ms 99% 119% 93%
#26: 2394ms 9542ms 2067ms 2325ms 9866ms 1963ms 97% 103% 94%
#27: 2387ms 9707ms 2052ms 2320ms 10256ms 1957ms 97% 105% 95%
#28: 2405ms 9032ms 2050ms 2321ms 9933ms 1959ms 96% 109% 95%
#29: 2394ms 10374ms 2070ms 2312ms 8873ms 1964ms 96% 85% 94%
#30: 2406ms 10485ms 2053ms 2327ms 9373ms 1984ms 96% 89% 96%
#31: 2430ms 10078ms 2042ms 2325ms 9171ms 1972ms 95% 91% 96%
#32: 2390ms 8826ms 2031ms 2323ms 10186ms 1952ms 97% 115% 96%
-----------------------------------------------------------------------------
avg: 2557ms 9965ms 2116ms 2381ms 10199ms 2042ms 93% 102% 96%
This random access test is reading the same, unchanged data, unlike a real world situation. I will try and find some time to modify this test to allow changing the data, and writing it back to memory, using a simple memory manager, much like a real world application would. I think this test, when finished, will show the most accurate results of emulating a real world situation. Any thoughts?