欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

一文秒懂CPU使用率

程序员文章站 2023-11-04 11:35:04
[TOC] CPU:Cores, and Hyper Threading 超线程(Hyper Threading ) 超线程是Intel最早提出一项技术,最早出现在2002年的Pentium4上。单个采用超线程的CPU对于操作系统来说就像有两个逻辑CPU,为此P4处理器需要多加入一个Logical ......

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。

一文秒懂CPU使用率
上图显示主板上有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%%\n", pid, cpuusage(userticks, systicks, period, clockticks) * 100);
    }
    ticks++;
    laststatdata = statdata;
}

int main(int argc, char* argv[]) {
    if (argc < 2) {
        printf("usage: %s pid\n", argv[0]);
        return 0;
    }
    pid = atoi(argv[1]);
    if (!processexists(pid)) {
        printf("process %d doesn't exist.\n", 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