测试CPU品牌和当前工作频率

测试CPU品牌和当前工作频率

这里有一段非常简单的代码，取自网络，我稍加修改，贴在这里。用来检查CPU的生产商和品牌，以及当前工作频率，如果是台式机CPU，频率应该恒定，但是移动版本的CPU，频率不停地在变。以下代码用Visual C ++ 编译，因为内嵌一点汇编，造成移植性变差(例如：GCC汇编跟AT & T汇编语法类似，但是MS汇编跟Intel汇编语法类似)，以下代码如果希望在MinGW(GCC)下编译，需要修改那点内嵌的汇编。

#include  " stdafx.h "
#ifndef CPUID_HPP_
#define  CPUID_HPP_

#include  < string >
#include  < cstring >
#include  < iostream >
#include  < windows.h >

typedef unsigned  long  DWORD;
typedef __int64 LONGLONG;

class  CPUID
{
public :
  CPUID() : m_eax( 0 ), m_ebx( 0 ), m_ecx( 0 ), m_edx( 0 ){}
  std:: string  vendor();  // 哪个厂商出的？Intel, AMD, VIA ?
  std:: string  name();    // 这是CPU的整体描述
  LONGLONG frequency(DWORD stime  =   1000 ); // CPU的当前工作频率

private :
   void   Executecpuid(DWORD veax);
  LONGLONG cycles()  const
  {
    DWORD h, l;          // 不能直接读取，用变量过渡一下
    __asm
    {
      rdtsc              // 把当前CPU周期读入寄存器
      mov l, eax
      mov h, edx
    }
    LONGLONG high  =  h, low  =  l;
     return  high  <<   32   |  low;
  }

  DWORD  m_eax;
  DWORD  m_ebx;
  DWORD  m_ecx;
  DWORD  m_edx;
};

void  CPUID::Executecpuid(DWORD veax)
{
  DWORD deax;
  DWORD debx;
  DWORD decx;
  DWORD dedx;

  __asm
  {
    mov eax, veax
    cpuid
    mov deax, eax
    mov debx, ebx
    mov decx, ecx
    mov dedx, edx
  }

  m_eax  =  deax;
  m_ebx  =  debx;
  m_ecx  =  decx;
  m_edx  =  dedx;
}

std:: string  CPUID::vendor()
{
   const  DWORD S  =   sizeof (DWORD);
   char  cVID[S * 3 + 1 ];
  std::memset(cVID,  0 ,  sizeof (cVID));
  Executecpuid( 0 );
  std::memcpy(cVID + S * 0 ,  & m_ebx, S);
  std::memcpy(cVID + S * 1 ,  & m_edx, S);
  std::memcpy(cVID + S * 2 ,  & m_ecx, S);

   return  std:: string (cVID);
}

std:: string  CPUID::name()
{
   const  DWORD vendorID  =   0x80000002 ;
   const  DWORD S  =   sizeof (DWORD);
   char  cvendor[S * 4 * 3 + 1 ];
  std::memset(cvendor,  0 ,  sizeof (cvendor));

   for (DWORD i  =   0 ; i  <   3 ; i ++ )
  {
    Executecpuid(vendorID  +  i);
     //  每次执行结束后，保存四个寄存器里的ascii码到数组
    std::memcpy(cvendor  +  i * S * 4   +  S * 0 ,  & m_eax, S);
    std::memcpy(cvendor  +  i * S * 4   +  S * 1 ,  & m_ebx, S);
    std::memcpy(cvendor  +  i * S * 4   +  S * 2 ,  & m_ecx, S);
    std::memcpy(cvendor  +  i * S * 4   +  S * 3 ,  & m_edx, S);
  }
   return  std:: string (cvendor);
}

LONGLONG CPUID::frequency(DWORD stime)
{
  HANDLE hp  =  GetCurrentProcess();
  HANDLE ht  =  GetCurrentThread();

  DWORD pc  =  GetPriorityClass(hp);
  DWORD tp  =  GetThreadPriority(ht);

  BOOL flag1  =  FALSE, flag2  =  FALSE;

  flag1  =  SetPriorityClass(hp, REALTIME_PRIORITY_CLASS);  // 优先级设置最高
  flag2  =  SetThreadPriority(ht, THREAD_PRIORITY_HIGHEST); // 优先级设置最高

   // 由于CPU本身时间波动较大，因此时间从系统读取，这样比较平均
  //周期除以时间就是工作频率，即单位时间内的周期
  Sleep(stime);
  LARGE_INTEGER fq, st, ed;
  QueryPerformanceFrequency( & fq);
  QueryPerformanceCounter( & st);
  LONGLONG start  =  cycles();
  Sleep(stime);
  QueryPerformanceCounter( & ed);
  LONGLONG end  =  cycles();
   if (flag1)
    SetPriorityClass(hp, pc);
   if (flag2)
    SetThreadPriority(ht, tp);

  CloseHandle(hp);
  CloseHandle(ht);

   return  (end  -  start)  *  fq.QuadPart  /  (ed.QuadPart  -  st.QuadPart);
}

#endif


#include  < cstdio >
#include  < cstdlib >

int  main()
{
  CPUID cpu;
  std::printf( " Vendor: %s\n " , cpu.vendor().c_str());
  std::printf( " Full name: %s\n " , cpu.name().c_str());
   const  unsigned TIMES  =   3 ;
  std::printf( " Frequency(testing %d times):  " , TIMES);
   const   double  UNIT  =   1000.0 ;
   for (unsigned i  =   0 ; i  <  TIMES;  ++ i)
  {
     double  fre  =  cpu.frequency()  /  UNIT;  //  假设CPU主频高于1000Hz
     if (fre  >  UNIT) 
      fre  /=  UNIT;
    std::printf( " %f%s  " , fre, (fre  >   10.0   ?   " MHz "  :  " GHz " ));
  }
  printf( " \n " );
  std::system( " PAUSE " );
   return   0 ;
}