當前位置：首頁 > 编程资源 > 综合教程 >内容正文

综合教程

CPU使用率原理及计算方式

發布時間：2023/12/13 综合教程 37 生活家

生活随笔收集整理的這篇文章主要介紹了 CPU使用率原理及计算方式小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

目錄CPU：Cores, and Hyper-Threading超線程（Hyper-Threading?）多核（multi-cores）CPU使用率計算CPU使用率測試如何計算CPU使用率實現CPU使用率統計程序

CPU：Cores, and Hyper-Threading

超線程（Hyper-Threading?）

超線程是Intel最早提出一項技術，最早出現在2002年的Pentium4上。單個采用超線程的CPU對于操作系統來說就像有兩個邏輯CPU，為此P4處理器需要多加入一個Logical CPU Pointer（邏輯處理單元）。

雖然采用超線程技術能同時執行兩個線程，但它并不像兩個真正的CPU那樣，每個CPU都具有獨立的資源。當兩個線程都同時需要某一個資源時，其中一個要暫時停止，并讓出資源，直到這些資源閑置后才能繼續。因此超線程的性能并不等于兩顆CPU的性能。

多核（multi-cores）

最開始CPU只有一個核（core），為了提高性能，引入了雙核CPU，四核CPU等，雙核CPU能同時執行兩個線程。和超線程不同的是，雙核CPU是實打實的有兩個central processing units在一個CPU chip。

上圖顯示主板上有1個插槽（socket），這個插槽插著一個CPU，這個CPU有4個核（core），每個核都使用超線程技術，所以這臺機器總共有8個邏輯核。

CPU使用率計算

CPU使用率測試

一臺擁有8個logic core CPU的機器，執行如下程序：

#include <pthread.h>

const int num = 9;
pthread_t threads[num];

void *func(void* arg) {
	while(1) {}
	return ((void *)0);
}

int main(int argc, char* argv[]) {
	for (int i = 0; i < num; i++) {
		pthread_create(&threads[i], NULL, func, NULL);
	}
	for (int i = 0; i < num; i++) {
		pthread_join(threads[i], NULL);
	}
	return 0;
}

該程序開啟9個線程每個線程都執行一個死循環。執行后用top查看cpu使用情況：

332 root      20   0   84312    612    416 S 800.0  0.0   7:18.41 cputest

可以看到cputest的CPU使用情況為800%，也就是8個logic core都在執行cputest這個進程。
而在一個只有1個logic的CPU上跑的結果如下：

13812 ubuntu    20   0   80284    708    628 S 97.7  0.1   0:10.14 cputest

可以看到，縱使開啟了9個線程，每個線程都執行死循環，CPU使用率只有97.7%。

如何計算CPU使用率

        1. %CPU  --  CPU Usage
           The task's share of the elapsed CPU time since the last screen update, expressed as a percentage of total CPU time.

           In a true SMP environment, if a process is multi-threaded and top is not operating in Threads mode, amounts greater than 100% may be reported.  You  toggle
           Threads mode with the `H' interactive command.

           Also  for  multi-processor environments, if Irix mode is Off, top will operate in Solaris mode where a task's cpu usage will be divided by the total number
           of CPUs.  You toggle Irix/Solaris modes with the `I' interactive command.

以上截取自man top中對于CPU使用率的定義，總結來說某個進程的CPU使用率就是這個進程在一段時間內占用的CPU時間占總的CPU時間的百分比。

比如某個開啟多線程的進程1s內占用了CPU0 0.6s, CPU1 0.9s, 那么它的占用率是150%。這樣就不難理解上例中cputest進程CPU占用率為800%這個結果了。

實現CPU使用率統計程序

某進程cpu使用率 = 該進程cpu時間 / 總cpu時間。

/proc/pid/stat中可以得出進程自啟動以來占用的cpu時間。以bash進程為例:

79 (bash) S 46 79 79 34816 0 0 0 0 0 0 46 135 387954 4807 20 0 1 0 6114 232049254400 873 18446744073709551615 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

第14項utime和第15項stime分別表示bash自啟動起來，執行用戶代碼態占用的時間和執行內核態代碼占用的時間，單位是clock tick，clock tick是時間單位。這兩項的詳細解釋如下（摘自man proc）：

              (14) utime  %lu
                        Amount  of  time  that  this process has been scheduled in user mode, measured in clock ticks (divide by sysconf(_SC_CLK_TCK)).  This includes
                        guest time, guest_time (time spent running a virtual CPU, see below), so that applications that are not aware of the guest time field  do  not
                        lose that time from their calculations.

              (15) stime  %lu
                        Amount of time that this process has been scheduled in kernel mode, measured in clock ticks (divide by sysconf(_SC_CLK_TCK)).

每個clock tick占用多少時間呢？
可以通過sysconf(_SC_CLK_TCK)獲取1秒內有多少個clock tick（通常是100）。也就是說1 clock tick為1 / 100秒。

有了上面的基礎，
我們可以每隔period秒讀取/proc/pid/stat，解析其中的utime和stime，將其和(utime+stime)減去上一次采樣時這兩項的和(lastutime + laststime)，這就是period秒內該進程占用CPU的時間，單位為clock tick。
總的CPU時間為period * sysconf(_SC_CLK_TCK)，單位也為clock tick。
所以公式如下：
某進程cpu使用率 = ((utime+stime) - (lastutime + laststime)) / (period * sysconf(_SC_CLK_TCK))

以下是實現：

#include <unistd.h>
#include <stdio.h>
#include <sys/time.h>
#include <string.h>
#include <signal.h>
#include <stdlib.h>
#include <fstream>
#include <iostream>
#include <sstream>

using namespace std;

struct StatData
{
  void parse(const string& content)
  {
	size_t rp = content.rfind(')');
    std::istringstream iss(content.data() + rp + 1);

    //            0    1    2    3     4    5       6   7 8 9  11  13   15
    // 3770 (cat) R 3718 3770 3718 34818 3770 4202496 214 0 0 0 0 0 0 0 20
    // 16  18     19      20 21                   22      23      24              25
    //  0 1 0 298215 5750784 81 18446744073709551615 4194304 4242836 140736345340592
    //              26
    // 140736066274232 140575670169216 0 0 0 0 0 0 0 17 0 0 0 0 0 0

    iss >> state;
    iss >> ppid >> pgrp >> session >> tty_nr >> tpgid >> flags;
    iss >> minflt >> cminflt >> majflt >> cmajflt;
    iss >> utime >> stime >> cutime >> cstime;
    iss >> priority >> nice >> num_threads >> itrealvalue >> starttime;
  }
  string name; 
  char state;
  int ppid;
  int pgrp;
  int session;
  int tty_nr;
  int tpgid;
  int flags;

  long minflt;
  long cminflt;
  long majflt;
  long cmajflt;

  long utime;
  long stime;
  long cutime;
  long cstime;

  long priority;
  long nice;
  long num_threads;
  long itrealvalue;
  long starttime;
};

int clockTicks = static_cast<int>(::sysconf(_SC_CLK_TCK));
const int period = 2;
int pid;
int ticks;
StatData lastStatData;

bool processExists(pid_t pid)
{
  char filename[256];
  snprintf(filename, sizeof filename, "/proc/%d/stat", pid);
  return ::access(filename, R_OK) == 0;
}

//read /proc/pid/stat
string readProcFile(int pid) {
	char filename[256];
	snprintf(filename, sizeof filename, "/proc/%d/stat", pid);
	ifstream in;
	in.open(filename);
	stringstream ss;
	ss << in.rdbuf();
	
	string ret = ss.str();
	return ret;
}

double cpuUsage(int userTicks, int sysTicks, double kPeriod, double kClockTicksPerSecond)
{
	return (userTicks + sysTicks) / (kClockTicksPerSecond * kPeriod); //CPU使用率計算
}

void tick(int num) {
	string content = readProcFile(pid);

	StatData statData;
	memset(&statData, 0, sizeof statData);
	statData.parse(content);
	if (ticks > 0) {
		int userTicks = std::max(0, static_cast<int>(statData.utime - lastStatData.utime));	
		int sysTicks = std::max(0, static_cast<int>(statData.stime - lastStatData.stime));
		printf("pid %d cpu usage:%.1f%%
", pid, cpuUsage(userTicks, sysTicks, period, clockTicks) * 100);
	}
	ticks++;
	lastStatData = statData;
}

int main(int argc, char* argv[]) {
	if (argc < 2) {
		printf("Usage: %s pid
", argv[0]);
		return 0;
	}
	pid = atoi(argv[1]);
	if (!processExists(pid)) {
		printf("Process %d doesn't exist.
", pid);
    	return 1;
	}

	if (signal(SIGALRM, tick) == SIG_ERR) {
		exit(0);
	}
	
	struct itimerval tick;
	memset(&tick, 0, sizeof tick);
	tick.it_value.tv_sec = period;
	tick.it_value.tv_usec = 0;
	tick.it_interval.tv_sec = period;
	tick.it_interval.tv_usec = 0;

	setitimer(ITIMER_REAL, &tick, NULL);

	while (1) {
		pause();
	}
	
	return 0;
}

代碼很簡單，每隔兩秒采一次樣，計算這兩秒內指定進程的CPU使用率。
為了測試，先將前文的cputest運行起來，該程序會占滿8個logic core。
./cputest &，然后top看下CPU使用率，大約占用了800%的CPU。

867 root      20   0   84312    616    416 S 800.0  0.0  17:44.60 cputest

接著用我們的自己的寫的程序看下，pid是867，
./cpumon 867

pid 867 cpu usage:786.0%
pid 867 cpu usage:785.5%
pid 867 cpu usage:787.5%
pid 867 cpu usage:759.5%
pid 867 cpu usage:781.5%
pid 867 cpu usage:791.5%
pid 867 cpu usage:743.5%
pid 867 cpu usage:782.0%
pid 867 cpu usage:777.5%
pid 867 cpu usage:785.0%
pid 867 cpu usage:790.5%
pid 867 cpu usage:786.0%
^C

可以看到每隔兩秒都會計算一次，使用率略低于800%，也可以理解，因為現在cpumon也會占用一定的CPU時間。

參考資料：
CPU Basics: Multiple CPUs, Cores, and Hyper-Threading Explained

總結

以上是生活随笔為你收集整理的CPU使用率原理及计算方式的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇： Node.js 对象合并
下一篇：火币网API文档——REST 行情、交易