Como calcular o uso da CPU de um processo por PID no Linux a partir de C?

Desejo calcular programaticamente [em C] a porcentagem de uso da CPU para um determinado ID de processo no Linux.

Como podemos obter a% de uso da CPU em tempo real para um determinado processo?

Para deixar mais claro:

• Devo ser capaz de determinar o uso da CPU para o processid ou processo fornecido.
• O processo não precisa ser filho.
• Quero a solução em linguagem 'C'.

Você precisa analisar os dados de /proc/<PID>/stat. Estes são os primeiros campos (da Documentation/filesystems/proc.txtfonte do kernel):

Table 1-3: Contents of the stat files (as of 2.6.22-rc3)
..............................................................................
 Field          Content
  pid           process id
  tcomm         filename of the executable
  state         state (R is running, S is sleeping, D is sleeping in an
                uninterruptible wait, Z is zombie, T is traced or stopped)
  ppid          process id of the parent process
  pgrp          pgrp of the process
  sid           session id
  tty_nr        tty the process uses
  tty_pgrp      pgrp of the tty
  flags         task flags
  min_flt       number of minor faults
  cmin_flt      number of minor faults with child's
  maj_flt       number of major faults
  cmaj_flt      number of major faults with child's
  utime         user mode jiffies
  stime         kernel mode jiffies
  cutime        user mode jiffies with child's
  cstime        kernel mode jiffies with child's

Você provavelmente está atrás utimee / ou stime. Você também precisará ler a cpulinha de /proc/stat, que se parece com:

cpu  192369 7119 480152 122044337 14142 9937 26747 0 0

Isso informa o tempo de CPU cumulativo que foi usado em várias categorias, em unidades de jiffies. Você precisa obter a soma dos valores nesta linha para obter uma time_totalmedida.

Leia ambos utimee stimepara o processo que você está interessado, e ler time_totala partir /proc/stat. Em seguida, durma por um segundo ou mais e leia todos novamente. Agora você pode calcular o uso da CPU do processo ao longo do tempo de amostragem, com:

user_util = 100 * (utime_after - utime_before) / (time_total_after - time_total_before);
sys_util = 100 * (stime_after - stime_before) / (time_total_after - time_total_before);

Faz sentido?

getrusage () pode ajudá-lo a determinar o uso do processo atual ou de seu filho

Atualização: não me lembro de uma API. Mas todos os detalhes estarão em / proc / PID / stat, então se pudermos analisá-los, podemos obter a porcentagem.

EDIT: Uma vez que CPU% não é fácil de calcular, você poderia usar o tipo de amostragem aqui. Leia ctime e utime para um PID em um ponto no tempo e leia os mesmos valores novamente após 1 segundo. Encontre a diferença e divida por cem. Você obterá a utilização desse processo por mais de um segundo.

(pode ficar mais complexo se houver muitos processadores)

Passo a passo fácil para iniciantes como eu:

1. Leia a primeira linha de /proc/stat para obter total_cpu_usage1.

    sscanf(line,"%*s %llu %llu %llu %llu",&user,&nice,&system,&idle);
    total_cpu_usage1 = user + nice + system + idle;

2. Ler /proc/pid/stat onde pidestá o PID do processo que deseja saber o uso da CPU, assim:

    sscanf(line,
    "%*d %*s %*c %*d" //pid,command,state,ppid

    "%*d %*d %*d %*d %*u %*lu %*lu %*lu %*lu"

    "%lu %lu" //usertime,systemtime

    "%*ld %*ld %*ld %*ld %*ld %*ld %*llu"

    "%*lu", //virtual memory size in bytes
    ....)

3. Agora somar usertimee systemtimee getproc_times1
4. Agora espere 1 segundo ou mais
5. Faça de novo, e obtenha total_cpu_usage2eproc_times2

A fórmula é:

(number of processors) * (proc_times2 - proc_times1) * 100 / (float) (total_cpu_usage2 - total_cpu_usage1)

Você pode obter a quantidade de CPU de /proc/cpuinfo.

Eu escrevi duas pequenas funções C com base na resposta de cafs para calcular o uso de CPU + kernel de um processo: https://github.com/fho/code_snippets/blob/master/c/getusage.c

Você pode ler o manual do proc para obter mais detalhes, mas em resumo, você pode ler / proc / [número] / stat para obter as informações sobre um processo. Isso também é usado pelo comando 'ps'.

Todos os campos e seus especificadores de formato scanf são documentados no proc manpag e.

Aqui estão algumas das informações da página de manual copiada (é bem longa):

          pid %d The process ID.

          comm %s
                 The  filename of the executable, in parentheses.  This is
                 visible whether or not the executable is swapped out.

          state %c
                 One character from the string "RSDZTW" where  R  is  runâ
                 ning,  S is sleeping in an interruptible wait, D is waitâ
                 ing in uninterruptible disk sleep,  Z  is  zombie,  T  is
                 traced or stopped (on a signal), and W is paging.

          ppid %d
                 The PID of the parent.

          pgrp %d
                 The process group ID of the process.

          session %d
                 The session ID of the process.

          tty_nr %d
                 The tty the process uses.

          tpgid %d
                 The  process group ID of the process which currently owns
                 the tty that the process is connected to.

Dê uma olhada no comando "pidstat", soa exatamente como você precisa.

Esta é a minha solução ...

/*
this program is looking for CPU,Memory,Procs also u can look glibtop header there was a lot of usefull function have fun..
systeminfo.c
*/
#include <stdio.h>
#include <glibtop.h>
#include <glibtop/cpu.h>
#include <glibtop/mem.h>
#include <glibtop/proclist.h>



int main(){

glibtop_init();

glibtop_cpu cpu;
glibtop_mem memory;
glibtop_proclist proclist;

glibtop_get_cpu (&cpu);
glibtop_get_mem(&memory);


printf("CPU TYPE INFORMATIONS \n\n"
"Cpu Total : %ld \n"
"Cpu User : %ld \n"
"Cpu Nice : %ld \n"
"Cpu Sys : %ld \n"
"Cpu Idle : %ld \n"
"Cpu Frequences : %ld \n",
(unsigned long)cpu.total,
(unsigned long)cpu.user,
(unsigned long)cpu.nice,
(unsigned long)cpu.sys,
(unsigned long)cpu.idle,
(unsigned long)cpu.frequency);

printf("\nMEMORY USING\n\n"
"Memory Total : %ld MB\n"
"Memory Used : %ld MB\n"
"Memory Free : %ld MB\n"
"Memory Buffered : %ld MB\n"
"Memory Cached : %ld MB\n"
"Memory user : %ld MB\n"
"Memory Locked : %ld MB\n",
(unsigned long)memory.total/(1024*1024),
(unsigned long)memory.used/(1024*1024),
(unsigned long)memory.free/(1024*1024),
(unsigned long)memory.shared/(1024*1024),
(unsigned long)memory.buffer/(1024*1024),
(unsigned long)memory.cached/(1024*1024),
(unsigned long)memory.user/(1024*1024),
(unsigned long)memory.locked/(1024*1024));

int which,arg;
glibtop_get_proclist(&proclist,which,arg);
printf("%ld\n%ld\n%ld\n",
(unsigned long)proclist.number,
(unsigned long)proclist.total,
(unsigned long)proclist.size);
return 0;
}

makefile is
CC=gcc
CFLAGS=-Wall -g
CLIBS=-lgtop-2.0 -lgtop_sysdeps-2.0 -lgtop_common-2.0

cpuinfo:cpu.c
$(CC) $(CFLAGS) systeminfo.c -o systeminfo $(CLIBS)
clean:
rm -f systeminfo

Quando você deseja monitorar o processo especificado, geralmente isso é feito por script. Aqui está um exemplo de perl. Isso coloca as porcentagens da mesma forma que no topo, transferindo-as para uma CPU. Então, quando algum processo está ativo trabalhando com 2 threads, o uso da CPU pode ser superior a 100%. Observe especialmente como os núcleos da CPU são contados: D, então, deixe-me mostrar meu exemplo:

#!/usr/bin/perl

my $pid=1234; #insert here monitored process PID

#returns current process time counters or single undef if unavailable
#returns:  1. process counter  , 2. system counter , 3. total system cpu cores
sub GetCurrentLoads {
    my $pid=shift;
    my $fh;
    my $line;
    open $fh,'<',"/proc/$pid/stat" or return undef;
    $line=<$fh>;
    close $fh;
    return undef unless $line=~/^\d+ \([^)]+\) \S \d+ \d+ \d+ \d+ -?\d+ \d+ \d+ \d+ \d+ \d+ (\d+) (\d+)/;
    my $TimeApp=$1+$2;
    my $TimeSystem=0;
    my $CpuCount=0;
    open $fh,'<',"/proc/stat" or return undef;
    while (defined($line=<$fh>)) {
        if ($line=~/^cpu\s/) {
            foreach my $nr ($line=~/\d+/g) { $TimeSystem+=$nr; };
            next;
        };
        $CpuCount++ if $line=~/^cpu\d/;
    }
    close $fh;
    return undef if $TimeSystem==0;
    return $TimeApp,$TimeSystem,$CpuCount;
}

my ($currApp,$currSys,$lastApp,$lastSys,$cores);
while () {
    ($currApp,$currSys,$cores)=GetCurrentLoads($pid);
    printf "Load is: %5.1f\%\n",($currApp-$lastApp)/($currSys-$lastSys)*$cores*100 if defined $currApp and defined $lastApp and defined $currSys and defined $lastSys;
    ($lastApp,$lastSys)=($currApp,$currSys);
    sleep 1;
}

Espero que ajude em algum monitoramento. É claro que você deve usar scanf ou outras funções C para converter qualquer regexpes perl que usei em código-fonte C. Claro que 1 segundo para dormir não é obrigatório. você pode usar a qualquer momento. efeito é, você obterá carga média no período de tempo especificado. Quando você for usá-lo para monitorar, é claro que os últimos valores que você deve colocar de fora. É necessário, porque o monitoramento geralmente chama scripts periodicamente, e o script deve terminar seu trabalho o mais rápido possível.

Instale psacctou acctempacote. Em seguida, use o sacomando para exibir o tempo de CPU usado para vários comandos. uma página de manual

Um bom tutorial do site nixCraft.

Acho que vale a pena olhar o código-fonte do comando GNU "time". time Produz o tempo da CPU do usuário / sistema junto com o tempo real decorrido. Ele chama a chamada do sistema wait3 / wait4 (se disponível) e, caso contrário, ele chama a chamada do sistema vezes. wait * chamada do sistema retorna uma variável de estrutura "rusage" e vezes que a chamada do sistema retorna "tms". Além disso, você pode dar uma olhada na chamada do sistema getrusage, que também retorna informações de tempo muito interessantes. Tempo

Em vez de analisar isso a partir de proc, pode-se usar funções como getrusage () ou clock_gettime () e calcular o uso da cpu como uma razão ou tempo de parede e tempo do processo / thread usado na cpu.

Use strace encontrado que o uso da CPU precisa ser calculado por um período de tempo:

# top -b -n 1 -p 3889
top - 16:46:37 up  1:04,  3 users,  load average: 0.00, 0.01, 0.02
Tasks:   1 total,   0 running,   1 sleeping,   0 stopped,   0 zombie
%Cpu(s):  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
KiB Mem :  5594496 total,  5158284 free,   232132 used,   204080 buff/cache
KiB Swap:  3309564 total,  3309564 free,        0 used.  5113756 avail Mem 

  PID USER      PR  NI    VIRT    RES    SHR S  %CPU %MEM     TIME+ COMMAND
 3889 root      20   0  162016   2220   1544 S   0.0  0.0   0:05.77 top

# strace top -b -n 1 -p 3889

.
.
.
stat("/proc/3889", {st_mode=S_IFDIR|0555, st_size=0, ...}) = 0
open("/proc/3889/stat", O_RDONLY)       = 7
read(7, "3889 (top) S 3854 3889 3854 3481"..., 1024) = 342
.
.
.

nanosleep({0, 150000000}, NULL)         = 0
.
.
.
stat("/proc/3889", {st_mode=S_IFDIR|0555, st_size=0, ...}) = 0
open("/proc/3889/stat", O_RDONLY)       = 7
read(7, "3889 (top) S 3854 3889 3854 3481"..., 1024) = 342
.
.
.