Wie man den CPU- und Speicherverbrauch innerhalb eines Prozesses ermittelt

Question

Ich hatte einmal die Aufgabe, die folgenden Leistungsparameter innerhalb einer laufenden Anwendung zu ermitteln:

• Gesamter verfügbarer virtueller Speicher

• Derzeit genutzter virtueller Speicher

• Virtueller Speicher, der derzeit von meinem Prozess verwendet wird

• Verfügbares RAM insgesamt

• Derzeit genutztes RAM

• Derzeit von meinem Prozess genutztes RAM

• % aktuell genutzte CPU

• % CPU, die derzeit von meinem Prozess verwendet wird

Der Code musste unter Windows und Linux laufen. Obwohl dies eine Standardaufgabe zu sein scheint, hat es mich mehrere Tage gekostet, die notwendigen Informationen in den Handbüchern (WIN32 API, GNU docs) und im Internet zu finden, da es dort so viele unvollständige/unrichtige/veraltete Informationen zu diesem Thema gibt.

Um anderen die gleichen Schwierigkeiten zu ersparen, dachte ich, es wäre eine gute Idee, alle verstreuten Informationen und das, was ich durch Versuch und Irrtum herausgefunden habe, hier an einem Ort zu sammeln.

Answer 1

Windows

Einige der oben genannten Werte sind leicht über die entsprechende Win32-API verfügbar, ich führe sie hier nur der Vollständigkeit halber auf. Andere müssen jedoch aus der Performance Data Helper Library (PDH) bezogen werden, die etwas "unintuitiv" ist und viel mühsames Ausprobieren erfordert, um sie zum Laufen zu bringen. (Zumindest hat es bei mir eine ganze Weile gedauert, vielleicht war ich auch nur ein bisschen dumm...)

Hinweis: Aus Gründen der Übersichtlichkeit wurden im folgenden Code alle Fehlerprüfungen weggelassen. Prüfen Sie die Rückgabewerte...!

• Gesamter virtueller Speicher:

  #include "windows.h"
  
  MEMORYSTATUSEX memInfo;
  memInfo.dwLength = sizeof(MEMORYSTATUSEX);
  GlobalMemoryStatusEx(&memInfo);
  DWORDLONG totalVirtualMem = memInfo.ullTotalPageFile;

  Hinweis: Die Bezeichnung "TotalPageFile" ist hier etwas irreführend. In Wirklichkeit gibt dieser Parameter die "Virtual Memory Size" an, die sich aus der Größe der Auslagerungsdatei und dem installierten RAM zusammensetzt.

• Derzeit verwendeter virtueller Speicher:

  Gleicher Code wie bei "Gesamter virtueller Speicher" und dann

   DWORDLONG virtualMemUsed = memInfo.ullTotalPageFile - memInfo.ullAvailPageFile;

• Virtueller Speicher, der derzeit vom aktuellen Prozess verwendet wird:

  #include "windows.h"
  #include "psapi.h"
  
  PROCESS_MEMORY_COUNTERS_EX pmc;
  GetProcessMemoryInfo(GetCurrentProcess(), (PROCESS_MEMORY_COUNTERS*)&pmc, sizeof(pmc));
  SIZE_T virtualMemUsedByMe = pmc.PrivateUsage;

• Gesamter physischer Speicher (RAM):

  Gleicher Code wie bei "Gesamter virtueller Speicher" und dann

  DWORDLONG totalPhysMem = memInfo.ullTotalPhys;

• Derzeit verwendeter physischer Speicher:

  Gleicher Code wie bei "Gesamter virtueller Speicher" und dann

  DWORDLONG physMemUsed = memInfo.ullTotalPhys - memInfo.ullAvailPhys;

• Physischer Speicher, der derzeit vom aktuellen Prozess verwendet wird:

  Gleicher Code wie in "Virtual Memory currently used by current process" und dann

  SIZE_T physMemUsedByMe = pmc.WorkingSetSize;

• Derzeit verwendete CPU:

  #include "TCHAR.h"
  #include "pdh.h"
  
  static PDH_HQUERY cpuQuery;
  static PDH_HCOUNTER cpuTotal;
  
  void init(){
      PdhOpenQuery(NULL, NULL, &cpuQuery);
      // You can also use L"\\Processor(*)\\% Processor Time" and get individual CPU values with PdhGetFormattedCounterArray()
      PdhAddEnglishCounter(cpuQuery, L"\\Processor(_Total)\\% Processor Time", NULL, &cpuTotal);
      PdhCollectQueryData(cpuQuery);
  }
  
  double getCurrentValue(){
      PDH_FMT_COUNTERVALUE counterVal;
  
      PdhCollectQueryData(cpuQuery);
      PdhGetFormattedCounterValue(cpuTotal, PDH_FMT_DOUBLE, NULL, &counterVal);
      return counterVal.doubleValue;
  }

• CPU, die derzeit vom aktuellen Prozess verwendet wird:

  #include "windows.h"
  
  static ULARGE_INTEGER lastCPU, lastSysCPU, lastUserCPU;
  static int numProcessors;
  static HANDLE self;
  
  void init(){
      SYSTEM_INFO sysInfo;
      FILETIME ftime, fsys, fuser;
  
      GetSystemInfo(&sysInfo);
      numProcessors = sysInfo.dwNumberOfProcessors;
  
      GetSystemTimeAsFileTime(&ftime);
      memcpy(&lastCPU, &ftime, sizeof(FILETIME));
  
      self = GetCurrentProcess();
      GetProcessTimes(self, &ftime, &ftime, &fsys, &fuser);
      memcpy(&lastSysCPU, &fsys, sizeof(FILETIME));
      memcpy(&lastUserCPU, &fuser, sizeof(FILETIME));
  }
  
  double getCurrentValue(){
      FILETIME ftime, fsys, fuser;
      ULARGE_INTEGER now, sys, user;
      double percent;
  
      GetSystemTimeAsFileTime(&ftime);
      memcpy(&now, &ftime, sizeof(FILETIME));
  
      GetProcessTimes(self, &ftime, &ftime, &fsys, &fuser);
      memcpy(&sys, &fsys, sizeof(FILETIME));
      memcpy(&user, &fuser, sizeof(FILETIME));
      percent = (sys.QuadPart - lastSysCPU.QuadPart) +
          (user.QuadPart - lastUserCPU.QuadPart);
      percent /= (now.QuadPart - lastCPU.QuadPart);
      percent /= numProcessors;
      lastCPU = now;
      lastUserCPU = user;
      lastSysCPU = sys;
  
      return percent * 100;
  }

---

Linux

Unter Linux schien es zunächst naheliegend, die POSIX-APIs zu verwenden, wie getrusage() usw. Ich habe einige Zeit damit verbracht, dies zum Funktionieren zu bringen, habe aber nie sinnvolle Werte erhalten. Als ich schließlich die Kernel-Quellen selbst überprüfte, fand ich heraus, dass diese APIs offenbar ab Linux-Kernel 2.6 noch nicht vollständig implementiert sind!?

Letztendlich habe ich alle Werte durch eine Kombination aus dem Lesen des Pseudodateisystems /proc und Kernel-Aufrufe.

• Gesamter virtueller Speicher:

  #include "sys/types.h"
  #include "sys/sysinfo.h"
  
  struct sysinfo memInfo;
  
  sysinfo (&memInfo);
  long long totalVirtualMem = memInfo.totalram;
  //Add other values in next statement to avoid int overflow on right hand side...
  totalVirtualMem += memInfo.totalswap;
  totalVirtualMem *= memInfo.mem_unit;

• Derzeit verwendeter virtueller Speicher:

  Gleicher Code wie bei "Gesamter virtueller Speicher" und dann

  long long virtualMemUsed = memInfo.totalram - memInfo.freeram;
  //Add other values in next statement to avoid int overflow on right hand side...
  virtualMemUsed += memInfo.totalswap - memInfo.freeswap;
  virtualMemUsed *= memInfo.mem_unit;

• Virtueller Speicher, der derzeit vom aktuellen Prozess verwendet wird:

  #include "stdlib.h"
  #include "stdio.h"
  #include "string.h"
  
  int parseLine(char* line){
      // This assumes that a digit will be found and the line ends in " Kb".
      int i = strlen(line);
      const char* p = line;
      while (*p <'0' || *p > '9') p++;
      line[i-3] = '\0';
      i = atoi(p);
      return i;
  }
  
  int getValue(){ //Note: this value is in KB!
      FILE* file = fopen("/proc/self/status", "r");
      int result = -1;
      char line[128];
  
      while (fgets(line, 128, file) != NULL){
          if (strncmp(line, "VmSize:", 7) == 0){
              result = parseLine(line);
              break;
          }
      }
      fclose(file);
      return result;
  }

• Gesamter physischer Speicher (RAM):

  Gleicher Code wie bei "Gesamter virtueller Speicher" und dann

  long long totalPhysMem = memInfo.totalram;
  //Multiply in next statement to avoid int overflow on right hand side...
  totalPhysMem *= memInfo.mem_unit;

• Derzeit verwendeter physischer Speicher:

  Gleicher Code wie bei "Gesamter virtueller Speicher" und dann

  long long physMemUsed = memInfo.totalram - memInfo.freeram;
  //Multiply in next statement to avoid int overflow on right hand side...
  physMemUsed *= memInfo.mem_unit;

• Physischer Speicher, der derzeit vom aktuellen Prozess verwendet wird:

  Ändern Sie getValue() in "Virtual Memory currently used by current process" wie folgt:

  int getValue(){ //Note: this value is in KB!
      FILE* file = fopen("/proc/self/status", "r");
      int result = -1;
      char line[128];
  
      while (fgets(line, 128, file) != NULL){
          if (strncmp(line, "VmRSS:", 6) == 0){
              result = parseLine(line);
              break;
          }
      }
      fclose(file);
      return result;
  }

• Derzeit verwendete CPU:

  #include "stdlib.h"
  #include "stdio.h"
  #include "string.h"
  
  static unsigned long long lastTotalUser, lastTotalUserLow, lastTotalSys, lastTotalIdle;
  
  void init(){
      FILE* file = fopen("/proc/stat", "r");
      fscanf(file, "cpu %llu %llu %llu %llu", &lastTotalUser, &lastTotalUserLow,
          &lastTotalSys, &lastTotalIdle);
      fclose(file);
  }
  
  double getCurrentValue(){
      double percent;
      FILE* file;
      unsigned long long totalUser, totalUserLow, totalSys, totalIdle, total;
  
      file = fopen("/proc/stat", "r");
      fscanf(file, "cpu %llu %llu %llu %llu", &totalUser, &totalUserLow,
          &totalSys, &totalIdle);
      fclose(file);
  
      if (totalUser < lastTotalUser || totalUserLow < lastTotalUserLow ||
          totalSys < lastTotalSys || totalIdle < lastTotalIdle){
          //Overflow detection. Just skip this value.
          percent = -1.0;
      }
      else{
          total = (totalUser - lastTotalUser) + (totalUserLow - lastTotalUserLow) +
              (totalSys - lastTotalSys);
          percent = total;
          total += (totalIdle - lastTotalIdle);
          percent /= total;
          percent *= 100;
      }
  
      lastTotalUser = totalUser;
      lastTotalUserLow = totalUserLow;
      lastTotalSys = totalSys;
      lastTotalIdle = totalIdle;
  
      return percent;
  }

• CPU, die derzeit vom aktuellen Prozess verwendet wird:

  #include "stdlib.h"
  #include "stdio.h"
  #include "string.h"
  #include "sys/times.h"
  #include "sys/vtimes.h"
  
  static clock_t lastCPU, lastSysCPU, lastUserCPU;
  static int numProcessors;
  
  void init(){
      FILE* file;
      struct tms timeSample;
      char line[128];
  
      lastCPU = times(&timeSample);
      lastSysCPU = timeSample.tms_stime;
      lastUserCPU = timeSample.tms_utime;
  
      file = fopen("/proc/cpuinfo", "r");
      numProcessors = 0;
      while(fgets(line, 128, file) != NULL){
          if (strncmp(line, "processor", 9) == 0) numProcessors++;
      }
      fclose(file);
  }
  
  double getCurrentValue(){
      struct tms timeSample;
      clock_t now;
      double percent;
  
      now = times(&timeSample);
      if (now <= lastCPU || timeSample.tms_stime < lastSysCPU ||
          timeSample.tms_utime < lastUserCPU){
          //Overflow detection. Just skip this value.
          percent = -1.0;
      }
      else{
          percent = (timeSample.tms_stime - lastSysCPU) +
              (timeSample.tms_utime - lastUserCPU);
          percent /= (now - lastCPU);
          percent /= numProcessors;
          percent *= 100;
      }
      lastCPU = now;
      lastSysCPU = timeSample.tms_stime;
      lastUserCPU = timeSample.tms_utime;
  
      return percent;
  }

---

TODO: Andere Plattformen

Ich würde davon ausgehen, dass ein Teil des Linux-Codes auch für Unixe funktioniert, mit Ausnahme der Teile, die das /proc-Pseudodateisystem lesen. Vielleicht können diese Teile unter Unix ersetzt werden durch getrusage() und ähnliche Funktionen?

Answer 2

Mac OS X

Gesamter virtueller Speicher

Dies ist unter Mac OS X schwierig, da es keine voreingestellte Auslagerungspartition oder -datei wie Linux verwendet. Hier ist ein Eintrag aus Apples Dokumentation:

Anmerkung: Im Gegensatz zu den meisten Unix-basierten Betriebssystemen verwendet Mac OS X keine vorab zugewiesene Swap-Partition für virtuellen Speicher. Stattdessen wird der gesamte verfügbare Speicherplatz auf der Boot-Partition des Rechners verwendet.

Wenn Sie also wissen wollen, wie viel virtueller Speicher noch verfügbar ist, müssen Sie die Größe der Root-Partition ermitteln. Das können Sie wie folgt tun:

struct statfs stats;
if (0 == statfs("/", &stats))
{
    myFreeSwap = (uint64_t)stats.f_bsize * stats.f_bfree;
}

Total Virtual Derzeit verwendet

Der Aufruf von systcl mit dem Schlüssel "vm.swapusage" liefert interessante Informationen über die Swap-Nutzung:

sysctl -n vm.swapusage
vm.swapusage: total = 3072.00M  used = 2511.78M  free = 560.22M  (encrypted)

Der hier angezeigte Gesamt-Swap-Verbrauch kann sich jedoch ändern, wenn mehr Swap benötigt wird, wie im obigen Abschnitt erläutert. Die Gesamtzahl ist also eigentlich die aktuell Insgesamt auslagern. In C++ können diese Daten auf diese Weise abgefragt werden:

xsw_usage vmusage = {0};
size_t size = sizeof(vmusage);
if( sysctlbyname("vm.swapusage", &vmusage, &size, NULL, 0)!=0 )
{
   perror( "unable to get swap usage by calling sysctlbyname(\"vm.swapusage\",...)" );
}

Beachten Sie, dass die "xsw_usage", die in sysctl.h deklariert ist, nicht dokumentiert zu sein scheint und ich vermute, dass es einen portableren Weg gibt, auf diese Werte zuzugreifen.

Derzeit von meinem Prozess verwendeter virtueller Speicher

Sie können Statistiken über Ihren aktuellen Prozess erhalten, indem Sie die task_info Funktion. Dazu gehören die aktuelle residente Größe Ihres Prozesses und die aktuelle virtuelle Größe.

#include<mach/mach.h>

struct task_basic_info t_info;
mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT;

if (KERN_SUCCESS != task_info(mach_task_self(),
                              TASK_BASIC_INFO, (task_info_t)&t_info,
                              &t_info_count))
{
    return -1;
}
// resident size is in t_info.resident_size;
// virtual size is in t_info.virtual_size;

Verfügbares RAM insgesamt

Die Menge des in Ihrem System verfügbaren physischen Arbeitsspeichers können Sie mit der Option sysctl System wie folgt funktionieren:

#include <sys/types.h>
#include <sys/sysctl.h>
...
int mib[2];
int64_t physical_memory;
mib[0] = CTL_HW;
mib[1] = HW_MEMSIZE;
length = sizeof(int64_t);
sysctl(mib, 2, &physical_memory, &length, NULL, 0);

Derzeit verwendetes RAM

Allgemeine Speicherstatistiken können Sie über die host_statistics Systemfunktion.

#include <mach/vm_statistics.h>
#include <mach/mach_types.h>
#include <mach/mach_init.h>
#include <mach/mach_host.h>

int main(int argc, const char * argv[]) {
    vm_size_t page_size;
    mach_port_t mach_port;
    mach_msg_type_number_t count;
    vm_statistics64_data_t vm_stats;

    mach_port = mach_host_self();
    count = sizeof(vm_stats) / sizeof(natural_t);
    if (KERN_SUCCESS == host_page_size(mach_port, &page_size) &&
        KERN_SUCCESS == host_statistics64(mach_port, HOST_VM_INFO,
                                        (host_info64_t)&vm_stats, &count))
    {
        long long free_memory = (int64_t)vm_stats.free_count * (int64_t)page_size;

        long long used_memory = ((int64_t)vm_stats.active_count +
                                 (int64_t)vm_stats.inactive_count +
                                 (int64_t)vm_stats.wire_count) *  (int64_t)page_size;
        printf("free memory: %lld\nused memory: %lld\n", free_memory, used_memory);
    }

    return 0;
}

Dabei ist zu beachten, dass es in Mac OS X fünf Arten von Speicherseiten gibt. Sie sind wie folgt:

1. Verkabelt Seiten, die an ihrem Platz fixiert sind und nicht ausgetauscht werden können
2. Aktiv Seiten, die in den physischen Speicher geladen werden und relativ schwer auszulagern wären
3. Inaktiv Seiten, die in den Speicher geladen sind, aber in letzter Zeit nicht benutzt wurden und vielleicht auch gar nicht benötigt werden. Dies sind potenzielle Kandidaten für das Swapping. Dieser Speicher müsste wahrscheinlich geleert werden.
4. Cached Seiten, die auf irgendeine Weise zwischengespeichert wurden und wahrscheinlich leicht wiederverwendet werden können. Zwischengespeicherter Speicher müsste wahrscheinlich nicht geleert werden. Es ist immer noch möglich, dass zwischengespeicherte Seiten reaktiviert werden
5. Kostenlos Seiten, die völlig kostenlos sind und sofort verwendet werden können.

Es ist gut zu wissen, dass die Tatsache, dass Mac OS X manchmal nur sehr wenig freien Speicher anzeigt, kein guter Hinweis darauf ist, wie viel davon kurzfristig genutzt werden kann.

Derzeit von meinem Prozess genutztes RAM

Siehe den Abschnitt "Von meinem Prozess derzeit verwendeter virtueller Speicher" oben. Es gilt der gleiche Code.

Answer 3

Linux

Unter Linux sind diese Informationen im Dateisystem /proc verfügbar. Ich bin kein großer Fan des verwendeten Textdateiformats, da jede Linux-Distribution mindestens eine wichtige Datei anzupassen scheint. Ein kurzer Blick auf die Quelle von "ps" offenbart das Chaos.

Aber hier finden Sie die Informationen, die Sie suchen:

/proc/meminfo enthält die meisten systemweiten Informationen, die Sie suchen. Hier sieht es auf meinem System so aus; ich denke, Sie sind interessiert an MemTotal , MemFree , SwapTotal und SwapFree :

Anderson cxc # more /proc/meminfo
MemTotal:      4083948 kB
MemFree:       2198520 kB
Buffers:         82080 kB
Cached:        1141460 kB
SwapCached:          0 kB
Active:        1137960 kB
Inactive:       608588 kB
HighTotal:     3276672 kB
HighFree:      1607744 kB
LowTotal:       807276 kB
LowFree:        590776 kB
SwapTotal:     2096440 kB
SwapFree:      2096440 kB
Dirty:              32 kB
Writeback:           0 kB
AnonPages:      523252 kB
Mapped:          93560 kB
Slab:            52880 kB
SReclaimable:    24652 kB
SUnreclaim:      28228 kB
PageTables:       2284 kB
NFS_Unstable:        0 kB
Bounce:              0 kB
CommitLimit:   4138412 kB
Committed_AS:  1845072 kB
VmallocTotal:   118776 kB
VmallocUsed:      3964 kB
VmallocChunk:   112860 kB
HugePages_Total:     0
HugePages_Free:      0
HugePages_Rsvd:      0
Hugepagesize:     2048 kB

Für die CPU-Auslastung müssen Sie sich ein wenig anstrengen. Linux stellt die gesamte CPU-Auslastung seit dem Systemstart zur Verfügung; daran sind Sie wahrscheinlich nicht interessiert. Wenn Sie wissen wollen, wie die CPU-Auslastung in der letzten Sekunde oder in den letzten 10 Sekunden war, müssen Sie die Informationen abfragen und selbst berechnen.

Die Informationen sind verfügbar in /proc/stat die recht gut dokumentiert ist unter http://www.linuxhowtos.org/System/procstat.htm So sieht es bei meiner 4-adrigen Box aus:

Anderson cxc #  more /proc/stat
cpu  2329889 0 2364567 1063530460 9034 9463 96111 0
cpu0 572526 0 636532 265864398 2928 1621 6899 0
cpu1 590441 0 531079 265949732 4763 351 8522 0
cpu2 562983 0 645163 265796890 682 7490 71650 0
cpu3 603938 0 551790 265919440 660 0 9040 0
intr 37124247
ctxt 50795173133
btime 1218807985
processes 116889
procs_running 1
procs_blocked 0

Zunächst müssen Sie feststellen, wie viele CPUs (oder Prozessoren bzw. Prozessorkerne) im System verfügbar sind. Dazu zählen Sie die Anzahl der 'cpuN'-Einträge, wobei N bei 0 beginnt und inkrementiert. Zählen Sie nicht die 'cpu'-Zeile, die eine Kombination aus den 'cpuN'-Zeilen ist. In meinem Beispiel sehen Sie cpu0 bis cpu3, also insgesamt 4 Prozessoren. Von nun an können Sie cpu0..cpu3 ignorieren und sich nur auf die 'cpu'-Zeile konzentrieren.

Als Nächstes müssen Sie wissen, dass die vierte Zahl in diesen Zeilen ein Maß für die Leerlaufzeit ist, und daher ist die vierte Zahl in der Zeile "cpu" die gesamte Leerlaufzeit für alle Prozessoren seit dem Start. Diese Zeit wird in Linux-"Jiffies" gemessen, die jeweils 1/100 einer Sekunde betragen.

Aber Sie interessieren sich nicht für die gesamte Leerlaufzeit, sondern für die Leerlaufzeit in einem bestimmten Zeitraum, z. B. in der letzten Sekunde. Um das zu berechnen, müssen Sie diese Datei zweimal im Abstand von 1 Sekunde lesen und dann den vierten Wert der Zeile vergleichen. Zum Beispiel, wenn Sie eine Probe nehmen und erhalten:

cpu  2330047 0 2365006 1063853632 9035 9463 96114 0

Eine Sekunde später erhalten Sie diese Probe:

cpu  2330047 0 2365007 1063854028 9035 9463 96114 0

Subtrahiert man die beiden Zahlen, erhält man einen Wert von 396, was bedeutet, dass die CPU in den letzten 1,00 Sekunden 3,96 Sekunden lang im Leerlauf war. Der Trick ist natürlich, dass Sie durch die Anzahl der Prozessoren dividieren müssen. 3,96 / 4 = 0,99, und das ist der Prozentsatz des Leerlaufs: 99 % Leerlauf und 1 % belegt.

In meinem Code habe ich einen Ringspeicher mit 360 Einträgen, und ich lese diese Datei jede Sekunde. So kann ich schnell die CPU-Auslastung für 1 Sekunde, 10 Sekunden usw. bis hin zu 1 Stunde berechnen.

Die prozessspezifischen Informationen finden Sie unter /proc/pid Wenn Sie sich nicht um Ihre pid kümmern, können Sie in /proc/self nachsehen.

Die von Ihrem Prozess verwendete CPU ist verfügbar unter /proc/self/stat . Dies ist eine seltsam aussehende Datei, die aus einer einzigen Zeile besteht; zum Beispiel:

19340 (whatever) S 19115 19115 3084 34816 19115 4202752 118200 607 0 0 770 384 2
 7 20 0 77 0 266764385 692477952 105074 4294967295 134512640 146462952 321468364
8 3214683328 4294960144 0 2147221247 268439552 1276 4294967295 0 0 17 0 0 0 0

Die wichtigen Daten sind hier das 13. und 14. Token (hier 0 und 770). Das 13. Token ist die Anzahl der Jiffies, die der Prozess im Benutzermodus ausgeführt hat, und das 14. ist die Anzahl der Jiffies, die der Prozess im Kernelmodus ausgeführt hat. Addiert man diese beiden Werte, erhält man die gesamte CPU-Auslastung des Prozesses.

Auch hier müssen Sie diese Datei in regelmäßigen Abständen abfragen und die Differenz berechnen, um die CPU-Auslastung des Prozesses im Laufe der Zeit zu ermitteln.

Edita: Denken Sie daran, dass Sie bei der Berechnung der CPU-Auslastung Ihres Prozesses 1) die Anzahl der Threads in Ihrem Prozess und 2) die Anzahl der Prozessoren im System berücksichtigen müssen. Wenn Ihr Single-Thread-Prozess beispielsweise nur 25 % der CPU nutzt, kann das gut oder schlecht sein. Gut auf einem Einprozessorsystem, aber schlecht auf einem 4-Prozessor-System; das bedeutet, dass Ihr Prozess ständig läuft und 100% der ihm zur Verfügung stehenden CPU-Zyklen nutzt.

Für die prozessspezifischen Speicherinformationen müssen Sie sich /proc/self/status ansehen, das wie folgt aussieht

Name:   whatever
State:  S (sleeping)
Tgid:   19340
Pid:    19340
PPid:   19115
TracerPid:      0
Uid:    0       0       0       0
Gid:    0       0       0       0
FDSize: 256
Groups: 0 1 2 3 4 6 10 11 20 26 27
VmPeak:   676252 kB
VmSize:   651352 kB
VmLck:         0 kB
VmHWM:    420300 kB
VmRSS:    420296 kB
VmData:   581028 kB
VmStk:       112 kB
VmExe:     11672 kB
VmLib:     76608 kB
VmPTE:      1244 kB
Threads:        77
SigQ:   0/36864
SigPnd: 0000000000000000
ShdPnd: 0000000000000000
SigBlk: fffffffe7ffbfeff
SigIgn: 0000000010001000
SigCgt: 20000001800004fc
CapInh: 0000000000000000
CapPrm: 00000000ffffffff
CapEff: 00000000fffffeff
Cpus_allowed:   0f
Mems_allowed:   1
voluntary_ctxt_switches:        6518
nonvoluntary_ctxt_switches:     6598

Die Einträge, die mit "Vm" beginnen, sind die interessanten:

• VmPeak ist der maximale virtuelle Speicherplatz, den der Prozess verwendet, in kB (1024 Bytes).
• VmSize ist der aktuelle virtuelle Speicherplatz, der vom Prozess verwendet wird, in kB. In meinem Beispiel ist er ziemlich groß: 651.352 kB, also etwa 636 Megabyte.
• VmRss ist die Menge des Speichers, die in den Adressraum des Prozesses eingeblendet wurde, oder die Größe der residenten Gruppe. Diese ist wesentlich kleiner (420.296 kB, oder etwa 410 Megabyte). Der Unterschied: Mein Programm hat 636 MB über mmap() abgebildet, aber nur 410 MB davon abgerufen, und daher wurden ihm nur 410 MB an Seiten zugewiesen.

Der einzige Punkt, bei dem ich mir nicht sicher bin, ist Derzeit von meinem Prozess genutzter Swapspace . Ich weiß nicht, ob das verfügbar ist.

Answer 4

Linux

Ein portabler Weg zum Lesen von Speicher- und Lastnummern ist die sysinfo aufrufen

Verwendung

   #include <sys/sysinfo.h>

   int sysinfo(struct sysinfo *info);

BESCHREIBUNG

   Until Linux 2.3.16, sysinfo() used to return information in the
   following structure:

       struct sysinfo {
           long uptime;             /* Seconds since boot */
           unsigned long loads[3];  /* 1, 5, and 15 minute load averages */
           unsigned long totalram;  /* Total usable main memory size */
           unsigned long freeram;   /* Available memory size */
           unsigned long sharedram; /* Amount of shared memory */
           unsigned long bufferram; /* Memory used by buffers */
           unsigned long totalswap; /* Total swap space size */
           unsigned long freeswap;  /* swap space still available */
           unsigned short procs;    /* Number of current processes */
           char _f[22];             /* Pads structure to 64 bytes */
       };

   and the sizes were given in bytes.

   Since Linux 2.3.23 (i386), 2.3.48 (all architectures) the structure
   is:

       struct sysinfo {
           long uptime;             /* Seconds since boot */
           unsigned long loads[3];  /* 1, 5, and 15 minute load averages */
           unsigned long totalram;  /* Total usable main memory size */
           unsigned long freeram;   /* Available memory size */
           unsigned long sharedram; /* Amount of shared memory */
           unsigned long bufferram; /* Memory used by buffers */
           unsigned long totalswap; /* Total swap space size */
           unsigned long freeswap;  /* swap space still available */
           unsigned short procs;    /* Number of current processes */
           unsigned long totalhigh; /* Total high memory size */
           unsigned long freehigh;  /* Available high memory size */
           unsigned int mem_unit;   /* Memory unit size in bytes */
           char _f[20-2*sizeof(long)-sizeof(int)]; /* Padding to 64 bytes */
       };

   and the sizes are given as multiples of mem_unit bytes.

Answer 5

Unter Windows können Sie die CPU-Auslastung mit folgendem Code ermitteln:

#include <windows.h>
#include <stdio.h>

//------------------------------------------------------------------------------------------------------------------
// Prototype(s)...
//------------------------------------------------------------------------------------------------------------------
CHAR cpuusage(void);

//-----------------------------------------------------
typedef BOOL ( __stdcall * pfnGetSystemTimes)( LPFILETIME lpIdleTime, LPFILETIME lpKernelTime, LPFILETIME lpUserTime );
static pfnGetSystemTimes s_pfnGetSystemTimes = NULL;

static HMODULE s_hKernel = NULL;
//-----------------------------------------------------
void GetSystemTimesAddress()
{
    if(s_hKernel == NULL)
    {
        s_hKernel = LoadLibrary(L"Kernel32.dll");
        if(s_hKernel != NULL)
        {
            s_pfnGetSystemTimes = (pfnGetSystemTimes)GetProcAddress(s_hKernel, "GetSystemTimes");
            if(s_pfnGetSystemTimes == NULL)
            {
                FreeLibrary(s_hKernel);
                s_hKernel = NULL;
            }
        }
    }
}
//----------------------------------------------------------------------------------------------------------------

//----------------------------------------------------------------------------------------------------------------
// cpuusage(void)
// ==============
// Return a CHAR value in the range 0 - 100 representing actual CPU usage in percent.
//----------------------------------------------------------------------------------------------------------------
CHAR cpuusage()
{
    FILETIME               ft_sys_idle;
    FILETIME               ft_sys_kernel;
    FILETIME               ft_sys_user;

    ULARGE_INTEGER         ul_sys_idle;
    ULARGE_INTEGER         ul_sys_kernel;
    ULARGE_INTEGER         ul_sys_user;

    static ULARGE_INTEGER     ul_sys_idle_old;
    static ULARGE_INTEGER  ul_sys_kernel_old;
    static ULARGE_INTEGER  ul_sys_user_old;

    CHAR usage = 0;

    // We cannot directly use GetSystemTimes in the C language
    /* Add this line :: pfnGetSystemTimes */
    s_pfnGetSystemTimes(&ft_sys_idle,    /* System idle time */
        &ft_sys_kernel,  /* system kernel time */
        &ft_sys_user);   /* System user time */

    CopyMemory(&ul_sys_idle  , &ft_sys_idle  , sizeof(FILETIME)); // Could been optimized away...
    CopyMemory(&ul_sys_kernel, &ft_sys_kernel, sizeof(FILETIME)); // Could been optimized away...
    CopyMemory(&ul_sys_user  , &ft_sys_user  , sizeof(FILETIME)); // Could been optimized away...

    usage  =
        (
        (
        (
        (
        (ul_sys_kernel.QuadPart - ul_sys_kernel_old.QuadPart)+
        (ul_sys_user.QuadPart   - ul_sys_user_old.QuadPart)
        )
        -
        (ul_sys_idle.QuadPart-ul_sys_idle_old.QuadPart)
        )
        *
        (100)
        )
        /
        (
        (ul_sys_kernel.QuadPart - ul_sys_kernel_old.QuadPart)+
        (ul_sys_user.QuadPart   - ul_sys_user_old.QuadPart)
        )
        );

    ul_sys_idle_old.QuadPart   = ul_sys_idle.QuadPart;
    ul_sys_user_old.QuadPart   = ul_sys_user.QuadPart;
    ul_sys_kernel_old.QuadPart = ul_sys_kernel.QuadPart;

    return usage;
}

//------------------------------------------------------------------------------------------------------------------
// Entry point
//------------------------------------------------------------------------------------------------------------------
int main(void)
{
    int n;
    GetSystemTimesAddress();
    for(n=0; n<20; n++)
    {
        printf("CPU Usage: %3d%%\r", cpuusage());
        Sleep(2000);
    }
    printf("\n");
    return 0;
}