home *** CD-ROM | disk | FTP | other *** search
/ PC Online 1997 October / PCO1097.ISO / FilesBBS / OS2 / DISKIO11.ARJ / DISKIO11.ZIP / diskio.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-02-09  |  17.2 KB  |  734 lines
  1. /* diskio.c - disk benchmark
  2.  *
  3.  * Author:  Kai Uwe Rommel <rommel@ars.muc.de>
  4.  * Created: Fri Jul 08 1994
  5.  */
  6.  
  7. static char *rcsid =
  8. "$Id: diskio.c,v 1.11 1997/02/09 15:06:38 rommel Exp rommel $";
  9. static char *rcsrev = "$Revision: 1.11 $";
  10.  
  11. /*
  12.  * $Log: diskio.c,v $
  13.  * Revision 1.11  1997/02/09 15:06:38  rommel
  14.  * changed command line interface
  15.  *
  16.  * Revision 1.10  1997/01/12 21:15:10  rommel
  17.  * added CD-ROM benchmarks
  18.  *
  19.  * Revision 1.9  1995/12/31 20:24:09  rommel
  20.  * Changed CPU load calculation
  21.  * General cleanup
  22.  *
  23.  * Revision 1.8  1995/12/28 11:28:07  rommel
  24.  * Fixed async timer problem.
  25.  *
  26.  * Revision 1.7  1995/12/28 10:04:15  rommel
  27.  * Added CPU benchmark (concurrently to disk I/O)
  28.  *
  29.  * Revision 1.6  1995/11/24 16:02:10  rommel
  30.  * Added bus/drive cache speed test by 
  31.  * repeatedly reading a small amount of data
  32.  *
  33.  * Revision 1.5  1995/08/09 13:07:02  rommel
  34.  * Changes for new diskacc2 library, minor corrections, arguments.
  35.  *
  36.  * Revision 1.4  1994/07/11 14:23:00  rommel
  37.  * Changed latency timing
  38.  *
  39.  * Revision 1.3  1994/07/09 13:07:20  rommel
  40.  * Changed transfer speed test
  41.  *
  42.  * Revision 1.2  1994/07/08 21:53:05  rommel
  43.  * Cleanup
  44.  *
  45.  * Revision 1.1  1994/07/08 21:29:41  rommel
  46.  * Initial revision
  47.  * 
  48.  */
  49.  
  50. #include <stdio.h>
  51. #include <stdlib.h>
  52. #include <string.h>
  53.  
  54. #define INCL_DOS
  55. #define INCL_DOSDEVICES
  56. #define INCL_DOSDEVIOCTL
  57. #define INCL_DOSERRORS
  58. #define INCL_NOPM
  59. #include <os2.h>
  60.  
  61. #include "diskacc2.h"
  62.  
  63. #define INTERVAL 10
  64.  
  65. #define THREADSTACK 65536
  66.  
  67. char *pBuffer;
  68.  
  69. int time_over;
  70. long dhry_time, dhry_result;
  71.  
  72. extern unsigned long Number_Of_Runs;
  73. extern long dhry_stone(void);
  74.  
  75. VOID APIENTRY timer_thread(ULONG nArg)
  76. {
  77.   HEV hSem;
  78.   HTIMER hTimer;
  79.  
  80.   // DosSetPriority(PRTYS_THREAD, PRTYC_TIMECRITICAL, PRTYD_MAXIMUM, 0);
  81.  
  82.   DosCreateEventSem(0, &hSem, DC_SEM_SHARED, 0);
  83.  
  84.   DosAsyncTimer(nArg * 1000, (HSEM) hSem, &hTimer);
  85.   DosWaitEventSem(hSem, SEM_INDEFINITE_WAIT);
  86.   DosStopTimer(hTimer);
  87.  
  88.   DosCloseEventSem(hSem);
  89.  
  90.   time_over = 1;
  91.   Number_Of_Runs = 0;
  92.  
  93.   DosExit(EXIT_THREAD, 0);
  94. }
  95.  
  96. int start_alarm(ULONG nSeconds)
  97. { 
  98.   TID ttid;
  99.  
  100.   time_over = 0;
  101.   Number_Of_Runs = -1;
  102.  
  103.   if (DosCreateThread(&ttid, timer_thread, nSeconds, 0, THREADSTACK))
  104.     return printf("Cannot create timer thread.\n"), -1;
  105.  
  106.   return 0;
  107. }
  108.  
  109. int start_timer(QWORD *nStart)
  110. {
  111.   if (DosTmrQueryTime(nStart))
  112.     return printf("Timer error.\n"), -1;
  113.  
  114.   return 0;
  115. }
  116.  
  117. int stop_timer(QWORD *nStart, int accuracy)
  118. {
  119.   QWORD nStop;
  120.   ULONG nFreq;
  121.  
  122.   if (DosTmrQueryTime(&nStop))
  123.     return printf("Timer error.\n"), -1;
  124.   if (DosTmrQueryFreq(&nFreq))
  125.     return printf("Timer error.\n"), -1;
  126.  
  127.   nFreq = (nFreq + accuracy / 2) / accuracy;
  128.  
  129.   return (nStop.ulLo - nStart->ulLo) / nFreq;
  130. }
  131.  
  132. VOID APIENTRY dhry_thread(ULONG nArg)
  133. {
  134.   DosSetPriority(PRTYS_THREAD, PRTYC_IDLETIME, PRTYD_MAXIMUM, 0);
  135.  
  136.   dhry_time = dhry_stone();
  137.  
  138.   DosExit(EXIT_THREAD, 0);
  139. }
  140.  
  141. int bench_hd_bus(int nHandle, unsigned nSectors)
  142. {
  143.   int nCnt, nData = 0, nTime;
  144.   QWORD nLocal;
  145.  
  146.   printf("Drive cache/bus transfer rate: ");
  147.   fflush(stdout);
  148.  
  149.   if (start_alarm(INTERVAL))
  150.     return -1;
  151.  
  152.   if (start_timer(&nLocal))
  153.     return -1;
  154.  
  155.   for (nCnt = 0; !time_over; nCnt++)
  156.   {
  157.     if (DskRead(nHandle, 0, 0, 1, nSectors, pBuffer))
  158.       return printf("Disk read error.\n"), -1;
  159.  
  160.     nData += nSectors * 512;
  161.   }
  162.  
  163.   if ((nTime = stop_timer(&nLocal, 1024)) == -1)
  164.     return -1;
  165.  
  166.   printf("%d k/sec\n", nData / nTime);
  167.  
  168.   return 0;
  169. }
  170.  
  171. int bench_hd_transfer(int nHandle, int nTrack, int nDirection, 
  172.               unsigned nSides, unsigned nSectors)
  173. {
  174.   int nCnt, nData = 0, nTime;
  175.   QWORD nLocal;
  176.  
  177.   printf("Data transfer rate on track %-4d: ", nTrack);
  178.   fflush(stdout);
  179.  
  180.   if (start_alarm(INTERVAL))
  181.     return -1;
  182.  
  183.   if (start_timer(&nLocal))
  184.     return -1;
  185.  
  186.   for (nCnt = 0; !time_over; nCnt++)
  187.   {
  188.     if (DskRead(nHandle, nCnt % nSides, 
  189.         nTrack + (nCnt / nSides) * nDirection, 1, nSectors, pBuffer))
  190.       return printf("Disk read error.\n"), -1;
  191.  
  192.     nData += nSectors * 512;
  193.   }
  194.  
  195.   if ((nTime = stop_timer(&nLocal, 1024)) == -1)
  196.     return -1;
  197.  
  198.   printf("%d k/sec\n", nData / nTime);
  199.  
  200.   return 0;
  201. }
  202.  
  203. int bench_hd_cpuusage(int nHandle, unsigned nSides, unsigned nSectors)
  204. {
  205.   int nCnt, nData = 0, nTime, nPercent;
  206.   QWORD nLocal;
  207.   TID dtid;
  208.   APIRET rc;
  209.  
  210.   printf("CPU usage by full speed disk transfers: ");
  211.   fflush(stdout);
  212.  
  213.   if (start_alarm(INTERVAL))
  214.     return -1;
  215.  
  216.   if (DosCreateThread(&dtid, dhry_thread, 0, 0, THREADSTACK))
  217.     return -1;
  218.  
  219.   if (start_timer(&nLocal))
  220.     return -1;
  221.  
  222.   for (nCnt = 0; !time_over; nCnt++)
  223.   {
  224.     if (DskRead(nHandle, nCnt % nSides, nCnt / nSides, 1, nSectors, pBuffer))
  225.       return printf("Disk read error.\n"), -1;
  226.  
  227.     nData += nSectors * 512;
  228.   }
  229.  
  230.   if ((nTime = stop_timer(&nLocal, 1024)) == -1)
  231.     return -1;
  232.  
  233.   if ((rc = DosWaitThread(&dtid, DCWW_WAIT)) && rc != ERROR_INVALID_THREADID)
  234.     return -1;                             /* it may have already terminated */
  235.  
  236.   if (dhry_result == 0)
  237.     dhry_result = 1; /* to avoid dividing by zero */
  238.  
  239.   dhry_time = (dhry_time + 500) / 1000;
  240.   nPercent = (dhry_result - Number_Of_Runs / dhry_time) * 100 / dhry_result;
  241.  
  242.   printf("%d%%\n", nPercent);
  243.  
  244.   return 0;
  245. }
  246.  
  247. int bench_hd_latency(int nHandle, unsigned nSectors)
  248. {
  249.   int nCnt, nSector, nTime;
  250.   QWORD nLocal;
  251.  
  252.   printf("Average latency time: ");
  253.   fflush(stdout);
  254.  
  255.   srand(1);
  256.  
  257.   if (start_alarm(INTERVAL))
  258.     return -1;
  259.  
  260.   if (start_timer(&nLocal))
  261.     return -1;
  262.  
  263.   for (nCnt = 0; !time_over; nCnt++)
  264.   {
  265.     nSector = rand() * nSectors / RAND_MAX + 1;
  266.  
  267.     if (DskRead(nHandle, 0, 0, nSector, 1, pBuffer))
  268.       return printf("Disk read error.\n"), -1;
  269.   }
  270.  
  271.   if ((nTime = stop_timer(&nLocal, 1000)) == -1)
  272.     return -1;
  273.  
  274.   nTime = nTime * 10 / nCnt;
  275.  
  276.   printf("%d.%d ms\n", nTime / 10, nTime % 10);
  277.  
  278.   return nTime;
  279. }
  280.  
  281. int bench_hd_seek(int nHandle, unsigned nSides, unsigned nSectors, unsigned nTracks)
  282. {
  283.   int nCnt, nSide, nTrack, nSector, nTime;
  284.   QWORD nLocal;
  285.  
  286.   printf("Average data access time: ");
  287.   fflush(stdout);
  288.  
  289.   srand(1);
  290.  
  291.   if (start_alarm(INTERVAL))
  292.     return -1;
  293.  
  294.   if (start_timer(&nLocal))
  295.     return -1;
  296.  
  297.   for (nCnt = 0; !time_over; nCnt++)
  298.   {
  299.     nSide   = rand() * nSides   / RAND_MAX;
  300.     nSector = rand() * nSectors / RAND_MAX;
  301.     nTrack  = rand() * nTracks  / RAND_MAX;
  302.  
  303.     if (DskRead(nHandle, nSide, nTrack, nSector, 1, pBuffer))
  304.       return printf("Disk read error.\n"), -1;
  305.   }
  306.  
  307.   if ((nTime = stop_timer(&nLocal, 1000)) == -1)
  308.     return -1;
  309.  
  310.   nTime = nTime * 10 / nCnt;
  311.  
  312.   printf("%d.%d ms\n", nTime / 10, nTime % 10);
  313.  
  314.   return 0;
  315. }
  316.  
  317. int bench_hd(int nDisk)
  318. {
  319.   int nHandle;
  320.   unsigned nSides, nTracks, nSectors;
  321.   char szName[8];
  322.  
  323.   sprintf(szName, "$%d:", nDisk);
  324.  
  325.   if ((nHandle = DskOpen(szName, 0, 0, &nSides, &nTracks, &nSectors)) < 0)
  326.     return printf("\nCannot access disk %d.\n", nDisk), -1;
  327.  
  328.   printf("\nHard disk %d: %d sides, %d cylinders, %d sectors per track = %d MB\n", 
  329.      nDisk, nSides, nTracks, nSectors,
  330.      nSides * nTracks * nSectors / 2048);
  331.  
  332.   if ((pBuffer = malloc(nSectors * 512)) == NULL)
  333.     return printf("\nNot enough memory.\n"), -1;
  334.  
  335.   bench_hd_bus(nHandle, nSectors);
  336.   bench_hd_transfer(nHandle, 0, 1, nSides, nSectors);
  337.   bench_hd_transfer(nHandle, nTracks - 1, -1, nSides, nSectors);
  338.   bench_hd_cpuusage(nHandle, nSides, nSectors);
  339.   bench_hd_latency(nHandle, nSectors);
  340.   bench_hd_seek(nHandle, nSides, nSectors, nTracks);
  341.  
  342.   free(pBuffer);
  343.   DskClose(nHandle);
  344.  
  345.   return 0;
  346. }
  347.  
  348. int bench_cd_transfer(int nHandle)
  349. {
  350.   int nCnt, nData = 0, nTime, nRate;
  351.   QWORD nLocal;
  352.  
  353.   printf("Data transfer rate: ");
  354.   fflush(stdout);
  355.   
  356.   if (start_alarm(INTERVAL))
  357.     return -1;
  358.  
  359.   if (start_timer(&nLocal))
  360.     return -1;
  361.  
  362.   for (nCnt = 0; !time_over; nCnt++)
  363.   {
  364.     if (CDRead(nHandle, nCnt * 32, 32, pBuffer) == -1)
  365.       return printf("CD-ROM read error.\n"), -1;
  366.  
  367.     nData += 32 * 2048;
  368.   }
  369.  
  370.   if ((nTime = stop_timer(&nLocal, 1024)) == -1)
  371.     return -1;
  372.  
  373.   nRate = nData / nTime;
  374.   printf("%d k/sec (~%.1fx)\n", nRate, (double) nRate / 150.0);
  375.  
  376.   return 0;
  377. }
  378.  
  379. int bench_cd_cpuusage(int nHandle)
  380. {
  381.   int nCnt, nData = 0, nTime, nPercent;
  382.   QWORD nLocal;
  383.   TID dtid;
  384.   APIRET rc;
  385.  
  386.   printf("CPU usage by full speed CD-ROM reads: ");
  387.   fflush(stdout);
  388.  
  389.   if (start_alarm(INTERVAL))
  390.     return -1;
  391.  
  392.   if (DosCreateThread(&dtid, dhry_thread, 0, 0, THREADSTACK))
  393.     return -1;
  394.  
  395.   if (start_timer(&nLocal))
  396.     return -1;
  397.  
  398.   for (nCnt = 0; !time_over; nCnt++)
  399.   {
  400.     if (CDRead(nHandle, nCnt * 32, 32, pBuffer) == -1)
  401.       return printf("CD-ROM read error.\n"), -1;
  402.  
  403.     nData += 32 * 2048;
  404.   }
  405.  
  406.   if ((nTime = stop_timer(&nLocal, 1024)) == -1)
  407.     return -1;
  408.  
  409.   if ((rc = DosWaitThread(&dtid, DCWW_WAIT)) && rc != ERROR_INVALID_THREADID)
  410.     return -1;                             /* it may have already terminated */
  411.  
  412.   if (dhry_result == 0)
  413.     dhry_result = 1; /* to avoid dividing by zero */
  414.  
  415.   dhry_time = (dhry_time + 500) / 1000;
  416.   nPercent = (dhry_result - Number_Of_Runs / dhry_time) * 100 / dhry_result;
  417.  
  418.   printf("%d%%\n", nPercent);
  419.  
  420.   return 0;
  421. }
  422.  
  423. int bench_cd_seek(int nHandle, unsigned nSectors)
  424. {
  425.   int nCnt, nSector, nTime;
  426.   QWORD nLocal;
  427.  
  428.   printf("Average data access time: ");
  429.   fflush(stdout);
  430.  
  431.   srand(1);
  432.  
  433.   if (start_alarm(INTERVAL))
  434.     return -1;
  435.  
  436.   if (start_timer(&nLocal))
  437.     return -1;
  438.  
  439.   for (nCnt = 0; !time_over; nCnt++)
  440.   {
  441.     nSector = (nSectors * 1000) / RAND_MAX;
  442.     nSector = nSector * rand() / 1000;
  443.  
  444.     if (CDRead(nHandle, nSector, 1, pBuffer) != 1)
  445.       return printf("CD-ROM read error.\n"), -1;
  446.   }
  447.  
  448.   if ((nTime = stop_timer(&nLocal, 1000)) == -1)
  449.     return -1;
  450.  
  451.   nTime = nTime * 10 / nCnt;
  452.  
  453.   printf("%d.%d ms\n", nTime / 10, nTime % 10);
  454.  
  455.   return 0;
  456. }
  457.  
  458. int bench_cd(int nDrive)
  459. {
  460.   int nHandle, nDriveLetter;
  461.   unsigned nSectors;
  462.   char szDrive[3], szUPC[8];
  463.  
  464.   if ((nDriveLetter = CDFind(nDrive)) == -1)
  465.     return printf("\nCannot access CD-ROM drive %d.\n", nDrive), -1;
  466.  
  467.   szDrive[0] = (char) nDriveLetter;
  468.   szDrive[1] = ':';
  469.   szDrive[2] = 0;
  470.  
  471.   if ((nHandle = CDOpen(szDrive, 1, szUPC, &nSectors)) == -1)
  472.     return -1;
  473.  
  474.   printf("\nCD-ROM drive %s %d sectors = %d MB\n", 
  475.      szDrive, nSectors, nSectors / 512);
  476.  
  477.   if ((pBuffer = malloc(32 * 2048)) == NULL)
  478.     return printf("\nNot enough memory.\n"), -1;
  479.  
  480.   /* spin up and seek to first sector */
  481.   if (CDRead(nHandle, 0, 32, pBuffer) == -1)
  482.     return printf("CD-ROM read error.\n"), -1;
  483.  
  484.   bench_cd_transfer(nHandle);
  485.   bench_cd_cpuusage(nHandle);
  486.   bench_cd_seek(nHandle, nSectors);
  487.  
  488.   free(pBuffer);
  489.   CDClose(nHandle);
  490.  
  491.   return 0;
  492. }
  493.  
  494. typedef struct 
  495. {
  496.   int nHandle, nData;
  497.   unsigned nSides, nSectors, nTracks;
  498.   void *pBuffer;
  499. }
  500. THREADPARMS;
  501.  
  502. VOID APIENTRY bench_concurrent_hd(ULONG nArg)
  503. {
  504.   THREADPARMS *ptr = (THREADPARMS *) nArg;
  505.   int nCnt;
  506.  
  507.   for (nCnt = 0; !time_over; nCnt++)
  508.   {
  509.     if (DskRead(ptr->nHandle, nCnt % ptr->nSides, nCnt / ptr->nSides, 1, 
  510.         ptr->nSectors, ptr->pBuffer))
  511.     {
  512.       printf("Disk read error.\n");
  513.       break;
  514.     }
  515.  
  516.     ptr->nData += ptr->nSectors * 512;
  517.   }
  518.  
  519.   DosExit(EXIT_THREAD, 0);
  520. }
  521.  
  522. VOID APIENTRY bench_concurrent_cd(ULONG nArg)
  523. {
  524.   THREADPARMS *ptr = (THREADPARMS *) nArg;
  525.   int nCnt;
  526.  
  527.   for (nCnt = 0; !time_over; nCnt++)
  528.   {
  529.     if (CDRead(ptr->nHandle, nCnt * 32, 32, ptr->pBuffer) == -1)
  530.     {
  531.       printf("CD-ROM read error.\n");
  532.       break;
  533.     }
  534.  
  535.     ptr->nData += 32 * 2048;
  536.   }
  537.  
  538.   DosExit(EXIT_THREAD, 0);
  539. }
  540.  
  541. int bench_concurrent(int nDisk, int nCD)
  542. {
  543.   int nDriveLetter, nTime, nPercent;
  544.   char szDrive[3], szUPC[8], szName[8];
  545.   THREADPARMS tHD, tCD;
  546.   TID tidHD, tidCD;
  547.   QWORD nLocal;
  548.   APIRET rc;
  549.  
  550.   sprintf(szName, "$%d:", nDisk);
  551.  
  552.   if ((tHD.nHandle = DskOpen(szName, 0, 0, 
  553.                  &tHD.nSides, &tHD.nTracks, &tHD.nSectors)) < 0)
  554.     return printf("\nCannot access disk %d.\n", nDisk), -1;
  555.  
  556.   if ((tHD.pBuffer = malloc(tHD.nSectors * 512)) == NULL)
  557.     return printf("\nNot enough memory.\n"), -1;
  558.  
  559.   if ((nDriveLetter = CDFind(nCD)) == -1)
  560.     return printf("\nCannot access CD-ROM drive %d.\n", nCD), -1;
  561.  
  562.   szDrive[0] = (char) nDriveLetter;
  563.   szDrive[1] = ':';
  564.   szDrive[2] = 0;
  565.  
  566.   if ((tCD.nHandle = CDOpen(szDrive, 1, szUPC, &tCD.nSectors)) == -1)
  567.     return -1;
  568.  
  569.   if ((tCD.pBuffer = malloc(32 * 2048)) == NULL)
  570.     return printf("\nNot enough memory.\n"), -1;
  571.  
  572.   /* spin up and seek to first sector */
  573.   if (CDRead(tCD.nHandle, 0, 32, tCD.pBuffer) == -1)
  574.     return printf("CD-ROM read error.\n"), -1;
  575.  
  576.   printf("\nConcurrent hard disk %d and CD-ROM %d reads at full speed:", nDisk, nCD);
  577.   fflush(stdout);
  578.   tHD.nData = tCD.nData = 0;
  579.  
  580.   if (start_alarm(INTERVAL))
  581.     return -1;
  582.  
  583.   if (start_timer(&nLocal))
  584.     return -1;
  585.  
  586.   if (DosCreateThread(&tidHD, bench_concurrent_hd, (ULONG) &tHD, 0, THREADSTACK))
  587.     return -1;
  588.   if (DosCreateThread(&tidCD, bench_concurrent_cd, (ULONG) &tCD, 0, THREADSTACK))
  589.     return -1;
  590.  
  591.   DosSetPriority(PRTYS_THREAD, PRTYC_IDLETIME, PRTYD_MAXIMUM, 0);
  592.   dhry_time = dhry_stone();
  593.   DosSetPriority(PRTYS_THREAD, PRTYC_REGULAR, PRTYD_MINIMUM, 0);
  594.  
  595.   if ((rc = DosWaitThread(&tidHD, DCWW_WAIT)) && rc != ERROR_INVALID_THREADID)
  596.     return -1;                             /* it may have already terminated */
  597.   if ((rc = DosWaitThread(&tidCD, DCWW_WAIT)) && rc != ERROR_INVALID_THREADID)
  598.     return -1;                             /* it may have already terminated */
  599.  
  600.   if ((nTime = stop_timer(&nLocal, 1024)) == -1)
  601.     return -1;
  602.  
  603.   if (dhry_result == 0)
  604.     dhry_result = 1; /* to avoid dividing by zero */
  605.  
  606.   dhry_time = (dhry_time + 500) / 1000;
  607.   nPercent = (dhry_result - Number_Of_Runs / dhry_time) * 100 / dhry_result;
  608.  
  609.   printf("\nHard disk throughput: %d k/sec\n", tHD.nData / nTime);
  610.   printf("CD-ROM throughput: %d k/sec\n", tCD.nData / nTime);
  611.   printf("CPU usage: %d%%\n", nPercent);
  612.  
  613.   free(tCD.pBuffer);
  614.   CDClose(tCD.nHandle);
  615.  
  616.   free(tHD.pBuffer);
  617.   DskClose(tHD.nHandle);
  618.  
  619.   return 0;
  620. }
  621.  
  622. int bench_dhry(void)
  623. {
  624.   printf("Dhrystone benchmark for this CPU: ");
  625.   fflush(stdout);
  626.  
  627.   if (start_alarm(INTERVAL / 2))
  628.     return -1;
  629.  
  630.   // DosSetPriority(PRTYS_THREAD, PRTYC_REGULAR, PRTYD_MAXIMUM, 0);
  631.   dhry_time = dhry_stone();
  632.   // DosSetPriority(PRTYS_THREAD, PRTYC_REGULAR, PRTYD_MINIMUM, 0);
  633.  
  634.   dhry_time = (dhry_time + 500) / 1000;
  635.   dhry_result = Number_Of_Runs / dhry_time;
  636.  
  637.   printf("%d runs/sec\n", dhry_result);
  638.  
  639.   return 0;
  640. }
  641.  
  642. int main(int argc, char **argv)
  643. {
  644.   char szVersion[32];
  645.   USHORT nDisks;
  646.   int nCDROMs, nCount, xHD[26], xCD[26], cHD = 0, cCD = 0;
  647.  
  648.   strcpy(szVersion, rcsrev + sizeof("$Revision: ") - 1);
  649.   *strchr(szVersion, ' ') = 0;
  650.  
  651.   printf("\nDISKIO - Fixed Disk Benchmark, Version %s"
  652.      "\n(C) 1994-1997 Kai Uwe Rommel\n", szVersion);
  653.  
  654.   if (DosPhysicalDisk(INFO_COUNT_PARTITIONABLE_DISKS, &nDisks, sizeof(nDisks), 0, 0))
  655.     return printf("\nCannot determine number of disks.\n"), 1;
  656.  
  657.   printf("\nNumber of fixed disks: %d\n", nDisks);
  658.  
  659.   nCDROMs = CDFind(0);
  660.   printf("Number of CD-ROM drives: %d\n", nCDROMs);
  661.  
  662.   if (argc > 1)
  663.   {
  664.     nDisks = nCDROMs = 0;
  665.  
  666.     for (nCount = 1; nCount < argc; )
  667.       if (stricmp(argv[nCount], "-hd") == 0)
  668.       {
  669.     for (nCount++; argv[nCount][0] != '-'; nCount++)
  670.       xHD[nDisks++] = atoi(argv[nCount]);
  671.       }
  672.       else if (stricmp(argv[nCount], "-cd") == 0)
  673.       {
  674.     for (nCount++; argv[nCount][0] != '-'; nCount++)
  675.       xCD[nCDROMs++] = atoi(argv[nCount]);
  676.       }      
  677.       else if (stricmp(argv[nCount], "-c") == 0)
  678.       {
  679.     if (argv[nCount + 1][0] != '-' && argv[nCount + 2][0] != '-')
  680.     {
  681.       cHD = atoi(argv[nCount + 1]);
  682.       cCD = atoi(argv[nCount + 2]);
  683.       nCount += 3;
  684.     }
  685.       }
  686.       else if (stricmp(argv[nCount], "-?") == 0)
  687.       {
  688.     printf("\nUsage:\tdiskio [options]\n"
  689.            "\n\t-hd <list of hard disk numbers>"
  690.            "\n\t-cd <list of CD-ROM drive numbers>"
  691.                  "\n\t-c  <pair of hard disk and CD-ROM drive numbers>\n"
  692.            "\nHard disk and CD-ROM drive numbers are physical ones and start at 1."
  693.            "\nThe drive number lists must be blank separated.\n"
  694.            "\nWith -cd, -hd and -c you can explicitly select the drives to be used"
  695.            "\nfor hard disk, CD-ROM drive and concurrent hard disk and CD-ROM benchmarks.\n"
  696.            "\nIf none of them is used, all drives are used for hard disk and CD-ROM"
  697.            "\ndrive benchmarks and the first hard disk and CD-ROM drives are used"
  698.            "\nfor the concurrent hard disk and CD-ROM benchmark\n"
  699.            "\nExample: diskio -hd 2 3 -cd 1 -c 3 1\n");
  700.     exit(1);
  701.       }
  702.  
  703.       else
  704.     nCount++;
  705.   }
  706.   else
  707.   {
  708.     for (nCount = 1; nCount <= nDisks; nCount++)
  709.       xHD[nCount - 1] = nCount;
  710.  
  711.     for (nCount = 1; nCount <= nCDROMs; nCount++)
  712.       xCD[nCount - 1] = nCount;
  713.  
  714.     if (nDisks > 0 && nCDROMs > 0)
  715.       cHD = cCD = 1;
  716.   }
  717.  
  718.   printf("\nDhrystone 2.1 C benchmark routines (C) 1988 Reinhold P. Weicker\n");
  719.   bench_dhry();
  720.  
  721.   for (nCount = 0; nCount < nDisks; nCount++)
  722.     bench_hd(xHD[nCount]);
  723.  
  724.   for (nCount = 0; nCount < nCDROMs; nCount++)
  725.     bench_cd(xCD[nCount]);
  726.  
  727.   if (cHD != 0 && cCD != 0)
  728.     bench_concurrent(cHD, cCD);
  729.  
  730.   return 0;
  731. }
  732.  
  733. /* end of diskio.c */
  734.