精华内容
下载资源
问答
  • Linux计算cpu使用率

    千次阅读 2016-03-10 10:16:19
    计算总的 CPU 使用率 TOTALCPUUSE 1)采样两个足够短的时间间隔的 CPU 快照,即读取 /proc/stat 文件,获取两个时间点的下列数据: CPUT1 (user1, nice1, system1, idle1, iowait1, irq1, softirq1, stealstolen1,...
    计算总的 CPU 使用率 TOTALCPUUSE
    
    1)采样两个足够短的时间间隔的 CPU 快照,即读取 /proc/stat 文件,获取两个时间点的下列数据:
    
    CPUT1 (user1, nice1, system1, idle1, iowait1, irq1, softirq1, stealstolen1, guest1);
    CPUT2 (user2, nice2, system2, idle2, iowait2, irq2, softirq2, stealstolen2, guest2);
    2)计算总的 CPU 时间 totalCPUTime:
    
    CPUTime1 = user1 + nice1 + system1 + idle1 + iowait1 + irq1 + softirq1 + stealstolen1 + guest1;
    CPUTime2 = user2 + nice2 + system2 + idle2 + iowait2 + irq2 + softirq2 + stealstolen2 + guest2;
    totalCPUTime = CPUTime2 – CPUTime1;
    
    3)计算 CPU 空闲时间 idleCPUTime:
    
    idleCPUTime = idle2 – idle1;
    
    4)计算总的 CPU 使用率 totalCPUUse:
    
    totalCPUUse = (totalCPUTime – idleCPUTime) / totalCPUTime;
    
    计算某一进程的 CPU 使用率 PROCESSCPUUSE
    
    1)采样两个足够短的时间间隔的 CPU 快照和对应的进程快照,即读取 /proc/stat 文件,获取两个时间点的下列数据:
    
    CPUT1 (user1, nice1, system1, idle1, iowait1, irq1, softirq1, stealstolen1, guest1);
    CPUT2 (user2, nice2, system2, idle2, iowait2, irq2, softirq2, stealstolen2, guest2);
    读取 /proc/[PID]/stat 文件,获取两个时间点的下列数据:
    
    ProcessT1 (utime1, stime1, cutime1, cstime1);
    ProcessT2 (utime2, stime2, cutime2, cstime2);
    2)计算总的 CPU 时间 totalCPUTime 和进程时间 processTime:
    
    CPUTime1 = user1 + nice1 + system1 + idle1 + iowait1 + irq1 + softirq1 + stealstolen1 + guest1;
    CPUTime2 = user2 + nice2 + system2 + idle2 + iowait2 + irq2 + softirq2 + stealstolen2 + guest2;
    totalCPUTime = CPUTime2 – CPUTime1;
    
    processTime1 = utime1 + stime1 + cutime1 + cstime1;
    processTime2 = utime2 + stime2 + cutime1 + cstime2;
    processTime = processTime2 – processTime1;
    
    3)计算该进程的 CPU 使用率 processCPUUse:
    
    processCPUUse = processTime / totalCPUTime;
    
    计算某一线程的 CPU 使用率 threadCPUUse
    
    1)采样两个足够短的时间间隔的 CPU 快照和对应的线程快照,即读取 /proc/stat 文件,获取两个时间点的下列数据:
    
    CPUT1 (user1, nice1, system1, idle1, iowait1, irq1, softirq1, stealstolen1, guest1);
    CPUT2 (user2, nice2, system2, idle2, iowait2, irq2, softirq2, stealstolen2, guest2);
    读取 /proc/[PID]/task/[TID]/stat 文件,获取两个时间点的下列数据:
    
    threadT1 (utime1, stime1);
    threadT2 (utime2, stime2);
    2)计算总的 CPU 时间 totalCPUTime 和线程时间 threadTime:
    
    CPUTime1 = user1 + nice1 + system1 + idle1 + iowait1 + irq1 + softirq1 + stealstolen1 + guest1;
    CPUTime2 = user2 + nice2 + system2 + idle2 + iowait2 + irq2 + softirq2 + stealstolen2 + guest2;
    totalCPUTime = CPUTime2 – CPUTime1;
    
    threadTime1 = utime1 + stime1;
    threadTime2 = utime2 + stime2;
    threadTime = threadTime2 – threadTime1;
    
    3)计算该线程的 CPU 使用率 threadCPUUse:
    
    threadCPUUse = threadTime / totalCPUTime;
    
    
    
    2.5、多核情况下 CPU 使用率的计算
    
    2.5.1、基本思想
    
    首先,通过读取 /proc/stat 文件获取总的 CPU 时间,读取 /proc/[PID]/stat 获取进程 CPU 时间,读取 /proc/[PID]/task/[TID]/stat 获取线程 CPU 时间,读取 /proc/cpuinfo 获取 CPU 个数。
    
    在多核情况下计算进程或线程的 CPU 使用率,用上面的方式得到的通常是相对于 CPU 所有核的总共时间的占用率,而我们通常习惯得到进程或线程对某一个单核的占用率。所以我们可以按上面的方式计算得到 CPU 占用率,然后把结果乘上 CPU 的核数,即可得到进程或线程相对于一个单核的占用率。
    
    2.5.2、计算总的 CPU 使用率
    
    同 2.4.2。
    
    2.5.3、计算某一进程的 CPU 使用率 mProcessCPUUse
    
    1)同 2.4.3 计算某一进程的 CPU 使用率 processCPUUse;
    
    2)读取 /proc/cpuinfo 文件获取逻辑 CPU(processor) 的个数(参见 1.1): processorNum
    
    3)多核情况下该进程的 CPU 使用率 mProcessCPUUse:
    
    mProcessCPUUse = processCPUUse * processorNum;
    
    2.5.4、计算某一线程的 CPU 使用率 mThreadCPUUse
    
    1)同 2.4.4 计算某一线程的 CPU 使用率 threadCPUUse;
    
    2)读取 /proc/cpuinfo 文件获取逻辑 CPU(processor) 的个数(参见 1.1): processorNum
    
    3)多核情况下该线程的 CPU 使用率 mThreadCPUUse:
    
    mThreadCPUUse = threadCPUUse * processorNum;

    展开全文
  • linux 计算CPU使用率(C代码)

    千次阅读 2017-10-18 14:48:41
    int getcpuutilization(char *cpuutilization) {  int sum1[2]={0};  int sum2[2]={0};  int i=0;  for(i=0;i  if(i==1)  {  sleep(3);  }  FILE

    int getcpuutilization(char *cpuutilization)
    {
        int sum1[2]={0};
        int sum2[2]={0};
        int i=0;
        for(i=0;i<2;i++){
            if(i==1)
            {
                    sleep(3);
            }
            FILE *stream1=NULL;
            FILE *stream2=NULL;
            FILE *stream3=NULL;
            FILE *stream4=NULL;
            FILE *stream5=NULL;
            FILE *stream6=NULL;
            FILE *stream7=NULL;
            FILE *stream8=NULL;
            FILE *stream9=NULL;
            char COMMAND1[OSNAMESZ]="cat /proc/stat | sed -n 1p | awk '{print $2}'";
            char COMMAND2[OSNAMESZ]="cat /proc/stat | sed -n 1p | awk '{print $3}'";
            char COMMAND3[OSNAMESZ]="cat /proc/stat | sed -n 1p | awk '{print $4}'";
            char COMMAND4[OSNAMESZ]="cat /proc/stat | sed -n 1p | awk '{print $5}'";
            char COMMAND5[OSNAMESZ]="cat /proc/stat | sed -n 1p | awk '{print $6}'";
            char COMMAND6[OSNAMESZ]="cat /proc/stat | sed -n 1p | awk '{print $7}'";
            char COMMAND7[OSNAMESZ]="cat /proc/stat | sed -n 1p | awk '{print $8}'";
            char COMMAND8[OSNAMESZ]="cat /proc/stat | sed -n 1p | awk '{print $9}'";
            char COMMAND9[OSNAMESZ]="cat /proc/stat | sed -n 1p | awk '{print $10}'";
            char buff1[OSNAMESZ]={0};
            char buff2[OSNAMESZ]={0};
            char buff3[OSNAMESZ]={0};
            char buff4[OSNAMESZ]={0};
            char buff5[OSNAMESZ]={0};
            char buff6[OSNAMESZ]={0};
            char buff7[OSNAMESZ]={0};
            char buff8[OSNAMESZ]={0};
            char buff9[OSNAMESZ]={0};
            int cpudata1;
            int cpudata2;
            int cpudata3;
            int cpudata4;
            int cpudata5;
            int cpudata6;
            int cpudata7;
            int cpudata8;
            int cpudata9;

            stream1=popen(COMMAND1,"r");
            signal(SIGCHLD,SIG_IGN);
            stream2=popen(COMMAND2,"r");
            signal(SIGCHLD,SIG_IGN);
            stream3=popen(COMMAND3,"r");
            signal(SIGCHLD,SIG_IGN);
            stream4=popen(COMMAND4,"r");
            signal(SIGCHLD,SIG_IGN);
            stream5=popen(COMMAND5,"r");
            signal(SIGCHLD,SIG_IGN);
            stream6=popen(COMMAND6,"r");
            signal(SIGCHLD,SIG_IGN);
            stream7=popen(COMMAND7,"r");
            signal(SIGCHLD,SIG_IGN);
            stream8=popen(COMMAND8,"r");
            signal(SIGCHLD,SIG_IGN);
            stream9=popen(COMMAND9,"r");
            signal(SIGCHLD,SIG_IGN);
            if(!stream1 || !stream2 || !stream3 || !stream4 || !stream5 || !stream6 || !stream7 || !stream8 || !stream9)
            {
                    return -1;
            }
            fread(buff1,sizeof(char),OSNAMESZ,stream1);
            pclose(stream1);
            fread(buff2,sizeof(char),OSNAMESZ,stream2);
            pclose(stream2);
            fread(buff3,sizeof(char),OSNAMESZ,stream3);
            pclose(stream3);
            fread(buff4,sizeof(char),OSNAMESZ,stream4);
            pclose(stream4);
            fread(buff5,sizeof(char),OSNAMESZ,stream5);
            pclose(stream5);
            fread(buff6,sizeof(char),OSNAMESZ,stream6);
            pclose(stream6);
            fread(buff7,sizeof(char),OSNAMESZ,stream7);
            pclose(stream7);
            fread(buff8,sizeof(char),OSNAMESZ,stream8);
            pclose(stream8);
            fread(buff9,sizeof(char),OSNAMESZ,stream9);
            pclose(stream9);
            if(strlen(buff1)==0 || strlen(buff2)==0 || strlen(buff3)==0 || strlen(buff4)==0 || strlen(buff5)==0 || strlen(buff6)==0 || strlen(buff7)==0 || strlen(buff8)==0 || strlen(buff9)==0)
            {
                    return -1;
            }
            cpudata1=atoi(buff1);
            cpudata2=atoi(buff2);
            cpudata3=atoi(buff3);
            cpudata4=atoi(buff4);
            cpudata5=atoi(buff5);
            cpudata6=atoi(buff6);
            cpudata7=atoi(buff7);
            cpudata8=atoi(buff8);
            cpudata9=atoi(buff9);
            sum1[i]=cpudata1+cpudata2+cpudata3;
            sum2[i]=cpudata1+cpudata2+cpudata3+cpudata4+cpudata5+cpudata6+cpudata7+cpudata8+cpudata9;
        }
        sprintf(cpuutilization,"%0.1f",(float)(sum1[1]-sum1[0])/(sum2[1]-sum2[0])*100);
        return 0;
    }


    完!!

    展开全文
  • CPU 使用率是最常用来描述系统CPU 性能的指标。 CPU 使用率是单位时间内 CPU 使用情况的统计,以百分比的方式展示。那么 **CPU 使用率到底是怎么算出来的吗?再有 %user、%nice、 %system、%iowait 、%steal 等等,...

    CPU 使用率是最常用来描述系统CPU 性能的指标

    CPU 使用率是单位时间内 CPU 使用情况的统计,以百分比的方式展示。那么 **CPU 使用率到底是怎么算出来的吗?再有 %user、%nice、 %system、%iowait 、%steal 等等,它们之间有什么不同吗?

    CPU 使用率

    Linux 作为一个多任务操作系统,将每个 CPU 的时间划分为很短的时间片,再通过调度器轮流分配给各个任务使用,因此造成多任务同时运行的错觉

    为了维护 CPU 时间,Linux 通过事先定义的节拍率(内核中表示为 HZ),触发时间中断,并使用全局变量 Jiffies 记录了开机以来的节拍数每发生一次时间中断,Jiffies 的值就加 1

    节拍率 HZ 是内核的可配选项,可以设置为 100、250、1000 等。不同的系统可能设置不同数值,你可以通过查询 /boot/config 内核选项来查看它的配置值。示例如下:

    $ grep 'CONFIG_HZ=' /boot/config-$(uname -r)
    CONFIG_HZ=250
    

    正因为节拍率 HZ 是内核选项,所以用户空间程序并不能直接访问。为了方便用户空间程序,内核还提供了一个用户空间节拍率 USER_HZ,它总是固定为 100,也就是 1/100 秒。这样,用户空间程序并不需要关心内核中 HZ 被设置成了多少,因为它看到的总是固定值 USER_HZ

    Linux 通过 /proc 虚拟文件系统,向用户空间提供了系统内部状态的信息,而 /proc/stat 提供的就是系统的 CPU 和任务统计信息。比方说,如果只关注 CPU 的话可以执行下面的命令

    # 只保留各个CPU的数据
    $ cat /proc/stat | grep ^cpu
    cpu  280580 7407 286084 172900810 83602 0 583 0 0 0
    cpu0 144745 4181 176701 86423902 52076 0 301 0 0 0
    cpu1 135834 3226 109383 86476907 31525 0 282 0 0 0
    

    这里的输出结果是一个表格。其中,第一列表示的是 CPU 编号,如 cpu0、cpu1 ,而第一行没有编号的 cpu ,表示的是所有 CPU 的累加。其他列则表示不同场景下 CPU 的累加节拍数它的单位是 USER_HZ,也就是 10 ms(1/100 秒),所以这其实就是不同场景下的 CPU 时间

    具体含义可以man proc了解具体指标含义,这里着重介绍下面这些指标的含义:

    • user(通常缩写为 us),代表用户态 CPU 时间。注意,它不包括下面的 nice 时间,但包括了 guest 时间
    • nice(通常缩写为 ni),代表低优先级用户态 CPU 时间,也就是进程的 nice 值被调整为 1-19 之间时的 CPU 时间。这里注意,nice 可取值范围是 -20 到 19,数值越大,优先级反而越低
    • system(通常缩写为 sys),代表内核态 CPU 时间
    • idle(通常缩写为 id),代表空闲时间。注意,它不包括等待 I/O 的时间(iowait)
    • iowait(通常缩写为 wa),代表等待 I/O 的 CPU 时间
    • irq(通常缩写为 hi),代表处理硬中断的 CPU 时间
    • softirq(通常缩写为 si),代表处理软中断的 CPU 时间
    • steal(通常缩写为 st),代表当系统运行在虚拟机中的时候,被其他虚拟机占用的 CPU 时间
    • guest(通常缩写为 guest),代表通过虚拟化运行其他操作系统的时间,也就是运行虚拟机的 CPU 时间
    • guest_nice(通常缩写为 gnice),代表以低优先级运行虚拟机的时间
      通常所说的 CPU 使用率,就是除了空闲时间外的其他时间占总 CPU 时间的百分比,用公式来表示就是:
      img

    根据这个公式,就可以从 /proc/stat 中的数据,很容易地计算出 CPU 使用率。当然,也可以用每一个场景的 CPU 时间,除以总的 CPU 时间,计算出每个场景的 CPU 使用率

    直接用 /proc/stat 的数据,算的是开机以来的节拍数累加值,所以直接算出来的,是开机以来的平均 CPU 使用率,一般没啥参考价值

    为了计算 CPU 使用率,性能工具一般都会取间隔一段时间(比如 3 秒)的两次值,作差后,再计算出这段时间内的平均 CPU 使用率,即:​ img
    这个公式,就是各种性能工具所看到的 CPU 使用率的实际计算方法

    现在,知道了系统 CPU 使用率的计算方法,那进程的呢?跟系统的指标类似,Linux 也给每个进程提供了运行情况的统计信息,也就是 /proc/[pid]/stat。不过,这个文件包含的数据就比较丰富了,总共有 52 列的数据。需要的时候,查 man proc 就行。

    回过头来看,是不是说要查看 CPU 使用率,就必须先读取 /proc/stat 和 /proc/[pid]/stat 这两个文件,然后再按照上面的公式计算出来呢

    当然不是,各种各样的性能分析工具已经帮我们计算好了。不过要注意的是,性能分析工具给出的都是间隔一段时间的平均 CPU 使用率,所以要注意间隔时间的设置,特别是用多个工具对比分析时,你一定要保证它们用的是相同的间隔时间

    比如,对比一下 top 和 ps 这两个工具报告的 CPU 使用率,默认的结果很可能不一样,因为 top 默认使用 3 秒时间间隔,而 ps 使用的却是进程的整个生命周期

    怎么查看 CPU 使用率

    top 和 ps 是最常用的性能分析工具

    • top 显示了系统总体的 CPU 和内存使用情况,以及各个进程的资源使用情况。
    • ps 则只显示了每个进程的资源使用情况

    比如,top 的输出格式为:

    # 默认每3秒刷新一次
    $ top
    top - 11:58:59 up 9 days, 22:47,  1 user,  load average: 0.03, 0.02, 0.00
    Tasks: 123 total,   1 running,  72 sleeping,   0 stopped,   0 zombie
    %Cpu(s):  0.3 us,  0.3 sy,  0.0 ni, 99.3 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
    KiB Mem :  8169348 total,  5606884 free,   334640 used,  2227824 buff/cache
    KiB Swap:        0 total,        0 free,        0 used.  7497908 avail Mem
    
      PID USER      PR  NI    VIRT    RES    SHR S  %CPU %MEM     TIME+ COMMAND
        1 root      20   0   78088   9288   6696 S   0.0  0.1   0:16.83 systemd
        2 root      20   0       0      0      0 S   0.0  0.0   0:00.05 kthreadd
        4 root       0 -20       0      0      0 I   0.0  0.0   0:00.00 kworker/0:0H
    ...
    

    不过需要注意,top 默认显示的是所有 CPU 的平均值,这个时候你只需要按下数字 1 ,就可以切换到每个 CPU 的使用率了。

    空白行之后是进程的实时信息,每个进程都有一个 %CPU 列,表示进程的 CPU 使用率。它是用户态和内核态 CPU 使用率的总和,包括进程用户空间使用的 CPU、通过系统调用执行的内核空间 CPU 、以及在就绪队列等待运行的 CPU。在虚拟化环境中,它还包括了运行虚拟机占用的 CPU。

    top 并没有细分进程的用户态 CPU 和内核态 CPU。那要怎么查看每个进程的详细情况呢?pidstat 是一个专门分析每个进程 CPU 使用情况的工具

    比如,下面的 pidstat 命令,就间隔 1 秒展示了进程的 5 组 CPU 使用率,包括:

    • 用户态 CPU 使用率 (%usr);
    • 内核态 CPU 使用率(%system);
    • 运行虚拟机 CPU 使用率(%guest);
    • 等待 CPU 使用率(%wait);
    • 以及总的 CPU 使用率(%CPU)。

    最后的 Average 部分,还计算了 5 组数据的平均值。

    # 每隔1秒输出一组数据,共输出5组
    $ pidstat 1 5
    15:56:02      UID       PID    %usr %system  %guest   %wait    %CPU   CPU  Command
    15:56:03        0     15006    0.00    0.99    0.00    0.00    0.99     1  dockerd
    
    ...
    
    Average:      UID       PID    %usr %system  %guest   %wait    %CPU   CPU  Command
    Average:        0     15006    0.00    0.99    0.00    0.00    0.99     -  dockerd
    

    CPU 使用率过高怎么办?

    通过 top、ps、pidstat 等工具,你能够轻松找到 CPU 使用率较高(比如 100% )的进程。接下来,如何找到占用 CPU 的到底是代码里的哪个函数呢?只有找到它,才能更高效、更针对性地进行优化
    这里推荐是 perf。perf 是 Linux 2.6.31 以后内置的性能分析工具。它以性能事件采样为基础不仅可以分析系统的各种事件和内核性能,还可以用来分析指定应用程序的性能问题

    使用 perf 分析 CPU 性能问题,这里给出两种最常见用法。

    第一种常见用法是 perf top

    类似于 top,它能够实时显示占用 CPU 时钟最多的函数或者指令,因此可以用来查找热点函数,使用界面如下所示:

    $ perf top
    Samples: 833  of event 'cpu-clock', Event count (approx.): 97742399
    Overhead  Shared Object       Symbol
       7.28%  perf                [.] 0x00000000001f78a4
       4.72%  [kernel]            [k] vsnprintf
       4.32%  [kernel]            [k] module_get_kallsym
       3.65%  [kernel]            [k] _raw_spin_unlock_irqrestore
    ...
    

    输出结果中,第一行包含三个数据,分别是采样数(Samples)、事件类型(event)和事件总数量(Event count)。比如这个例子中,perf 总共采集了 833 个 CPU 时钟事件,而总事件数则为 97742399。

    另外,采样数需要我们特别注意。如果采样数过少(比如只有十几个),那下面的排序和百分比就没什么实际参考价值了。

    再往下看是一个表格式样的数据,每一行包含四列,分别是:

    • 第一列 Overhead ,是该符号的性能事件在所有采样中的比例,用百分比来表示。
    • 第二列 Shared ,是该函数或指令所在的动态共享对象(Dynamic Shared Object),如内核、进程名、动态链接库名、内核模块名等
    • 第三列 Object ,是动态共享对象的类型。比如 [.] 表示用户空间的可执行程序、或者动态链接库,而 [k] 则表示内核空间
    • 最后一列 Symbol 是符号名,也就是函数名。当函数名未知时,用十六进制的地址来表示。

    还是以上面的输出为例,可以看到,占用 CPU 时钟最多的是 perf 工具自身,不过它的比例也只有 7.28%,说明系统并没有 CPU 性能问题

    第二种常见用法是 perf record 和 perf report

    perf top 虽然实时展示了系统的性能信息,但它的缺点是并不保存数据,也就无法用于离线或者后续的分析。而 perf record 则提供了保存数据的功能保存后的数据,需要你用 perf report 解析展示

    $ perf record # 按Ctrl+C终止采样
    [ perf record: Woken up 1 times to write data ]
    [ perf record: Captured and wrote 0.452 MB perf.data (6093 samples) ]
    
    $ perf report # 展示类似于perf top的报告
    

    实际使用中,还经常为 perf top 和 perf record 加上 -g 参数,开启调用关系的采样,方便根据调用链来分析性能问题

    总结

    CPU 使用率是最直观和最常用的系统性能指标,更是在排查性能问题时,通常会关注的第一个指标。所以要熟悉它的含义,尤其要弄清楚用户(%user)、Nice(%nice)、系统(%system) 、等待 I/O(%iowait) 、中断(%irq)以及软中断(%softirq)这几种不同 CPU 的使用率。比如说:

    • 用户 CPU 和 Nice CPU 高,说明用户态进程占用了较多的 CPU,所以应该着重排查进程的性能问题
    • 系统 CPU 高,说明内核态占用了较多的 CPU,所以应该着重排查内核线程或者系统调用的性能问题
    • I/O 等待 CPU 高,说明等待 I/O 的时间比较长,所以应该着重排查系统存储是不是出现了 I/O 问题
    • 软中断和硬中断高,说明软中断或硬中断的处理程序占用了较多的 CPU,所以应该着重排查内核中的中断服务程序

    碰到 CPU 使用率升高的问题,可以借助 top、pidstat 等工具,确认引发 CPU 性能问题的来源再使用 perf 等工具,排查出引起性能问题的具体函数

    展开全文
  • linux系统计算cpu使用率,进程cpu使用率,线程cpu使用率的计算方法

    转载:http://www.blogjava.net/fjzag/articles/317773.html

    proc文件系统

    /proc文件系统是一个伪文件系统,它只存在内存当中,而不占用外存空间。它以文件系统的方式为内核与进程提供通信的接口。用户和应用程序可以通过/proc得到系统的信息,并可以改变内核的某些参数。由于系统的信息,如进程,是动态改变的,所以用户或应用程序读取/proc目录中的文件时,proc文件系统是动态从系统内核读出所需信息并提交的。

    /proc目录中有一些以数字命名的目录,它们是进程目录。系统中当前运行的每一个进程在/proc下都对应一个以进程号为目录名的目录/proc/pid,它们是读取进程信息的接口。此外,Linux 2.6.0-test6以上的版本中/proc/pid目录中有一个task目录,/proc/pid/task目录中也有一些以该进程所拥有的线程的线程号命名的目录/proc/pid/task/tid,它们是读取线程信息的接口。

    /proc/cpuinfo文件

             该文件中存放了有关 cpu的相关信息(型号,缓存大小等)。

    [zhengangen@buick ~]$ cat /proc/cpuinfo

    processor       : 0

    vendor_id       : GenuineIntel

    cpu family      : 15

    model           : 4

    model name      : Intel(R) Xeon(TM) CPU 3.00GHz

    stepping        : 10

    cpu MHz         : 3001.177

    cache size      : 2048 KB

    physical id     : 0

    siblings        : 2

    core id         : 0

    cpu cores       : 1

    fdiv_bug        : no

    hlt_bug         : no

    f00f_bug        : no

    coma_bug        : no

    fpu             : yes

    fpu_exception   : yes

    cpuid level     : 5

    wp              : yes

    flags           : fpu vme de pse tsc msr pae mce cx8 apic mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe lm pni monitor ds_cpl cid xtpr

    bogomips        : 6004.52

     

    说明:以下只解释对我们计算Cpu使用率有用的相关参数。

             参数                            解释

    processor (0)                       cpu的一个物理标识

     

    结论1:可以通过该文件根据processor出现的次数统计cpu的逻辑个数(包括多核、超线程)

    /proc/stat文件

             该文件包含了所有CPU活动的信息,该文件中的所有值都是从系统启动开始累计到当前时刻。不同内核版本中该文件的格式可能不大一致,以下通过实例来说明数据该文件中各字段的含义。

    实例数据:2.6.24-24版本上的

     

    fjzag@fjzag-desktop:~$ cat /proc/stat

    cpu  38082 627 27594 893908 12256 581 895 0 0

    cpu0 22880 472 16855 430287 10617 576 661 0 0

    cpu1 15202 154 10739 463620 1639 4 234 0 0

    intr 120053 222 2686 0 1 1 0 5 0 3 0 0 0 47302 0 0 34194 29775 0 5019 845 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 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 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 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 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 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 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 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

    ctxt 1434984

    btime 1252028243

    processes 8113

    procs_running 1

    procs_blocked 0

    第一行的数值表示的是CPU总的使用情况,所以我们只要用第一行的数字计算就可以了。下表解析第一行各数值的含义:

    参数          解析(单位:jiffies)

    (jiffies是内核中的一个全局变量,用来记录自系统启动一来产生的节拍数,在linux中,一个节拍大致可理解为操作系统进程调度的最小时间片,不同linux内核可能值有不同,通常在1ms到10ms之间)

    user (38082)    从系统启动开始累计到当前时刻,处于用户态的运行时间,不包含 nice值为负进程。

    nice (627)      从系统启动开始累计到当前时刻,nice值为负的进程所占用的CPU时间

    system (27594)  从系统启动开始累计到当前时刻,处于核心态的运行时间

    idle (893908)   从系统启动开始累计到当前时刻,除IO等待时间以外的其它等待时间iowait (12256从系统启动开始累计到当前时刻,IO等待时间(since 2.5.41)

    irq (581)           从系统启动开始累计到当前时刻,硬中断时间(since 2.6.0-test4)

    softirq (895)      从系统启动开始累计到当前时刻,软中断时间(since 2.6.0-test4)stealstolen(0)                   which is the time spent in other operating systems when running in a virtualized environment(since 2.6.11)

    guest(0)                               which is the time spent running a virtual  CPU  for  guest operating systems under the control of the Linux kernel(since 2.6.24)

     

    结论2:总的cpu时间totalCpuTime = user + nice + system + idle + iowait + irq + softirq + stealstolen  +  guest

    /proc/<pid>/stat文件                                          

    该文件包含了某一进程所有的活动的信息,该文件中的所有值都是从系统启动开始累计

    到当前时刻。以下通过实例数据来说明该文件中各字段的含义。

     

    [zhengangen@buick ~]# cat /proc/6873/stat

    6873 (a.out) R 6723 6873 6723 34819 6873 8388608 77 0 0 0 41958 31 0 0 25 0 3 0 5882654 1409024 56 4294967295 134512640 134513720 3215579040 0 2097798 0 0 0 0 0 0 0 17 0 0 0

     

    说明:以下只解释对我们计算Cpu使用率有用相关参数

    参数                                                                解释

    pid=6873                            进程号

    utime=1587                       该任务在用户态运行的时间,单位为jiffies

    stime=41958                      该任务在核心态运行的时间,单位为jiffies

    cutime=0                            所有已死线程在用户态运行的时间,单位为jiffies

    cstime=0                            所有已死在核心态运行的时间,单位为jiffies

     

    结论3进程的总Cpu时间processCpuTime = utime + stime + cutime + cstime,该值包括其所有线程的cpu时间。

    /proc/<pid>/task/<tid>/stat文件

    该文件包含了某一进程所有的活动的信息,该文件中的所有值都是从系统启动开始累计到当前时刻。该文件的内容格式以及各字段的含义同/proc/<pid>/stat文件。

             注意,该文件中的tid字段表示的不再是进程号,而是linux中的轻量级进程(lwp),即我们通常所说的线程。

     

    结论4:线程Cpu时间threadCpuTime = utime + stime

    系统中有关进程cpu使用率的常用命令

    ps 命令

    通过ps命令可以查看系统中相关进程的Cpu使用率的信息。以下在linux man文档中对ps命令输出中有关cpu使用率的解释:

     

    CPU usage is currently expressed as the percentage of time spent running during the entire lifetime of a process. This is not ideal, and it does not conform to the standards that ps otherwise conforms to. CPU usage is unlikely to add up to exactly 100%.

     

    %cpu   cpu utilization of the process in "##.#" format. It is the CPU time used                           divided by the time the process has been running (cputime/realtime ratio),                           expressed as a percentage. It will not add up to 100% unless you are lucky.

     

    结论5ps命令算出来的cpu使用率相对于进程启动时的平均值,随着进程运行时间的增大,该值会趋向于平缓。

    top命令

    通过top命令可以查看系统中相关进程的实时信息(cpu使用率等)。以下是man文档中对top命令输出中有关进程cpu使用率的解释。

     

    #C  --  Last used CPU (SMP)                   A number representing the last used processor. In a true  SMP  environment  this  will  likely change  frequently  since  the  kernel intentionally uses weak affinity. Also, the very act of running top may break this weak affinity and cause more processes to  change  CPUs  more  often (because of the extra demand for cpu time).

     

    %CPU  --  CPU usage                   The  task’s share of the elapsed CPU time since the last screen update, expressed as a percent-age of total CPU time.  In a true SMP environment, 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.

     

    结论6某一个线程在其运行期间其所使用的cpu可能会发生变化。

    结论7在多核的情况下top命令输出的cpu使用率实质是按cpu个数*100%计算的。

    单核情况下Cpu使用率的计算

    基本思想

    通过读取/proc/stat 、/proc/<pid>/stat、/proc/<pid>/task/<tid>/stat以及/proc/cpuinfo这几个文件获取总的Cpu时间、进程的Cpu时间、线程的Cpu时间以及Cpu的个数的信息,然后通过一定的算法进行计算(采样两个足够短的时间间隔的Cpu快照与进程快照来计算进程的Cpu使用率)。

     

    总的Cpu使用率计算

    计算方法:

    1、  采样两个足够短的时间间隔的Cpu快照,分别记作t1,t2,其中t1、t2的结构均为:

    (user、nice、system、idle、iowait、irq、softirq、stealstolen、guest)的9元组;

    2、  计算总的Cpu时间片totalCpuTime

    a)         把第一次的所有cpu使用情况求和,得到s1;

    b)         把第二次的所有cpu使用情况求和,得到s2;

    c)         s2 - s1得到这个时间间隔内的所有时间片,即totalCpuTime = j2 - j1 ;

    3、计算空闲时间idle

    idle对应第四列的数据,用第二次的第四列 - 第一次的第四列即可

    idle=第二次的第四列 - 第一次的第四列

    6、计算cpu使用率

    pcpu =100* (total-idle)/total

    某一进程Cpu使用率的计算

    计算方法:  

    1.               采样两个足够短的时间间隔的cpu快照与进程快照,

    a)         每一个cpu快照均为(user、nice、system、idle、iowait、irq、softirq、stealstolen、guest)的9元组;

    b)         每一个进程快照均为 (utimestimecutimecstime)4元组;

    2.               分别根据结论2、结论3计算出两个时刻的总的cpu时间与进程的cpu时间,分别记作:totalCpuTime1totalCpuTime2processCpuTime1processCpuTime2

    3.               计算该进程的cpu使用率pcpu = 100*( processCpuTime2 – processCpuTime1) / (totalCpuTime2 – totalCpuTime1) (按100%计算,如果是多核情况下还需乘以cpu的个数);

    实验数据

    实验一: 监控一空循环的进程的cpu使用率。

    说明:左边的数据是按以上算法得到的数据,其中采样的时间间隔与top命令刷新屏幕的时间间隔相同。

    按以上方法计算得到的cpu使用率

    通过top命令得到的

     

    99.50083

    98.333336

    98.0

    98.83138

    99.0

    99.0

    99.83361

    98.83527

    98.4975

     

    PID    USER      PR   NI   VIRT   RES   SHR   S  %CPU %MEM  TIME+  COMMAND 

    7639 fjzag     20   0  206m  10m 7136 S   99  2.2   1:00.74 java              

     7639 fjzag     20   0  206m  10m 7136 S   99  2.2   1:03.71 java              

     7639 fjzag     20   0  206m  10m 7136 S   99  2.2   1:06.67 java              

     7639 fjzag     20   0  206m  10m 7136 S   99  2.2   1:09.63 java              

     7639 fjzag     20   0  206m  10m 7136 S   98  2.2   1:12.59 java              

     7639 fjzag     20   0  206m  10m 7136 S   99  2.2   1:15.55 java              

     7639 fjzag     20   0  206m  10m 7136 S  100  2.2   1:18.55 java              

     7639 fjzag     20   0  206m  10m 7136 S  100  2.2   1:21.54 java              

     7639 fjzag     20   0  206m  10m 7136 S   99  2.2   1:24.52 java              

     7639 fjzag     20   0  206m  10m 7136 S   98  2.2   1:27.46 java

     

    实验二: 监控jconsole进程的cpu使用率。

    说明:左边的数据是按以上算法得到的数据,其中采样的时间间隔与top命令刷新屏幕的时间间隔相同。

    按以上方法计算得到的cpu使用率

    通过top命令得到的

     

    8.681135

    12.0

    10.350584

    7.6539097

    7.6539097

    5.0

    13.021703

    11.0

    8.666667

    PID   USER      PR   NI  VIRT   RES   SHR  S  %CPU %MEM  TIME+  COMMAND 

    7753 fjzag     20   0  252m  72m  22m S   10 14.4   0:18.70 jconsole          

     7753 fjzag     20   0  252m  72m  22m S   12 14.4   0:19.07 jconsole          

     7753 fjzag     20   0  252m  72m  22m S   11 14.4   0:19.39 jconsole          

     7753 fjzag     20   0  252m  72m  22m S    7 14.4   0:19.61 jconsole          

     7753 fjzag     20   0  252m  72m  22m S    7 14.4   0:19.83 jconsole          

     7753 fjzag     20   0  252m  72m  22m S    5 14.4   0:19.97 jconsole          

     7753 fjzag     20   0  252m  72m  22m S   14 14.4   0:20.38 jconsole          

     7753 fjzag     20   0  252m  72m  22m S   10 14.4   0:20.68 jconsole          

     7753 fjzag     20   0  252m  72m  22m S    9 14.5   0:20.96 jconsole

    某一线程Cpu使用率的计算

    计算方法:  

    1.               采样两个足够短的时间隔的cpu快照与线程快照,

    a)         每一个cpu快照均为(user、nice、system、idle、iowait、irq、softirq、stealstealon、guest)的9元组;

    b)         每一个线程快照均为 (utimestime)2元组;

    2.               分别根据结论2、结论4计算出两个时刻的总的cpu时间与线程的cpu时间,分别记作:totalCpuTime1totalCpuTime2threadCpuTime1threadCpuTime2

    3.               计算该线程的cpu使用率pcpu = 100*( threadCpuTime2 – threadCpuTime1) / (totalCpuTime2 – totalCpuTime1) (按100%计算,如果是多核情况下还需乘以cpu的个数);

    实验数据

    实验一: 监控一空循环的线程的cpu使用率。

    说明:左边的数据是按以上算法得到的数据,其中采样的时间间隔与top命令刷新屏幕的时间间隔相同。

    按以上方法计算得到的cpu使用率

    通过top命令得到的

     

    98.83138

    97.00997

    96.98997

    97.49583

    98.169716

    96.8386

    97.333336

    93.82304

    98.66667

    PID    USER      PR   NI   VIRT   RES   SHR   S  %CPU %MEM  TIME+  COMMAND 

    7649 fjzag     20   0  206m  10m 7136 R   97  2.2   7:22.94 java              

     7649 fjzag     20   0  206m  10m 7136 R   97  2.2   7:25.86 java              

     7649 fjzag     20   0  206m  10m 7136 R   97  2.2   7:28.76 java              

     7649 fjzag     20   0  206m  10m 7136 R   99  2.2   7:31.72 java              

     7649 fjzag     20   0  206m  10m 7136 R   98  2.2   7:34.65 java              

     7649 fjzag     20   0  206m  10m 7136 R   96  2.2   7:37.53 java              

     7649 fjzag     20   0  206m  10m 7136 R   98  2.2   7:40.47 java              

     7649 fjzag     20   0  206m  10m 7136 R   96  2.2   7:43.34 java              

     7649 fjzag     20   0  206m  10m 7136 R   97  2.2   7:46.25 java

     

    实验二: 监控jconsole程序某一线程的cpu使用率。

    说明:左边的数据是按以上算法得到的数据,其中采样的时间间隔与top命令刷新屏幕的时间间隔相同。

    按以上方法计算得到的cpu使用率

    通过top命令得到的

     

    1.3400335

    6.644518

    1.3333334

    0.6677796

    0.6666667

    1.3333334

    1.3333334

     PID    USER      PR   NI   VIRT   RES  SHR  S  %CPU %MEM  TIME+  COMMAND 

    7755 fjzag     20   0  251m  72m  22m S    1 14.4   0:11.92 jconsole          

     7755 fjzag     20   0  251m  72m  22m S    7 14.4   0:12.12 jconsole          

     7755 fjzag     20   0  251m  72m  22m S    2 14.4   0:12.18 jconsole          

     7755 fjzag     20   0  251m  72m  22m S    0 14.4   0:12.18 jconsole          

     7755 fjzag     20   0  251m  72m  22m S    1 14.4   0:12.20 jconsole          

     7755 fjzag     20   0  251m  72m  22m S    1 14.4   0:12.24 jconsole          

     7755 fjzag     20   0  251m  72m  22m S    1 14.4   0:12.28 jconsole

    多核情况下cpu使用率的计算                                                    

    以下通过实验数据来说明多核情况下某一进程cpu使用率是按cpu个数*100%计算的.

    实验一

    描述:

    双核的情况下作的一组实验,第一组数据是通过ps  -eLo pid,lwp,pcpu | grep 9140命令查看进程号为9140的进程中各线程的详细信息。第二组数据是通过 ps命令查看进程号为9140进程的cpu使用率。

    数据一:

    pid   lwp  %cpu

    9140  9140  0.0
     9140  9141  0.0
     9140  9142  0.0
     9140  9143  0.0
     9140  9144  0.0
     9140  9149  0.0
     9140  9150  0.0
     9140  9151  0.0
     9140  9152  0.1
     
    9140  9153 96.6                         该线程是一个空循环
     9140  9154 95.9
                             该线程是一个空循环

    以上除了红色标注出来的两个线程以外,其他的线程都是后台线程。

    数据二:

    pid   %cpu

    9140  193

    实验二

    描述:

    单核的情况下作的一组实验,第一组数据是通过ps  -eLo pid,lwp,pcpu | grep 6137命令查看进程号为6137的进程中各线程的详细信息。第二组数据是通过 ps命令查看进程号为6137进程的cpu使用率。

    数据一:

     pid    lwp   %cpu

     6137  6137  0.0

     6137  6138  0.1

     6137  6143  0.0

     6137  6144  0.0

     6137  6145  0.0

     6137  6146  0.0

     6137  6147  0.0

     6137  6148  0.0

     6137  6149  0.0

     6137  6150 46.9                                                 空循环线程

     6137  6151 46.9                                                 空循环线程

    以上除了红色标注出来的两个线程以外,其他的线程都是后台线程。

    数据二

    pid %cpu

    6137 92.9

    主要问题:

    1.       不同内核版本/proc/stat文件格式不大一致。/proc/stat文件中第一行为总的cpu使用情况。

    各个版本都有的4个字段: user、nice、system、idle

    2.5.41版本新增字段:iowait

    2.6.0-test4新增字段:irq、softirq

    2.6.11新增字段:stealstolen :                    which is the time spent in other operating

    systems when running in a virtualized environment

    2.6.24新增字段:guest:                                    which is the time spent running a virtual  CPU  for  guest operating systems under the control of the Linux kernel

    2./proc/pid/task目录是Linux 2.6.0-test6之后才有的功能。

     

    3.关于出现cpu使用率为负的情况,目前想到的解决方案是如果出现负值,连续采样计算cpu使用率直到为非负。

     

    4. 有些线程生命周期较短,可能在我们采样期间就已经死掉了.

     

    展开全文
  • 目前linux统计cpu利用时,所用到的信息,大多数是从 /proc/stat中获得,其中信息大致如下: 打开/proc/stat 后会看到类似如下信息,不同Linux略微会有不一样。 cpu 432661 13295 86656 422145968 171474 233 ...
  • Linux平台Cpu使用率计算 http://www.blogjava.net/fjzag/articles/317773.html
  • Linux计算特定CPU使用率

    万次阅读 2018-12-23 20:03:51
    Linux计算特定CPU使用率需求解决方案拓展参考 需求 在Linux中可以通过top指令查看某一进程占用的CPU情况,也可以查看某一个CPU使用率情况(先top指令,然后按数字“1”键即可显示每一个CPU的使用情况),如下图: ...
  • Linux下,CPU利用分为用户态,系统态和空闲态,分别表示CPU处于用户态执行的时间,系统内核执行的时间,和空闲系统进程执行的时间,三者之和就是CPU的总时间,当没有用户进程、系统进程等需要执行的时候,CPU就...
  • Linux平台Cpu使用率计算proc文件系统/proc文件系统是一个伪文件系统,它只存在内存当中,而不占用外存空间。它以文件系统的方式为内核与进程提供通信的接口。用户和应用程序可以通过/proc得到系统的信息,并可以...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 426
精华内容 170
关键字:

linux计算cpu使用率

linux 订阅