home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 8 Other / 08-Other.zip / iostone2.zip / IOStone.c next >
Text File  |  1995-05-15  |  14KB  |  436 lines
  1. /*
  2. *
  3. *   "I/O Stone" Benchmark Program
  4. *
  5. *   Written by: Arvin Park (park@midas.ucdavis.edu) and
  6. *            Jeff Becker (becker@iris.ucdavis.edu)
  7. *            Division of Computer Science
  8. *            University of California, Davis
  9. *            Davis CA 95616
  10. *            (916) 752-5183
  11. *
  12. *   Version C/II
  13. *   Date: 06/27/90
  14. *
  15. *   Defines: If your version of "C" does not include an ftime()
  16. *            function or the C library time.h, define NOTIME.
  17. *            Use a stopwatch to measure elapsed wall time.
  18. *            Divide 2,000,000 by the elapsed time to get
  19. *            the correct number of iostones/second.
  20. *
  21. *   To compile:   cc -O io.c -o io
  22. *
  23. *   Note:    [1] This program should be run without other processes
  24. *            competing for system resources. Run it in the dead of
  25. *            night if you have to.
  26. *
  27. *            [2] This program uses 5 megabytes of disk space. Make
  28. *            sure that at least this much space is available on
  29. *            your file system before you run the program.
  30. *
  31. *   Results: If you get results from a new (machine/operating
  32. *            system/disk controller and drive) combination, please
  33. *            send them to becker@iris.ucdavis.edu. Please include
  34. *            complete information on the machine type, operating
  35. *            system, version, disk controller, and disk drives.
  36. *            Also make a note of any system modifications that
  37. *            have been performed.
  38. *
  39. *-------------------------------------------------------------------------
  40. * 8/26/91 Tin Le
  41. *    Added simple Makefile.
  42. *
  43. *    As far as I can determine from examining the code, iostone is
  44. *    meant for benchmarking file I/O and buffer cache efficiencies.
  45. *
  46. *    It does this by creating NSETS (4) of SET_SIZE (99) files.  Then
  47. *    iostone performs I/O on each file in each set.  The type of I/O is
  48. *    randomly picked (r/w).
  49. *
  50. *--------------------------------------------------------------------------
  51. * 7/21/93 Oddgeir Kvien, kvien@elkraft.unit.no
  52. *
  53. * Slightly modified to compile with Borland C++ for OS/2
  54. *
  55. *--------------------------------------------------------------------------
  56. * 11/17/93 Ketil Kintel, kintel@hsr.no
  57. *
  58. * -Fixed bug with the file name generation for the spacer file.
  59. * -Slightly modified to show some output while running. Users with slow
  60. * systems will shurely appriciate this. (I do ...)
  61. * This may cause IOStone to show a _slightly_ lower value than it would do
  62. * normally. If you don't want it #define NOEXTRAOUTPUT
  63. * -Added code for average read/write troughput.
  64. * -Added code for number of file opens/closes.
  65. * -Modified to compile on a 16bit compiler also (Bolrand C++ 3.11 DOS)
  66. *  An int ain't always an int...
  67. *--------------------------------------------------------------
  68. * 5/13/95 - Galen Rhodes <grhodes@moscow.com>
  69. * 
  70. * -Bypassed the Borland Runtime in critical areas.
  71. *
  72. */
  73.  
  74. #ifdef __OS2__
  75. #define INCL_DOSFILEMGR
  76. #define INCL_DOSMISC
  77. #include <os2.h>
  78. #endif
  79.  
  80. #include <stdio.h>
  81. #include <io.h>
  82. #include <string.h>
  83. #include <time.h>
  84. #include <stdlib.h>
  85. #include <sys\stat.h>
  86. #include <fcntl.h>
  87.  
  88. #define BFLUSH_FILE_SIZE (512L*1024L)   /*size of files used to flush buffers*/
  89. #define NBFLUSH_FILES 8                 /*number of files used to flush buffers*/
  90. #define NBLOCKSIZES 9                   /*number of different block sizes*/
  91. #define SEED 34710373L                  /*random number generator seed*/
  92. #define CONST 500000L                   /*iostone normalization constant*/
  93. #define ITER 4                          /*number of iterations of the code*/
  94. #define BUFFERSIZE (16L*1024L)        /*size of temporary buffer*/
  95.  
  96. /* #define NOEXTRAOUTPUT 1    /* Define if you dont want the extra    */
  97.                             /* time consuming output while running. */
  98.  
  99. #define CR=13 /* Carriage Return on MS-DOS system */
  100.  
  101. /* define only one of the next three defines */
  102. /*#define NOTIME        /* Define if no time function in library */
  103. /*#define TIME            /* Use UNIX time function */
  104. #define NON_UNIX_TIME 1        /* Use if a non-unix system */
  105.  
  106. #define NSETS 4                         /*number of sets of files*/
  107. #define SET_SIZE 99                     /*number of files in each set*/
  108. #define FNAMELEN  8                     /*maximum file name length*/
  109.  
  110. /* char *malloc(); */
  111. char tmp[FNAMELEN];                     /*a temporary string*/
  112. char *files[NSETS][SET_SIZE];           /*array of file names*/
  113. char *buf_flush_files[NBFLUSH_FILES];   /*array of names of files to flush*/
  114.                                                      /*system buffers*/
  115. char buffer[BUFFERSIZE];                /*a temporary buffer*/
  116.  
  117. long int nbytes;                        /*number of bytes transfered*/
  118. long int fd;                                 /*file descriptor*/
  119. long int i,j,k;                              /*counter variables*/
  120. long bsize[NBLOCKSIZES];                /*array for different block sizes*/
  121. long bfreq[NBLOCKSIZES];                 /*number of accesses for each block*/
  122.  
  123. #ifdef TIME
  124. #include <sys\types.h>
  125. #include <sys\timeb.h>
  126. struct timeb before;
  127. struct timeb after;
  128. long int sec;
  129. long int msec;
  130. #endif
  131.  
  132. #ifdef NON_UNIX_TIME
  133. long int starttime;
  134. long int totaltime;
  135. #endif
  136.  
  137. /* PREDEFINISJON */
  138. void init(void);
  139. long int my_rand(int max);
  140. void initfile(char *fname,long fsize);
  141. void readswrites(void);
  142.  
  143. unsigned long int troughr; /* Counts number read IO bytes */
  144. unsigned long int troughw; /* Counts number write IO bytes */
  145. unsigned long int fileoc; /* Counts number of file opens/closes */
  146.  
  147. void main(void) {
  148.  
  149.   printf("\nWait - IOSTONE is setting up test files:\t");
  150.   init();
  151.   printf("\rWait - IOSTONE is performing disk IO with varying blocksizes.\t\n");
  152.                             /*start timing*/
  153. #ifdef NOTIME
  154.   printf("start timing\n");
  155. #endif
  156. #ifdef TIME
  157.   ftime(&before);
  158. #endif
  159. #ifdef NON_UNIX_TIME
  160.   starttime = time(0);
  161. #endif
  162.  
  163.   for(k=0; k<ITER; k++)            /*perform string of file operations*/
  164.   {
  165. #ifndef NOEXTRAOUTPUT
  166.     printf("\r\t\t\t\t\t\t\rPass %d:\t",(k+1));
  167. #endif
  168.     readswrites();
  169.   }
  170.                     /*stop timimg*/
  171. #ifdef NOTIME
  172.   printf("stop timing\n");
  173. #endif
  174. #ifdef TIME
  175.   ftime(&after);
  176.   sec = after.time - before.time;
  177.   msec = after.millitm - before.millitm;
  178.   if (msec < 0) {            /*adjust if fractional time < 0*/
  179.     sec -= 1;
  180.      msec += 1000;
  181.   }
  182.   printf("\r\t\t\t\t\t\t\nTotal elapsed time is %d seconds and %d milliseconds.\n",sec,msec);
  183.   printf("Files were opened %u times. %u kb read. %u kb written. \n",
  184.     fileoc,((troughr+512)/1024),((troughw+512)/1024));
  185.   if (sec!=0 || msec!=0)
  186.   {
  187.     printf("Average read/write troughput was %.0f kb/sec, including open/close overhead.\n",
  188.       (((troughr+troughw)/((float) sec + (float) msec/1000)) + 0.5)/1024);
  189.  
  190.      printf("\nThis machine benchmarks at %.0f iostones/sec.\n\n",
  191.         ((float)(CONST*ITER)/((float) sec + (float) msec/1000)) + 0.5);
  192.   }
  193.  
  194. #endif
  195. #ifdef NON_UNIX_TIME
  196.   totaltime = time(0) - starttime;
  197.   printf("\r\t\t\t\t\t\t\nTotal elapsed time is %ld sec.\n",totaltime); /* Uses multipple lines */
  198.   printf("Files were opened %u times.",fileoc);             /* because of bug in BorlandC */
  199.   printf(" %u kb was read, and",((troughr+512)/1024));
  200.   printf(" %u kb written.\n",((troughw+512)/1024));
  201.   if (totaltime!=0)
  202.   {
  203.     printf("Average read/write troughput was %.0f kb/sec, including open/close overhead.\n",
  204.       (((troughr+troughw)/((float) totaltime)) + 0.5)/1024);
  205.  
  206.     printf("\nThis machine benchmarks at %.0f iostones/sec.\n\n",
  207.         ((float)(CONST*ITER)/((float) totaltime)) + 0.5);
  208.   }
  209.  
  210. #endif
  211.   for (i=0;i<NSETS;i++)
  212.     for (j=0;j<SET_SIZE;j++)
  213.         unlink(files[i][j]);              /*remove files*/
  214.   for (k=0;k<NBFLUSH_FILES;k++)
  215.     unlink(buf_flush_files[k]);
  216. }
  217.  
  218. void init(void) {
  219.  
  220.   long int this_set;                         /*mark the file set (0..NSETS-1)*/
  221.   long int bcount;                           /*counter to track #spacer files*/
  222.   long int fcount;                           /*a counter to tell where to create*/
  223.                                         /*files to flush buffer cache and*/
  224.                                         /*spread other files across disk*/
  225.   bsize[0]=256; bfreq[0]=128;
  226.   bsize[1]=512; bfreq[1]=64;
  227.   bsize[2]=1024; bfreq[2]=64;
  228.   bsize[3]=2048; bfreq[3]=64;
  229.   bsize[4]=4096; bfreq[4]=32;           /*set file block sizes and*/
  230.   bsize[5]=8192; bfreq[5]=32;           /*access frequencies*/
  231.   bsize[6]=16384; bfreq[6]=8;
  232.   bsize[7]=32768; bfreq[7]=2;
  233.   bsize[8]=65536; bfreq[8]=2;
  234.  
  235.   troughr=0;
  236.   troughw=0;
  237.   fileoc=0;
  238.  
  239.   k=0;                                  /*set up files*/
  240.   bcount=0;
  241.   fcount=0;
  242.   for(i=0;i<NBLOCKSIZES;i++) {
  243.     printf(".");
  244.     for(j=0;j<bfreq[i];j++) {
  245.       if (i<NBLOCKSIZES-1)
  246.     this_set = j%NSETS;
  247.       else
  248.     this_set = (j+2)%NSETS;
  249.         sprintf(tmp,"%0d_%0d",i,j);       /*create filename*/
  250.         files[this_set][k] = malloc(1+strlen(tmp));
  251.       if (!files[this_set][k]) {
  252.     printf("Could not allocate string for filename\n");
  253.     exit(1);
  254.       }
  255.         strcpy(files[this_set][k],tmp);
  256.       initfile(tmp,bsize[i]);
  257.         if (i < NBLOCKSIZES-1 && this_set == NSETS-1) k++;
  258.         if (bcount < NBFLUSH_FILES && fcount%44 == 0) {
  259.     sprintf(tmp,"s_%0d",bcount);       /*create spacer file*/
  260.     buf_flush_files[bcount] = malloc(1+strlen(tmp));
  261.     if (!buf_flush_files[bcount]) {
  262.       printf("Could not allocate string for filename\n");
  263.       exit(1);
  264.     }
  265.     strcpy(buf_flush_files[bcount],tmp);
  266.     initfile(tmp,BFLUSH_FILE_SIZE);
  267.     bcount++;
  268.         }
  269.         fcount++;
  270.      }
  271.   }
  272.  
  273.   for(i=0;i<NBFLUSH_FILES;i++) {        /*read spacer files to flush buffers*/
  274.      if ((fd = open(buf_flush_files[i],O_RDWR))<0) /* UNIX 2 */ {
  275.         printf("\nError opening buffer flush file %d of %d.\n",i+1,NBFLUSH_FILES);
  276.       exit(1);
  277.      }
  278.      lseek(fd,0L,0);
  279.     k = BFLUSH_FILE_SIZE/BUFFERSIZE;
  280.      for(j=0;j<k;j++) {
  281.       if((nbytes = read(fd,buffer,BUFFERSIZE))<0) {
  282.     printf("\nError reading buffer flush file %d of %d.\n",j+1,k);
  283.     exit(1);
  284.       }
  285.     }
  286.      close(fd);
  287.   }
  288.  
  289. #ifdef NON_UNIX_TIME
  290.   srand(SEED);
  291. #else
  292.   srandom(SEED);            /*initialize random number generator*/
  293. #endif                    /*and order files in a random*/
  294.   for(i=0;i<NSETS;i++) {        /*permutation for reading/writing*/
  295.      for(j=SET_SIZE;j>0;j--) {
  296.         k=my_rand(j);
  297.         strcpy(tmp,files[i][j-1]);
  298.         strcpy(files[i][j-1],files[i][k]);
  299.         strcpy(files[i][k],tmp);
  300.      }
  301.   }
  302. }
  303.  
  304. long int my_rand(int max)
  305. {
  306. #ifdef NON_UNIX_TIME
  307.   return rand()%max;
  308. #else
  309.   return random()%max;
  310. #endif
  311. }
  312.  
  313.  
  314. void initfile(char *fname,long fsize)
  315. {                                       /*create a temporary file*/
  316.   FILE *fs;
  317.   long int block, num_blocks;
  318.  
  319.   if((fs=fopen(fname,"w"))==NULL){
  320.      printf("init: Cannot create temporary file\n");
  321.      exit(1);
  322.   }
  323.   rewind(fs);                /*write initial portion of file*/
  324.   if (fsize > BUFFERSIZE) {
  325.      num_blocks=fsize/BUFFERSIZE;
  326.      for(block=0;block<num_blocks;block++) {
  327.         if ((nbytes=fwrite(buffer,1,BUFFERSIZE,fs))<0) {
  328.     printf("init: error writing block\n");
  329.     exit(1);
  330.         }
  331.      }
  332.   }
  333.   else {
  334.      if ((nbytes=fwrite(buffer,1,fsize,fs))<0) {
  335.         printf("init: error writing block\n");
  336.         exit(1);
  337.      }
  338.   }
  339.   fclose(fs);
  340. }
  341.  
  342. void readswrites(void){
  343.  
  344.   long int xfer, num_xfer;                   /*to access buffer correct # times*/
  345.   long int xfer_amt;                        /*amount to transfer to/from buffer*/
  346.   long int fsize_index;            /*file size index (0..8)*/
  347.   long int rnum;                /*rand. num to choose read or write*/
  348.   long int rep1,rep2;            /*indices to loop through each file*/
  349.                     /*set twice, and all sets three times*/
  350. #ifdef __OS2__
  351.   HFILE hfFile;
  352.   ULONG ulAction;
  353.   ULONG ulLocal;
  354. #endif
  355.   for(rep1=0;rep1<3;rep1++) {        /*in order to achieve locality which*/
  356.      for(i=0;i<NSETS;i++) {        /*is consistent with buffer cache data*/
  357.         for(rep2=0;rep2<2;rep2++) {    /*of Ousterhout et al (1985)*/
  358. #ifndef NOEXTRAOUTPUT
  359.           printf(".");
  360. #endif
  361.     for(j=0;j<SET_SIZE;j++) {
  362.  
  363. #ifdef __OS2__
  364.           if(DosOpen(files[i][j],
  365.                      &hfFile,
  366.                      &ulAction,
  367.                      0,
  368.                      FILE_NORMAL,
  369.                      FILE_OPEN,
  370.                      OPEN_FLAGS_FAIL_ON_ERROR |
  371.                      OPEN_FLAGS_RANDOMSEQUENTIAL |
  372.                      OPEN_ACCESS_READWRITE |
  373.                      OPEN_SHARE_DENYWRITE,
  374.                      NULL)) /* OS/2 */ {
  375. #else
  376.       if ((fd = open(files[i][j],O_RDWR))<0) /* UNIX 2 */ {
  377. #endif
  378.          printf("readswrites: cannot open file[%d][%d]\n",i,j);
  379.          exit(1);
  380.       }
  381.       fileoc++; /* Counts number of file opens/closes */
  382.       fsize_index = *(files[i][j]) -'0';     /*max xfer_amt = BUFFERSIZE*/
  383.       if (bsize[fsize_index] >= BUFFERSIZE) {
  384.          num_xfer = bsize[fsize_index]/BUFFERSIZE;
  385.          xfer_amt = BUFFERSIZE;}
  386.       else {
  387.          num_xfer = 1;
  388.          xfer_amt = bsize[fsize_index];}
  389.       rnum = my_rand(3);
  390.       if (rnum < 2) {       /*read:write = 2:1*/
  391. #ifdef __OS2__
  392.                  DosSetFilePtr(hfFile,0L,FILE_BEGIN,&ulLocal);
  393. #else
  394.          lseek(fd,0L,0);
  395. #endif
  396.          for (xfer=0; xfer<num_xfer; xfer++) {
  397.             troughr+=xfer_amt; /* Counts total read IO bytes*/
  398. #ifdef __OS2__
  399.                         if(DosRead(hfFile,buffer,xfer_amt,&nbytes)) {
  400. #else
  401.             if((nbytes=read(fd,buffer,xfer_amt))<0) {
  402. #endif
  403.                 printf ("readswrites: read error[%d][%d]\n",i,j);
  404.                 exit(1);
  405.             }
  406.          }
  407.       }
  408.       else {
  409. #ifdef __OS2__
  410.                  DosSetFilePtr(hfFile,0L,FILE_BEGIN,&ulLocal);
  411. #else
  412.          lseek(fd,0L,0);
  413. #endif
  414.          for (xfer=0; xfer<num_xfer; xfer++) {
  415.             troughw+=xfer_amt; /* Counts total write IO bytes*/
  416. #ifdef __OS2__
  417.                         if(DosWrite(hfFile,buffer,xfer_amt,&nbytes)) {
  418. #else
  419.             if((nbytes=write(fd,buffer,xfer_amt))<0) {
  420. #endif
  421.                 printf ("readswrites: write error[%d][%d]\n",i,j);
  422.                 exit(1);
  423.             }
  424.          }
  425.       }
  426. #ifdef __OS2__
  427.           DosClose(hfFile);
  428. #else
  429.       close(fd);
  430. #endif
  431.     }
  432.         }
  433.      }
  434.   }
  435. }
  436.