home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 8 Other / 08-Other.zip / mdisk.lzh / MDisk.C < prev    next >
C/C++ Source or Header  |  1993-12-09  |  9KB  |  355 lines
  1.  
  2. #define  INCL_DOS
  3. #define  INCL_NOPMAPI
  4. #include <os2.h>
  5.  
  6. #include "MDisk.h"
  7.  
  8. #include <stdio.h>
  9. #include <time.h>
  10. #include <dir.h>
  11. #include <alloc.h>
  12.  
  13. #define  STACKSIZE       8192
  14.  
  15. PCTV            pCpu;
  16. PDTV            pDsk[ 2 ];
  17. time_t          tmStartTime,
  18.                 tmEndTime;
  19. HEV             hevGo,
  20.                 hevTimer;
  21.  
  22. /* local functions */
  23. int  IsValidDrive( char * szDrive );
  24. void StartCpuThd( void );
  25. void StartDskThd( ULONG ulTask );
  26. void CreateFiles( ULONG ulTask );
  27. void StartTest( void );
  28. void EndTest( void );
  29. void DeleteFiles( ULONG ulTask );
  30. void Cleanup( INT rc );
  31.  
  32.  
  33. void main( void )
  34. {
  35.   HTIMER   hTimer;
  36.   ULONG    ulRunTime,
  37.            ulDiskOps,
  38.            ulCpuBasePerf,
  39.            ulTestPerf;
  40.  
  41.   /* ------------------------------------------------------------- */
  42.   /* display program logo                                          */
  43.   /* ------------------------------------------------------------- */
  44.   printf( "\n\n" );
  45.   printf( "    MDisk - Multitasking Disk Subsystem Performance\n" );
  46.   printf( "                Version 1.00  12/93\n\n" );
  47.  
  48.   /* allocate thread data structures */
  49.   if( ( pCpu = (PCTV) malloc( sizeof( CTV ) ) ) == NULL )
  50.     {
  51.       printf("Not enough memory to allocate buffer\n");
  52.       DosExit( 1, 1 );  /* terminate program if out of memory */
  53.     }
  54.   if( ( pDsk[ DISK1 ] = (PDTV) malloc( sizeof( DTV ) ) ) == NULL )
  55.     {
  56.       printf("Not enough memory to allocate buffer\n");
  57.       DosExit( 1, 1 );  /* terminate program if out of memory */
  58.     }
  59.   if( ( pDsk[ DISK2 ] = (PDTV) malloc( sizeof( DTV ) ) ) == NULL )
  60.     {
  61.       printf("Not enough memory to allocate buffer\n");
  62.       DosExit( 1, 1 );  /* terminate program if out of memory */
  63.     }
  64.  
  65.   /* ------------------------------------------------------------- */
  66.   /* get input parameters
  67.   /* ------------------------------------------------------------- */
  68.   printf( "\tEnter 1st drive to test: " );
  69.   scanf( "%s", &pDsk[ DISK1 ]->szDrive );
  70.   if( ! IsValidDrive( pDsk[ DISK1 ]->szDrive ) )
  71.     {
  72.       DosExit( 1, 1 );
  73.     }
  74.  
  75.   printf( "\tEnter 2nd drive to test: " );
  76.   scanf( "%s", &pDsk[ DISK2 ]->szDrive );
  77.   if( ! IsValidDrive( pDsk[ DISK2 ]->szDrive ) )
  78.     {
  79.       DosExit( 1, 1 );
  80.     }
  81.   printf( "\n" );
  82.  
  83.   /* create semaphores */
  84.   DosCreateEventSem( NULL, &hevGo,    DC_SEM_SHARED, 0 );
  85.   DosCreateEventSem( NULL, &hevTimer, DC_SEM_SHARED, 0 );
  86.   DosCreateEventSem( NULL, &pCpu->hevReady, DC_SEM_SHARED, 0 );
  87.   DosCreateEventSem( NULL, &pCpu->hevDone,  DC_SEM_SHARED, 0 );
  88.   DosCreateEventSem( NULL, &pDsk[ DISK1 ]->hevReady, DC_SEM_SHARED, 0 );
  89.   DosCreateEventSem( NULL, &pDsk[ DISK1 ]->hevDone,  DC_SEM_SHARED, 0 );
  90.   DosCreateEventSem( NULL, &pDsk[ DISK2 ]->hevReady, DC_SEM_SHARED, 0 );
  91.   DosCreateEventSem( NULL, &pDsk[ DISK2 ]->hevDone,  DC_SEM_SHARED, 0 );
  92.  
  93.   /* test baseline cpu perf */
  94.   StartCpuThd();
  95.  
  96.   DosWaitEventSem( pCpu->hevReady, SEM_INDEFINITE_WAIT );
  97.  
  98.   DosAsyncTimer( 10000, (HSEM) hevTimer, &hTimer );
  99.  
  100.   StartTest();
  101.  
  102.   DosWaitEventSem( hevTimer, SEM_INDEFINITE_WAIT );
  103.  
  104.   EndTest();
  105.  
  106.   ulCpuBasePerf = pCpu->ulCount / ( tmEndTime - tmStartTime );
  107.  
  108.   /* initialize test files */
  109.   CreateFiles( DISK1 );
  110.   CreateFiles( DISK2 );
  111.  
  112.   /* print headings */
  113.   printf( "            Drive   MultiStones     CPU Usage\n" );
  114.  
  115.   /* test disk 1 by itselt */
  116.   StartCpuThd();
  117.   StartDskThd( DISK1 );
  118.  
  119.   DosWaitEventSem( pCpu->hevReady, SEM_INDEFINITE_WAIT );
  120.   DosWaitEventSem( pDsk[ DISK1 ]->hevReady, SEM_INDEFINITE_WAIT );
  121.  
  122.   StartTest();
  123.  
  124.   DosWaitEventSem( pDsk[ DISK1 ]->hevDone, SEM_INDEFINITE_WAIT );
  125.  
  126.   EndTest();
  127.  
  128.   if( pDsk[ DISK1 ]->iExitCode != 0 )
  129.     Cleanup( 1 );
  130.  
  131.   ulDiskOps  = pDsk[ DISK1 ]->ulCount;
  132.   ulRunTime  = tmEndTime - tmStartTime;
  133.   ulTestPerf = pCpu->ulCount / ulRunTime;
  134.  
  135.   printf( "           %4s        %6d         %3d %%\n",
  136.           pDsk[ DISK1 ]->szDrive,
  137.           ( ulDiskOps / ulRunTime ),
  138.           100 - (( ulTestPerf * 100 ) / ulCpuBasePerf ) );
  139.  
  140.   /* test disk 2 by itself */
  141.   StartCpuThd();
  142.   StartDskThd( DISK2 );
  143.  
  144.   DosWaitEventSem( pCpu->hevReady, SEM_INDEFINITE_WAIT );
  145.   DosWaitEventSem( pDsk[ DISK2 ]->hevReady, SEM_INDEFINITE_WAIT );
  146.  
  147.   StartTest();
  148.  
  149.   DosWaitEventSem( pDsk[ DISK2 ]->hevDone, SEM_INDEFINITE_WAIT );
  150.  
  151.   EndTest();
  152.  
  153.   if( pDsk[ DISK2 ]->iExitCode != 0 )
  154.     Cleanup( 1 );
  155.  
  156.   ulDiskOps  = pDsk[ DISK2 ]->ulCount;
  157.   ulRunTime  = tmEndTime - tmStartTime;
  158.   ulTestPerf = pCpu->ulCount / ulRunTime;
  159.  
  160.   printf( "           %4s        %6d         %3d %%\n",
  161.           pDsk[ DISK2 ]->szDrive,
  162.           ( ulDiskOps / ulRunTime ),
  163.           100 - (( ulTestPerf * 100 ) / ulCpuBasePerf ) );
  164.  
  165.   /* test both disks */
  166.   StartCpuThd();
  167.   StartDskThd( DISK1 );
  168.   StartDskThd( DISK2 );
  169.  
  170.   DosWaitEventSem( pCpu->hevReady, SEM_INDEFINITE_WAIT );
  171.   DosWaitEventSem( pDsk[ DISK1 ]->hevReady, SEM_INDEFINITE_WAIT );
  172.   DosWaitEventSem( pDsk[ DISK2 ]->hevReady, SEM_INDEFINITE_WAIT );
  173.  
  174.   StartTest();
  175.  
  176.   DosWaitEventSem( pDsk[ DISK1 ]->hevDone, SEM_INDEFINITE_WAIT );
  177.   DosWaitEventSem( pDsk[ DISK2 ]->hevDone, SEM_INDEFINITE_WAIT );
  178.  
  179.   EndTest();
  180.  
  181.   if( ( pDsk[ DISK1 ]->iExitCode != 0 ) || ( pDsk[ DISK2 ]->iExitCode != 0 ) )
  182.     Cleanup( 1 );
  183.  
  184.   ulDiskOps  = pDsk[ DISK1 ]->ulCount + pDsk[ DISK2 ]->ulCount;
  185.   ulRunTime  = tmEndTime - tmStartTime;
  186.   ulTestPerf = pCpu->ulCount / ulRunTime;
  187.  
  188.   printf( "           %4s        %6d         %3d %%\n",
  189.           "Both",
  190.           ( ulDiskOps / ulRunTime ),
  191.           100 - (( ulTestPerf * 100 ) / ulCpuBasePerf ) );
  192.  
  193.   printf( "\n\n" );
  194.   Cleanup( 0 );
  195. }
  196.  
  197.  
  198. int IsValidDrive( char * Drive )
  199. {
  200.   if( ( Drive[ 0 ] >= 'c' ) && ( Drive[ 0 ] <= 'z' ) )
  201.     Drive[ 0 ] -= 0x20;
  202.  
  203.   if( ( Drive[ 0 ] < 'C' ) || ( Drive[ 0 ] > 'Z' ) )
  204.     {
  205.       printf( "Invalid drive spec\n" );
  206.       return( FALSE );
  207.     }
  208.  
  209.   Drive[ 1 ] = ':';
  210.   Drive[ 2 ] = 0;
  211.  
  212.   return( TRUE );
  213. }
  214.  
  215. void StartDskThd( ULONG ulTask )
  216. {
  217.   ULONG ulPostCount;
  218.   PSZ   pszDir = "/MDisk ";
  219.   INT   i = 0;
  220.  
  221.   pDsk[ ulTask ]->ulTask       = ulTask;
  222.   pDsk[ ulTask ]->ulCount      = 0;
  223.   pDsk[ ulTask ]->iExitCode    = 0;
  224.  
  225.   while( pszDir[ i ] )
  226.     pDsk[ ulTask ]->szDir[ i ] = pszDir[ i++ ];
  227.  
  228.   DosResetEventSem( pDsk[ ulTask ]->hevReady, &ulPostCount );
  229.   DosResetEventSem( pDsk[ ulTask ]->hevDone,  &ulPostCount );
  230.  
  231.   DosCreateThread( &pDsk[ ulTask ]->tid,
  232.                    ThdDskPerf,
  233.                    (ULONG)pDsk[ ulTask ],
  234.                    0,
  235.                    STACKSIZE );
  236. }
  237.  
  238.  
  239. void StartCpuThd( void )
  240. {
  241.   ULONG ulPostCount;
  242.  
  243.   pCpu->ulCount      = 0;
  244.   pCpu->iExitCode    = 0;
  245.  
  246.   DosResetEventSem( pCpu->hevReady, &ulPostCount );
  247.   DosResetEventSem( pCpu->hevDone,  &ulPostCount );
  248.   DosResetEventSem( hevGo,          &ulPostCount );
  249.   DosResetEventSem( hevTimer,       &ulPostCount );
  250.  
  251.   DosCreateThread( &pCpu->tid,
  252.                    ThdCpuPerf,
  253.                    (ULONG)pCpu,
  254.                    0,
  255.                    STACKSIZE );
  256. }
  257.  
  258.  
  259. void StartTest( void )
  260. {
  261.   tmStartTime = time( NULL );
  262.   DosPostEventSem( hevGo );
  263. }
  264.  
  265.  
  266. void EndTest( void )
  267. {
  268.   tmEndTime = time( NULL );
  269.  
  270.   DosPostEventSem( pCpu->hevDone );
  271.  
  272.   /* this ensures that the cpu thd has time to end before */
  273.   /* it gets restarted for the next test                  */
  274.   DosSleep( 1000 );
  275. }
  276.  
  277.  
  278. void CreateFiles( ULONG ulTask )
  279. {
  280.   char szDir[ 16 ] = "/MDisk ";
  281.  
  282.   szDir[ 6 ] = (char)( ulTask + 0x30 );
  283.   szDir[ 7 ] = 0;
  284.  
  285.   setdisk( (int)( pDsk[ ulTask ]->szDrive[ 0 ] - 'A' ) );
  286.   mkdir( szDir );
  287.   chdir( szDir );
  288.  
  289.   /* create test files */
  290.   init( pDsk[ ulTask ] );
  291. }
  292.  
  293.  
  294. void DeleteFiles( ULONG ulTask )
  295. {
  296.   char szDir[ 16 ] = "/MDisk ";
  297.  
  298.   szDir[ 6 ] = (char)( ulTask + 0x30 );
  299.   szDir[ 7 ] = 0;
  300.  
  301.   setdisk( (int)( pDsk[ ulTask ]->szDrive[ 0 ] - 'A' ) );
  302.   chdir( szDir );
  303.  
  304.   /*remove files*/
  305.   removefiles( pDsk[ ulTask ] );
  306.  
  307.   chdir( "\\" );
  308.   rmdir( szDir );
  309. }
  310.  
  311.  
  312. void Cleanup( INT rc )
  313. {
  314.   if( rc )
  315.     {
  316.       DosBeep( 1000, 500 );
  317.       printf( "Fatal error - test aborted\n" );
  318.     }
  319.  
  320.   DeleteFiles( DISK1 );
  321.   DeleteFiles( DISK2 );
  322.  
  323.   free( pCpu );
  324.   free( pDsk[ DISK1 ] );
  325.   free( pDsk[ DISK2 ] );
  326.  
  327.   DosExit( 1, rc );
  328. }
  329.  
  330.  
  331. VOID APIENTRY ThdCpuPerf( ULONG ulTask )
  332. {
  333.   INT   i;
  334.   ULONG ulPostCt = 0;
  335.   PCTV  pCpu;
  336.  
  337.   pCpu = (PCTV) ulTask;
  338.  
  339.   DosPostEventSem( pCpu->hevReady );
  340.   DosWaitEventSem( hevGo, SEM_INDEFINITE_WAIT );
  341.  
  342.   DosSetPriority( PRTYS_THREAD, PRTYC_IDLETIME, PRTYD_MAXIMUM, 0 );
  343.  
  344.   while( ! ulPostCt )
  345.     {
  346.       for( i = 1; i > 0; i++ );
  347.       pCpu->ulCount++;
  348.       DosQueryEventSem( pCpu->hevDone, &ulPostCt );
  349.     }
  350.  
  351.   DosExit( 0, 0 );
  352. }
  353.  
  354.  
  355.