我要评论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%%\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
您可能感兴趣的文章:
如您对本文有疑问或者有任何想说的，请点击进行留言回复，万千网友为您解惑！
网友评论