home *** CD-ROM | disk | FTP | other *** search
/ PC User 1997 April / PCU_APR_97.ISO / utils / cpu / cpuinfo / source / tstdll32 / tstdll32.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-06  |  16.9 KB  |  696 lines
  1. /***************************************************************
  2. * C file:  Tstdll32.c... for Tstdll32.exe
  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. * History:
  26. *  June 12 96: fixed misdeclaration for wincpufeatures() -- now a DWORD
  27. *            : added message for MMX(TM) Technology processors
  28. *  Aug 96    : added check for missing dll.  
  29. *
  30. ***************************************************************/
  31.  
  32. #include <windows.h>
  33. #include <stdio.h>
  34. #include <math.h>
  35.  
  36. #include "tstdll32.h"
  37. #include "resource.h"
  38.  
  39.  
  40.  
  41. HINSTANCE hLibrary;                //handle for cpuinf32 dll
  42.  
  43. WORD (FAR *lpfnwincpuid)();
  44. WORD (FAR *lpfnwincpuidsupport)();
  45. WORD (FAR *lpfnwincpuidext)();
  46. DWORD (FAR *lpfnwincpufeatures)();
  47. ushort(FAR PASCAL *lpfngetdllversion)();
  48. struct TIME_STAMP (FAR *lpfnwinrdtsc)();
  49. struct FREQ_INFO  (FAR *lpfnwincpuspeed)(int BSFclocks);
  50.  
  51. HWND    hWnd;
  52. HDC         hDC;
  53.  
  54. #if !defined (APIENTRY)
  55.         #define    APIENTRY pascal
  56. #endif
  57.  
  58.  
  59.         // The name of this application
  60. #define APPCLASSNAME "tstdll32"
  61.  
  62.  
  63.  
  64. HINSTANCE hInst;
  65. char szAppName[] = "tstdll32";
  66. char szAppIconName[] = "test32icon";
  67. char szTitle[]   = "32-bit dll test";
  68. char szAppClass[32];
  69.  
  70.  
  71. /***************************************************************
  72. * WinMain()
  73. *
  74. * Inputs:
  75. *    hInstance        Main window handle instance
  76. *    hPrevInstance    Previous window handle instance
  77. *    lpCmdLine        Pointer to command line string
  78. *    nCmdShow        Window display flag
  79. *
  80. * Results:
  81. *    return value of the PostQuitMessage function if the function
  82. *       is successful.
  83. *    return NULL if it terminates before entering the message 
  84. *      loop.            
  85. ***************************************************************/
  86.  
  87. int APIENTRY WinMain ( HINSTANCE hInstance, 
  88.                        HINSTANCE hPrevInstance,
  89.                           LPSTR lpCmdLine, int nCmdShow )
  90. {
  91.         char buf[512]="";        // String Variable for 
  92.                                     //   Message Boxes
  93.  
  94.     //Load CPUINF32.DLL and do CPUID
  95.     if (LoadLibrary(CPUINFODLL)==NULL) {
  96.  
  97.         if (LOBYTE(LOWORD(GetVersion()))<4) {
  98.                 
  99.             return (FALSE);                    // if DLL not found exit app
  100.             }
  101.         else {
  102.             sprintf(buf, "CPUINF32.DLL not found");
  103.                MessageBox(NULL,buf,"Error", MB_ICONINFORMATION); 
  104.             return (FALSE);                    // if DLL not found exit app
  105.             }
  106.     }//if
  107.     else {
  108.     
  109.     
  110.     sprintf( szAppClass, "%s%d", APPCLASSNAME, hInstance);
  111.     if (!InitApplication( hInstance)) {
  112.         return (FALSE);
  113.     }
  114.     // Initialization for specific instance
  115.     if (!InitInstance(hInstance, nCmdShow)) {
  116.         return (FALSE);
  117.     }
  118.     EventLoop(hInstance);
  119.     return 0;
  120.  
  121.     lpCmdLine;
  122.    }
  123. } // WinMain()
  124.  
  125.  
  126.  
  127. /***************************************************************
  128. * InitApplication()
  129. *
  130. * Inputs:
  131. *    hInstance    Handle for first instance of app
  132. *
  133. * Returns:
  134. *    atom that uniquely identifies the class being registered.
  135. *    zero if an error occurs.
  136. ***************************************************************/
  137.  
  138. BOOL InitApplication( HINSTANCE hInstance)
  139. {    // called for first instance of app
  140.     WNDCLASS  wc;
  141.  
  142.     wc.style = (CS_HREDRAW | CS_VREDRAW | CS_OWNDC);
  143.     
  144.     wc.lpfnWndProc   = (WNDPROC)WndProc;    // Window Procedure
  145.     
  146.     wc.cbClsExtra    = 0;                    // No per-class 
  147.                                             //   extra data.
  148.     
  149.     wc.cbWndExtra    = (int)NULL;            // 4-bytes extra 
  150.                                             //   data.
  151.     
  152.     wc.hInstance     = hInstance;            // Owner of this
  153.                                             //   class
  154.     
  155.     wc.hIcon         = LoadIcon (hInstance, szAppIconName);    
  156.                                             // Icon name from 
  157.                                             //   .RC
  158.     
  159.     wc.hCursor       = LoadCursor(NULL, IDC_ARROW);     
  160.                                             // Cursor
  161.     
  162.     wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);        
  163.                                             // Default color
  164.     
  165.     wc.lpszMenuName  = szAppName;            // Menu name from
  166.                                             //   .RC file
  167.     
  168.     wc.lpszClassName = szAppClass;            // Name to register
  169.                                             //   as
  170.  
  171.     return (RegisterClass(&wc));
  172. } // InitApplication()
  173.  
  174.  
  175.  
  176. /***************************************************************
  177. * InitInstance()
  178. * 
  179. * Purpose:
  180. *   Initialization for first instance of app.
  181. *
  182. * Inputs:
  183. *    hInstance    Main window handle instance 
  184. *    nCmdShow    Main window display flag
  185. *
  186. * Returns:
  187. *    Always returns true.
  188. ***************************************************************/
  189.  
  190. BOOL InitInstance( HINSTANCE hInstance, int nCmdShow )
  191. {
  192.     HWND    wHdl;
  193.  
  194.  
  195.     hInst = hInstance;             // Save instance handle
  196.                                 
  197.                                 // Main window for this app 
  198.                                 //   instance.
  199.     wHdl = CreateWindow(
  200.         szAppClass,                // See RegisterClass()
  201.         szTitle,                // Window title bar
  202.         WS_OVERLAPPEDWINDOW,    // Window style.
  203.         CW_USEDEFAULT,            // Init x pos
  204.         CW_USEDEFAULT,            // Init y pos
  205.         CW_USEDEFAULT,            // Init x size
  206.         CW_USEDEFAULT,            // Init y size
  207.         
  208.         NULL,                    // Overlapped windows have no 
  209.                                 //   parent.
  210.         
  211.         NULL,                    // Use the window class menu.
  212.         
  213.         hInstance,                // This instance owns this 
  214.                                 //   window.
  215.         
  216.         NULL                    // We don't use any data in our
  217.                                 //   WM_CREATE
  218.     );
  219.  
  220.  
  221.     // Make the window visible; update its client area; 
  222.     //   and return "success"
  223.     
  224.     ShowWindow(wHdl, nCmdShow); // Show the window
  225.     UpdateWindow(wHdl);            // Sends WM_PAINT message
  226.  
  227.     hWnd = wHdl;                // Used in actions.c
  228.     return (TRUE);                // We succeeded...
  229.  
  230. } // InitInstance()
  231.  
  232.  
  233.  
  234. /***************************************************************
  235. * EventLoop()
  236. *
  237. * Inputs:
  238. *    hInstance    Window instance handle
  239. *
  240. * Returns: none
  241. ***************************************************************/
  242.  
  243. void EventLoop(HINSTANCE hInstance)
  244. {
  245.     MSG     msg;
  246.      HANDLE hAccel;
  247.  
  248.     hAccel=LoadAccelerators(hInstance, szAppName);
  249.     while (GetMessage(&msg,     // Message structure
  250.               NULL,               // Handle of window receiving 
  251.                                   //   the message
  252.               0,                  // Lowest message to examine
  253.               0))                 // Highest message to examine
  254.     {
  255.     
  256.     if (!TranslateAccelerator (hWnd,hAccel, &msg)) {
  257.     TranslateMessage(&msg);        // Translates virtual key codes
  258.     DispatchMessage(&msg);         // Dispatches message to window
  259.     }
  260.  
  261.     }
  262. } // EventLoop()       
  263.  
  264.  
  265. void GetSpeed( int iType )
  266. {
  267.     WORD    cpu_type   = 0;    // CPU Family variable
  268.     WORD    extensions = 0; // CPU Extensions variable
  269.     DWORD    features   = 0;    // CPU Features variable
  270.     
  271.     ushort    version       = 0; // CPUINFO DLL Version
  272.  
  273.     struct FREQ_INFO cpu_speed;        // Return variable 
  274.                                             //   structure for 
  275.                                             //   cpuspeed 
  276.                                             //   routine
  277.             
  278.     char buf[512]="";        // String Variable for 
  279.                                     //   Message Boxes
  280.     
  281.       
  282.     
  283.     int u1,u2,exact;        // Statistical variables for
  284.     int d1,d2;                //   raw frequency analysis
  285.          
  286.     float per1,per2,per3;    // Statistical Percentages
  287.  
  288.     ulong norm_freq, raw_freq;        // Previous Normalized 
  289.                                     //   Frequency
  290.         
  291.     int missed=0;            // Keeps track of whether 
  292.                                     //   any speeds more than
  293.                                     //   3 MHz from the 
  294.                                     //   normalized occurred
  295.         
  296.        LARGE_INTEGER start, end;    // Variables to delay
  297.     ulong time;                    //   determine average
  298.                                         //    per test 
  299.  
  300.     int i, response;            // Variable for processing
  301.                                     //   MessageBox responses
  302.                 
  303.  
  304.     hLibrary=LoadLibrary(CPUINFODLL);
  305.  
  306.     (FARPROC) lpfnwincpuspeed = 
  307.             GetProcAddress(hLibrary,"cpuspeed");
  308.                 
  309.     cpu_speed = (*lpfnwincpuspeed)(iType);
  310.                 
  311.     if ( cpu_speed.in_cycles == 0 && cpu_speed.ex_ticks  == 0 ) {
  312.                      
  313.          sprintf(buf,
  314.                  "This processor cannot be accurately "
  315.                  "timed with this program.\n The "
  316.                  "processor is either an Intel Clone "
  317.                  "or is below 80386 level.");
  318.          MessageBox(NULL,buf,"error", MB_ICONINFORMATION );
  319.     }
  320.  
  321.     sprintf(buf,
  322.             "Clock Cycles: %lu cycles\n"
  323.             "Elapsed Time: %luus\n"
  324.             "Raw Clock Frequency: %luMHz\n"
  325.             "Normalized Frequency: %luMHz",
  326.             cpu_speed.in_cycles,
  327.             cpu_speed.ex_ticks,
  328.             cpu_speed.raw_freq,
  329.             cpu_speed.norm_freq);          
  330.  
  331.     MessageBox(NULL,buf,"32-bit cpuspeed", 
  332.                 MB_ICONINFORMATION );
  333.  
  334.     if ( iType == -1 )    // If Cmos time, then return because too slow
  335.         return;
  336.  
  337.     sprintf(buf,
  338.             "Would you like to perform\n"
  339.             "  a 1000 iteration test?");
  340.  
  341.     response = MessageBox(NULL,buf,"test", 
  342.             MB_YESNO|MB_ICONQUESTION );
  343.                 
  344.     if ( response == IDNO ) {
  345.             
  346.         FreeLibrary(hLibrary);
  347.         return;
  348.     }
  349.         
  350.     // Testing Code.... Runs 100 times and does 
  351.     //   statistical analysis on the data returned.
  352.     //       --BEGIN--
  353.             
  354.     norm_freq = cpu_speed.norm_freq;
  355.     raw_freq = cpu_speed.raw_freq;
  356.     u2=0;
  357.     u1=0;
  358.     exact=0;
  359.     d1=0;
  360.     d2=0;
  361.  
  362.     QueryPerformanceCounter(&start);
  363.  
  364.     for ( i = 0; i<1000; i++ ) {
  365.  
  366.            cpu_speed = (*lpfnwincpuspeed)(iType);
  367.                             
  368.         switch ( (int)cpu_speed.norm_freq - 
  369.                  (int)norm_freq ) {
  370.                         
  371.             case 0:
  372.                 exact++;
  373.                 break;
  374.                         
  375.             case 1:
  376.                 u1++;
  377.                 break;
  378.                         
  379.             case 2:
  380.                 u2++;
  381.                 break;
  382.                         
  383.             case -1:
  384.                 d1++;
  385.                 break;
  386.                     
  387.             case -2:
  388.                 d2++;
  389.                 break;
  390.                     
  391.             default:
  392.                 missed++; // Set missed flag; deviate more than 3Mhz
  393.         }
  394.     }
  395.                 
  396.     QueryPerformanceCounter(&end);
  397.                 
  398.     time = (ulong) (end.LowPart - start.LowPart);
  399.     time = time / 1193180;
  400.  
  401.     per1 = (float)((float)exact/10.0);
  402.                 
  403.     per2 = (float)((float)(u1+d1)/10.0);
  404.                 
  405.     per3 = (float)((float)(u2+d2)/10.0);
  406.  
  407.     sprintf(buf,
  408.             "%luMHz\t%luMHz\t%luMHz\t%luMHz\t%luMHz\n"
  409.             "  %03d\t  %03d\t  %03d\t  %03d\t  %03d\t"
  410.             "\n\n"
  411.             "Exact value  \t: %.2f\n"
  412.             "Within 1 MHz \t: %.2f\n"
  413.             "Within 2 MHz \t: %.2f\n\n"
  414.             "Beyond 2 MHz \t: %.2f\n\n"
  415.             "----->  Normalized Speed  \t=  %lu\n"
  416.             "----->    Raw Speed       \t=  %lu\n\n"
  417.             "   Delay per test = %dms",
  418.             norm_freq-2,norm_freq-1,norm_freq,norm_freq+1,norm_freq+2,d2,d1,
  419.             exact,u1,u2,per1,per2,per3,0.0,
  420.             norm_freq,raw_freq,time);
  421.                 
  422.     MessageBox(NULL,buf,"32-bit cpuspeed",
  423.                 MB_ICONINFORMATION );
  424.  
  425.     //        --END--
  426.     // Testing Code.... Ran 100 times and did 
  427.     //   statistical analysis on the data returned.
  428.                                                    
  429.     FreeLibrary(hLibrary);
  430. }
  431.  
  432.  
  433. /***************************************************************
  434. * WndProc(HWND, UINT, WPARAM, LPARAM)
  435. *
  436. * Purpose:
  437. *   Processes messages
  438. *
  439. * Messages:
  440. *    WM_COMMAND    - application menu (About dialog box)
  441. *    WM_DESTROY    - destroy window
  442. *
  443. * Inputs:
  444. *   hWnd        Window Handle
  445. *   message        Type of Message
  446. *   uParam        Additional Information
  447. *    LParam        Additional Information
  448. *
  449. * Returns:
  450. *   LRESULT returned by DefWindowProc or 0
  451. ***************************************************************/
  452.  
  453. LRESULT CALLBACK WndProc(
  454.       HWND hWnd,                 // Window handle
  455.       UINT message,              // Type of message
  456.       WPARAM uParam,             // Additional information
  457.       LPARAM lParam              // Additional information
  458.       )
  459. {                                // Message Handler
  460.     PAINTSTRUCT    ps;                                         
  461.     
  462.     switch (message) {
  463.         
  464.         case WM_CREATE:
  465.             hDC = GetDC( hWnd);
  466.             break;
  467.     
  468.         case WM_SIZE:
  469.             break ;
  470.  
  471.         case WM_PAINT:
  472.             hDC=BeginPaint(hWnd,&ps);
  473.             EndPaint(hWnd,&ps);
  474.             break;
  475.  
  476.         case WM_CLOSE:
  477.             return (DefWindowProc(hWnd,message,uParam,lParam));
  478.             break;
  479.  
  480.         case WM_DESTROY:    // Message: window being destroyed
  481.             PostQuitMessage(0);
  482.             break;
  483.  
  484.          case WM_COMMAND:    // Message: command from application 
  485.                              //   menu
  486.         {
  487.            
  488.             WORD    cpu_type   = 0;    // CPU Family variable
  489.             WORD    extensions = 0; // CPU Extensions variable
  490.             DWORD    features   = 0;    // CPU Features variable
  491.     
  492.             ushort    version       = 0; // CPUINFO DLL Version
  493.  
  494.             int major, minor;        // Variables for storing DLL
  495.                                     //   version
  496.  
  497.             char buf[512]="";        // String Variable for 
  498.                                     //   Message Boxes
  499.     
  500.         
  501.             int missed=0;            // Keeps track of whether 
  502.                                     //   any speeds more than
  503.                                     //   3 MHz from the 
  504.                                     //   normalized occurred
  505.         
  506.             char misses[256]= "";    // Keeps track of all raw 
  507.                                     //   speeds more than 3 MHz
  508.                                     //   from the normalized 
  509.                                     //   value
  510.  
  511.             struct TIME_STAMP stamp;    
  512.                                     // Variable for 64-bit Time
  513.                                     //   Stamp read
  514.  
  515.                int cpuid_support;        // Flag to determine whether
  516.                                     //   CPUID opcode is 
  517.                                     //   supported
  518.  
  519.         
  520.             WORD wmId, wmEvent;
  521.         
  522.             wmId    = LOWORD(uParam);
  523.             wmEvent = HIWORD(uParam);
  524.          
  525.             switch(LOWORD(uParam)) {
  526.  
  527.  
  528.             case IDM_EXIT:
  529.             
  530.                 SendMessage(hWnd, WM_CLOSE, 0, 0l);
  531.                 break;
  532.  
  533.  
  534.             case IDM_CPUID:
  535.  
  536.                 hLibrary=LoadLibrary(CPUINFODLL);
  537.             
  538.                 (FARPROC) lpfnwincpuid = 
  539.                         GetProcAddress(hLibrary,"wincpuid");
  540.                 (FARPROC) lpfnwincpuidsupport =
  541.                         GetProcAddress(hLibrary,
  542.                             "wincpuidsupport");
  543.                 
  544.                 cpu_type = (*lpfnwincpuid)();
  545.                 cpuid_support = (*lpfnwincpuidsupport)();
  546.  
  547.                 FreeLibrary(hLibrary);
  548.  
  549.                 if ( cpu_type & CLONE_MASK )
  550.                     sprintf(buf,"Intel Clone CPU Family : %x",
  551.                         cpu_type);
  552.  
  553.                 else if ( cpuid_support )    
  554.                                     // Intel processor presence 
  555.                                     //   can only be verified if
  556.                                     //   CPUID opcode is 
  557.                                     //   supported and the 
  558.                                     //   GenuineIntel vendor ID 
  559.                                     //   is read.
  560.                                                 
  561.                     sprintf(buf,"Intel CPU Family : %x",
  562.                         cpu_type);
  563.                 
  564.                 else
  565.                     sprintf(buf,"CPU Family : %x", cpu_type);
  566.             
  567.                 MessageBox(NULL,buf,"wincpuid",
  568.                     MB_ICONINFORMATION);
  569.                 
  570.                 break;
  571.  
  572.         case IDM_CPUID2:
  573.  
  574.                 hLibrary=LoadLibrary(CPUINFODLL);           
  575.                 
  576.                 (FARPROC) lpfnwincpuidext = 
  577.                         GetProcAddress(hLibrary,"wincpuidext");
  578.                 
  579.                 extensions = (*lpfnwincpuidext)();
  580.    
  581.                    FreeLibrary(hLibrary);
  582.  
  583.                 sprintf(buf,"Type/Family/Model/Stepping: %.4x",
  584.                         extensions);
  585.                 
  586.                 MessageBox(NULL,buf,"wincpuidext",
  587.                     MB_ICONINFORMATION);
  588.  
  589.                 break;
  590.  
  591.         case IDM_CMOSSPEED:
  592.             {
  593.                 int response;
  594.  
  595.                 response = MessageBox(NULL,"This feature is not supported for NT; do you want to continue?","test", 
  596.                                     MB_YESNO|MB_ICONQUESTION );
  597.                 
  598.                 if ( response == IDYES ) {
  599.                     GetSpeed( -1 );
  600.                 }
  601.             }
  602.             break;
  603.  
  604.         case IDM_CPUSPEED:
  605.                 GetSpeed( 0 );
  606.                 break;
  607.  
  608.  
  609.         case IDM_FEATUREFLAGS:
  610.  
  611.                 hLibrary=LoadLibrary(CPUINFODLL);
  612.                 
  613.                 (FARPROC) lpfnwincpufeatures = 
  614.                         GetProcAddress(hLibrary,
  615.                         "wincpufeatures");
  616.                 
  617.                 features = (*lpfnwincpufeatures)();
  618.         
  619.             /*Print extra line in message for MMX(TM) technology processor, ie, features(23)=1*/
  620.                 if (features & 0x00800000) //then MMX(TM) technology
  621.                  sprintf(buf,
  622.                    "Feature Flags: %.8x \n on a processor with MMX(TM) technology", features);
  623.                 else 
  624.                  sprintf(buf,"Feature Flags: %.8x",features);        
  625.                 /***************************/
  626.  
  627.                 
  628.                 MessageBox(NULL,buf,"wincpufeatures",
  629.                     MB_ICONINFORMATION);
  630.                 FreeLibrary(hLibrary);
  631.                 break;
  632.  
  633.         case IDM_READ:
  634.                 
  635.                 hLibrary=LoadLibrary(CPUINFODLL);
  636.                 (FARPROC) lpfnwinrdtsc = 
  637.                     GetProcAddress(hLibrary,"winrdtsc");
  638.                     
  639.                 stamp=(*lpfnwinrdtsc)();
  640.                 
  641.                 if ( stamp.High != 0 || stamp.Low != 0 ) {
  642.                 
  643.                     sprintf(buf,"Time Stamp: %08lx  %08lx",
  644.                         stamp.High,stamp.Low);
  645.                     
  646.                     MessageBox(NULL,buf,"winrdtsc",
  647.                         MB_ICONINFORMATION);
  648.                 
  649.                 }
  650.                 else {
  651.                     
  652.                     MessageBox(NULL,"Time Stamping not "
  653.                         "available on this system","error",
  654.                         MB_ICONINFORMATION);
  655.                 
  656.                 }
  657.                 
  658.                 FreeLibrary(hLibrary);
  659.                 break;
  660.             
  661.  
  662.         case IDM_GETDLLVERSION:
  663.             
  664.                 hLibrary=LoadLibrary(CPUINFODLL);
  665.                 (FARPROC) lpfngetdllversion =
  666.                     GetProcAddress(hLibrary,"getdllversion");
  667.                     
  668.                 version = (*lpfngetdllversion)();
  669.                 
  670.                 major = version >> 8;        // Shift out minor
  671.                                             //   version.
  672.                                             
  673.                 minor = version - major*256;    // Subtract off
  674.                                                 //   major 
  675.                                                 //   version.
  676.                 
  677.                 sprintf(buf,"CPUINFO32 DLL Version: %x.%x",
  678.                     major,minor);
  679.                 
  680.                 MessageBox(NULL,buf,"getdllversion",
  681.                     MB_ICONINFORMATION);
  682.                 
  683.                 FreeLibrary(hLibrary);    
  684.                 break;
  685.  
  686.         }
  687.     }
  688.  
  689.     default:          // Passes it on if unproccessed
  690.          return (DefWindowProc(hWnd, message, uParam, lParam));
  691.     }
  692.  
  693.     return (0);
  694. }
  695.  
  696.