home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 8 Other / 08-Other.zip / diski117.zip / diskio.c < prev    next >
C/C++ Source or Header  |  1999-10-28  |  26KB  |  1,079 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.17 1999/10/28 17:33:33 rommel Exp rommel $";
  9. static char *rcsrev = "$Revision: 1.17 $";
  10.  
  11. /*
  12.  * $Log: diskio.c,v $
  13.  * Revision 1.17  1999/10/28 17:33:33  rommel
  14.  * corrected OS/2 timer code
  15.  *
  16.  * Revision 1.16  1999/10/25 08:36:28  rommel
  17.  * corrected timer code for NT
  18.  *
  19.  * Revision 1.15  1998/07/05 07:44:17  rommel
  20.  * added Windows NT version
  21.  * added multi disk benchmark
  22.  * added preliminary multi thread I/O benchmark
  23.  * many fixes
  24.  * general cleanup
  25.  *
  26.  * Revision 1.14  1998/01/05 18:04:04  rommel
  27.  * add fix for CD-ROM size detection problem
  28.  *
  29.  * Revision 1.13  1997/03/01 20:36:55  rommel
  30.  * handle media access errors more gracefully
  31.  *
  32.  * Revision 1.12  1997/03/01 20:21:35  rommel
  33.  * catch a few bugs and obscure situations,
  34.  * increase accuracy, too
  35.  *
  36.  * Revision 1.11  1997/02/09 15:06:38  rommel
  37.  * changed command line interface
  38.  *
  39.  * Revision 1.10  1997/01/12 21:15:10  rommel
  40.  * added CD-ROM benchmarks
  41.  *
  42.  * Revision 1.9  1995/12/31 20:24:09  rommel
  43.  * Changed CPU load calculation
  44.  * General cleanup
  45.  *
  46.  * Revision 1.8  1995/12/28 11:28:07  rommel
  47.  * Fixed async timer problem.
  48.  *
  49.  * Revision 1.7  1995/12/28 10:04:15  rommel
  50.  * Added CPU benchmark (concurrently to disk I/O)
  51.  *
  52.  * Revision 1.6  1995/11/24 16:02:10  rommel
  53.  * Added bus/drive cache speed test by 
  54.  * repeatedly reading a small amount of data
  55.  *
  56.  * Revision 1.5  1995/08/09 13:07:02  rommel
  57.  * Changes for new diskacc2 library, minor corrections, arguments.
  58.  *
  59.  * Revision 1.4  1994/07/11 14:23:00  rommel
  60.  * Changed latency timing
  61.  *
  62.  * Revision 1.3  1994/07/09 13:07:20  rommel
  63.  * Changed transfer speed test
  64.  *
  65.  * Revision 1.2  1994/07/08 21:53:05  rommel
  66.  * Cleanup
  67.  *
  68.  * Revision 1.1  1994/07/08 21:29:41  rommel
  69.  * Initial revision
  70.  * 
  71.  */
  72.  
  73. #include <stdio.h>
  74. #include <stdlib.h>
  75. #include <string.h>
  76.  
  77. #include "diskacc.h"
  78.  
  79. #define INTERVAL     10
  80. #define MAXTHREADS   4
  81. #define THREADSTACK  65536
  82.  
  83. char *pBuffer;
  84.  
  85. int time_over;
  86. long dhry_result, dhry_stones;
  87.  
  88. extern unsigned long Number_Of_Runs;
  89. extern long dhry_stone(void);
  90.  
  91. #ifdef OS2
  92.  
  93. #define INCL_DOS
  94. #define INCL_DOSDEVICES
  95. #define INCL_DOSDEVIOCTL
  96. #define INCL_DOSERRORS
  97. #define INCL_NOPM
  98. #include <os2.h>
  99.  
  100. #define idle_priority() \
  101.   DosSetPriority(PRTYS_THREAD, PRTYC_IDLETIME, PRTYD_MAXIMUM, 0)
  102. #define normal_priority() \
  103.   DosSetPriority(PRTYS_THREAD, PRTYC_REGULAR, PRTYD_MINIMUM, 0)
  104.  
  105. typedef HEV semaphore;
  106. static ULONG nSemCount;
  107. #define create_sem(phsem) \
  108.   DosCreateEventSem(0, phsem, 0, FALSE)
  109. #define destroy_sem(hsem) \
  110.   DosCloseEventSem(hsem)
  111. #define post_sem(hsem) \
  112.   DosPostEventSem(hsem)
  113. #define reset_sem(hsem) \
  114.   DosResetEventSem(hsem, nSemCount)
  115. #define wait_sem(hsem) \
  116.   DosWaitEventSem(hsem, SEM_INDEFINITE_WAIT)
  117.  
  118. typedef QWORD TIMER;
  119.  
  120. HEV hSemTimer;
  121.  
  122. VOID APIENTRY timer_thread(ULONG nArg)
  123. {
  124.   HTIMER hTimer;
  125.  
  126.   DosCreateEventSem(0, &hSemTimer, DC_SEM_SHARED, 0);
  127.   DosAsyncTimer(nArg * 1000, (HSEM) hSemTimer, &hTimer);
  128.   DosWaitEventSem(hSemTimer, SEM_INDEFINITE_WAIT);
  129.   DosStopTimer(hTimer);
  130.   DosCloseEventSem(hSemTimer);
  131.  
  132.   time_over = 1;
  133.   Number_Of_Runs = 0;
  134.  
  135.   DosExit(EXIT_THREAD, 0);
  136. }
  137.  
  138. int start_alarm(ULONG nSeconds)
  139. { 
  140.   TID ttid;
  141.  
  142.   time_over = 0;
  143.   Number_Of_Runs = -1;
  144.  
  145.   if (DosCreateThread(&ttid, timer_thread, nSeconds, 0, THREADSTACK))
  146.     return printf("Cannot create timer thread.\n"), -1;
  147.  
  148.   return 0;
  149. }
  150.  
  151. void stop_alarm(void)
  152. {
  153.   DosPostEventSem(hSemTimer);
  154. }
  155.  
  156. int start_timer(TIMER *nStart)
  157. {
  158.   if (DosTmrQueryTime(nStart))
  159.     return printf("Timer error.\n"), -1;
  160.  
  161.   return 0;
  162. }
  163.  
  164. int stop_timer(TIMER *nStart, int accuracy)
  165. {
  166.   TIMER nStop;
  167.   ULONG nFreq;
  168.  
  169.   if (DosTmrQueryTime(&nStop))
  170.     return printf("Timer error.\n"), -1;
  171.   if (DosTmrQueryFreq(&nFreq))
  172.     return printf("Timer error.\n"), -1;
  173.  
  174.   nFreq = (nFreq + accuracy / 2) / accuracy;
  175.  
  176.   return (* (__int64*) &nStop - * (__int64*) nStart) / nFreq;
  177. }
  178.  
  179. #endif
  180.  
  181. #ifdef WIN32
  182.  
  183. /* the following perhaps only works with IBM's compiler */
  184. #define _INTEGRAL_MAX_BITS 64
  185. #include <windows.h>
  186.  
  187. #define idle_priority() \
  188.   SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_IDLE)
  189. #define normal_priority() \
  190.   SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL)
  191.  
  192. typedef HANDLE semaphore;
  193. #define create_sem(phsem) \
  194.   (*(phsem) = CreateEvent(0, TRUE, FALSE, 0))
  195. #define destroy_sem(hsem) \
  196.   CloseHandle(hsem)
  197. #define post_sem(hsem) \
  198.   SetEvent(hsem)
  199. #define reset_sem(hsem) \
  200.   ResetEvent(hsem)
  201. #define wait_sem(hsem) \
  202.   WaitForSingleObject(hsem, INFINITE)
  203.  
  204. typedef LARGE_INTEGER TIMER;
  205.  
  206. HANDLE hTimerThread;
  207.  
  208. DWORD CALLBACK timer_thread(void * pArg)
  209. {
  210.   Sleep((UINT) pArg * 1000);
  211.  
  212.   time_over = 1;
  213.   Number_Of_Runs = 0;
  214.  
  215.   return 0;
  216. }
  217.  
  218. int start_alarm(long nSeconds)
  219. { 
  220.   DWORD ttid;
  221.  
  222.   time_over = 0;
  223.   Number_Of_Runs = -1;
  224.  
  225.   hTimerThread = CreateThread(0, THREADSTACK, timer_thread, (void *) nSeconds, 0, &ttid);
  226.  
  227.   if (hTimerThread == NULL)
  228.     return printf("Cannot create timer thread.\n"), -1;
  229.  
  230.   return 0;
  231. }
  232.  
  233. void stop_alarm(void)
  234. {
  235.   TerminateThread(hTimerThread, 0);
  236.  
  237.   time_over = 1;
  238.   Number_Of_Runs = 0;
  239. }
  240.  
  241. int start_timer(TIMER *nStart)
  242. {
  243.   if (!QueryPerformanceCounter(nStart))
  244.     return printf("Timer error.\n"), -1;
  245.  
  246.   return 0;
  247. }
  248.  
  249. unsigned long stop_timer(TIMER *nStart, int nAccuracy)
  250. {
  251.   TIMER nStop, nFreq;
  252.  
  253.   if (!QueryPerformanceCounter(&nStop))
  254.     return printf("Timer error.\n"), -1;
  255.   if (!QueryPerformanceFrequency(&nFreq))
  256.     return printf("Timer error.\n"), -1;
  257.  
  258.   nFreq.QuadPart = (nFreq.QuadPart + nAccuracy / 2) / nAccuracy;
  259.  
  260.   return (nStop.QuadPart - nStart->QuadPart) / nFreq.QuadPart;
  261. }
  262.  
  263. #endif
  264.  
  265. typedef struct 
  266. {
  267.   int nHandle, nData, nCnt;
  268.   unsigned nSector, nSides, nSectors, nTracks;
  269.   void *pBuffer;
  270.   semaphore sDone;
  271. }
  272. THREADPARMS;
  273.  
  274. void run_dhrystone(void)
  275. {
  276.   long dhry_time = dhry_stone();
  277.  
  278.   /* originally, time is measured in ms */
  279.   dhry_time = (dhry_time + 5) / 10;
  280.   /* now it is in units of 10 ms */
  281.  
  282.   if (dhry_time == 0)
  283.     dhry_time = 1; /* if less than 10 ms, then assume at least 10 ms */
  284.  
  285.   /* now calculate runs per second */
  286.   dhry_stones = Number_Of_Runs * 100 / dhry_time;
  287.   /* by the time we cross 20 million dhrystones per second with a CPU, 
  288.      we will hopefully have only 64-bit machines to run this on ... */
  289. }
  290.  
  291. void dhry_thread(void *nArg)
  292. {
  293.   idle_priority();
  294.   run_dhrystone();
  295.  
  296.   _endthread();
  297. }
  298.  
  299. int bench_hd_bus(int nHandle, unsigned nSides, unsigned nSectors, unsigned nSector)
  300. {
  301.   int nCnt = 0, nData = 0, nTime, nTrack;
  302.   TIMER nLocal;
  303.  
  304.   printf("Drive cache/bus transfer rate: ");
  305.   fflush(stdout);
  306.  
  307.   if (start_alarm(INTERVAL))
  308.     return -1;
  309.  
  310.   if (start_timer(&nLocal))
  311.     return -1;
  312.  
  313.   while (!time_over)
  314.   {
  315.     if (DskRead(nHandle, 0, 0, 1, nSectors, pBuffer))
  316.     {
  317.       stop_alarm();
  318.       printf("Disk read error.\n");
  319.       return -1;
  320.     }
  321.  
  322.     nData += nSectors * nSector;
  323.   }
  324.  
  325.   if ((nTime = stop_timer(&nLocal, 1024)) == -1)
  326.     return -1;
  327.  
  328.   printf("%d k/sec\n", nData / nTime);
  329.  
  330.   return 0;
  331. }
  332.  
  333. int bench_hd_transfer(int nHandle, int nTrack, int nDirection, 
  334.               unsigned nSides, unsigned nSectors, unsigned nSector)
  335. {
  336.   int nCnt, nData = 0, nTime;
  337.   TIMER nLocal;
  338.  
  339.   printf("Data transfer rate on cylinder %-4d: ", nTrack);
  340.   fflush(stdout);
  341.  
  342.   if (start_alarm(INTERVAL))
  343.     return -1;
  344.  
  345.   if (start_timer(&nLocal))
  346.     return -1;
  347.  
  348.   for (nCnt = 0; !time_over; nCnt++)
  349.   {
  350.     if (DskRead(nHandle, nCnt % nSides, 
  351.         nTrack + (nCnt / nSides) * nDirection, 1, nSectors, pBuffer))
  352.     {
  353.       stop_alarm();
  354.       printf("Disk read error.\n");
  355.       return -1;
  356.     }
  357.  
  358.     nData += nSectors * nSector;
  359.   }
  360.  
  361.   if ((nTime = stop_timer(&nLocal, 1024)) == -1)
  362.     return -1;
  363.  
  364.   printf("%d k/sec\n", nData / nTime);
  365.  
  366.   return 0;
  367. }
  368.  
  369. int bench_hd_cpuusage(int nHandle, unsigned nSides, 
  370.               unsigned nSectors, unsigned nSector)
  371. {
  372.   int nCnt, nData = 0, nTime, nPercent;
  373.   TIMER nLocal;
  374.  
  375.   printf("CPU usage by full speed disk transfers: ");
  376.   fflush(stdout);
  377.  
  378.   if (start_alarm(INTERVAL))
  379.     return -1;
  380.  
  381.   if (_beginthread(dhry_thread, 0, THREADSTACK, 0) == -1)
  382.     return -1;
  383.  
  384.   if (start_timer(&nLocal))
  385.     return -1;
  386.  
  387.   for (nCnt = 0; !time_over; nCnt++)
  388.   {
  389.     if (DskRead(nHandle, nCnt % nSides, nCnt / nSides, 1, nSectors, pBuffer))
  390.     {
  391.       stop_alarm();
  392.       printf("Disk read error.\n");
  393.       return -1;
  394.     }
  395.  
  396.     nData += nSectors * nSector;
  397.   }
  398.  
  399.   if ((nTime = stop_timer(&nLocal, 1024)) == -1)
  400.     return -1;
  401.  
  402.   nPercent = (dhry_result - dhry_stones) * 100 / dhry_result;
  403.  
  404.   printf("%d%%\n", nPercent);
  405.  
  406.   return 0;
  407. }
  408.  
  409. int bench_hd_latency(int nHandle, unsigned nTracks, unsigned nSides, unsigned nSectors)
  410. {
  411.   int nCnt, nSector, nTime;
  412.   TIMER nLocal;
  413.  
  414.   printf("Average latency time: ");
  415.   fflush(stdout);
  416.  
  417.   srand(1);
  418.  
  419.   if (start_alarm(INTERVAL))
  420.     return -1;
  421.  
  422.   if (start_timer(&nLocal))
  423.     return -1;
  424.  
  425.   for (nCnt = 0; !time_over; nCnt++)
  426.   {
  427.     nSector = rand() * nSectors / RAND_MAX + 1;
  428.  
  429.     if (DskRead(nHandle, 0, 0, nSector, 1, pBuffer))
  430.     {
  431.       stop_alarm();
  432.       printf("Disk read error.\n");
  433.       return -1;
  434.     }
  435.   }
  436.  
  437.   if ((nTime = stop_timer(&nLocal, 1000)) == -1)
  438.     return -1;
  439.  
  440.   nTime = nTime * 10 / nCnt;
  441.  
  442.   printf("%d.%d ms\n", nTime / 10, nTime % 10);
  443.  
  444.   return nTime;
  445. }
  446.  
  447. int bench_hd_seek(int nHandle, unsigned nTracks, unsigned nSides, unsigned nSectors)
  448. {
  449.   int nCnt, nSide, nTrack, nSector, nTime;
  450.   TIMER nLocal;
  451.  
  452.   printf("Average data access time: ");
  453.   fflush(stdout);
  454.  
  455.   srand(1);
  456.  
  457.   if (start_alarm(INTERVAL))
  458.     return -1;
  459.  
  460.   if (start_timer(&nLocal))
  461.     return -1;
  462.  
  463.   for (nCnt = 0; !time_over; nCnt++)
  464.   {
  465.     nSide   = rand() * nSides   / RAND_MAX;
  466.     nSector = rand() * nSectors / RAND_MAX;
  467.     nTrack  = rand() * nTracks  / RAND_MAX;
  468.  
  469.     if (DskRead(nHandle, nSide, nTrack, nSector, 1, pBuffer))
  470.     {
  471.       stop_alarm();
  472.       printf("Disk read error.\n");
  473.       return -1;
  474.     }
  475.   }
  476.  
  477.   if ((nTime = stop_timer(&nLocal, 1000)) == -1)
  478.     return -1;
  479.  
  480.   nTime = nTime * 10 / nCnt;
  481.  
  482.   printf("%d.%d ms\n", nTime / 10, nTime % 10);
  483.  
  484.   return 0;
  485. }
  486.  
  487. void bench_hd_thread(void *pArg)
  488. {
  489.   THREADPARMS *ptr = (THREADPARMS *) pArg;
  490.   int nTrack, nSide;
  491.  
  492. #if 0
  493.   srand(1);
  494. #endif
  495.  
  496.   while (!time_over)
  497.   {
  498. #if 0
  499.     nTrack = rand() * ptr->nTracks / RAND_MAX;
  500.     nSide = rand() * ptr->nSides / RAND_MAX;
  501. #else
  502.     nTrack = ptr->nCnt / ptr->nSides;
  503.     nSide = ptr->nCnt % ptr->nSides;
  504.     ptr->nCnt += MAXTHREADS;
  505. #endif
  506.  
  507.     if (DskRead(ptr->nHandle, nSide, nTrack, 1, ptr->nSectors, ptr->pBuffer))
  508.     {
  509.       stop_alarm();
  510.       printf("Disk read error.\n");
  511.       break;
  512.     }
  513.  
  514.     ptr->nData += ptr->nSectors * ptr->nSector;
  515.   }
  516.  
  517.   post_sem(ptr->sDone);
  518.  
  519.   _endthread();
  520. }
  521.  
  522. int bench_hd_mthread(int nHandle, unsigned nTracks, unsigned nSides, 
  523.              unsigned nSectors, unsigned nSector)
  524. {
  525.   int nTime, nPercent, nCnt, nTotal;
  526.   THREADPARMS tHD[MAXTHREADS];
  527.   TIMER nLocal;
  528.  
  529.   printf("Multithreaded disk I/O (%d threads): ", MAXTHREADS);
  530.   fflush(stdout);
  531.  
  532.   for (nCnt = 0; nCnt < MAXTHREADS; nCnt++)
  533.   {
  534.     tHD[nCnt].nHandle  = nHandle;
  535.     tHD[nCnt].nTracks  = nTracks;
  536.     tHD[nCnt].nSides   = nSides;
  537.     tHD[nCnt].nSectors = nSectors;
  538.     tHD[nCnt].nSector  = nSector;
  539.     tHD[nCnt].nData    = 0;
  540.     tHD[nCnt].nCnt     = nCnt;
  541.  
  542.     if ((tHD[nCnt].pBuffer = DskAlloc(nSectors, nSector)) == NULL)
  543.       return printf("\nNot enough memory.\n"), -1;
  544.  
  545.     create_sem(&(tHD[nCnt].sDone));
  546.   }
  547.  
  548.   if (start_alarm(INTERVAL))
  549.     return -1;
  550.  
  551.   if (start_timer(&nLocal))
  552.     return -1;
  553.  
  554.   for (nCnt = 0; nCnt < MAXTHREADS; nCnt++)
  555.     if (_beginthread(bench_hd_thread, 0, THREADSTACK, tHD + nCnt) == -1)
  556.       return -1;
  557.  
  558.   idle_priority();
  559.   run_dhrystone();
  560.   normal_priority();
  561.  
  562.   if ((nTime = stop_timer(&nLocal, 1024)) == -1)
  563.     return -1;
  564.  
  565.   nPercent = (dhry_result - dhry_stones) * 100 / dhry_result;
  566.   nTotal = 0;
  567.  
  568.   for (nCnt = 0; nCnt < MAXTHREADS; nCnt++)
  569.   {
  570.     wait_sem(tHD[nCnt].sDone);
  571.     destroy_sem(tHD[nCnt].sDone);
  572.  
  573.     DskFree(tHD[nCnt].pBuffer);
  574.  
  575.     nTotal += tHD[nCnt].nData;
  576.   }
  577.  
  578.   printf("%d k/sec, %d%% CPU usage\n", nTotal / nTime, nPercent);
  579.  
  580.   return 0;
  581. }
  582.  
  583. int bench_hd(int nDisk)
  584. {
  585.   int nHandle;
  586.   unsigned nSector, nSides, nTracks, nSectors;
  587.   char szName[8];
  588.  
  589.   sprintf(szName, "$%d:", nDisk);
  590.  
  591.   if ((nHandle = DskOpen(szName, 0, 0, &nSector, &nSides, &nTracks, &nSectors)) < 0)
  592.     return printf("\nCannot access disk %d.\n", nDisk), -1;
  593.  
  594.   printf("\nHard disk %d: %d sides, %d cylinders, %d sectors per track = %d MB\n", 
  595.      nDisk, nSides, nTracks, nSectors,
  596.      nSides * nTracks * nSectors / 2048);
  597.  
  598.   if ((pBuffer = DskAlloc(nSectors, nSector)) == NULL)
  599.     return printf("\nNot enough memory.\n"), -1;
  600.  
  601.   bench_hd_bus(nHandle, nSides, nSectors, nSector);
  602.   bench_hd_transfer(nHandle, 0, 1, nSides, nSectors, nSector);
  603.   bench_hd_transfer(nHandle, nTracks - 2, -1, nSides, nSectors, nSector);
  604.   bench_hd_cpuusage(nHandle, nSides, nSectors, nSector);
  605.   /* bench_hd_latency(nHandle, nTracks, nSides, nSectors); */
  606.   bench_hd_seek(nHandle, nTracks, nSides, nSectors);
  607.   bench_hd_mthread(nHandle, nTracks, nSides, nSectors, nSector);
  608.  
  609.   DskFree(pBuffer);
  610.   DskClose(nHandle);
  611.  
  612.   return 0;
  613. }
  614.  
  615. int bench_cd_transfer(int nHandle, int nStart, int nSectors)
  616. {
  617.   int nCnt, nData = 0, nTime, nRate;
  618.   TIMER nLocal;
  619.  
  620.   printf("Data transfer rate at sector %-8d: ", nStart);
  621.   fflush(stdout);
  622.   
  623.   if (start_alarm(INTERVAL))
  624.     return -1;
  625.  
  626.   if (start_timer(&nLocal))
  627.     return -1;
  628.  
  629.   for (nCnt = 0; !time_over; nCnt++)
  630.   {
  631.     if (nStart + nCnt * 32 + 32 > nSectors)
  632.       nCnt = 0;
  633.  
  634.     if (CDRead(nHandle, nStart + nCnt * 32, 32, pBuffer) == -1)
  635.     {
  636.       stop_alarm();
  637.       printf("CD-ROM read error.\n");
  638.       return -1;
  639.     }
  640.  
  641.     nData += 32 * 2048;
  642.   }
  643.  
  644.   if ((nTime = stop_timer(&nLocal, 1024)) == -1)
  645.     return -1;
  646.  
  647.   nRate = nData / nTime;
  648.   printf("%d k/sec (~%.1fx)\n", nRate, (double) nRate / 150.0);
  649.  
  650.   return 0;
  651. }
  652.  
  653. int bench_cd_cpuusage(int nHandle, int nStart)
  654. {
  655.   int nCnt, nData = 0, nTime, nPercent;
  656.   TIMER nLocal;
  657.  
  658.   printf("CPU usage by full speed reads (middle of medium): ");
  659.   fflush(stdout);
  660.  
  661.   if (start_alarm(INTERVAL))
  662.     return -1;
  663.  
  664.   if (_beginthread(dhry_thread, 0, THREADSTACK, 0) == -1)
  665.     return -1;
  666.  
  667.   if (start_timer(&nLocal))
  668.     return -1;
  669.  
  670.   for (nCnt = 0; !time_over; nCnt++)
  671.   {
  672.     if (CDRead(nHandle, nStart + nCnt * 32, 32, pBuffer) == -1)
  673.     {
  674.       stop_alarm();
  675.       printf("CD-ROM read error.\n");
  676.       return -1;
  677.     }
  678.  
  679.     nData += 32 * 2048;
  680.   }
  681.  
  682.   if ((nTime = stop_timer(&nLocal, 1024)) == -1)
  683.     return -1;
  684.  
  685.   nPercent = (dhry_result - dhry_stones) * 100 / dhry_result;
  686.  
  687.   printf("%d%%\n", nPercent);
  688.  
  689.   return 0;
  690. }
  691.  
  692. int bench_cd_seek(int nHandle, unsigned nSectors)
  693. {
  694.   int nCnt, nSector, nTime;
  695.   TIMER nLocal;
  696.  
  697.   printf("Average data access time: ");
  698.   fflush(stdout);
  699.  
  700.   srand(1);
  701.  
  702.   if (start_alarm(INTERVAL))
  703.     return -1;
  704.  
  705.   if (start_timer(&nLocal))
  706.     return -1;
  707.  
  708.   for (nCnt = 0; !time_over; nCnt++)
  709.   {
  710.     nSector = (nSectors * 1000) / RAND_MAX;
  711.     nSector = nSector * rand() / 1000;
  712.  
  713.     if (CDRead(nHandle, nSector, 1, pBuffer) != 1)
  714.     {
  715.       stop_alarm();
  716.       printf("CD-ROM read error.\n");
  717.       return -1;
  718.     }
  719.   }
  720.  
  721.   if ((nTime = stop_timer(&nLocal, 1000)) == -1)
  722.     return -1;
  723.  
  724.   nTime = nTime * 10 / nCnt;
  725.  
  726.   printf("%d.%d ms\n", nTime / 10, nTime % 10);
  727.  
  728.   return 0;
  729. }
  730.  
  731. int bench_cd(int nDrive)
  732. {
  733.   int nHandle, nDriveLetter, nCnt;
  734.   unsigned nSectors;
  735.   char szName[8], szUPC[8];
  736.  
  737.   if ((nDriveLetter = CDFind(nDrive)) == -1)
  738.     return printf("\nCannot access CD-ROM drive %d.\n", nDrive), -1;
  739.  
  740.   sprintf(szName, "%c:", nDriveLetter);
  741.  
  742.   if ((nHandle = CDOpen(szName, 1, szUPC, &nSectors)) == -1)
  743.     return printf("\nCannot access CD-ROM drive %d.\n", nDrive), -1;
  744.  
  745.   printf("\nCD-ROM drive %s medium has %d sectors = %d MB\n", 
  746.      szName, nSectors, nSectors / 512);
  747.  
  748.   if ((pBuffer = DskAlloc(32, 2048)) == NULL)
  749.     return printf("\nNot enough memory.\n"), -1;
  750.  
  751.   /* spin up and seek to first sector */
  752.   if (CDRead(nHandle, nSectors - 64, 32, pBuffer) == -1)
  753.     return printf("CD-ROM read error.\n"), -1;
  754.   for (nCnt = 0; nCnt < 512; nCnt += 32)
  755.     if (CDRead(nHandle, nSectors / 2 + nCnt, 32, pBuffer) == -1)
  756.       return printf("CD-ROM read error.\n"), -1;
  757.   if (CDRead(nHandle, 0, 32, pBuffer) == -1)
  758.     return printf("CD-ROM read error.\n"), -1;
  759.  
  760.   bench_cd_transfer(nHandle, 0, nSectors);
  761.   bench_cd_transfer(nHandle, nSectors - 32768, nSectors);
  762.   bench_cd_cpuusage(nHandle, nSectors / 2);
  763.   bench_cd_seek(nHandle, nSectors);
  764.  
  765.   DskFree(pBuffer);
  766.   CDClose(nHandle);
  767.  
  768.   return 0;
  769. }
  770.  
  771. void bench_concurrent_hd(void *pArg)
  772. {
  773.   THREADPARMS *ptr = (THREADPARMS *) pArg;
  774.   int nCnt;
  775.  
  776.   for (nCnt = 0; !time_over; nCnt++)
  777.   {
  778.     if (DskRead(ptr->nHandle, nCnt % ptr->nSides, nCnt / ptr->nSides, 1, 
  779.         ptr->nSectors, ptr->pBuffer))
  780.     {
  781.       stop_alarm();
  782.       printf("Disk read error.\n");
  783.       break;
  784.     }
  785.  
  786.     ptr->nData += ptr->nSectors * ptr->nSector;
  787.   }
  788.  
  789.   post_sem(ptr->sDone);
  790.  
  791.   _endthread();
  792. }
  793.  
  794. int bench_concurrent_allhds(int *nHD, int nDisks)
  795. {
  796.   int nTime, nPercent, nTotal, nCnt;
  797.   char szName[8];
  798.   THREADPARMS tHD[256];
  799.   TIMER nLocal;
  800.  
  801.   printf("\nConcurrent full speed reads on %d hard disks: ", nDisks);
  802.   fflush(stdout);
  803.  
  804.   for (nCnt = 0; nCnt < nDisks; nCnt++)
  805.   {
  806.     sprintf(szName, "$%d:", nHD[nCnt]);
  807.  
  808.     if ((tHD[nCnt].nHandle = DskOpen(szName, 0, 0, &tHD[nCnt].nSector,
  809.                      &tHD[nCnt].nSides, &tHD[nCnt].nTracks, 
  810.                      &tHD[nCnt].nSectors)) < 0)
  811.       return printf("\nCannot access disk %d.\n", nHD[nCnt]), -1;
  812.  
  813.     if ((tHD[nCnt].pBuffer = DskAlloc(tHD[nCnt].nSectors, 
  814.                       tHD[nCnt].nSector)) == NULL)
  815.       return printf("\nNot enough memory.\n"), -1;
  816.  
  817.     create_sem(&tHD[nCnt].sDone);
  818.     tHD[nCnt].nData = tHD[nCnt].nCnt = nCnt;
  819.   }
  820.  
  821.   if (start_alarm(INTERVAL))
  822.     return -1;
  823.  
  824.   if (start_timer(&nLocal))
  825.     return -1;
  826.  
  827.   for (nCnt = 0; nCnt < nDisks; nCnt++)
  828.     if (_beginthread(bench_concurrent_hd, 0, THREADSTACK, tHD + nCnt) == -1)
  829.       return -1;
  830.  
  831.   idle_priority();
  832.   run_dhrystone();
  833.   normal_priority();
  834.  
  835.   if ((nTime = stop_timer(&nLocal, 1024)) == -1)
  836.     return -1;
  837.  
  838.   nPercent = (dhry_result - dhry_stones) * 100 / dhry_result;
  839.   nTotal = 0;
  840.  
  841.   for (nCnt = 0; nCnt < nDisks; nCnt++)
  842.   {
  843.     wait_sem(tHD[nCnt].sDone);
  844.     destroy_sem(tHD[nCnt].sDone);
  845.  
  846.     DskFree(tHD[nCnt].pBuffer);
  847.     DskClose(tHD[nCnt].nHandle);
  848.  
  849.     nTotal += tHD[nCnt].nData;
  850.   }
  851.  
  852.   printf("\nCombined throughput: %d k/sec\n", nTotal / nTime);
  853.   printf("CPU usage: %d%%\n", nPercent);
  854.  
  855.   return 0;
  856. }
  857.  
  858. void bench_concurrent_cd(void *pArg)
  859. {
  860.   THREADPARMS *ptr = (THREADPARMS *) pArg;
  861.   int nCnt, nStart = ptr->nSectors / 2;
  862.  
  863.   for (nCnt = 0; !time_over; nCnt++)
  864.   {
  865.     if (CDRead(ptr->nHandle, nStart + nCnt * 32, 32, ptr->pBuffer) == -1)
  866.     {
  867.       stop_alarm();
  868.       printf("CD-ROM read error.\n");
  869.       break;
  870.     }
  871.  
  872.     ptr->nData += 32 * 2048;
  873.   }
  874.  
  875.   post_sem(ptr->sDone);
  876.  
  877.   _endthread();
  878. }
  879.  
  880. int bench_concurrent_hdcd(int nDisk, int nCD)
  881. {
  882.   int nDriveLetter, nTime, nPercent, nCnt;
  883.   char szName[8], szUPC[8];
  884.   THREADPARMS tHD, tCD;
  885.   TIMER nLocal;
  886.  
  887.   printf("\nConcurrent hard disk %d and CD-ROM %d reads at full speed: ", nDisk, nCD);
  888.   fflush(stdout);
  889.  
  890.   sprintf(szName, "$%d:", nDisk);
  891.  
  892.   if ((tHD.nHandle = DskOpen(szName, 0, 0, &tHD.nSector,
  893.                  &tHD.nSides, &tHD.nTracks, &tHD.nSectors)) < 0)
  894.     return printf("\nCannot access disk %d.\n", nDisk), -1;
  895.  
  896.   if ((tHD.pBuffer = DskAlloc(tHD.nSectors, tHD.nSector)) == NULL)
  897.     return printf("\nNot enough memory.\n"), -1;
  898.  
  899.   create_sem(&tHD.sDone);
  900.   tHD.nData = tHD.nCnt = 0;
  901.  
  902.   if ((nDriveLetter = CDFind(nCD)) == -1)
  903.     return printf("\nCannot access CD-ROM drive %d.\n", nCD), -1;
  904.  
  905.   sprintf(szName, "%c:", nDriveLetter);
  906.  
  907.   if ((tCD.nHandle = CDOpen(szName, 1, szUPC, &tCD.nSectors)) == -1)
  908.     return printf("\nCannot access CD-ROM drive %d.\n", nCD), -1;
  909.  
  910.   if ((tCD.pBuffer = DskAlloc(32, 2048)) == NULL)
  911.     return printf("\nNot enough memory.\n"), -1;
  912.  
  913.   /* spin up and seek to first sector */
  914.   if (CDRead(tCD.nHandle, tCD.nSectors - 64, 32, tCD.pBuffer) == -1)
  915.     return printf("CD-ROM read error.\n"), -1;
  916.   for (nCnt = 0; nCnt < 512; nCnt += 32)
  917.     if (CDRead(tCD.nHandle, tCD.nSectors / 2 + nCnt, 32, tCD.pBuffer) == -1)
  918.       return printf("CD-ROM read error.\n"), -1;
  919.   if (CDRead(tCD.nHandle, 0, 32, tCD.pBuffer) == -1)
  920.     return printf("CD-ROM read error.\n"), -1;
  921.  
  922.   create_sem(&tCD.sDone);
  923.   tCD.nData = tCD.nCnt = 0;
  924.  
  925.   if (start_alarm(INTERVAL))
  926.     return -1;
  927.  
  928.   if (start_timer(&nLocal))
  929.     return -1;
  930.  
  931.   if (_beginthread(bench_concurrent_hd, 0, THREADSTACK, &tHD) == -1)
  932.     return -1;
  933.   if (_beginthread(bench_concurrent_cd, 0, THREADSTACK, &tCD) == -1)
  934.     return -1;
  935.  
  936.   idle_priority();
  937.   run_dhrystone();
  938.   normal_priority();
  939.  
  940.   if ((nTime = stop_timer(&nLocal, 1024)) == -1)
  941.     return -1;
  942.  
  943.   wait_sem(tHD.sDone);
  944.   destroy_sem(tHD.sDone);
  945.  
  946.   DskFree(tHD.pBuffer);
  947.   DskClose(tHD.nHandle);
  948.  
  949.   wait_sem(tCD.sDone);
  950.   destroy_sem(tCD.sDone);
  951.  
  952.   DskFree(tCD.pBuffer);
  953.   CDClose(tCD.nHandle);
  954.  
  955.   printf("\nHard disk throughput (cylinder 0): %d k/sec\n", tHD.nData / nTime);
  956.   printf("CD-ROM throughput (middle of medium): %d k/sec\n", tCD.nData / nTime);
  957.  
  958.   nPercent = (dhry_result - dhry_stones) * 100 / dhry_result;
  959.   printf("CPU usage: %d%%\n", nPercent);
  960.  
  961.   return 0;
  962. }
  963.  
  964. int bench_dhry(void)
  965. {
  966.   printf("Dhrystone benchmark for this CPU: ");
  967.   fflush(stdout);
  968.  
  969.   if (start_alarm(INTERVAL / 2))
  970.     return -1;
  971.  
  972.   run_dhrystone();
  973.  
  974.   dhry_result = dhry_stones;
  975.  
  976.   if (dhry_result == 0)
  977.     dhry_result = 1; /* to avoid dividing by zero later on */
  978.  
  979.   printf("%d runs/sec\n", dhry_result);
  980.  
  981.   return 0;
  982. }
  983.  
  984. int main(int argc, char **argv)
  985. {
  986.   char szVersion[32];
  987.   int nDisks, nCDROMs, nCount, xHD[256], xCD[256], cHD = 0, cCD = 0;
  988.  
  989.   strcpy(szVersion, rcsrev + sizeof("$Revision: ") - 1);
  990.   *strchr(szVersion, ' ') = 0;
  991.  
  992.   printf("\nDISKIO - Fixed Disk Benchmark, Version %s"
  993.      "\n(C) 1994-1998 Kai Uwe Rommel\n", szVersion);
  994.  
  995.   nDisks = DskCount();
  996.   printf("\nNumber of fixed disks: %d\n", nDisks);
  997.  
  998.   nCDROMs = CDFind(0);
  999.   if (nCDROMs == -1) /* not even the driver is loaded */
  1000.     nCDROMs = 0;
  1001.   printf("Number of CD-ROM drives: %d\n", nCDROMs);
  1002.  
  1003.   if (argc > 1)
  1004.   {
  1005.     nDisks = nCDROMs = 0;
  1006.  
  1007.     for (nCount = 1; nCount < argc; )
  1008.       if (stricmp(argv[nCount], "-hd") == 0)
  1009.       {
  1010.         for (nCount++; argv[nCount] && argv[nCount][0] != '-'; nCount++)    /*PLF Wed  97-02-26 22:31:38*/
  1011.       xHD[nDisks++] = atoi(argv[nCount]);
  1012.       }
  1013.       else if (stricmp(argv[nCount], "-cd") == 0)
  1014.       {
  1015.         for (nCount++; argv[nCount] && argv[nCount][0] != '-'; nCount++)    /*PLF Wed  97-02-26 22:31:47*/
  1016.       xCD[nCDROMs++] = atoi(argv[nCount]);
  1017.       }      
  1018.       else if (stricmp(argv[nCount], "-c") == 0)
  1019.       {
  1020.     if(argv[nCount+1] && argv[nCount+2])
  1021.       if (argv[nCount + 1][0] != '-' && argv[nCount + 2][0] != '-')
  1022.       {
  1023.         cHD = atoi(argv[nCount + 1]);
  1024.         cCD = atoi(argv[nCount + 2]);
  1025.         nCount += 3;
  1026.       }
  1027.       }
  1028.       else if (stricmp(argv[nCount], "-?") == 0)
  1029.       {
  1030.     printf("\nUsage:\tdiskio [options]\n"
  1031.            "\n\t-hd <list of hard disk numbers>"
  1032.            "\n\t-cd <list of CD-ROM drive numbers>"
  1033.                  "\n\t-c  <pair of hard disk and CD-ROM drive numbers>\n"
  1034.            "\nHard disk and CD-ROM drive numbers are physical ones and start at 1."
  1035.            "\nThe drive number lists must be blank separated.\n"
  1036.            "\nWith -cd, -hd and -c you can explicitly select the drives to be used"
  1037.            "\nfor hard disk, CD-ROM drive and concurrent hard disk and CD-ROM benchmarks.\n"
  1038.            "\nIf none of them is used, all drives are used for hard disk and CD-ROM"
  1039.            "\ndrive benchmarks and the first hard disk and CD-ROM drives are used"
  1040.            "\nfor the concurrent hard disk and CD-ROM benchmark\n"
  1041.            "\nExample: diskio -hd 2 3 -cd 1 -c 3 1\n");
  1042.     exit(1);
  1043.       }
  1044.  
  1045.       else
  1046.     nCount++;
  1047.   }
  1048.   else
  1049.   {
  1050.     for (nCount = 1; nCount <= nDisks; nCount++)
  1051.       xHD[nCount - 1] = nCount;
  1052.  
  1053.     for (nCount = 1; nCount <= nCDROMs; nCount++)
  1054.       xCD[nCount - 1] = nCount;
  1055.  
  1056.     if (nDisks > 0 && nCDROMs > 0)
  1057.       cHD = cCD = 1;
  1058.   }
  1059.  
  1060.   printf("\nDhrystone 2.1 C benchmark routines (C) 1988 Reinhold P. Weicker\n");
  1061.   bench_dhry();
  1062.  
  1063.   for (nCount = 0; nCount < nDisks; nCount++)
  1064.     bench_hd(xHD[nCount]);
  1065.  
  1066.   if (nDisks > 1)
  1067.     bench_concurrent_allhds(xHD, nDisks);
  1068.  
  1069.   for (nCount = 0; nCount < nCDROMs; nCount++)
  1070.     bench_cd(xCD[nCount]);
  1071.  
  1072.   if (cHD != 0 && cCD != 0)
  1073.     bench_concurrent_hdcd(cHD, cCD);
  1074.  
  1075.   return 0;
  1076. }
  1077.  
  1078. /* end of diskio.c */
  1079.