Wie berechnet man die CPU-Auslastung eines Prozesses durch PID in Linux von C?

Lesezeit: 10 Minuten

Benutzeravatar von encodingfreak
Programmierfreak

Ich möchte programmgesteuert [in C] Berechnen Sie die CPU-Auslastung in % für eine bestimmte Prozess-ID in Linux.

Wie können wir die CPU-Auslastung in Echtzeit für einen bestimmten Prozess erhalten?

Um es noch deutlicher zu machen:

  • Ich sollte in der Lage sein, die CPU-Auslastung für die bereitgestellte Prozess-ID oder den Prozess zu bestimmen.
  • Der Prozess muss nicht der untergeordnete Prozess sein.
  • Ich möchte die Lösung in C-Sprache.

  • Was ist mit dem Fangen (Grep-ing) der Ausgabe von top?

    – dusoft

    14. September 2009 um 8:59 Uhr

  • Das ist wirklich nicht der beste Weg, um effizient zu arbeiten;y

    – Programmierfreak

    14. September 2009 um 9:02 Uhr

  • Wird wahrscheinlich einen “teuren” Systemaufruf erfordern, um “oben” zu starten.

    – Liran Orevi

    14. September 2009 um 9:28 Uhr

  • @Liran: Richtig gesagt 🙂

    – vpram86

    14. September 2009 um 9:29 Uhr

  • Vergessen Sie diese Art, Dinge zu tun …. in C

    – Programmierfreak

    14. September 2009 um 9:33 Uhr

Sie müssen die Daten aus parsen /proc/<PID>/stat. Dies sind die ersten paar Felder (von Documentation/filesystems/proc.txt in Ihrer Kernel-Quelle):

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

Du bist wahrscheinlich hinterher utime und/oder stime. Sie müssen auch die lesen cpu Zeile ab /proc/statwas so aussieht:

cpu  192369 7119 480152 122044337 14142 9937 26747 0 0

Dies gibt Ihnen die kumulierte CPU-Zeit an, die in verschiedenen Kategorien verwendet wurde, in Einheiten von Jiffies. Sie müssen die Summe der Werte auf dieser Zeile nehmen, um a zu erhalten time_total messen.

Lies beides utime und stime für den Prozess, an dem Sie interessiert sind, und lesen Sie time_total aus /proc/stat. Dann schlafen Sie für eine Sekunde oder so und lesen Sie sie alle noch einmal. Sie können nun die CPU-Auslastung des Prozesses über die Abtastzeit berechnen, mit:

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);

Sinn ergeben?

  • Ein “Jiffy” ist eine Einheit der CPU-Zeit. Was es genau in Echtzeit entspricht, hängt von der Architektur und der Konfiguration Ihres Kernels ab, aber das Wichtigste ist das /proc/stat sagt Ihnen, wie viele Jiffies die CPU insgesamt ausgeführt hat, und /proc/<PID>/stat sagt Ihnen, wie viele Jiffies von einem einzelnen Prozess ausgeführt wurden.

    – Café

    15. September 2009 um 6:21 Uhr

  • @advocate: Es ist eine Pseudodatei, die eine Schnittstelle zum Abrufen von Prozessausführungsstatistiken aus dem Kernel implementiert.

    – Café

    7. Mai 2012 um 1:49 Uhr

  • An Personen, die weitere Informationen zu den Bereichen suchen: man proc ist dein Freund (Suche nach /proc/[pid]/stat)

    – roter Schatten

    28. Juni 2013 um 23:24 Uhr

  • Ich möchte ein kleines Beispielprogramm teilen, das ich basierend auf dieser Antwort erstellt habe: github.com/scaidermern/top-processes. Machen Sie gerne Gebrauch davon, es ist unter CC0 lizensiert.

    – scai

    14. August 2016 um 11:59 Uhr


  • Anscheinend war der OP anderer Meinung. Die wichtigste Erkenntnis hier ist die Verwendung von /proc Pseudo-Dateisystem: Die Lehre von Standard-C-Dateisystem-Zugriffsfunktionen wie fopen() und scanf() ist nebensächlich.

    – Café

    11. Januar 2018 um 0:33 Uhr

Benutzeravatar von vpram86
vpram86

getrusage() kann Ihnen helfen, die Verwendung des aktuellen Prozesses oder seines untergeordneten Prozesses zu bestimmen

Aktualisieren:
An eine API kann ich mich nicht erinnern. Aber alle Details werden in /proc/ seinPID/stat, also wenn wir es analysieren könnten, könnten wir den Prozentsatz bekommen.

BEARBEITEN:
Da CPU % nicht einfach zu berechnen ist, könnten Sie hier Stichproben verwenden. Lesen Sie ctime und utime für einen PID zu einem bestimmten Zeitpunkt und lesen Sie die gleichen Werte nach 1 Sekunde erneut. Finde die Differenz und teile durch Hundert. Sie werden für mehr als eine Sekunde für diesen Vorgang verwendet.

(kann bei vielen Prozessoren komplexer werden)

  • Wie hilft mir der Systemaufruf getrusage() bei der Berechnung der CPU-Auslastung eines Prozesses?

    – Programmierfreak

    14. September 2009 um 9:06 Uhr

  • @codingfreak. ich habe die Frage falsch verstanden. Jetzt, nachdem Sie es aktualisiert haben, klar.

    – vpram86

    14. September 2009 um 9:22 Uhr

  • @Aviator CPU % = (processusertime + processkerneltime)/(CPUusertime+CPUkerneltime) Wie bekomme ich die Werte für „processusertime“ und so weiter. ??? Ich sehe unterschiedliche Werte in der Datei „/proc/PID/stat“. Welcher entspricht also welchem ​​Wert ??

    – Programmierfreak

    14. September 2009 um 9:32 Uhr

  • @codingfreak: Die CPU-Zeit ist schwer zu berechnen. Sie müssen alle PID-Statistiken durchlaufen, denke ich (obwohl nicht sicher)

    – vpram86

    14. September 2009 um 10:08 Uhr

  • @Aviator, es gäbe die eine oder andere Möglichkeit, dies zu tun … da sogar Anwendungen wie top die CPU-Auslastung berechnen sollten, die in ihrer Ausgabe angezeigt werden soll

    – Programmierfreak

    14. September 2009 um 10:14 Uhr

zizzus Benutzeravatar
zizzu

Einfach Schritt für Schritt für Anfänger wie mich:

  1. Lesen Sie die erste Zeile von /proc/stat bekommen total_cpu_usage1.
    sscanf(line,"%*s %llu %llu %llu %llu",&user,&nice,&system,&idle);
    total_cpu_usage1 = user + nice + system + idle;
  1. Lesen /proc/pid/stat wo pid ist die PID des Prozesses, für den Sie die CPU-Auslastung wissen möchten, wie folgt:
    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
    ....)
  1. Jetzt summieren usertime und systemtime und bekomme proc_times1
  2. Warten Sie nun 1 Sekunde oder länger
  3. Mach es noch einmal und hol es dir total_cpu_usage2 und proc_times2

Die Formel lautet:

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

Sie können die Anzahl der CPUs von erhalten /proc/cpuinfo.

  • Ihre Lösung ist gut, aber um die Anzahl der CPUs zu erhalten, machen Sie es einfacher. Schließe diesen Typen ein #include <unistd.h> und rufen Sie diese Methode auf int nb = sysconf(_SC_NPROCESSORS_ONLN);

    – David Guyon

    3. Juni 2014 um 8:01 Uhr


  • Ich verstehe nicht, warum mit der (Anzahl der Prozessoren) multipliziert wird, vorausgesetzt, Delta (proc_times) ist für den Kern, auf dem es ausgeführt wurde. Ohne Multiplikation mit dem Faktor oder CPUs sollte es stimmen.

    – JayabalanAaron

    27. November 2017 um 11:53 Uhr

  • @JayabalanAaron: Linux misst den CPU-Prozentsatz auf einer Skala von 0 – (100 * #cores) %. Dies ist der sogenannte „Irix-Modus“. Unix-Systeme hingegen verwenden eine Skala von 0-100 % (der Solaris-Modus).

    – drgnfr

    5. Juni um 22:10 Uhr


Benutzeravatar von fho
fho

Ich habe zwei kleine C-Funktionen geschrieben, die auf der Antwort von cafs basieren, um die Benutzer- und Kernel-CPU-Auslastung eines Prozesses zu berechnen:
https://github.com/fho/code_snippets/blob/master/c/getusage.c

Sie können die lesen Handbuchseite für proc für mehr Details, aber zusammenfassend können Sie /proc/ lesen[number]/stat um Informationen über einen Prozess zu erhalten. Dies wird auch vom ‘ps’-Befehl verwendet.

Alle Felder und ihre scanf-Formatbezeichner sind in dokumentiert proc manpage.

Hier sind einige Informationen aus der manpage kopiert (es ist ziemlich lang):

          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.

  • „CPU-Auslastung“ und „aktueller Status“ sind wie Standort und Geschwindigkeit. Wenn du das eine kennst, kannst du das andere nicht kennen. Die CPU-Auslastung hängt von einer Dauer ab, daher müssen Sie selbst überprüfen, wie oft sich Ihr Prozess im Zustand „R“ befindet.

    – Bombe

    14. September 2009 um 9:45 Uhr

  • Hmm, gute Frage, ich bin immer davon ausgegangen, dass es da ist! Vermutlich sollten Sie es aus diesen Variablen berechnen können

    – André Müller

    14. September 2009 um 9:51 Uhr

  • Wenn Sie die Ausgabe des Top-Befehls überprüfen, können Sie die CPU-Auslastung sehen … aber ich bin nicht daran interessiert, die Top-Ausgabe zu durchsuchen, um die CPU-Auslastung zu berechnen …

    – Programmierfreak

    14. September 2009 um 9:54 Uhr

  • @codingfreak: ps aux ist besser 🙂

    – vpram86

    14. September 2009 um 9:55 Uhr

  • @Aviator – Ich habe dir bereits gesagt, dass du vergessen sollst, die Ausgabe eines Shell-Befehls zu gruppieren, um die CPU-NUTZUNG % zu bestimmen

    – Programmierfreak

    14. September 2009 um 10:13 Uhr

Benutzeravatar von James Anderson
James Anderson

Schauen Sie sich den Befehl “pidstat” an, das klingt genau so, wie Sie es benötigen.

  • „CPU-Auslastung“ und „aktueller Status“ sind wie Standort und Geschwindigkeit. Wenn du das eine kennst, kannst du das andere nicht kennen. Die CPU-Auslastung hängt von einer Dauer ab, daher müssen Sie selbst überprüfen, wie oft sich Ihr Prozess im Zustand „R“ befindet.

    – Bombe

    14. September 2009 um 9:45 Uhr

  • Hmm, gute Frage, ich bin immer davon ausgegangen, dass es da ist! Vermutlich sollten Sie es aus diesen Variablen berechnen können

    – André Müller

    14. September 2009 um 9:51 Uhr

  • Wenn Sie die Ausgabe des Top-Befehls überprüfen, können Sie die CPU-Auslastung sehen … aber ich bin nicht daran interessiert, die Top-Ausgabe zu durchsuchen, um die CPU-Auslastung zu berechnen …

    – Programmierfreak

    14. September 2009 um 9:54 Uhr

  • @codingfreak: ps aux ist besser 🙂

    – vpram86

    14. September 2009 um 9:55 Uhr

  • @Aviator – Ich habe dir bereits gesagt, dass du vergessen sollst, die Ausgabe eines Shell-Befehls zu gruppieren, um die CPU-NUTZUNG % zu bestimmen

    – Programmierfreak

    14. September 2009 um 10:13 Uhr

Benutzeravatar von Mohan Ram
Mohan Ram

Das ist meine Lösung…

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

  • Scheint mit Hilfe der libgtop-Bibliothek ..?

    – Programmierfreak

    13. März 2011 um 11:19 Uhr

  • Das gefällt mir – die Bibliothek ist unkompliziert. Ich frage mich, ob es eine Möglichkeit gibt, zu sehen, wie viel Prozent der Gesamtkapazität die Gesamtnutzung beträgt?

    – Kera

    26. Dezember 2012 um 2:19 Uhr

1421040cookie-checkWie berechnet man die CPU-Auslastung eines Prozesses durch PID in Linux von C?

This website is using cookies to improve the user-friendliness. You agree by using the website further.

Privacy policy