home *** CD-ROM | disk | FTP | other *** search
/ PC User 1997 April / PCU_APR_97.ISO / utils / cpu / cpuinfo / source / cpuinf16 / speed.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-11-13  |  16.6 KB  |  593 lines
  1. /***************************************************************
  2. * C file:  Speed.c... for cpuinf16 DLL
  3. *
  4. *       This program has been developed by Intel Corporation.  
  5. *        You have Intel's permission to incorporate this code 
  6. *       into your product, royalty free.  Intel has various 
  7. *        intellectual property rights which it may assert under
  8. *       certain circumstances, such as if another manufacturer's
  9. *       processor mis-identifies itself as being "GenuineIntel"
  10. *        when the CPUID instruction is executed.
  11. *
  12. *       Intel specifically disclaims all warranties, express or
  13. *       implied, and all liability, including consequential and
  14. *        other indirect damages, for the use of this code, 
  15. *        including liability for infringement of any proprietary
  16. *        rights, and including the warranties of merchantability
  17. *        and fitness for a particular purpose.  Intel does not 
  18. *        assume any responsibility for any errors which may 
  19. *        appear in this code nor any responsibility to update it.
  20. *
  21. *  * Other brands and names are the property of their respective
  22. *    owners.
  23. *
  24. *  Copyright (c) 1995, Intel Corporation.  All rights reserved.
  25. ***************************************************************/
  26.   
  27. #include <windows.h> 
  28. #include <math.h>
  29. #include <stdio.h>
  30. #include <mmsystem.h>
  31. #include <limits.h>    
  32. #include <memory.h>
  33.  
  34. #include "speed.h"
  35. #include "cpuid.h"
  36.  
  37. // Tabs set at 4
  38. #define ROUND_THRESHOLD        6
  39.  
  40. // Tabs set at 4
  41. static struct FREQ_INFO GetCmosCpuSpeed();
  42. static struct FREQ_INFO GetRDTSCCpuSpeed();
  43. static struct FREQ_INFO GetBSFCpuSpeed(ulong cycles);
  44. static unsigned long diffTime64(unsigned long t1Hi, unsigned long t1Low, 
  45.                          unsigned long t2Hi, unsigned long t2Low, 
  46.                            unsigned long *tHi, unsigned long *tLow );
  47.  
  48. // extern in ASM file
  49. ushort Time_Processor_bsf(void);
  50.  
  51. /***************************************************************
  52. * LibMain() -- Windows entry procedure for DLLSs
  53. * 
  54. ***************************************************************/
  55. int FAR PASCAL _export LibMain(HANDLE hI, WORD wDS, WORD cbHS, LPSTR lpszCL) {
  56.     if (cbHS != 0) 
  57.     
  58.         UnlockData(0);
  59.     
  60.     return 1;
  61. } // LibMain()
  62.  
  63.  
  64.  
  65. /***************************************************************
  66. * WEP() -- Windows exit procedure for the DLLs.
  67. *
  68. ***************************************************************/
  69. int FAR PASCAL _export WEP(int nParam) {
  70.     return 1;
  71. } // WEP()
  72.  
  73.  
  74.  
  75. /***************************************************************
  76. * CpurawSpeed() -- Return the raw clock rate of the host CPU.
  77. *
  78. * Inputs:
  79. *    clocks:        0: Use default value for number of cycles
  80. *                   per BSF instruction.
  81. *               -1: Use CMos timer to get cpu speed (DOES NOT WORK FOR WINNT).
  82. *               Positive Integer: Use clocks value for number
  83. *                   of cycles per BSF instruction.
  84. *
  85. * Returns:
  86. *        If error then return all zeroes in FREQ_INFO structure
  87. *        Else return FREQ_INFO structure containing calculated 
  88. *       clock frequency, normalized clock frequency, number of 
  89. *       clock cycles during test sampling, and the number of 
  90. *       microseconds elapsed during the sampling.
  91. ***************************************************************/
  92.  
  93. unsigned long FAR PASCAL cpurawspeed(int clocks)
  94. {
  95.     struct FREQ_INFO cpu_speed;
  96.  
  97.     cpu_speed = cpuspeed(clocks);
  98.     return cpu_speed.raw_freq;
  99. }
  100.  
  101. /***************************************************************
  102. * CpunormSpeed() -- Return the raw clock rate of the host CPU.
  103. *
  104. * Inputs:
  105. *    clocks:        0: Use default value for number of cycles
  106. *                   per BSF instruction.
  107. *               -1: Use CMos timer to get cpu speed.
  108. *               Positive Integer: Use clocks value for number
  109. *                   of cycles per BSF instruction.
  110. *
  111. * Returns:
  112. *        If error then return all zeroes in FREQ_INFO structure
  113. *        Else return FREQ_INFO structure containing calculated 
  114. *       clock frequency, normalized clock frequency, number of 
  115. *       clock cycles during test sampling, and the number of 
  116. *       microseconds elapsed during the sampling.
  117. ***************************************************************/
  118.  
  119. unsigned long FAR PASCAL cpunormspeed(int clocks)
  120. {
  121.     struct FREQ_INFO cpu_speed;
  122.  
  123.     cpu_speed = cpuspeed(clocks);
  124.     return cpu_speed.norm_freq;
  125. }
  126.  
  127. /***************************************************************
  128. * ProcessorCount() -- Return the number of CPU's on this machine.
  129. *
  130. * Inputs:
  131. *
  132. * Returns:
  133. *         always 1 for 16 bit dll
  134. ***************************************************************/
  135.  
  136. unsigned long FAR PASCAL ProcessorCount()
  137. {
  138.     return 1;
  139. }
  140.  
  141. /***************************************************************
  142. * CpuSpeed() -- Return the raw clock rate of the host CPU.
  143. *
  144. * Inputs:
  145. *    clocks:        NULL: Use default value for number of cycles
  146. *                   per BSF instruction.
  147. *               Positive Integer: Use clocks value for number
  148. *                   of cycles per BSF instruction.
  149. *
  150. * Returns:
  151. *        If error then return all zeroes in FREQ_INFO structure
  152. *        Else return FREQ_INFO structure containing calculated 
  153. *       clock frequency, normalized clock frequency, number of 
  154. *       clock cycles during test sampling, and the number of 
  155. *       microseconds elapsed during the sampling.
  156. ***************************************************************/
  157.  
  158. struct FREQ_INFO FAR PASCAL cpuspeed(int clocks) 
  159. {
  160.     ulong  cycles;                    // Clock cycles elapsed 
  161.                                     //   during test
  162.     
  163.     ushort processor = wincpuid();    // Family of processor
  164.  
  165.     DWORD features = wincpufeatures();    // Features of Processor
  166.     
  167.     int manual=0;            // Specifies whether the user 
  168.                             //   manually entered the number of
  169.                             //   cycles for the BSF instruction.
  170.  
  171.     struct FREQ_INFO cpu_speed;        // Return structure for
  172.                                     //   cpuspeed
  173.                     
  174.     // Number of cycles needed to execute a single BSF 
  175.     //   instruction. Note that processors below i386(tm) 
  176.     //   are not supported.
  177.     ushort processor_cycles[] = {
  178.         00,  00,  00, 115, 47, 43, 
  179.         38,  38,  38, 38,  38, 38, 
  180.     };
  181.  
  182.     memset(&cpu_speed, 0x00, sizeof(cpu_speed));
  183.     
  184.     if ( processor & CLONE_MASK )
  185.         return cpu_speed;
  186.  
  187.     // Check for manual BSF instruction clock count
  188.     if (0 <= clocks) {
  189.         cycles =ITERATIONS*(ulong)processor_cycles[processor];
  190.     }
  191.     else if (0 < clocks && clocks <= MAXCLOCKS)  {
  192.         cycles = ITERATIONS * (ulong) clocks;
  193.         manual = 1;            // Toggle manual control flag.
  194.                             //   Note that this mode will not
  195.                             //      work properly with processors
  196.                             //   which can process multiple
  197.                             //   BSF instructions at a time.
  198.                             //   For example, manual mode
  199.                             //   will not work on a 
  200.                             //   PentiumPro(R)
  201.     }
  202.  
  203.     if ( ( features&0x00000010 ) && !(manual) ) {
  204.         if ( clocks == 0 )
  205.             return GetRDTSCCpuSpeed();
  206.         else
  207.             return GetCmosCpuSpeed();    
  208.     }
  209.     else if ( processor >= 3 ) {
  210.         return GetBSFCpuSpeed(cycles);
  211.     }        
  212.  
  213.     return cpu_speed;
  214.        
  215. } // cpuspeed()
  216.  
  217.  
  218.  
  219. static struct FREQ_INFO GetBSFCpuSpeed(ulong cycles)
  220. {
  221.      ulong  ticks;    // Microseconds elapsed                                 //   during test
  222.     ulong freq;        // Most current frequ. calculation
  223.     int i;            // Temporary Variable
  224.  
  225.     ulong current = 0;      // Variable to store time
  226.                             //   elapsed during loop of
  227.                             //   of BSF instructions
  228.  
  229.     ulong lowest  = ULONG_MAX;    // Since algorithm finds 
  230.                                 //   the lowest value out of
  231.                                 //   a set of samplings, 
  232.                                 //   this variable is set 
  233.                                 //   intially to the max 
  234.                                 //   unsigned long value). 
  235.                                 //   This guarantees that 
  236.                                 //   the initialized value 
  237.                                 //   is not later used as 
  238.                                 //   the least time through 
  239.                                 //   the loop.
  240.  
  241.     struct FREQ_INFO cpu_speed;        // Return structure for
  242.                                     //   cpuspeed
  243.                     
  244.     memset(&cpu_speed, 0x00, sizeof(cpu_speed));
  245.     
  246.     for ( i = 0; i < SAMPLINGS; i++ ) {
  247.                                 // Sample SAMPLINGS times. 
  248.                                 //   Can be increased or 
  249.                                 //   decreased depending
  250.                                 //   on accuracy vs. time
  251.                                 //   requirements
  252.  
  253.             
  254.         current = Time_Processor_bsf();
  255.            
  256.         if ( current < lowest )        // Take lowest elapsed
  257.             lowest = current;        //   time to account
  258.                                     //   for some samplings
  259.                                     //   being interrupted
  260.                                     //   by other operations 
  261.     }
  262.  
  263.     ticks = lowest;                
  264.         
  265.         
  266.     // Note that some seemingly arbitrary mulitplies and
  267.     //   divides are done below. This is to maintain a 
  268.     //   high level of precision without truncating the 
  269.     //   most significant data. According to what value 
  270.     //   ITERATIIONS is set to, these multiplies and
  271.     //   divides might need to be shifted for optimal
  272.     //   precision.
  273.  
  274.     ticks = ticks * 100000;     // Convert ticks to hundred 
  275.                                   //   thousandths of a tick
  276.         
  277.     ticks = ticks / 119318;        // Convert hundred 
  278.                                    //   thousandths of ticks to
  279.                                    //   microseconds (us)
  280.         
  281.     if ( (ticks%119318) >= 119318/2 )
  282.            ticks++;                // Round up if necessary
  283.             
  284.     freq = cycles/ticks;        // Cycles / us  = MHz
  285.  
  286.     cpu_speed.raw_freq  = freq;
  287.     if ( cycles%ticks > ticks/2 )
  288.            freq++;                    // Round up if necessary
  289.  
  290.     cpu_speed.in_cycles = cycles;    // Return variable structure
  291.     cpu_speed.ex_ticks  = ticks;    //   determined by one of 
  292.     cpu_speed.norm_freq = freq;
  293.  
  294.     return cpu_speed;
  295. }            
  296.  
  297. static struct FREQ_INFO GetRDTSCCpuSpeed()
  298. {
  299.      ulong  total_ticks=0, ticks;    // Microseconds elapsed 
  300.                                     //   during test
  301.     
  302.     ulong  total_cycles=0, cycles;    // Clock cycles elapsed 
  303.                                     //   during test
  304.     
  305.     ulong  stamp0, stamp1;            // Time Stamp Variable 
  306.                                     //   for beginning and end 
  307.     
  308.     ushort u0,u1;                     // 16-bit variables for time
  309.     ushort v0,v1;                    //   stamp reads. These are 
  310.                                     //   later merged into 
  311.                                     //   stamp0, and stamp1 
  312.                                     //   (32-bit variables)
  313.  
  314.     ulong freq;                // Most current frequ. calculation
  315.     ulong freq2;            // 2nd most current frequ. calc.
  316.     ulong freq3;            // 3rd most current frequ. calc.
  317.     
  318.     ulong total;            // Sum of previous three frequency
  319.                             //   calculations
  320.  
  321.     int manual=0;            // Specifies whether the user 
  322.                             //   manually entered the number of
  323.                             //   cycles for the BSF instruction.
  324.  
  325.     int tries=0;            // Number of times a calculation has
  326.                             //   been made on this call to 
  327.                             //   cpuspeed
  328.  
  329.     struct FREQ_INFO cpu_speed;        // Return structure for
  330.                                     //   cpuspeed
  331.                     
  332.     DWORD t0,t1;                       // Variables to store 
  333.                                     //   timeGetTime values
  334.  
  335.     memset(&cpu_speed, 0x00, sizeof(cpu_speed));
  336.  
  337.     // On Pentium Processors or above use 
  338.     //   the Read Time Stamp method which 
  339.     //   compares elapsed time on from the
  340.     //   timeGetTime call with elaped
  341.     //   cycles on the Time Stamp Register.
  342.  
  343.     do {            // This do loop runs up to 20 times or
  344.                     //   until the average of the previous 
  345.                     //   three calculated frequencies is 
  346.                     //   within 2 MHz of each of the 
  347.                     //   individual calculated frequencies. 
  348.                     //   This resampling increases the 
  349.                     //   accuracy of the results since
  350.                     //   outside factors could affect this
  351.                     //   calculation
  352.             
  353.         tries++;        // Increment number of times sampled
  354.                         //   on this call to cpuspeed
  355.                                     
  356.         freq3 = freq2;    // Shift frequencies back to make
  357.         freq2 = freq;    //   room for new frequency 
  358.                             //   measurement
  359.  
  360.            t0 = timeGetTime();
  361.             
  362.         t1 = t0;        // Set Initial Time
  363.  
  364.            while ( t1 - t0 < INITIAL_DELAY ) {
  365.                            // Loop until three ticks have 
  366.                            //   passed    since last read of 
  367.                         //     timeGetTime. This accounts for
  368.                         //   overhead later.
  369.  
  370.             t1 = timeGetTime();
  371.         }                    
  372.  
  373.            __asm                        // Read Time Stamp...
  374.         {                       
  375.             RDTSC
  376.                 
  377.             MOV CL, 16
  378.                             
  379.             MOV u0, AX
  380.             OPND32
  381.             SHR    AX,CL
  382.             MOV u1, AX
  383.         }                   
  384.         
  385.         t0 = t1;                    // Reset Initial Time
  386.             
  387.           while ( t1 - t0 < SAMPLING_DELAY ) {
  388.                              // Loop until 60 ticks have passed 
  389.                              //   since last timeGetTime read. 
  390.                              //   This allows for elapsed time
  391.                              //   for sampling
  392.                               
  393.             t1 = timeGetTime();
  394.         }                            
  395.             
  396.  
  397.            __asm                        // Read Time Stamp...
  398.         {
  399.             RDTSC
  400.                 
  401.             MOV CL, 16
  402.                             
  403.             MOV v0, AX
  404.             OPND32
  405.             SHR    AX,CL
  406.             MOV v1, AX
  407.         }                   
  408.         
  409.         stamp0 = (ulong) u1*65536 + u0;
  410.         stamp1 = (ulong) v1*65536 + v0;
  411.                         // Move two 16-bit values into one 
  412.                         //   32-bit value for the time stamp
  413.                         //   read at both the beginning and 
  414.                         //   end of the test.
  415.                                                    
  416.            cycles = stamp1 - stamp0;    // Number of internal 
  417.                                        //   clock cycles is 
  418.                                        //   difference between 
  419.                                        //   two time stamp 
  420.                                        //   readings.
  421.  
  422.            ticks = (ulong) t1 - t0;    // Number of external 
  423.                                        //   ticks is difference 
  424.                                        //   between two 
  425.                                        //   timeGetTime reads
  426.                                     
  427.         ticks = ticks * 1000;        // Convert ticks to us 
  428.                                        //   (since the 
  429.                                        //   timeGetTime
  430.                                        //   frequency is 1 
  431.                                        //   tick/ms).
  432.  
  433.         total_ticks += ticks;
  434.         total_cycles += cycles;
  435.  
  436.         freq = cycles/ticks;        // Cycles / us  = MHz
  437.                                                 
  438.           if ( cycles%ticks > ticks/2 )
  439.                freq++;                    // Round up if necessary    
  440.                   
  441.         total = ( freq + freq2 + freq3 );
  442.                             // Total last three frequency 
  443.                             //   calculations
  444.  
  445.                 
  446.     } while((tries<3) ||             
  447.             (tries<MAX_TRIES)&&
  448.             ((abs(3*(int)freq -(int)total)>3*TOLERANCE)||
  449.              (abs(3*(int)freq2-(int)total)>3*TOLERANCE)||
  450.              (abs(3*(int)freq3-(int)total)>3*TOLERANCE)));    
  451.                     // Compare last three calculations to 
  452.                       //   average of last three calculations.        
  453.         
  454.     // Try one more significant digit.
  455.     freq3 = ( total_cycles * 10 ) / total_ticks;
  456.     freq2 = ( total_cycles * 100 ) / total_ticks;
  457.  
  458.     if ( freq2 - (freq3 * 10) >= ROUND_THRESHOLD )
  459.         freq3++;
  460.  
  461.     cpu_speed.raw_freq = total_cycles / total_ticks;
  462.     cpu_speed.norm_freq = cpu_speed.raw_freq;
  463.  
  464.     freq = cpu_speed.raw_freq * 10;
  465.     if( (freq3 - freq) >= ROUND_THRESHOLD )
  466.         cpu_speed.norm_freq++;
  467.  
  468.     cpu_speed.ex_ticks = total_ticks;
  469.     cpu_speed.in_cycles = total_cycles;
  470.  
  471.     return cpu_speed;
  472. }    
  473.  
  474.  
  475. static int GetCmosTick(void)
  476. {
  477.     int tick = 0;
  478.  
  479.     // __asm    mov ah, 02h
  480.     // __asm    int 1Ah
  481.     // __asm    mov al, dh
  482.     // __asm    and ax, 000Fh  
  483.  
  484.     __asm  xor ax, ax
  485.     __asm  out 070h, al
  486.  
  487.     __asm  xor ax, ax
  488.     __asm  in  al, 071h
  489.  
  490.     // _outp( 0x70, offset );
  491.     // base = _inp( 0x71 ); 
  492.  
  493. // value returned in ax by function
  494.  
  495.     __asm     mov word ptr tick, ax
  496.  
  497.     return tick;
  498. }
  499.  
  500.  
  501. //#define ABS_TICK(a,b)  (b<a)?b+60-a:b-a
  502. // since I am only interested in single ticks
  503. #define ABS_TICK(a,b)  (b<a)?b+10-a:b-a
  504.  
  505. static struct FREQ_INFO GetCmosCpuSpeed()
  506. {
  507.     int    timeStart, timeStop, lapseTime;
  508.     unsigned long   temp;
  509.     unsigned long   temp1;
  510.     struct FREQ_INFO cpu_speed;
  511.     unsigned long   cpuSpeed = 0l;
  512.     ulong  stamp0, stamp1;            // Time Stamp Variable 
  513.                                     //   for beginning and end 
  514.     
  515.     ushort u0,u1;                     // 16-bit variables for time
  516.     ushort v0,v1;                    //   stamp reads. These are 
  517.                                     //   later merged into 
  518.                                     //   stamp0, and stamp1 
  519.                                     //   (32-bit variables)
  520.  
  521.     memset(&cpu_speed, 0x00, sizeof(cpu_speed));
  522.  
  523.     // This loop waits for the next tick
  524.     // so that we begin speed test on a tick edge
  525.     timeStart = GetCmosTick();
  526.     for(;;)
  527.     {
  528.         timeStop = GetCmosTick();
  529.         if (  ABS_TICK(timeStart,timeStop) > 0 )
  530.         {
  531.             __asm                        // Read Time Stamp...
  532.             {                       
  533.                 RDTSC
  534.                 
  535.                 MOV CL, 16
  536.                             
  537.                 MOV u0, AX
  538.                 OPND32
  539.                 SHR    AX,CL
  540.                 MOV u1, AX
  541.             }                   
  542.             break;    
  543.         }    
  544.     }
  545.  
  546.     timeStart = timeStop;
  547.  
  548.     for(;;)
  549.     {
  550.         timeStop = GetCmosTick();
  551.         if (  ABS_TICK(timeStart,timeStop) > 0 )
  552.         {
  553.             __asm                        // Read Time Stamp...
  554.             {
  555.                 RDTSC
  556.                 
  557.                 MOV CL, 16
  558.                             
  559.                 MOV v0, AX
  560.                 OPND32
  561.                 SHR    AX,CL
  562.                 MOV v1, AX
  563.             }                   
  564.             break;    
  565.         }    
  566.     }
  567.  
  568.     // convert into long values
  569.     stamp0 = (ulong) u1*65536 + u0;
  570.     stamp1 = (ulong) v1*65536 + v0;
  571.  
  572.     lapseTime = ABS_TICK(timeStart,timeStop);
  573.  
  574.     cpuSpeed = stamp1 - stamp0; ///lapseTime; 
  575.     cpu_speed.in_cycles = cpuSpeed;        // Cycles count since we in this routine
  576.  
  577.     //round to nearest digit
  578.     temp =  cpuSpeed/1000000;     
  579.     temp1 = cpuSpeed/100000;  
  580.     temp = temp * 10;  // realign with last digit = zero
  581.  
  582.     cpuSpeed = cpuSpeed/1000000; // cpuSpeed/1000000;
  583.     cpu_speed.raw_freq = cpuSpeed;    
  584.  
  585.     if( (temp1 - temp) >= ROUND_THRESHOLD )
  586.         cpuSpeed++;
  587.     
  588.     cpu_speed.norm_freq = cpuSpeed;    
  589.     cpu_speed.ex_ticks = (timeStop - timeStart) * 1000000;
  590.  
  591.     return cpu_speed;            
  592. }
  593.