Wie, um zu bestimmen, CPU-und Speicher-Verbrauch von innerhalb eines Prozesses?

Ich hatte einmal die Aufgabe bestimmen Sie die folgenden performance-Parameter aus einer Laufenden Anwendung:

Gesamter virtueller Speicher zur Verfügung
Virtuellen Speicher derzeit verwendet
Virtuellen Speicher, der aktuell von meinem Prozess
Gesamt-RAM zur Verfügung
RAM derzeit verwendet
RAM, der aktuell von meinem Prozess
% CPU derzeit verwendet
% CPU-Zeit von meinem Prozess

War der code für die Ausführung auf Windows und Linux. Obwohl dies scheint eine standard-Aufgabe, das finden der notwendigen Informationen in den Handbüchern (WIN32-API, GNU docs) sowie auf das Internet hat mich mehrere Tage, weil es so viel unvollständige/fehlerhafte/veraltete Informationen zu diesem Thema zu finden gibt.

Um andere zu retten, gehen durch das gleiche Problem, ich dachte, es wäre eine gute Idee alle zu sammeln die verstreuten Informationen plus das, was ich durch Versuch und Irrtum gefunden, die hier in einem Ort.

"Gesamter virtueller Speicher verfügbar" ist sinnlos auf moderne Betriebssysteme.
Warum ist es sinnlos? Es tut erlischt die Antwort hier? stackoverflow.com/questions/3296211/... ... bitte nicht verlassen Cliffhanger, wenn zu kommentieren, es ist nicht eine TV-show.
Die Frage ist in etwa "total physical memory", das ist ein hardware bekannte Tatsache das OS. Sie bekommen die Summe, die durch addieren der Größen der alle Speicher-Module. "Gesamter virtueller Speicher verfügbar", auf der anderen Seite, was bedeutet das überhaupt? Ist, dass die Kombination von virtueller Adressraum aller Prozesse, die theoretisch erzeugt werden könnte? Diese Zahl würde um die 2^80 Byte, so dass sicherlich bedeutungslos.
danke für den Eingriff. Ich glaube, die Frage, was der OP im Sinn hatte, ist viel schonender und gesünder als die besagt, dass etwas sinnlos ist (w/o Erklärung). Wenn Sie beachten Sie, die Antworten sind auch unter der Annahme einer bestimmten position in Bezug auf diese: Virtueller Speicher = RAM + SWAP (oder AUSLAGERUNGSDATEI) - das ist eine vernünftige Annahme. Von diesem wissen wir, dass es nicht sinnlos, denn es ist insbesondere die Auslegung dieses Begriffes (die vielleicht nicht die technisch korrekte, colloquelism), das Sinn hat.
Ignoriert, dass memory-mapped-Dateien und code, der nicht ausgelagert. Linux ist nicht verpflichtet Speicherzuordnungen (nicht unterstützt von RAM oder swap) und Windows ist nicht verpflichtet stapeln.

InformationsquelleAutor Lanzelot | 2008-09-15

c c++cpu memory

551

Windows

Einige der oben genannten Werte sind leicht aus den entsprechenden WIN32-API, ich Liste Sie hier der Vollständigkeit halber aufgeführt. Andere jedoch müssen die aus der Performance Data Helper library (PDH), die ist etwas "unintuitiv" und nimmt eine Menge von schmerzhaften Versuch und Irrtum zu arbeiten. (Zumindest ist es mir dauerte eine ganze Weile, vielleicht habe ich es nur ein bisschen blöd...)

Hinweis: für Klarheit alle Fehler überprüft wurde, entfällt ab dem folgenden code. Sie überprüfen die return-codes...!

Gesamter Virtueller Speicher:
```
#include "windows.h"

MEMORYSTATUSEX memInfo;
memInfo.dwLength = sizeof(MEMORYSTATUSEX);
GlobalMemoryStatusEx(&memInfo);
DWORDLONG totalVirtualMem = memInfo.ullTotalPageFile;
```
Hinweis: Der name "TotalPageFile" ist ein bisschen irreführend hier. In Wirklichkeit ist dieser parameter gibt die "Virtual Memory Size", was die Größe der swap-Datei plus RAM installiert.
Virtuellen Speicher derzeit verwendet:

Gleichen code wie in "gesamter Virtueller Speicher" und dann
```
DWORDLONG virtualMemUsed = memInfo.ullTotalPageFile - memInfo.ullAvailPageFile;
```

Virtuellen Speicher, die derzeit bei den aktuellen Prozess:

#include "windows.h"
#include "psapi.h"

PROCESS_MEMORY_COUNTERS_EX pmc;
GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc));
SIZE_T virtualMemUsedByMe = pmc.PrivateUsage;

Gesamten Physischen Speicher (RAM):

Gleichen code wie in "gesamter Virtueller Speicher" und dann
```
DWORDLONG totalPhysMem = memInfo.ullTotalPhys;
```

Physischen Speicher derzeit verwendet:

Same code as in "Total Virtual Memory" and then

DWORDLONG physMemUsed = memInfo.ullTotalPhys - memInfo.ullAvailPhys;

Physikalischen Speicher, die derzeit bei den aktuellen Prozess:

Gleichen code wie in der "Virtuellen Speicher, die derzeit bei den aktuellen Prozess" 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;
}

CPU, die derzeit bei den aktuellen Prozess:

#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 der Wahl, das schien offensichtlich auf den ersten, war der Einsatz der POSIX-APIs wie getrusage (), etc. Ich verbrachte einige Zeit versucht, diese zu arbeiten, aber nie sinnvolle Werte. Wenn ich abschließend überprüft der kernel-Quellen selbst, fand ich heraus, dass scheinbar diese APIs sind noch nicht vollständig umgesetzt werden, da der Linux-kernel 2.6!?

Letztendlich habe ich alle Werte über eine Kombination der Lektüre der pseudo-Dateisystem /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;

Virtuellen Speicher derzeit verwendet:

Gleichen code wie in "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;

Virtuellen Speicher, die derzeit bei den aktuellen Prozess:

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

Gesamten Physischen Speicher (RAM):

Gleichen code wie in "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;

Physischen Speicher derzeit verwendet:

Gleichen code wie in "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;

Physikalischen Speicher, die derzeit bei den aktuellen Prozess:

Ändern getValue() im "Virtuellen Speicher, die derzeit bei den aktuellen Prozess" 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;
}

CPU, die derzeit bei den aktuellen Prozess:

#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: Anderen Plattformen

Ich würde davon ausgehen, dass einige der Linux-code funktioniert auch für die UNIX-Varianten, außer für die Teile, die Lesen das /proc-pseudo-Dateisystem. Vielleicht auf Unix diese Teile können ersetzt werden durch getrusage() und ähnlichen Funktionen?
Wenn sich jemand mit Unix-know-how Bearbeiten könnten diese Antwort und füllen Sie die details?!

Warnung: in PdhAddCounter die Abfrage muss lokalisiert werden, sonst läuft es nur auf einem Englisch-native-system. Für Vista/2008 und höher system, lieber mit PdhAddEnglishCounter zu vermeiden Lokalisierung.
Bei der Verwendung von PROCESS_MEMORY_COUNTERS, wie Sie das abrufen der "Virtuelle Speicher, die derzeit bei den aktuellen Prozess"? PrivateUsage ist nicht Mitglied der PROCESS_MEMORY_COUNTERS ist die compiler-Fehlermeldung, die ich erhalten!
Warum verwenden Sie "quotes like these" für einschließlich system-Header?
Sie müssen ein casting.. ersetzen GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc)); mit GetProcessMemoryInfo(GetCurrentProcess(), (PROCESS_MEMORY_COUNTERS*)&pmc, sizeof(pmc));
Da sind wir weit über dem Linux-Kernel 3.0. Können Sie aktualisieren Sie Ihre Linux-Antwort auf die POSIX-API? Wenn möglich, korrigieren Sie die Windows-Antwort als auch durch Auswechseln GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc)); mit GetProcessMemoryInfo(GetCurrentProcess(), (PROCESS_MEMORY_COUNTERS*)&pmc, sizeof(pmc));

InformationsquelleAutor Lanzelot

130

Mac OS X

Ich hatte gehofft, dass ähnliche Informationen für Mac OS X als auch. Da war es nicht hier, ich ging hin und grub es mir. Hier sind einige der Dinge, die ich gefunden habe. Wenn jemand noch andere Vorschläge, ich würde lieben, Sie zu hören.

Gesamter Virtueller Speicher

Dies ist schwierig auf Mac OS X, weil es keine preset-swap-partition oder-Datei wie Linux. Hier ist ein Eintrag aus der Apple-Dokumentation:

Hinweis: im Gegensatz zu den meisten Unix-basierten Betriebssystemen Mac OS X nicht verwenden Sie eine Feste swap-partition für den virtuellen Speicher. Stattdessen wird der gesamte verfügbare Platz auf der Maschine, auf der boot-partition.

Also, wenn Sie wissen möchten, wie viel virtuellen Speicher noch verfügbar ist, müssen Sie die Größe der root-partition. Sie können tun, wie diese:
```
struct statfs stats;
if (0 == statfs("/", &stats))
{
    myFreeSwap = (uint64_t)stats.f_bsize * stats.f_bfree;
}
```
Gesamter Virtueller Derzeit Verwendet

Aufrufen systcl mit dem "vm.swapusage" - Taste bietet interessante Informationen über die Auslastung des swap-Speichers:
```
sysctl -n vm.swapusage
vm.swapusage: total = 3072.00M  used = 2511.78M  free = 560.22M  (encrypted)
```
Nicht, dass die gesamte Auslastung des swap-Speichers angezeigt, hier kann sich ändern, wenn mehr swap erforderlich ist, wie in dem Abschnitt oben. Also die Summe ist tatsächlich die aktuellen swap insgesamt. In C++ können diese Daten abgefragt werden, auf diese Weise:
```
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", erklärt sysctl.h, scheint nicht dokumentiert und ich vermute, es ist eine mehr tragbare Weise auf diese Werte zugreifen.

Virtuellen Speicher, der Aktuell von meinem Prozess

Können Sie Statistiken über Ihre aktuelle Prozess mit der task_info Funktion. Das beinhaltet die aktuellen Bewohner der Größe des 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;
```
Gesamt-RAM zur Verfügung

Die Menge des physischen RAM in Ihrem system verfügbar ist, mit der sysctl system-Funktion wie folgt:
```
#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

Erhalten Sie Allgemeine Speicher-Statistik der host_statistics system-Funktion.
```
#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;
}
```
Eine Sache, die hier zu beachten sind, dass es fünf Typen von Speicher-Seiten in Mac OS X. Sie lauten wie folgt:
1. WLAN - Seiten sind gesperrt und können nicht ausgelagert werden,
2. Aktiv Seiten, die beim laden in den Hauptspeicher und wäre relativ schwierig zu tauschen
3. Inaktiv Seiten, die in den Speicher geladen sind, aber noch nicht verwendet worden, vor kurzem, und möglicherweise gar nicht erforderlich. Diese sind potentielle Kandidaten für das Swap. Dieser Speicher würde wahrscheinlich müssen geleert werden.
4. Zwischengespeichert Seiten, wurden, wie einige zwischengespeichert, wahrscheinlich werden einfach wiederverwendet. Cache-Speicher würde nicht wahrscheinlich erfordern eine Spülung. Es ist immer noch möglich für zwischengespeicherte Seiten wieder aktiviert werden
5. Frei Seiten, die völlig frei ist und bereit, verwendet werden.
Es ist gut zu beachten, dass, nur weil Mac OS X kann von sehr wenig freier Speicher bei Zeiten, dass es nicht ein gutes Indiz dafür, wie viel bereit ist kurzfristig.

RAM, der Aktuell von meinem Prozess

Finden Sie unter "Virtueller Arbeitsspeicher, der Aktuell von meinem Prozess" vor. Der gleiche code gilt.

Sie Links aus #include<mach/mach.h> definieren task_info() in den "Virtuellen Speicher, der Aktuell von meinem Process" Abschnitt. Diese header enthalten muss, zu definieren, dass die Funktion.
Keine Ahnung von erste CPU-Auslastung ?
Taylor, Das ist großartig, danke, aber die Frage über die RAM derzeit für OS X, es scheint, dass Sie immer die VM-stats, nicht der physische Speicher. Ist das wirklich hier der Fall?
Das vm-system verwaltet den Speicher, so dass ist, warum Sie die Abfrage. Die Speicher sind Statistiken für die tatsächliche Speicher. Ich habe einen test auf meinem Rechner, und einige der physischen Speicher fehlt in der Statistik (die Sie nicht hinzufügen bis zu meinem physischen Speicher). Sie scheinen nicht auf meine swap-obwohl. Leider können Sie nur Lesen Sie die überschriften für die docs.
Wie können wir berechnen APP-Speicher und cache-Speicher wie activity monitor? Ich verwendet vm_stats.inactive_page_count *page_size t berechnen, Datei-Cache, aber es wird nicht synchronisiert mit dem Activity monitor. Vielen Dank im Voraus

InformationsquelleAutor Michael Taylor
57

Linux

In Linux, diese Informationen werden in das /proc-Dateisystem. Ich bin kein großer fan der text-Datei-format verwendet, wie jede Linux-distribution scheint zu passen mindestens eine wichtige Datei. Ein kurzer Blick als Quelle für die 'ps' zeigt die bescherung.

Aber hier ist, wo zu finden die Informationen, die Sie suchen:

/proc/meminfo enthält die Mehrheit der system-weiten Informationen die Sie suchen. Hier sieht es aus wie auf meinem system, ich denke, Sie sind daran interessiert, 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 Arbeit. Linux zur Verfügung stellt, die gesamte CPU-Auslastung seit dem start des Systems; dies ist wahrscheinlich nicht das, was Sie interessiert. Wenn Sie wissen wollen, was die CPU-Auslastung war für die letzten Sekunden, oder 10 Sekunden, dann müssen Sie für die Abfrage der Informationen und selbst berechnen.

Den Informationen, die verfügbar ist in /proc/stat, die dokumentiert ist ziemlich gut in der http://www.linuxhowtos.org/System/procstat.htm; hier ist, was es sieht aus wie auf meinem 4-core box:
```
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
```
Zuerst müssen Sie bestimmen, wie viele CPUs (oder Prozessoren oder Prozessorkerne) im system verfügbar sind. Dazu zählen der Anzahl von 'cpuN' - Einträge, wobei N der bei 0 beginnt und inkrementiert. Zählen Sie nicht die 'cpu' Linie, die eine Kombination aus dem cpuN-Linien. In meinem Beispiel können Sie sehen, cpu0 durch cpu3, für insgesamt 4 Prozessoren. Von nun an können Sie ignorieren cpu0..cpu3, und konzentrieren Sie sich nur auf die 'cpu' - Zeile.

Als Nächstes müssen Sie wissen, dass die vierte Zahl in diesen Zeilen ist ein Maß der Zeit im Leerlauf, und so ist die vierte Nummer auf die 'cpu' - Linie ist die Gesamt-idle-time für alle Prozessoren, da die boot-Zeit. Diese Zeit wird gemessen in Linux "jiffies", die sind 1/100 einer Sekunde.

Aber Sie kümmern sich nicht um die Gesamt-idle-time; Sie kümmern sich um die idle-Zeit, die in einem bestimmten Zeitraum, z.B. der letzten Sekunde. Tun ausrechnen, müssen Sie diese Datei zu Lesen, zweimal, 1 Sekunde auseinander.Dann kann man ein "diff" der vierte Wert der Zeile. Zum Beispiel, wenn Sie nehmen Sie eine Probe und 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
```
Subtrahieren Sie die beiden zahlen und Sie erhalten eine diff 396, was bedeutet, dass Ihre CPU im Leerlauf war 3.96 Sekunden aus der letzten 1.00 Sekunden. Der trick, natürlich, ist, dass Sie brauchen, um zu dividieren durch die Anzahl der Prozessoren. 3.96 /4 = 0.99, und es ist Ihre idle-Anteil; 99% Leerlauf, und 1% beschäftigt.

In meinem code, ich habe einen ring-Puffer 360 Einträge, und ich lese diese Datei in jeder Sekunde. Dass lässt mich schnell zu berechnen, die CPU-Auslastung für 1 Sekunde, 10 Sekunden, etc., den ganzen Weg bis zu 1 Stunde.

Für die Prozess-spezifische Informationen, Sie haben sich in /proc/pid; wenn Sie don ' T care über die pid, suchen Sie in /proc/self.

CPU-Ihr Prozess ist in /proc/self/stat. Dies ist eine seltsam aussehende Datei, die aus einer einzelnen Zeile ein; 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
```
Wichtige Daten sind hier die 13 und 14 Spielfiguren (0 und 770 hier). Der 13-token ist die Anzahl der jiffies, dass der Prozess ausgeführt wurde, die im user-Modus, und die 14 ist die Anzahl der jiffies, dass der Prozess ausgeführt wurde, der im kernel-Modus. Fügen Sie die beiden zusammen, und Sie haben Ihre gesamte CPU-Auslastung.

Wieder, Sie haben zum Beispiel diese Datei in regelmäßigen Abständen, und berechnen Sie die diff, um festzustellen, ob die Prozess-CPU-Auslastung über die Zeit.

Edit: denken Sie daran, dass, wenn Sie berechnen Sie Ihre Prozess die CPU-Auslastung, die Sie haben zu berücksichtigen 1) die Anzahl der threads im Prozess und 2) die Anzahl der Prozessoren im system. Zum Beispiel, wenn Ihre single-threaded-Prozess mit nur 25% der CPU, das könnte gut sein oder schlecht. Gut, auf einer single-Prozessor-system, aber schlecht auf einem 4-Prozessor-system; dies bedeutet, dass der Prozess ständig läuft, und die Verwendung von 100% der CPU-Zyklen zur Verfügung stehen.

Für die Prozess-spezifische Speicher von Informationen, die Sie haben zu schauen, /proc/self/status, die 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 beginnen mit 'Vm' sind die interessanten:
- VmPeak ist die maximale virtuelle Speicher von dem Prozess verwendet wird, in kB (1024 bytes).
- VmSize ist die aktuelle virtuelle Speicher von dem Prozess verwendet wird, in kB. In meinem Beispiel, es ist ziemlich groß: 651,352 kB, oder etwa 636 Megabyte.
- VmRss ist die Menge an Speicher, die zugeordnet wurden, in den Prozess " Adressraum, oder seine resident set size. Dieser ist wesentlich kleiner (420,296 kB, oder etwa 410 Megabyte). Der Unterschied: mein Programm zugeordnet hat 636 MB via mmap(), hat aber nur zugegriffen 410 MB und damit nur 410 MB Seiten zugeordnet wurden.
Der einzige Artikel, den ich bin mir nicht sicher Swapspace derzeit von meinem Prozess. Ich weiß nicht, ob diese verfügbar ist.

Danke Martin, wenn ich all diese Informationen an einem Ort gesammelt, es würde gespeichert haben mich ein paar schlaflose Nächte... Aber für CPU von aktuellen Prozess-ich denke mal die () - Funktion ist ein einfacher und zuverlässiger Ansatz. BTW: Swapspace von aktuellen Prozess = VmSize - VmRSS, ist es nicht?

InformationsquelleAutor Martin Del Vecchio

in windows erhalten Sie die cpu-Auslastung durch code unten:

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

kann dies geändert werden, für die eine externe DLL-Funktion kann ich später Aufruf in c#?
ja es ist möglich
Die Formatierung der usage = ist das kreativste was ich gesehen haben in eine Weile, nicht lesbar, aber kreativ
Warnung: der Ausdruck in dem obigen code, berechnet 'Gebrauch' ist Weg. Wenn das system im Leerlauf war, es würde eine Division durch null. Im Falle der Leerlauf war gleich der user-und kernel-Zeit, es würde die Produktion von 0 anstatt 50%, wie man erwarten würde.
Beachten Sie auch, dass nach der aktuellen MSDN, kernel-Zeit beinhaltet auch die idle-Zeit!

InformationsquelleAutor sayyed mohsen zahraee

Linux

Einen tragbaren Weg des Lesen-Speicher und load-zahlen ist die sysinfo - Aufruf

Nutzung

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

InformationsquelleAutor Mark Lakata

QNX

Da dies wie eine "wikipage of code" möchte ich hinzufügen, dass einige code, der aus den QNX-Knowledge base (Hinweis: dies ist nicht mein Werk, aber ich überprüft und es funktioniert gut auf meinem system):

Wie man 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();
}

Wie man die Kostenlose (!) 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;
}

InformationsquelleAutor Boernii

Mac-OS-X - CPU -

Gesamt-CPU-Auslastung:

Vom Abrufen von system-Informationen auf MacOS X? :

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

InformationsquelleAutor souch

Habe ich diese folgenden code in mein C++ Projekt, und es funktionierte Prima:

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

Noch nicht Sie haben Werte wie 0.00% und Werte über 100% durch diesen Mechanismus?
Ist das für Mac OS ?

InformationsquelleAutor Salman Ghaffar

Für Linux
Sie können auch verwenden /proc/self/statm um eine einzelne Zeile von zahlen, mit wesentlichen Prozess-Speicher-Informationen, die eine schnellere Sache zu verarbeiten, als sich durch eine lange Liste der gemeldeten Informationen erhalten Sie von proc/self/status

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

Wer weiß, wie zuverlässig die Gesamtgröße berichtet in Seiten? Ist diese tatsächliche Präsenz in mem in Seiten ?

InformationsquelleAutor Steven Warner

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Windows

Linux

TODO: Anderen Plattformen

Mac OS X

Gesamter Virtueller Speicher

Gesamter Virtueller Derzeit Verwendet

Virtuellen Speicher, der Aktuell von meinem Prozess

Gesamt-RAM zur Verfügung

RAM Derzeit Verwendet

RAM, der Aktuell von meinem Prozess

Linux

Linux

Nutzung

BESCHREIBUNG

QNX