it-swarm-eu.dev

Wie bestimme ich den CPU- und Speicherverbrauch innerhalb eines Prozesses?

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

  • Insgesamt verfügbarer virtueller Speicher
  • Derzeit verwendeter virtueller Speicher
  • Virtueller Speicher, der derzeit von meinem Prozess verwendet wird
  • Gesamt RAM verfügbar
  • Derzeit verwendeter RAM
  • Derzeit von meinem Prozess verwendeter Arbeitsspeicher
  • % CPU derzeit verwendet
  • % CPU wird derzeit von meinem Prozess verwendet

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

Um zu verhindern, dass andere die gleichen Probleme haben, hielt ich es für eine gute Idee, alle verstreuten Informationen und die durch Ausprobieren gefundenen Informationen an einem Ort zu sammeln.

542
Lanzelot

Windows

Einige der oben genannten Werte sind in der entsprechenden WIN32-API leicht verfügbar. Der Vollständigkeit halber liste ich sie hier auf. Andere müssen jedoch über die Performance Data Helper-Bibliothek (PDH) bezogen werden, die ein bisschen "unintuitiv" ist und eine Menge mühsamer Versuche und Irrtümer erfordert, um an die Arbeit zu gelangen. (Zumindest hat es eine Weile gedauert, vielleicht war ich nur ein bisschen dumm ...)

Hinweis: Aus Gründen der Übersichtlichkeit wurde die Fehlerprüfung im folgenden Code weggelassen. Überprüfen Sie die Rückkehrcodes ...!


  • Virtueller Gesamtspeicher:

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

    Hinweis: Der Name "TotalPageFile" ist hier etwas irreführend. In Wirklichkeit gibt dieser Parameter die "Größe des virtuellen Speichers" an, dh die Größe der Auslagerungsdatei plus des installierten Arbeitsspeichers.

  • Derzeit verwendeter virtueller Speicher:

    Gleicher Code wie in "Total Virtual Memory" und dann

    DWORDLONG virtualMemUsed = memInfo.ullTotalPageFile - memInfo.ullAvailPageFile;
    
  • Derzeit vom aktuellen Prozess verwendeter virtueller Speicher:

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



  • Gesamter physischer Speicher (RAM):

    Gleicher Code wie in "Total Virtual Memory" und dann

    DWORDLONG totalPhysMem = memInfo.ullTotalPhys;
    
  • Derzeit verwendeter physischer Speicher:

    Same code as in "Total Virtual Memory" and then
    
    DWORDLONG physMemUsed = memInfo.ullTotalPhys - memInfo.ullAvailPhys;
    
  • Physischer Speicher, der derzeit vom aktuellen Prozess verwendet wird:

    Gleicher Code wie unter "Derzeit vom aktuellen Prozess verwendeter virtueller Speicher" und dann

    SIZE_T physMemUsedByMe = pmc.WorkingSetSize;
    



  • CPU derzeit verwendet:

    #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;
    }
    
  • Derzeit vom aktuellen Prozess verwendete CPU:

    #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 lag die Wahl zunächst auf der Hand, POSIX-APIs wie getrusage() usw. zu verwenden. Ich habe einige Zeit damit verbracht, dies zum Laufen zu bringen, aber keine aussagekräftigen Werte erhalten. Als ich schließlich die Kernelquellen selbst überprüfte, stellte ich fest, dass diese APIs anscheinend ab Linux-Kernel 2.6 noch nicht vollständig implementiert sind !?

Am Ende habe ich alle Werte durch eine Kombination aus Lesen des Pseudo-Dateisystems /proc und Kernel-Aufrufen erhalten.

  • Virtueller Gesamtspeicher:

    #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 in "Total Virtual Memory" 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;
    
  • Derzeit vom aktuellen Prozess verwendeter virtueller Speicher:

    #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 in "Total Virtual Memory" 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 in "Total Virtual Memory" 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 "Derzeit vom aktuellen Prozess verwendeter virtueller Speicher" 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;
    }
    



  • CPU derzeit verwendet:

    #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;
    }
    
  • Derzeit vom aktuellen Prozess verwendete CPU:

    #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 annehmen, dass ein Teil des Linux-Codes auch für die Unixe funktioniert, mit Ausnahme der Teile, die das/proc-Pseudodateisystem lesen. Vielleicht können diese Teile unter Unix durch getrusage() und ähnliche Funktionen ersetzt werden? Wenn jemand mit Unix-Know-how diese Antwort bearbeiten und die Details eintragen könnte ?!

600
Lanzelot

Mac OS X

Ich hatte gehofft, ähnliche Informationen auch für Mac OS X zu finden. Da es nicht hier war, ging ich raus und grub es selbst aus. Hier sind einige der Dinge, die ich gefunden habe. Wenn jemand andere Vorschläge hat, würde ich sie gerne hören.

Virtueller Gesamtspeicher

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

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

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

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

Summe der aktuell genutzten virtuellen Ressourcen

Wenn Sie systcl mit der Taste "vm.swapusage" aufrufen, erhalten Sie interessante Informationen zur Swap-Verwendung:

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

Nicht, dass sich die hier angezeigte Gesamtswap-Nutzung ändern kann, wenn mehr Swap erforderlich ist, wie im obigen Abschnitt erläutert. Die Summe ist also tatsächlich die aktuelle Swap-Summe. In C++ können diese Daten folgendermaßen 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 in sysctl.h deklarierte "xsw_usage" nicht dokumentiert zu sein scheint und ich vermute, dass es eine portablere Möglichkeit gibt, auf diese Werte zuzugreifen.

Virtueller Speicher, der derzeit von meinem Prozess verwendet wird

Mit der Funktion task_info können Sie Statistiken über Ihren aktuellen Prozess abrufen. Dies schließt die aktuelle Größe Ihres Prozesses und die aktuelle virtuelle Größe ein.

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

Gesamt RAM verfügbar

Die Menge an physischem RAM, die in Ihrem System verfügbar ist, kann mit der Systemfunktion sysctl wie folgt ermittelt werden:

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

RAM Derzeit verwendet

Sie können allgemeine Speicherstatistiken über die Systemfunktion Host_statistics abrufen.

#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;
}

Hierbei ist zu beachten, dass es in Mac OS X fünf Arten von Speicherseiten gibt. Diese lauten wie folgt:

  1. Verkabelt Seiten, die an Ort und Stelle gesperrt sind und nicht ausgetauscht werden können
  2. Aktiv Seiten, die in den physischen Speicher geladen werden und relativ schwer auszutauschen sind
  3. Inaktiv Seiten, die in den Speicher geladen, aber in letzter Zeit nicht verwendet wurden und möglicherweise überhaupt nicht benötigt werden. Dies sind potenzielle Kandidaten für den Austausch. Dieser Speicher müsste wahrscheinlich gelöscht werden.
  4. zwischengespeichert Seiten, die in gewisser Weise zwischengespeichert wurden und wahrscheinlich leicht wiederverwendet werden können. Der zwischengespeicherte Speicher muss wahrscheinlich nicht geleert werden. Zwischengespeicherte Seiten können weiterhin reaktiviert werden
  5. Free Seiten, die komplett kostenlos und einsatzbereit sind.

Es ist zu beachten, dass Mac OS X unter Umständen nur sehr wenig freien Arbeitsspeicher aufweist und daher möglicherweise nicht aussagekräftig ist, wie viel davon kurzfristig verwendet werden kann.

RAM Wird derzeit von meinem Prozess verwendet

Siehe "Virtueller Speicher, der derzeit von meinem Prozess verwendet wird" oben. Der gleiche Code gilt.

136
Michael Taylor

Linux

Unter Linux stehen diese Informationen im Dateisystem/proc zur Verfügung. Ich bin kein großer Fan des verwendeten Textdateiformats, da jede Linux-Distribution anscheinend mindestens eine wichtige Datei anpasst. Ein kurzer Blick als Quelle für 'ps' zeigt das Durcheinander.

Hier finden Sie die gewünschten Informationen:

/proc/meminfo enthält den Großteil der systemweiten Informationen, die Sie suchen. Hier sieht es auf meinem System so aus; Ich denke, Sie interessieren sich für 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 ein wenig arbeiten. Linux stellt die gesamte CPU-Auslastung seit dem Systemstart zur Verfügung. Dies ist wahrscheinlich nicht das, woran Sie interessiert sind. Wenn Sie wissen möchten, wie hoch die CPU-Auslastung in der letzten Sekunde oder in 10 Sekunden war, müssen Sie die Informationen abfragen und selbst berechnen.

Die Informationen sind in /proc/stat verfügbar, was unter http://www.linuxhowtos.org/System/) ziemlich gut dokumentiert ist. procstat.htm ; So sieht es auf meiner 4-Kern-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 ermitteln, wie viele CPUs (oder Prozessoren oder Prozessorkerne) im System verfügbar sind. Zählen Sie dazu die Anzahl der 'cpuN'-Einträge, wobei N bei 0 beginnt und inkrementiert. Zählen Sie nicht die 'cpu'-Zeile, die eine Kombination der cpuN-Zeilen ist. In meinem Beispiel sehen Sie cpu0 bis cpu3 für insgesamt 4 Prozessoren. Von nun an können Sie cpu0..cpu3 ignorieren und sich nur noch 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 'CPU'-Zeile die gesamte Leerlaufzeit für alle Prozessoren seit der Startzeit. Diese Zeit wird in Linux "jiffies" gemessen, die jeweils 1/100 Sekunde betragen.

Die gesamte Leerlaufzeit interessiert Sie jedoch nicht. Sie interessieren sich für die Leerlaufzeit in einem bestimmten Zeitraum, z. B. der letzten Sekunde. Berechnen Sie das, Sie müssen diese Datei zweimal im Abstand von 1 Sekunde lesen. Dann können Sie einen Unterschied zum vierten Wert der Zeile machen. Wenn Sie beispielsweise eine Probe entnehmen und Folgendes erhalten:

cpu  2330047 0 2365006 1063853632 9035 9463 96114 0

Dann eine Sekunde später erhalten Sie dieses Beispiel:

cpu  2330047 0 2365007 1063854028 9035 9463 96114 0

Wenn Sie die beiden Zahlen subtrahieren, erhalten Sie eine Differenz von 396, was bedeutet, dass Ihre CPU von den letzten 1,00 Sekunden 3,96 Sekunden im Leerlauf war. Der Trick ist natürlich, dass Sie durch die Anzahl der Prozessoren dividieren müssen. 3,96/4 = 0,99, und es gibt Ihren Leerlaufprozentsatz; 99% im Leerlauf und 1% beschäftigt.

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

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

Die von Ihrem Prozess verwendete CPU ist in /proc/self/stat verfügbar. Dies ist eine seltsam aussehende Datei, die aus einer einzelnen 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 die 13. und 14. Marke (hier 0 und 770). Das 13. Token ist die Anzahl der Warteschlangen, die der Prozess im Benutzermodus ausgeführt hat, und das 14. Token ist die Anzahl der Warteschlangen, die der Prozess im Kernelmodus ausgeführt hat. Addieren Sie die beiden Werte und Sie haben die gesamte CPU-Auslastung.

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

Bearbeiten: 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 Threads berücksichtigen müssen Anzahl der Prozessoren im System. Wenn Ihr Single-Thread-Prozess beispielsweise nur 25% der CPU beansprucht, kann dies gut oder schlecht sein. Gut auf einem System mit einem Prozessor, aber schlecht auf einem System mit vier Prozessoren. Dies bedeutet, dass Ihr Prozess ständig ausgeführt wird und 100% der ihm zur Verfügung stehenden CPU-Zyklen verwendet.

Für die prozessspezifischen Speicherinformationen müssen Sie sich/proc/self/status ansehen, was so 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 interessantesten:

  • VmPeak ist der maximale vom Prozess belegte virtuelle Speicherplatz in kB (1024 Byte).
  • VmSize ist der aktuell vom Prozess verwendete virtuelle Speicherplatz in kB. In meinem Beispiel ist es ziemlich groß: 651.352 kB oder ungefähr 636 Megabyte.
  • VmRss ist die Speicherkapazität, die dem Adressraum des Prozesses oder seiner residenten Satzgröße zugeordnet wurde. Dies ist wesentlich kleiner (420.296 kB oder etwa 410 Megabyte). Der Unterschied: Mein Programm hat 636 MB über mmap () zugeordnet, hat jedoch nur auf 410 MB davon zugegriffen, sodass ihm nur 410 MB Seiten zugewiesen wurden.

Der einzige Punkt, bei dem ich mir nicht sicher bin, ist Swapspace, der derzeit von meinem Prozess verwendet wird . Ich weiß nicht, ob dies verfügbar ist.

63

In Windows können Sie die CPU-Auslastung durch folgenden Code erhalten:

#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 on 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;
    }
12

Linux

Eine tragbare Methode zum Lesen von Speicher- und Ladezahlen ist der Aufruf sysinfo

Verwendungszweck

   #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.
11
Mark Lakata

QNX

Da dies wie eine "Wiki-Seite mit Code" ist, möchte ich Code aus der QNX Knowledge Base hinzufügen (Hinweis: Dies ist nicht meine Arbeit, aber ich habe es überprüft und es funktioniert einwandfrei auf meinem System):

So erhalten Sie die CPU-Auslastung in%: http://www.qnx.com/support/knowledgebase.html?id=50130000000P9b5

#include <atomic.h>
#include <libc.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/iofunc.h>
#include <sys/neutrino.h>
#include <sys/resmgr.h>
#include <sys/syspage.h>
#include <unistd.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/debug.h>
#include <sys/procfs.h>
#include <sys/syspage.h>
#include <sys/neutrino.h>
#include <sys/time.h>
#include <time.h>
#include <fcntl.h>
#include <devctl.h>
#include <errno.h>

#define MAX_CPUS 32

static float Loads[MAX_CPUS];
static _uint64 LastSutime[MAX_CPUS];
static _uint64 LastNsec[MAX_CPUS];
static int ProcFd = -1;
static int NumCpus = 0;


int find_ncpus(void) {
    return NumCpus;
}

int get_cpu(int cpu) {
    int ret;
    ret = (int)Loads[ cpu % MAX_CPUS ];
    ret = max(0,ret);
    ret = min(100,ret);
    return( ret );
}

static _uint64 nanoseconds( void ) {
    _uint64 sec, usec;
    struct timeval tval;
    gettimeofday( &tval, NULL );
    sec = tval.tv_sec;
    usec = tval.tv_usec;
    return( ( ( sec * 1000000 ) + usec ) * 1000 );
}

int sample_cpus( void ) {
    int i;
    debug_thread_t debug_data;
    _uint64 current_nsec, sutime_delta, time_delta;
    memset( &debug_data, 0, sizeof( debug_data ) );

    for( i=0; i<NumCpus; i++ ) {
        /* Get the sutime of the idle thread #i+1 */
        debug_data.tid = i + 1;
        devctl( ProcFd, DCMD_PROC_TIDSTATUS,
        &debug_data, sizeof( debug_data ), NULL );
        /* Get the current time */
        current_nsec = nanoseconds();
        /* Get the deltas between now and the last samples */
        sutime_delta = debug_data.sutime - LastSutime[i];
        time_delta = current_nsec - LastNsec[i];
        /* Figure out the load */
        Loads[i] = 100.0 - ( (float)( sutime_delta * 100 ) / (float)time_delta );
        /* Flat out strange rounding issues. */
        if( Loads[i] < 0 ) {
            Loads[i] = 0;
        }
        /* Keep these for reference in the next cycle */
        LastNsec[i] = current_nsec;
        LastSutime[i] = debug_data.sutime;
    }
    return EOK;
}

int init_cpu( void ) {
    int i;
    debug_thread_t debug_data;
    memset( &debug_data, 0, sizeof( debug_data ) );
/* Open a connection to proc to talk over.*/
    ProcFd = open( "/proc/1/as", O_RDONLY );
    if( ProcFd == -1 ) {
        fprintf( stderr, "pload: Unable to access procnto: %s\n",strerror( errno ) );
        fflush( stderr );
        return -1;
    }
    i = fcntl(ProcFd,F_GETFD);
    if(i != -1){
        i |= FD_CLOEXEC;
        if(fcntl(ProcFd,F_SETFD,i) != -1){
            /* Grab this value */
            NumCpus = _syspage_ptr->num_cpu;
            /* Get a starting point for the comparisons */
            for( i=0; i<NumCpus; i++ ) {
                /*
                * the sutime of idle thread is how much
                * time that thread has been using, we can compare this
                * against how much time has passed to get an idea of the
                * load on the system.
                */
                debug_data.tid = i + 1;
                devctl( ProcFd, DCMD_PROC_TIDSTATUS, &debug_data, sizeof( debug_data ), NULL );
                LastSutime[i] = debug_data.sutime;
                LastNsec[i] = nanoseconds();
            }
            return(EOK);
        }
    }
    close(ProcFd);
    return(-1);
}

void close_cpu(void){
    if(ProcFd != -1){
        close(ProcFd);
        ProcFd = -1;
    }
}

int main(int argc, char* argv[]){
    int i,j;
    init_cpu();
    printf("System has: %d CPUs\n", NumCpus);
    for(i=0; i<20; i++) {
        sample_cpus();
        for(j=0; j<NumCpus;j++)
        printf("CPU #%d: %f\n", j, Loads[j]);
        sleep(1);
    }
    close_cpu();
}

So erhalten Sie den freien (!) Speicher: http://www.qnx.com/support/knowledgebase.html?id=50130000000mlbx

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <err.h>
#include <sys/stat.h>
#include <sys/types.h>

int main( int argc, char *argv[] ){
    struct stat statbuf;
    paddr_t freemem;
    stat( "/proc", &statbuf );
    freemem = (paddr_t)statbuf.st_size;
    printf( "Free memory: %d bytes\n", freemem );
    printf( "Free memory: %d KB\n", freemem / 1024 );
    printf( "Free memory: %d MB\n", freemem / ( 1024 * 1024 ) );
    return 0;
} 
3
Boernii

Mac OS X - CPU

Allgemeine CPU-Auslastung:

Von Systeminformationen unter MacOS X abrufen? :

#include <mach/mach_init.h>
#include <mach/mach_error.h>
#include <mach/mach_Host.h>
#include <mach/vm_map.h>

static unsigned long long _previousTotalTicks = 0;
static unsigned long long _previousIdleTicks = 0;

// Returns 1.0f for "CPU fully pinned", 0.0f for "CPU idle", or somewhere in between
// You'll need to call this at regular intervals, since it measures the load between
// the previous call and the current one.
float GetCPULoad()
{
   Host_cpu_load_info_data_t cpuinfo;
   mach_msg_type_number_t count = Host_CPU_LOAD_INFO_COUNT;
   if (Host_statistics(mach_Host_self(), Host_CPU_LOAD_INFO, (Host_info_t)&cpuinfo, &count) == KERN_SUCCESS)
   {
      unsigned long long totalTicks = 0;
      for(int i=0; i<CPU_STATE_MAX; i++) totalTicks += cpuinfo.cpu_ticks[i];
      return CalculateCPULoad(cpuinfo.cpu_ticks[CPU_STATE_IDLE], totalTicks);
   }
   else return -1.0f;
}

float CalculateCPULoad(unsigned long long idleTicks, unsigned long long totalTicks)
{
  unsigned long long totalTicksSinceLastTime = totalTicks-_previousTotalTicks;
  unsigned long long idleTicksSinceLastTime  = idleTicks-_previousIdleTicks;
  float ret = 1.0f-((totalTicksSinceLastTime > 0) ? ((float)idleTicksSinceLastTime)/totalTicksSinceLastTime : 0);
  _previousTotalTicks = totalTicks;
  _previousIdleTicks  = idleTicks;
  return ret;
}
1
souch

Für Linux Sie können auch/proc/self/statm verwenden, um eine einzelne Zeile mit Zahlen abzurufen, die wichtige Informationen zum Prozessspeicher enthält. Diese sind schneller zu verarbeiten als eine lange Liste der gemeldeten Informationen, die Sie aus proc/self/status abrufen

Siehe http://man7.org/linux/man-pages/man5/proc.5.html

   /proc/[pid]/statm
          Provides information about memory usage, measured in pages.
          The columns are:

              size       (1) total program size
                         (same as VmSize in /proc/[pid]/status)
              resident   (2) resident set size
                         (same as VmRSS in /proc/[pid]/status)
              shared     (3) number of resident shared pages (i.e., backed by a file)
                         (same as RssFile+RssShmem in /proc/[pid]/status)
              text       (4) text (code)
              lib        (5) library (unused since Linux 2.6; always 0)
              data       (6) data + stack
              dt         (7) dirty pages (unused since Linux 2.6; always 0)
0
Steven Warner

Ich habe diesen folgenden Code in meinem C++ - Projekt verwendet und es hat gut funktioniert:

static HANDLE self;
static int numProcessors;
SYSTEM_INFO sysInfo;

double percent;

numProcessors = sysInfo.dwNumberOfProcessors;

//Getting system times information
FILETIME SysidleTime;
FILETIME SyskernelTime; 
FILETIME SysuserTime; 
ULARGE_INTEGER SyskernelTimeInt, SysuserTimeInt;
GetSystemTimes(&SysidleTime, &SyskernelTime, &SysuserTime);
memcpy(&SyskernelTimeInt, &SyskernelTime, sizeof(FILETIME));
memcpy(&SysuserTimeInt, &SysuserTime, sizeof(FILETIME));
__int64 denomenator = SysuserTimeInt.QuadPart + SyskernelTimeInt.QuadPart;  

//Getting process times information
FILETIME ProccreationTime, ProcexitTime, ProcKernelTime, ProcUserTime;
ULARGE_INTEGER ProccreationTimeInt, ProcexitTimeInt, ProcKernelTimeInt, ProcUserTimeInt;
GetProcessTimes(self, &ProccreationTime, &ProcexitTime, &ProcKernelTime, &ProcUserTime);
memcpy(&ProcKernelTimeInt, &ProcKernelTime, sizeof(FILETIME));
memcpy(&ProcUserTimeInt, &ProcUserTime, sizeof(FILETIME));
__int64 numerator = ProcUserTimeInt.QuadPart + ProcKernelTimeInt.QuadPart;
//QuadPart represents a 64-bit signed integer (ULARGE_INTEGER)

percent = 100*(numerator/denomenator);
0
Salman Ghaffar