如何取得linux下进程的一些核心信息-白红宇

如何取得linux下进程的一些核心信息

阅读量：6677 次

发布时间：2019-06-25

本文共 18117 字，大约阅读时间需要 60 分钟。

有时候我们为了便于管理，需要获取到对应的进程信息，例如进程的优先级，进程的cpu使用率，占用内存多少等等。那么我们应该如何得到那些关键的信息呢？其实在实时变化的proc目录下就有对应的信息，不过需要我们动手读取出来或测算出来而已。不信请看

------------------------------------------------------

proc原理

/proc/pid/stat

[root@localhost ~]# 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

每个参数意思为：

参数解释

pid=6873 进程(包括轻量级进程，即线程)号

comm=a.out 应用程序或命令的名字

task_state=R 任务的状态，R:runnign, S:sleeping (TASK_INTERRUPTIBLE), D:disk sleep (TASK_UNINTERRUPTIBLE), T: stopped, T:tracing stop,Z:zombie, X:dead

ppid=6723 父进程ID

pgid=6873 线程组号

sid=6723 c该任务所在的会话组ID

tty_nr=34819(pts/3) 该任务的tty终端的设备号，INT（34817/256）=主设备号，（34817-主设备号）=次设备号

tty_pgrp=6873 终端的进程组号，当前运行在该任务所在终端的前台任务(包括shell 应用程序)的PID。

task->flags=8388608 进程标志位，查看该任务的特性

min_flt=77 该任务不需要从硬盘拷数据而发生的缺页（次缺页）的次数

cmin_flt=0 累计的该任务的所有的waited-for进程曾经发生的次缺页的次数目

maj_flt=0 该任务需要从硬盘拷数据而发生的缺页（主缺页）的次数

cmaj_flt=0 累计的该任务的所有的waited-for进程曾经发生的主缺页的次数目

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

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

cutime=0 累计的该任务的所有的waited-for进程曾经在用户态运行的时间，单位为jiffies

cstime=0 累计的该任务的所有的waited-for进程曾经在核心态运行的时间，单位为jiffies

priority=25 任务的动态优先级

nice=0 任务的静态优先级

num_threads=3 该任务所在的线程组里线程的个数

it_real_value=0 由于计时间隔导致的下一个 SIGALRM 发送进程的时延，以 jiffy 为单位.

start_time=5882654 该任务启动的时间，单位为jiffies

vsize=1409024（page）该任务的虚拟地址空间大小

rss=56(page) 该任务当前驻留物理地址空间的大小

Number of pages the process has in real memory,minu 3 for administrative purpose.

这些页可能用于代码，数据和栈。

rlim=4294967295（bytes）该任务能驻留物理地址空间的最大值

start_code=134512640 该任务在虚拟地址空间的代码段的起始地址

end_code=134513720 该任务在虚拟地址空间的代码段的结束地址

start_stack=3215579040 该任务在虚拟地址空间的栈的结束地址

kstkesp=0 esp(32 位堆栈指针) 的当前值, 与在进程的内核堆栈页得到的一致.

kstkeip=2097798 指向将要执行的指令的指针, EIP(32 位指令指针)的当前值.

pendingsig=0 待处理信号的位图，记录发送给进程的普通信号

block_sig=0 阻塞信号的位图

sigign=0 忽略的信号的位图

sigcatch=082985 被俘获的信号的位图

wchan=0 如果该进程是睡眠状态，该值给出调度的调用点

nswap 被swapped的页数，当前没用

cnswap 所有子进程被swapped的页数的和，当前没用

exit_signal=17 该进程结束时，向父进程所发送的信号

task_cpu(task)=0 运行在哪个CPU上

task_rt_priority=0 实时进程的相对优先级别

task_policy=0 进程的调度策略，0=非实时进程，1=FIFO实时进程；2=RR实时进程

------------------------------------------------------

cpu使用率计算原理转自：

/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.

结论5：ps命令算出来的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) 每一个进程快照均为 (utime、stime、cutime、cstime)的4元组；

2． 分别根据结论2、结论3计算出两个时刻的总的cpu时间与进程的cpu时间，分别记作：totalCpuTime1、totalCpuTime2、processCpuTime1、processCpuTime2

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) 每一个线程快照均为 (utime、stime)的2元组；

2． 分别根据结论2、结论4计算出两个时刻的总的cpu时间与线程的cpu时间，分别记作：totalCpuTime1、totalCpuTime2、threadCpuTime1、threadCpuTime2

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

------------------------------------------------------

int get_process_time (unsigned int uPid, Process_Time_t* Pro_time)

{

char buffer[BUFF_SIZE*4];

char cmd[20]={0};

int bufLen;

sprintf (cmd, "cat /proc/%d/stat",uPid);

parse_cmd(cmd,buffer); //此接口返回cmd得到的内容

bufLen=strlen(buffer);

sscanf (buffer, "%d %s %s %s %s\

%s %s %s %s %s\

%s %s %s %d %d\

%d %d %s %s %s\

%s %s %s %s %s\

%s %s %s %s",

&(Pro_time->uPid), cmd, cmd, cmd, cmd,

cmd, cmd, cmd, cmd, cmd,

cmd, cmd, cmd, &(Pro_time->uTime),&(Pro_time->sTime),

&(Pro_time->cuTime),&(Pro_time->csTime),cmd,cmd,cmd,

cmd, cmd, cmd, cmd, cmd,

cmd, cmd, cmd, cmd );

if(Pro_time->uPid != uPid)

{

printf("the pid is not match!!!!!!\n");

return (-1);

}

printf("Pro_time->uPid:%d,Pro_time->uTime:%d,Pro_time->sTime:%d,Pro_time->cuTime:%d,Pro_time->csTime:%d.\n",\

Pro_time->uPid,Pro_time->uTime,Pro_time->sTime,Pro_time->cuTime,Pro_time->csTime);

}

int get_cpu_total_time (CPU_Total_Time_t * cpuTotalTime)

{

char buffer[BUFF_SIZE*4];

char cmd[20]={0};

int bufLen;

sprintf (cmd, "cat /proc/stat");

parse_cmd(cmd,buffer); //此接口返回cmd得到的内容

bufLen=strlen(buffer);

sscanf (buffer, "%s %d %d %d %d\

%d %d %d %d %d",\

cmd,&(cpuTotalTime->user),&(cpuTotalTime->nice),&(cpuTotalTime->system),&(cpuTotalTime->idle),\

&(cpuTotalTime->iowait),&(cpuTotalTime->irq),&(cpuTotalTime->softirq),&(cpuTotalTime->stealstolen),&(cpuTotalTime->guest));

printf("cpuTotalTime->user:%d ,cpuTotalTime->nice:%d,cpuTotalTime->system:%d,cpuTotalTime->idle:%d\

cpuTotalTime->iowait:%d,cpuTotalTime->irq:%d,cpuTotalTime->softirq:%d,cpuTotalTime->stealstolen:%d,\

cpuTotalTime->guest:%d",cpuTotalTime->user,cpuTotalTime->nice,cpuTotalTime->system,cpuTotalTime->idle,\

cpuTotalTime->iowait,cpuTotalTime->irq,cpuTotalTime->softirq,cpuTotalTime->stealstolen,cpuTotalTime->guest);

}

int get_process_info (unsigned int uPid, Process_Info* info)

{

FILE *fp,*stream;

char buffer[BUFF_SIZE*4]={0};

char cmd[20]={0};

char str_pid[10]={0};

char proc_name[ROC_PROCESS_NAME_MAX_LEN]={0};

int bufLen=0;

//分别对应任务对应优先级，静态优先级，实时进程相对优先级，调度策略

int priority,nice_vale,rt_priority,policy;

char vSize[20]={0};

Roc_Task_Process_Time_t Pro_time_one,Pro_time_two;

Roc_Task_CPU_Total_Time_t cpuTotalTime_one,cpuTotalTime_two;

int pro_total_one,pro_total_two;

int cpu_total_one,cpu_total_two;

int pro_total,cpu_total;

unsigned int count_temp,i,j;

info->uPid=uPid;

// itoa(uPid,str_pid,10);

if(uPid ==NULL || info==NULL)

{

printf("error pid or Roc_task_Proinfo struct!!!!\n");

return (-1);

}

sprintf(cmd,"cat /proc/%d/status",uPid);//对应文件获取到进程名

parse_cmd(cmd,buffer);

bufLen=strlen(buffer);

for(i=0,j=0;i<bufLen;i++)

{

if(buffer[i]==' ')

{

printf("into j=%d!!!!\n",j);

while(buffer[++i] !='\n')

{

proc_name[j++]=buffer[i];

printf("proc_name[%d]:%c\n",j-1,proc_name[j-1]);

printf("buffer[%d]:%c\n",i,buffer[i]);

}

if(j>0)//对应文件获取到进程名立即跳出循环

{

printf("j over=%d.\n",j);

proc_name[j]='\0';

strcpy(info->name,proc_name);

printf("pid 1 name is %s \n",proc_name);

break;

}

memset(buffer,0,BUFF_SIZE*4);

sprintf (cmd, "cat /proc/%d/stat",uPid);//读取进程的优先级

printf("cmd infomation is %s",cmd);

parse_cmd(cmd,buffer);

bufLen=strlen(buffer);

sscanf (buffer, "%s %s %s %s %s\

%s %s %s %s %s\

%s %s %d %d %s\

%s %s %s %s %s\

%s %s %s %s %d\

%d %s %s %s",

cmd, cmd, cmd, cmd, cmd,

cmd, cmd, &priority, &nice_vale, cmd,

cmd, cmd, &vSize, cmd, cmd,

cmd, cmd, cmd, cmd, cmd,

cmd, cmd, cmd, cmd, &rt_priority,

&policy, cmd, cmd, cmd );

// 用户角度看到的实时任务的优先级值域

printf ("rt_priority : %4d [ 0L - 99H]\n", rt_priority);

info->priority = rt_priority;

info->ramUsed =atol(vSize)/1024;

printf("vSize =%s,ramUsed =%d\n",vSize,info->ramUsed);

printf("buffer back:\n%s",buffer);

// sprintf (cmd, "cat /proc/%d/stat",uPid);

get_process_time (uPid,&Pro_time_one);

get_cpu_total_time(&cpuTotalTime_one);

pro_total_one=Pro_time_one.uTime+Pro_time_one.sTime+Pro_time_one.cuTime+Pro_time_one.csTime;

cpu_total_one=cpuTotalTime_one.user+cpuTotalTime_one.nice+cpuTotalTime_one.system+cpuTotalTime_one.idle+\

cpuTotalTime_one.iowait+cpuTotalTime_one.irq+cpuTotalTime_one.softirq+cpuTotalTime_one.stealstolen+cpuTotalTime_one.guest;

get_process_time (uPid,&Pro_time_two);

_get_cpu_total_time(&cpuTotalTime_two);

pro_total_two=Pro_time_two.uTime+Pro_time_two.sTime+Pro_time_two.cuTime+Pro_time_two.csTime;

cpu_total_two=cpuTotalTime_two.user+cpuTotalTime_two.nice+cpuTotalTime_two.system+cpuTotalTime_two.idle+\

cpuTotalTime_two.iowait+cpuTotalTime_two.irq+cpuTotalTime_two.softirq+cpuTotalTime_two.stealstolen+cpuTotalTime_two.guest;

pro_total=pro_total_two-pro_total_one;

cpu_total=cpu_total_two-cpu_total_one;

printf("chenyouda,pro_total:%d,cpu_total:%d",pro_total,cpu_total);

info->cpuLoad=((1.0*(pro_total_two-pro_total_one)/(cpu_total_two-cpu_total_one))*100);

printf("\npro_total_one:%d,cpu_total_one:%d,pro_total_two:%d,cpu_total_two:%d\n",pro_total_one,cpu_total_one,pro_total_two,cpu_total_two);

printf("info->cpuLoad:%d\n",info->cpuLoad);

return 0;

}

typedef struct Process_Info_

{

unsigned int uPid; //进程pid

int priority; //进程优先级

char name[ROC_PROCESS_NAME_MAX_LEN]; //进程名,最大48 字节

int ramUsed; //进程内存消耗

int cpuLoad; //进程cpu负载，

}Process_Info_t;

typedef struct Process_Time_

{

int uPid; //进程pid

int uTime; //进程用户态时间

int sTime; //进程系统态时间

int cuTime; //所有已死线程在用户态的时间

int csTime; //所有已死线程在系统态的时间

}Process_Time_t;

typedef struct CPU_Total_Time_

{

int user; //启动到当前用户态时间

int nice; //启动开始累计到当前时刻，nice值为负的进程所占用的CPU时间

int system; //启动开始累计到当前时刻，处于核心态的运行时间

int idle; //启动开始累计到当前时刻，除IO等待时间以外的其它等待时间

int iowait; //从系统启动开始累计到当前时刻，IO等待时间

int irq; //从系统启动开始累计到当前时刻，硬中断时间

int softirq; //从系统启动开始累计到当前时刻，软中断时间

int stealstolen; //which is the time spent in other operating systems when running in a virtualized environment

int guest; //which is the time spent running a virtual CPU for guest operating systems under the control of the Linux kernel

}CPU_Total_Time_t;

------------------------------------------------------

转载于:https://www.cnblogs.com/kernel-style/archive/2013/02/01/2889223.html

你可能感兴趣的文章

中国首个LTE IoT多模外场测试启动多模成物联网时代主旋律

查看>>

ARM 发布最新高端移动技术，提升沉浸式体验

英航网络瘫痪原来不是黑客所为只因工程师拔错电源

查看>>

高新兴使用2.6亿募集资金投资四个智慧城市项目

查看>>

智慧城市建设如火如荼刺激传感器市场需求扩大

查看>>

物联网“突围” 移动医疗产业加速试水

查看>>

外媒：40余外国企业团体致函反对中国网络安全法

服务器部署十大问题系列三：创建文档与旧设备处理

查看>>

零基础学习SVN之（三）：可视化SVN的使用

查看>>

IOS开发之显示微博表情

查看>>

Snap首份季度财报或让投资人失望股价被指偏高

查看>>

新来的NB-IoT为什么这么NB？

查看>>

DoCoMo跳过HSPA+ 力争全球首家推出LTE商用服务

查看>>