让cpu占用率曲线听你指挥（多核处理器）

编程之美 1.1 让cpu占用率曲线听你指挥（多核处理器）

【版权声明】转载请注明出处 http://www.cnblogs.com/TenosDoIt/p/3242910.html 

【目录】

不考虑其他进程，cpu画正弦曲线

获取总体cpu利用率

获取多核处理器单个cpu利用率

考虑其他进程，cpu画正弦曲线

---

下面的程序针对多核处理器，可以设置让任何一个cpu显示相应的曲线（本文以正弦曲线为例）

代码编译环境：windows 7 64位 酷睿 i5 处理器，vs2010.

可以修改CpuSin函数的计算 busySpan 和 idleSpan的部分以显示不同的曲线。

下面的代码没有考虑cpu中其他进程的占用情况，这种情况详见第二部分

 1 #include <windows.h>
 2 #include <stdio.h>
 3 #include <math.h>
 4
 5 //把一条正弦曲线0~2pi 之间的弧度等分200份抽样，计算每个点的振幅
 6 //然后每隔300ms设置下一个抽样点,并让cpu工作对应振幅时间
 7 const int samplingCount = 200; //抽样点数目
 8 const double pi = 3.1415926;
 9 const int totalAmplitude = 300; //每个抽样点对应时间片
10 const double delta = 2.0/samplingCount;  //抽样弧度的增量
11
12 int busySpan[samplingCount];//每个抽样点对应的busy时间
13 int idleSpan[samplingCount];//每个抽样点对应的idle时间
14
15 //一个线程调用MakeUsageSin，并把该线程绑定到一个cpu，那么该cpu呈现正弦曲线
16 DWORD WINAPI MakeUsageSin(LPVOID lpParameter)
17 {
18     DWORD startTime = 0;
19     for(int j = 0; ; j = (j + 1) % samplingCount)
20     {
21         startTime = GetTickCount();
22         while ((GetTickCount() - startTime) < busySpan[j]);
23         Sleep(idleSpan[j]);
24     }
25 }
26
27 //如果cpuindex < 0 则所有cpu都显示正弦曲线
28 //否则只有第 cpuindex个cpu显示正弦曲线
29 //cpuindex 从 0 开始计数
30 void CpuSin(int cpuIndex)
31 {
32     //计算 busySpan 和 idleSpan
33     double radian = 0;
34     int amplitude = totalAmplitude / 2;
35     for (int i = 0; i < samplingCount; i++)
36     {
37         busySpan[i] = (DWORD)(amplitude + sin(pi*radian)*amplitude);
38         idleSpan[i] = totalAmplitude - busySpan[i];
39         radian += delta;
40     }
41
42     //获取系统cup数量
43     SYSTEM_INFO SysInfo;
44     GetSystemInfo(&SysInfo);
45     int num_processors = SysInfo.dwNumberOfProcessors;
46     if(cpuIndex + 1 > num_processors)
47     {
48         printf("error: the index of cpu is out of boundary\n");
49         printf("cpu number: %d\n", num_processors);
50         printf("your index: %d\n", cpuIndex);
51         printf("** tip: the index of cpu start from 0 **\n");
52         return;
53     }
54
55     if(cpuIndex < 0)
56     {
57         HANDLE* threads = new HANDLE[num_processors];
58         for (int i = 0;i < num_processors;i++)
59         {
60             DWORD mask = 1<<i;
61             threads[i] = CreateThread(NULL, 0, MakeUsageSin, &mask, 0, NULL);
62             SetThreadAffinityMask(threads[i], 1<<i);//线程指定在某个cpu运行
63         }
64         WaitForMultipleObjects(num_processors, threads, TRUE, INFINITE);
65     }
66     else
67     {
68         HANDLE thread;
69         DWORD mask = 1;
70         thread = CreateThread(NULL, 0, MakeUsageSin, &mask, 0, NULL);
71         SetThreadAffinityMask(thread, 1<<cpuIndex);
72         WaitForSingleObject(thread,INFINITE);
73     }
74
75 }
76 int main()
77 {
78
79     CpuSin(0);
80     return 0;
81 }

运行结果：

---

下面我们考虑其他进程对cpu的影响，即需要检测出某个cpu当前的使用率。

首先对于单核处理器获取cpu利用率，或者多核处理器获取总的cpu利用率，可以通过windows api “GetSystemTimes” 来实现

该函数声明如下：BOOL GetSystemTimes（LPFILETIME  IdleTime，LPFILETIME   KernelTime，LPFILETIME   UserTime），具体可以参考msdn接口介绍

cpu利用率计算公式为：CPURate=100.0-（NowIdleTime-LastIdleTime）/（NowKernelTime-LastKernelTime+NowUserTime-LastUserTime）*100.0

计算总的cpu利用率或者单核处理器cpu利用率的类实现如下：

 1 class CCPUUseRate
 2 {
 3 public:
 4     BOOL Initialize()
 5     {
 6         FILETIME ftIdle, ftKernel, ftUser;
 7         BOOL flag = FALSE;
 8         if (flag = GetSystemTimes(&ftIdle, &ftKernel, &ftUser))
 9         {
10             m_fOldCPUIdleTime = FileTimeToDouble(ftIdle);
11             m_fOldCPUKernelTime = FileTimeToDouble(ftKernel);
12             m_fOldCPUUserTime = FileTimeToDouble(ftUser);
13
14         }
15         return flag;
16     }
17     //调用Initialize后要等待1左右秒再调用此函数
18     int GetCPUUseRate()
19     {
20         int nCPUUseRate = -1;
21         FILETIME ftIdle, ftKernel, ftUser;
22         if (GetSystemTimes(&ftIdle, &ftKernel, &ftUser))
23         {
24             double fCPUIdleTime = FileTimeToDouble(ftIdle);
25             double fCPUKernelTime = FileTimeToDouble(ftKernel);
26             double fCPUUserTime = FileTimeToDouble(ftUser);
27             nCPUUseRate= (int)(100.0 - (fCPUIdleTime - m_fOldCPUIdleTime)
28                 / (fCPUKernelTime - m_fOldCPUKernelTime + fCPUUserTime - m_fOldCPUUserTime)
29                 *100.0);
30             m_fOldCPUIdleTime = fCPUIdleTime;
31             m_fOldCPUKernelTime = fCPUKernelTime;
32             m_fOldCPUUserTime = fCPUUserTime;
33         }
34         return nCPUUseRate;
35     }
36 private:
37     double FileTimeToDouble(FILETIME &filetime)
38     {
39         return (double)(filetime.dwHighDateTime * 4.294967296E9) + (double)filetime.dwLowDateTime;
40     }
41 private:
42     double m_fOldCPUIdleTime;
43     double m_fOldCPUKernelTime;
44     double m_fOldCPUUserTime;
45 };

注意：前后两次调用GetSystemTimes之间要间隔一定时间，使用方法如下：

 1 int main()
 2 {
 3     CCPUUseRate cpuUseRate;
 4     if (!cpuUseRate.Initialize())
 5     {
 6         printf("Error! %d\n", GetLastError());
 7         getch();
 8         return -1;
 9     }
10     else
11     {
12         while (true)
13         {
14             Sleep(1000);
15             printf("\r当前CPU使用率为：%4d%%", cpuUseRate.GetCPUUseRate());
16         }
17     }
18     return 0;
19 }

对于计算多核处理器中单个cpu的使用率，可以使用pdh.h头文件中的接口，该头文件是visual studio自带的，包含该头文件时，还需要引入相关的lib库：

 1 #include <TCHAR.h>
 2 #include <windows.h>
 3 #include <pdh.h>
 4 #include <cstdio>
 5 #include <cmath>
 6 #pragma comment(lib, "pdh.lib")
 7
 8 //---------------------------------------------------comput the cpu usage rate
 9 static PDH_HQUERY cpuQuery;
10 static PDH_HCOUNTER cpuTotal;
11
12 //cpuindex 为指定的cpu id ，从0开始
13 void init(int cpuIndex)
14 {
15     PDH_STATUS Status = PdhOpenQuery(NULL, NULL, &cpuQuery);
16     if (Status != ERROR_SUCCESS)
17     {
18         printf("\nPdhOpenQuery failed with status 0x%x.", Status);
19         exit(-1);
20     }
21     char buf[50];
22     sprintf(buf, "\\Processor(%d)\\%% Processor Time", cpuIndex);
23     PdhAddCounter(cpuQuery, LPCSTR(buf), NULL, &cpuTotal);
24     PdhCollectQueryData(cpuQuery);
25 }
26
27
28 double getCpuUsageRate()
29 {
30     PDH_FMT_COUNTERVALUE counterVal;
31     PdhCollectQueryData(cpuQuery);
32     PdhGetFormattedCounterValue(cpuTotal, PDH_FMT_DOUBLE, NULL, &counterVal);
33     return counterVal.doubleValue;
34 }

注：该方法也可以计算总的cpu利用率，只要把PdhAddCounter的第二个字符串参数改为"\\Processor(_Total)\\%% Processor Time"

前后两次调用PdhCollectQueryData之间也需要间隔一定时间

使用方法如下：

1 int main()
2 {
3     init(0);
4     while(1)
5     {
6         Sleep(800);
7         printf("\n%f\n", getCpuUsageRate());
8     }
9 }

---

利用上述方法获取cpu当前利用率后，再画正弦曲线，只需要改变进程的busy时间和idle时间，如果当前点曲线需要的cpu利用率是a%，cpu实际利用率是b%

若a>b, 那么进程的busy时间为该点时间片的(a-b)%

若a<=b，那么进程busy时间为0（实际情况中由于cpu使用率采集的不精确以及使用率的不断变化，busy时间设置为0效果不一定最好，本文中是设置为原来时间的3/4）

实际上除了当前进程外，如果cpu一直占用某个使用率，会影响曲线的形状，特别是曲线的下部分.

代码如下：

  1 #include <TCHAR.h>
  2 #include <windows.h>
  3 #include <pdh.h>
  4 #include <cstdio>
  5 #include <cmath>
  6 #pragma comment(lib, "pdh.lib")
  7
  8 //---------------------------------------------------comput the cpu usage rate
  9 static PDH_HQUERY cpuQuery;
 10 static PDH_HCOUNTER cpuTotal;
 11
 12 //cpuindex 为指定的cpu id ，从0开始
 13 void init(int cpuIndex)
 14 {
 15     PDH_STATUS Status = PdhOpenQuery(NULL, NULL, &cpuQuery);
 16     if (Status != ERROR_SUCCESS)
 17     {
 18         printf("\nPdhOpenQuery failed with status 0x%x.", Status);
 19         exit(-1);
 20     }
 21     char buf[50];
 22     sprintf(buf, "\\Processor(%d)\\%% Processor Time",cpuIndex);
 23     PdhAddCounter(cpuQuery, LPCSTR(buf), NULL, &cpuTotal);
 24     PdhCollectQueryData(cpuQuery);
 25 }
 26
 27
 28 double getCpuUsageRate()
 29 {
 30     PDH_FMT_COUNTERVALUE counterVal;
 31     PdhCollectQueryData(cpuQuery);
 32     PdhGetFormattedCounterValue(cpuTotal, PDH_FMT_DOUBLE, NULL, &counterVal);
 33     return counterVal.doubleValue;
 34 }
 35
 36 //--------------------------------------------------------------------cpu sin
 37 //把一条正弦曲线0~2pi 之间的弧度等分200份抽样，计算每个点的振幅
 38 //然后每隔300ms设置下一个抽样点,并让cpu工作对应振幅时间
 39 const int samplingCount = 200; //抽样点数目
 40 const double pi = 3.1415926;
 41 const int totalAmplitude = 300; //每个抽样点对应时间片
 42 const double delta = 2.0/samplingCount;  //抽样弧度的增量
 43
 44 DWORD busySpan[samplingCount];//每个抽样点对应的busy时间
 45 int idleSpan[samplingCount];//每个抽样点对应的idle时间
 46
 47 //一个线程调用MakeUsageSin，并把该线程绑定到一个cpu，那么该cpu呈现正弦曲线
 48 DWORD WINAPI MakeUsageSin(LPVOID lpParameter)
 49 {
 50     DWORD startTime = 0;
 51     for(int j = 0; ; j = (j + 1) % samplingCount)
 52     {
 53         startTime = GetTickCount();
 54         DWORD realBusy = busySpan[j];
 55
 56         double currentCpuUsageRate = getCpuUsageRate();
 57         if(currentCpuUsageRate < busySpan[j]*1.0/totalAmplitude)
 58             realBusy = (busySpan[j]*1.0/totalAmplitude - currentCpuUsageRate)*totalAmplitude;
 59         else
 60             realBusy *= 0.75;
 61
 62         while ((GetTickCount() - startTime) < realBusy);
 63         Sleep(idleSpan[j]);
 64     }
 65 }
 66
 67 //如果cpuindex < 0 则所有cpu都显示正弦曲线
 68 //否则只有第 cpuindex个cpu显示正弦曲线
 69 //cpuindex 从 0 开始计数
 70 void CpuSin(int cpuIndex)
 71 {
 72     //计算 busySpan 和 idleSpan
 73     double radian = 0;
 74     int amplitude = totalAmplitude / 2;
 75     for (int i = 0; i < samplingCount; i++)
 76     {
 77         busySpan[i] = (DWORD)(amplitude + sin(pi*radian)*amplitude);
 78         idleSpan[i] = totalAmplitude - busySpan[i];
 79         radian += delta;
 80     }
 81
 82     //获取系统cup数量
 83     SYSTEM_INFO SysInfo;
 84     GetSystemInfo(&SysInfo);
 85     int num_processors = SysInfo.dwNumberOfProcessors;
 86     if(cpuIndex + 1 > num_processors)
 87     {
 88         printf("error: the index of cpu is out of boundary\n");
 89         printf("cpu number: %d\n", num_processors);
 90         printf("your index: %d\n", cpuIndex);
 91         printf("** tip: the index of cpu start from 0 **\n");
 92         return;
 93     }
 94
 95     if(cpuIndex < 0)
 96     {
 97         HANDLE* threads = new HANDLE[num_processors];
 98         for (int i = 0;i < num_processors;i++)
 99         {
100             DWORD mask = 1<<i;
101             threads[i] = CreateThread(NULL, 0, MakeUsageSin, &mask, 0, NULL);
102             SetThreadAffinityMask(threads[i], 1<<i);//线程指定在某个cpu运行
103         }
104         WaitForMultipleObjects(num_processors, threads, TRUE, INFINITE);
105     }
106     else
107     {
108         init(cpuIndex);
109         HANDLE thread;
110         DWORD mask = 1;
111         thread = CreateThread(NULL, 0, MakeUsageSin, &mask, 0, NULL);
112         SetThreadAffinityMask(thread, 1<<cpuIndex);
113         WaitForSingleObject(thread,INFINITE);
114     }
115
116 }
117 //-------------------------------------
118
119 int main()
120 {
121     CpuSin(0);
122 }

主要改动在MakeUsageSin函数，初始化在上面代码108行

结果如下：

【版权声明】转载请注明出处 http://www.cnblogs.com/TenosDoIt/p/3242910.html