home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / C / SCBENCH.ZIP / SCHDSEEK.C < prev    next >
Encoding:
C/C++ Source or Header  |  1980-01-01  |  3.7 KB  |  164 lines
  1. /*
  2. ** BYTE Hard disk seek benchmark
  3. ** Version 1 for 8088/8086/80286/80386
  4. ** March 1988
  5. ** Written in BYTE Small-C
  6. ** Based on Small-C by J.E. Hendrix
  7. **
  8. ** Operation:
  9. **  1. Determine geometry of disk drive (how many cylinders)
  10. **  2. Perform COUNT iterations of the following (reporting
  11. **     times for each):
  12. **     (a) Adjacent track seeks for innermost cylinder
  13. **     (b) Adjacent track seeks for outermost cylinder
  14. **     (c) Half-platter seeks
  15. **     (d) Full-platter seeks
  16. **  3. Exit
  17. **
  18. */
  19.  
  20. #define COUNT 100    /* Repititions */
  21.  
  22. int tblock[4];        /* Timer block */
  23. int dblock[4];        /* Disk block */
  24. int sourc;        /* Source cylinder */
  25. int destc;        /* Destination cylinder */
  26. int accum;        /* Time accumulator */
  27. int i;            /* index */
  28. char dbuff[516];    /* Buffer needed for disk read */
  29.  
  30. extern gtime();        /* Get time */
  31. extern calctim();    /* Calc. elapsed time */
  32.  
  33. main()
  34. {
  35.  
  36.     printf("BYTE Hard Disk Seek Benchmark\n");
  37.     printf("All times given are in 1/100ths of a second\n");
  38. /* Get the hard disk parameters */
  39.     dblock[0]=128;    /* First hard disk */
  40.     gdinfo(dblock);
  41.  
  42.     printf("Max cylinder %d\n\n",dblock[2]);
  43.  
  44.     printf("All tests done for %d iterations\n\n",COUNT*2);
  45.  
  46. /* Do outer track-track seek */
  47.     sourc = 0;
  48.     destc = 1;
  49.     doseek();
  50.     printf("***Outer track-track time***\n");
  51.     printf("Total time:%d\n\n",accum);
  52.  
  53. /* Do inner track-track seek */
  54.     sourc = dblock[2]-2;
  55.     destc = dblock[2]-1;
  56.     doseek();
  57.     printf("***Inner track-track time***\n");
  58.     printf("Total time:%d\n\n",accum);
  59.  
  60. /* Do half-platter seek */
  61.     sourc = 0;
  62.     destc = dblock[2]/2;
  63.     doseek();
  64.     printf("***Half-platter time***\n");
  65.     printf("Total time:%d\n\n",accum);
  66.  
  67. /* Do full-platter seek */
  68.     sourc = 0;
  69.     destc = dblock[2] - 1;
  70.     doseek();
  71.     printf("***Full-platter time***\n");
  72.     printf("Total time:%d\n\n",accum);
  73.  
  74. /* Exit */
  75.     exit(0);
  76. }
  77.  
  78. /*
  79. ** doseek()
  80. ** Uses global variables:
  81. ** sourc = starting cylinder
  82. ** destc = destination cylinder
  83. ** accum = accumulated time
  84. */
  85. doseek()
  86. {
  87.     accum=0;
  88.     hdseek(dbuff,sourc);    /* Init. track to source */
  89.     for(i=0;i<COUNT;++i)
  90.     {
  91.         gtime(tblock);
  92.         hdseek(dbuff,destc);
  93.         hdseek(dbuff,sourc);
  94.         calctim(tblock);    /* Get elapsed time */
  95.         accum+=tblock[3]+100*(tblock[2]+60*tblock[1]);
  96.     }
  97.     return;
  98. }
  99.  
  100. /*
  101. ** hdseek(buff,cyl) char *buff; int cyl;
  102. ** Hard disk seek to cylinder cyl
  103. ** Buff is a pointer to a buffer to read the sector in.
  104. ** NOTE: We assume ES=DS
  105. ** 
  106. */
  107. hdseek(buff,cyl) char *buff; int cyl;
  108. {
  109. #asm
  110.     MOV    BP,SP
  111.     MOV    BX,4[BP]        ;Pointer to buffer
  112.     MOV    CX,2[BP]        ;Get cylinder
  113.     XCHG    CH,CL            ;Swap parts
  114.     ROR    CL,1            ;Set up low part
  115.     ROR    CL,1
  116.     INC    CL            ;Set to sector 1
  117.     MOV    DX,80H            ;Set hard disk no.
  118.     MOV    AH,02H            ;Function
  119.     MOV    AL,1            ;Read 1 sector
  120.     INT    13H            ;do the int
  121.     XOR    CX,CX            ;Just in case
  122. #endasm
  123. }
  124. /*
  125. ** 8088/8086 version
  126. ** gdinfo(dblock) int dblock[]; {
  127. ** Get disk information.
  128. ** dblock[] is assumed to be a 4-element array.  Upon entry,
  129. ** dblock[0] should have the disk number in it
  130. ** (0=A, 1=B...80H=First hard disk...etc.)
  131. ** Upon return, dblock holds:
  132. ** dblock[0] = # of hard disks on first controller
  133. ** dblock[1] = Number of heads
  134. ** dblock[2] = Number of cylinders
  135. ** dblcok[3] = Sectors per track
  136. */
  137. gdinfo(dblock) int dblock[]; {
  138. #asm
  139.     MOV    BP,SP
  140.     MOV    SI,2[BP]    ;Pointer to dblock
  141.     MOV    DL,[SI]        ;Get drive number
  142.     MOV    AH,08H        ;Get params
  143.     INT    13H
  144.     XOR    AX,AX        ;Clear high byte
  145.     MOV    AL,DL
  146.     MOV    [SI],AX        ;# Hard disks on 1st controller
  147.     MOV    AL,DH
  148.     INC    AL        ;Starts at zero
  149.     MOV    2[SI],AX    ;Number of heads
  150.     MOV    AL,CL
  151.     AND    AL,3FH        ;Sectors/track
  152.     MOV    6[SI],AX
  153.     MOV    AL,CL
  154.     SHL    AX,1
  155.     SHL    AX,1
  156.     MOV    AL,CH
  157.     INC    AX        ;Starts at zero
  158.     MOV    4[SI],AX    ;Max cylinders
  159.     XOR    CX,CX        ;clear CX
  160. #endasm
  161. }
  162.  
  163.     
  164.