home *** CD-ROM | disk | FTP | other *** search
/ 17 Bit Software 2: Collection B / 17Bit_Collection_B.iso / files / 1545.dms / in.adf / DiskPerf / diskperf.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-03-25  |  18.8 KB  |  569 lines
  1. /*
  2. ** Disk performance benchmark.  If your Amiga configuration is substantially
  3. ** different from the ones mentioned here, please run the benchmark and
  4. ** report the results to either: ..!philabs!sbcs!rick or posting to
  5. ** comp.sys.amiga.  Thanks!
  6. **
  7. ** To compile benchmark for Unix 4.2/4.3 SUN 3.0/3.2:
  8. **
  9. **    cc -o diskperf -O -DUNIX diskperf.c
  10. **
  11. ** Amiga version was cross compiled from a SUN, so you'll have to figure out
  12. ** how to compile diskperf under your favorite compiler system.  A uuencoded
  13. ** Amiga binary version of diskperfa is included with the shar file that 
  14. ** contained this source listing.
  15. **
  16. ** To run diskperf, simply type:
  17. **
  18. **    diskperf [location], e.g. (on Amiga) diskperf ram:
  19. **
  20. ** On the Amiga, you will need at least 256K bytes of "disk" wherever you
  21. ** choose to run.  Unix systems will need about 3 mBytes free (larger size
  22. ** test files to delete buffer caching effect).
  23. **
  24. ** Disclaimer:
  25. **
  26. **    This benchmark is provided only for the purpose of seeing how fast
  27. **    _your_ system runs the program.  No claims are made on my part
  28. **    as to what conclusions may be drawn from the statistics gathered.
  29. **    Just consider this program the "Sieve of Eratosthenes" of disk
  30. **    benchmarks - haggle over the numbers with friends, etc, but
  31. **    don't base purchasing decisions solely on the numbers produced
  32. **    by this program.
  33. **
  34. ** Addendum:
  35. **     Timings may also be reported in BIX where Rick is rspanbauer. This has
  36. **    been slightly modified by jdow@bix. It no longer leaves dangling locks.
  37. **    It now executes reads as large as 524288 bytes. It also makes more reads
  38. **    so that hard disk timings are more accurate. As such it may be a bit
  39. **    difficult to run on smaller Amigas or particularly slow disk drives.
  40. **    It also now compiles under Lattice C. (At least 4.1.)
  41. **    lc:lc -dLATTICE -b0 -Lm -r0 diskperf ==> This works even if not optimal.
  42. **
  43. ** Timings:
  44. **    Various timings gathered thus far:
  45. **
  46. -----------------------------------------------------------------------------
  47. Amiga A-2000/A2620 ~14mHZ 68020, Micropolis 1578 HardDisk with MicroBotics
  48.                  HardFrame controller.
  49.  
  50. File create/delete: create 20 files/sec, delete 55 files/sec
  51. Directory scan:        227 entries/sec
  52. Seek/read test:        317 seek/reads per second
  53. r/w speed:        buf 512 bytes, rd 123604 byte/sec, wr 28519 byte/sec
  54. r/w speed:        buf 4096 bytes, rd 194781 byte/sec, wr 163840 byte/sec
  55. r/w speed:        buf 8192 bytes, rd 32939= byte/sec, wr 247695 byte/sec
  56. r/w speed:        buf 32768 bytes, rd 683853 byte/sec, wr 367921 byte/sec
  57. r/w speed:        buf 131072 bytes, rd 925214 byte/sec, wr 483958 byte/sec
  58. r/w speed:        buf 524288 bytes, rd 953250 byte/sec, wr 537731 byte/sec
  59. -----------------------------------------------------------------------------
  60. Amiga A-1000, ~7mHz 68000, RAM:
  61.  
  62. File create/delete:    create 5 files/sec, delete 10 files/sec
  63. Directory scan:        5 entries/sec
  64. Seek/read test:        51 seek/reads per second
  65. r/w speed:        buf 512 bytes, rd 201469 byte/sec, wr 154202 byte/sec
  66. r/w speed:        buf 4096 bytes, rd 655360 byte/sec, wr 374491 byte/sec
  67. r/w speed:        buf 8192 bytes, rd 873813 byte/sec, wr 374491 byte/sec
  68. r/w speed:        buf 32768 bytes, rd 873813 byte/sec, wr 436906 byte/sec
  69. -----------------------------------------------------------------------------
  70. Amiga A-1000, ~7mHz 68000, DF1:
  71.  
  72. File create/delete:    create [0..1] files/sec, delete 1 files/sec
  73. Directory scan:        43 entries/sec
  74. Seek/read test:        18 seek/reads per second
  75. r/w speed:        buf 512 bytes, rd 11861 byte/sec, wr 5050 byte/sec
  76. r/w speed:        buf 4096 bytes, rd 12542 byte/sec, wr 5180 byte/sec
  77. r/w speed:        buf 8192 bytes, rd 12542 byte/sec, wr 5130 byte/sec
  78. r/w speed:        buf 32768 bytes, rd 12542 byte/sec, wr 5160 byte/sec
  79. -----------------------------------------------------------------------------
  80. Amiga A-1000/CSA Turbo board, ~14 mHz 68020, no 32 bit ram installed, RAM:
  81.  
  82. File create/delete:    create 7 files/sec, delete 15 files/sec
  83. Directory scan:        8 entries/sec
  84. Seek/read test:        84 seek/reads per second
  85. r/w speed:        buf 512 bytes, rd 187245 byte/sec, wr 145625 byte/sec
  86. r/w speed:        buf 4096 bytes, rd 655360 byte/sec, wr 327680 byte/sec
  87. r/w speed:        buf 8192 bytes, rd 873813 byte/sec, wr 374491 byte/sec
  88. r/w speed:        buf 32768 bytes, rd 873813 byte/sec, wr 436906 byte/sec
  89. -----------------------------------------------------------------------------
  90. Amiga A-1000, ~7 mHz 68000, Ameristar NFS  -> SUN-3/50, Micropolis 1325 disk:
  91.  
  92. File create/delete:    create 3 files/sec, delete 7 files/sec
  93. Directory scan:        10 entries/sec
  94. Seek/read test:        35 seek/reads per second
  95. r/w speed:        buf 512 bytes, rd 30481 byte/sec, wr 3481 byte/sec
  96. r/w speed:        buf 4096 bytes, rd 113975 byte/sec, wr 21664 byte/sec
  97. r/w speed:        buf 8192 bytes, rd 145635 byte/sec, wr 38550 byte/sec
  98. r/w speed:        buf 32768 bytes, rd 145365 byte/sec, wr 37449 byte/sec
  99. -----------------------------------------------------------------------------
  100. SUN-3/50, Adaptec SCSI<->ST-506, Micropolis 1325 drive (5.25", 5 mBit/sec):
  101.  
  102. File create/delete:    create 6 files/sec, delete 11 files/sec
  103. Directory scan:        350 entries/sec
  104. Seek/read test:        298 seek/reads per second
  105. r/w speed:        buf 512 bytes, rd 240499 byte/sec, wr 215166 byte/sec
  106. r/w speed:        buf 4096 bytes, rd 234057 byte/sec, wr 182466 byte/sec
  107. r/w speed:        buf 8192 bytes, rd 233189 byte/sec, wr 179755 byte/sec
  108. r/w speed:        buf 32768 bytes, rd 236343 byte/sec, wr 187580 byte/sec
  109. -----------------------------------------------------------------------------
  110.  
  111. **
  112. ** Some sample figures from "large" systems: 
  113. **
  114.  
  115. -----------------------------------------------------------------------------
  116. SUN-3/160, Fujitsu SuperEagle, Interphase VSMD-3200 controller:
  117.  
  118. File create/delete:    create 15 files/sec, delete 18 files/sec
  119. Directory scan:        722 entries/sec
  120. Seek/read test:        465 seek/reads per second
  121. r/w speed:        buf 512 bytes, rd 361162 byte/sec, wr 307200 byte/sec
  122. r/w speed:        buf 4096 bytes, rd 419430 byte/sec, wr 315519 byte/sec
  123. r/w speed:        buf 8192 bytes, rd 409067 byte/sec, wr 314887 byte/sec
  124. r/w speed:        buf 32768 bytes, rd 409600 byte/sec, wr 328021 byte/sec
  125. -----------------------------------------------------------------------------
  126. SUN-3/75, NFS filesystem, full 8192 byte transactions:
  127.  
  128. File create/delete:    create 9 files/sec, delete 12 files/sec
  129. Directory scan:        88 entries/sec
  130. Seek/read test:        282 seek/reads per second
  131. r/w speed:        buf 512 bytes, rd 238674 byte/sec, wr 52012 byte/sec
  132. r/w speed:        buf 4096 bytes, rd 259334 byte/sec, wr 54956 byte/sec
  133. r/w speed:        buf 8192 bytes, rd 228116 byte/sec, wr 26483 byte/sec
  134. r/w speed:        buf 32768 bytes, rd 243477 byte/sec, wr 36174 byte/sec
  135. -----------------------------------------------------------------------------
  136. DEC VAX 780, RP07:
  137.  
  138. File create/delete:    create 12 files/sec, delete 12 files/sec
  139. Directory scan:        509 entries/sec
  140. Seek/read test:        245 seek/reads per second
  141. r/w speed:        buf 512 bytes, rd 168041 byte/sec, wr 141064 byte/sec
  142. r/w speed:        buf 4096 bytes, rd 210135 byte/sec, wr 239765 byte/sec
  143. r/w speed:        buf 8192 bytes, rd 206277 byte/sec, wr 239948 byte/sec
  144. r/w speed:        buf 32768 bytes, rd 199222 byte/sec, wr 232328 byte/sec
  145. -----------------------------------------------------------------------------
  146. DEC VAX 750, RA81:
  147.  
  148. File create/delete:    create 12 files/sec, delete 15 files/sec
  149. Directory scan:        208 entries/sec
  150. Seek/read test:        153 seek/reads per second
  151. r/w speed:        buf 512 bytes, rd 99864 byte/sec, wr 72549 byte/sec
  152. r/w speed:        buf 4096 bytes, rd 142663 byte/sec, wr 166882 byte/sec
  153. r/w speed:        buf 8192 bytes, rd 147340 byte/sec, wr 153525 byte/sec
  154. r/w speed:        buf 32768 bytes, rd 142340 byte/sec, wr 141571 byte/sec
  155. -----------------------------------------------------------------------------
  156.  
  157. */ 
  158.  
  159. #ifdef UNIX
  160.  
  161. #include <sys/types.h>
  162. #include <sys/file.h>
  163. #include <sys/time.h>
  164. #include <sys/stat.h>
  165.  
  166. #define SCAN_ITER       10
  167. #define RW_ITER         3
  168. #define RW_SIZE         (3*1024*1024)
  169. #define SEEK_TEST_FSIZE (1024*1024)
  170. #define OPEN_TEST_FILES 200
  171. #define TIMER_RATE      100
  172.  
  173. /*
  174. ** Amiga compatibility library for Unix.  These are NOT full or correct 
  175. ** emulations of the Amiga I/F routines - they are intended only to 
  176. ** run this benchmark.
  177. */
  178.  
  179. #define MODE_OLDFILE    1005
  180. #define MODE_NEWFILE    1006
  181. #define ERROR_NO_MORE_ENTRIES 
  182. #define OFFSET_BEGINNING -1
  183. #define OFFSET_CURRENT 0
  184.  
  185. int
  186. Open(name, accessMode)
  187.         char    *name;
  188.         long    accessMode;
  189. {
  190.         int     flags, file;
  191.  
  192.         flags = O_RDWR;
  193.         if(accessMode == MODE_NEWFILE)
  194.                 flags |= O_TRUNC|O_CREAT;
  195.         if((file = open(name, flags, 0644)) < 0)
  196.                 file = 0;
  197.         return(file);
  198. }
  199.  
  200. /*
  201. ** To be fair, write should be followed by fsync(file) to flush cache.  But
  202. ** since when are benchmarks fair??
  203. */
  204. #define Write(file, buffer, length) write(file, buffer, length)
  205. #define Read(file, buffer, length) read(file, buffer, length)
  206. #define Close(file) close(file)
  207. #define CreateDir(name) mkdir(name, 0755)
  208. #define Seek(file, position, mode) lseek(file, position, \
  209.                 (mode==OFFSET_BEGINNING ? 0 : (mode==OFFSET_CURRENT?1:2)))
  210. #define AllocMem(size, constraints) malloc(size)
  211. #define FreeMem(p, size) free(p, size)
  212. #define DeleteFile(filename) unlink(filename)
  213.  
  214. int
  215. timer_init()
  216. {
  217.         return(1);
  218. }
  219.  
  220. void
  221. timer_quit()
  222. {
  223. }
  224.  
  225. void
  226. timer(valp)
  227.         long    *valp;
  228. {
  229.         static struct timeval ref;
  230.         struct timeval current;
  231.         
  232.         if(valp == (long *)0){
  233.                 gettimeofday(&ref, 0);
  234.                 return;
  235.         } 
  236.         gettimeofday(¤t, 0);
  237.         *valp = (current.tv_usec - ref.tv_usec)/(1000000/TIMER_RATE);
  238.         if(*valp < 0){
  239.                 current.tv_sec--;
  240.                 *valp += TIMER_RATE;
  241.         }
  242.         *valp += (current.tv_sec - ref.tv_sec)*TIMER_RATE;
  243. }
  244.  
  245. int
  246. OpenStat(filename)
  247.         char    *filename;
  248. {
  249.         int     fd, result;
  250.         struct stat statb;
  251.  
  252.         if((fd = open(filename, 0)) < 0)
  253.                 return(0);
  254.         result = fstat(fd, &statb);
  255.         close(fd);
  256.         return(result == 0);
  257. }
  258.  
  259. #else
  260.  
  261. /*
  262. ** Iteration/size definitions smaller for Amiga so benchmark doesn't take
  263. ** as long and fits on empty floppy.
  264. */
  265.  
  266. #include <exec/types.h>
  267. #include <libraries/dos.h>
  268. #include <devices/timer.h>
  269.  
  270. #ifdef MANX
  271. #include <functions.h>        /* For Manx only */
  272. #endif
  273.  
  274. #define SCAN_ITER       5
  275. #define RW_ITER         3
  276. #define RW_SIZE         (2*1024*1024)
  277. #define SEEK_TEST_FSIZE (256*1024)
  278. #define OPEN_TEST_FILES 100
  279. #define TIMER_RATE      10              /* misnomer, should be resolution */
  280.  
  281. struct MsgPort *timerport, *CreatePort();
  282. struct timerequest *timermsg, *CreateExtIO();
  283. long    TimerBase;
  284.  
  285. int
  286. timer_init()
  287. {
  288.         timerport = CreatePort(0, 0);
  289.         if(timerport == (struct MsgPort *)0)
  290.                 return(0);
  291.         timermsg = CreateExtIO(timerport, sizeof(struct timerequest));
  292.         if(timermsg == (struct timerequest *)0){
  293.                 DeletePort(timerport);
  294.                 return(0);
  295.         }
  296.         if(OpenDevice(TIMERNAME, UNIT_VBLANK, timermsg, 0) != 0){
  297.                 DeletePort(timerport);
  298.                 DeleteExtIO(timermsg, sizeof(struct timerequest));
  299.                 return(0);
  300.         }
  301.         TimerBase = (long)timermsg->tr_node.io_Device;  /* Hack */
  302.         return(1);
  303. }
  304.  
  305. void
  306. timer_quit()
  307. {
  308.         CloseDevice(timermsg);
  309.         DeleteExtIO(timermsg, sizeof(struct timerequest));
  310.         DeletePort(timerport);
  311. }
  312.  
  313. void
  314. timer(valp)
  315.         long    *valp;
  316. {
  317.         static struct timeval ref;
  318.         long    t;
  319.  
  320.         timermsg->tr_node.io_Command = TR_GETSYSTIME;
  321.         DoIO(timermsg);
  322.         t = timermsg->tr_time.tv_secs;
  323.         if(valp == (long *)0)
  324.                 ref = timermsg->tr_time;
  325.         else {
  326.                 SubTime(&timermsg->tr_time, &ref);
  327.                 *valp = timermsg->tr_time.tv_secs*TIMER_RATE +
  328.                         (timermsg->tr_time.tv_micro/(1000000/TIMER_RATE));
  329.         }
  330. }
  331.  
  332. int
  333. OpenStat(filename)
  334.         char    *filename;
  335. {
  336.         long    lock, result;
  337.         static struct FileInfoBlock fib;  /* must be on &fib mod 4 == 0 */
  338.  
  339.         if((lock = Lock(filename, MODE_OLDFILE)) == 0)
  340.                 return(0); 
  341.         result = Examine(lock, &fib);
  342.         UnLock(lock);
  343.         return(result);
  344. }
  345.  
  346. #endif
  347.  
  348. /*
  349. ** Benchmarks performed:
  350. **
  351. **      1)  Raw file read/write rates.  Tested for operation sizes of
  352. **          512/4096/8192/32768/131072/524288 bytes.  Return read/write figures
  353. **        for each tranfer size in bytes/sec.
  354. **
  355. **      2)  Directory create/delete rates.  Return create/delete entries
  356. **          per second.
  357. **
  358. **      3)  Directory lookup rate.  Create files in directory, and
  359. **          then measure time to lookup, open & stat entire directory contents.
  360. **          Return entries/second.
  361. **
  362. **      4)  Seek speed test - create large file, then seek to various
  363. **          positions in file & read one byte.  Seek distances intentionally
  364. **          chosen large to reduce cacheing effectiveness - want basic
  365. **          speed of disk format here.  Return seeks/second.
  366. */
  367.  
  368. char    *prepend = "";  /* prepend this path to all filenames created   */
  369. char    scratch[8192];  /* scratch buffer used in various tests         */
  370.  
  371. /*
  372. ** Our `C' library for the Amiga is a bit different than Unix's, so this
  373. ** routine will look a bit obtuse to most of you.  Trying to avoid using
  374. ** sprintf()..
  375. */
  376. void
  377. maketemp(buf, pref)
  378.         char    *buf;
  379. {
  380.         char    *p, *q;
  381.         int     fnum;
  382.         static  int cnt;
  383.         
  384.         fnum = cnt++;
  385.         q = buf;
  386.         if(pref)
  387.                 for(p = prepend; *p; )
  388.                         *q++ = *p++;
  389.         for(p = "diskperf"; *p; )
  390.                 *q++ = *p++;
  391.         *q++ = 'A' + ((fnum>>8)&0xf);
  392.         *q++ = 'A' + ((fnum>>4)&0xf);
  393.         *q++ = 'A' + (fnum&0xf);
  394.         *q++ = 0;
  395. }
  396.  
  397. long    sptest[] = {512, 4096,  8192, 32768, 131072, 524288, 0};
  398.  
  399. void rw_test()
  400. {
  401.         long    i, j, k, maxsize, file, RDaccTime, WRaccTime, Dt, error;
  402.         char    *p, filename[64];
  403.  
  404.         maxsize = -1;
  405.         for(k = 0; sptest[k] != 0; k++)
  406.                 if(sptest[k] > maxsize)
  407.                         maxsize = sptest[k];
  408.         if((p = (char *)AllocMem(maxsize, 0)) == (char *)0L){
  409.                 printf("Could not get %d bytes of memory\n", maxsize);
  410.                 return;
  411.         }
  412.         for(k = 0; sptest[k] != (char *) 0L; k++){
  413.                 RDaccTime = WRaccTime = 0;
  414.                 for(j = 0; j < RW_ITER; j++){
  415.  
  416.                         maketemp(filename, 1);
  417.  
  418.                         if((file = (long) Open(filename, MODE_NEWFILE)) == 0){
  419.                                 printf("Could not create %s\n", filename);
  420.                                 return;
  421.                         }
  422.                         timer(0);
  423.                         for(i = RW_SIZE/sptest[k]; i > 0; i--)
  424.                                 error = Write(file, p, sptest[k]);
  425.                         timer(&Dt);
  426.             if (error != sptest[k])
  427.                 printf("Write error! %d != %d\n", sptest[k], error);
  428.                         WRaccTime += Dt;
  429.                         Close(file);
  430.  
  431.                         if((file = (long) Open(filename, MODE_OLDFILE)) == 0){
  432.                                 printf("Could not open %s\n", filename);
  433.                                 return;
  434.                         }
  435.                         timer(0);
  436.                         for(i = RW_SIZE/sptest[k]; i > 0; i--)
  437.                                 error = Read(file, p, sptest[k]);
  438.                         timer(&Dt);
  439.             if (error != sptest[k])
  440.                 printf("Read error! %d != %d\n", sptest[k], error);
  441.                         RDaccTime += Dt;
  442.                         Close(file);
  443.  
  444.                         DeleteFile(filename);
  445.                 }
  446.         if (RDaccTime == 0) printf( "Still bingo read.\n");
  447.         else printf("r/w speed:\t    buf %d bytes, rd %d byte/sec, wr %d byte/sec\n", 
  448.                                 sptest[k],
  449.                                 (TIMER_RATE*RW_SIZE*RW_ITER)/RDaccTime,
  450.                                 (TIMER_RATE*RW_SIZE*RW_ITER)/WRaccTime);
  451.  
  452.         }
  453.         FreeMem(p, maxsize);
  454. }
  455.  
  456. void
  457. seek_test()
  458. {
  459.         char    fname[64];
  460.         long    i, fd, Dt, cnt, pos, dist;
  461.  
  462.         maketemp(fname, 1);
  463.         if((fd = (long) Open(fname, MODE_NEWFILE)) == 0){
  464.                 printf("Could not create %s\n", fname);
  465.                 return;
  466.         }
  467.         for(i = SEEK_TEST_FSIZE/sizeof(scratch); i > 0; i--)
  468.                 if(Write(fd, scratch, sizeof(scratch)) != sizeof(scratch))
  469.                         break;
  470.         if(i == 0){
  471.                 cnt = 0;
  472.                 timer(0);
  473.                 for(dist = 256; dist <= 65536; dist <<= 2)
  474.                         for(pos = 0; pos < SEEK_TEST_FSIZE; pos += dist){
  475.                                 cnt++;
  476.                                 Seek(fd, pos, OFFSET_BEGINNING);
  477.                                 Read(fd, scratch, 1);
  478.                         }
  479.                 timer(&Dt);
  480.                 printf("Seek/read test:\t    %d seek/reads per second\n", 
  481.                                 (TIMER_RATE*cnt)/Dt);
  482.         }
  483.         Close(fd);
  484.         DeleteFile(fname);
  485. }
  486.  
  487. char    tempname[OPEN_TEST_FILES][16];
  488.  
  489. void
  490. open_scan_test()
  491. {
  492.         char    dirname[64];
  493.         long    lock, oldlock, cDt, dDt, sDt, i, j, fd, numRead;
  494. /*        struct FileInfoBlock *fib; */
  495.  
  496.         maketemp(dirname, 1);
  497.         lock = CreateDir(dirname);
  498. #ifdef UNIX
  499.         chdir(dirname);
  500. #else
  501.         oldlock = CurrentDir(lock);
  502. #endif
  503.         for(i = 0; i < OPEN_TEST_FILES; i++)
  504.                 maketemp(tempname[i], 0);
  505.         
  506.         /*
  507.         ** Time Open of files.
  508.         */
  509.         timer(0);
  510.         for(i = 0; i < OPEN_TEST_FILES; i++){
  511.                 if((fd = Open(tempname[i], MODE_NEWFILE)) == 0){
  512.                         printf("Could not open %s/%s\n", dirname, tempname);
  513.                         break;
  514.                 }
  515.                 Close(fd);
  516.         }
  517.         timer(&cDt);
  518.  
  519.         /*
  520.         ** Time open scan of directory.
  521.         */
  522.         timer(0);
  523.         numRead = 1;
  524.         for(i = 0; i < SCAN_ITER; i++)
  525.                 for(j = 0; j < OPEN_TEST_FILES; j++)
  526.                         if(OpenStat(tempname[i]) != 0)
  527.                                 numRead++;
  528.         timer(&sDt);
  529.  
  530.         /*
  531.         ** Time Close of files.
  532.         */
  533.         timer(0);
  534.         for(i = 0; i < OPEN_TEST_FILES; i++)
  535.                 DeleteFile(tempname[i]);
  536.         timer(&dDt);
  537.  
  538.         printf("File create/delete:    create %d files/sec, delete %d files/sec\n",
  539.                                 (TIMER_RATE*OPEN_TEST_FILES)/cDt, 
  540.                                 (TIMER_RATE*OPEN_TEST_FILES)/dDt);
  541.         printf("Directory scan:\t    %d entries/sec\n", 
  542.                                 (TIMER_RATE*numRead)/sDt);
  543. #ifdef UNIX
  544.         chdir("..");
  545.         rmdir(dirname);
  546. #else
  547.         CurrentDir(oldlock);
  548.     UnLock(lock);
  549.         DeleteFile(dirname);
  550. #endif
  551. }
  552.  
  553. void
  554. main(argc, argv)
  555.         int     argc;
  556.         char    **argv;
  557. {
  558.         if(!timer_init()){
  559.                 printf("Could not init timer\n");
  560.                 return(0);      /* Exit in most systems, but not ours! */
  561.         }
  562.         if(argc > 1)
  563.                 prepend = argv[1];
  564.         open_scan_test();
  565.         seek_test();
  566.         rw_test();
  567. }
  568.  
  569.