it-swarm-eu.dev

Jak zjistit spotřebu CPU a paměti zevnitř procesu?

Jednou jsem měl za úkol určit následující parametry výkonu z uvnitř spuštěné aplikace:

  • Celková dostupná virtuální paměť
  • Virtuální paměť je aktuálně používána
  • Virtuální paměť aktuálně používaná mým procesem
  • Celkem RAM k dispozici
  • Aktuálně používaná RAM
  • RAM aktuálně používaná v mém procesu
  • % CPU v současné době používá
  • % CPU aktuálně používané mým procesem

Kód musel běžet na Windows a Linuxu. I když se to jeví jako standardní úkol, nalezení potřebných informací v příručkách (WIN32 API, GNU docs) i na internetu mi trvalo několik dní, protože je tolik neúplných/nesprávných/zastaralých informace o tomto tématu najdete zde.

Abychom zachránili ostatní před stejným problémem, myslel jsem, že by bylo dobré shromáždit všechny rozptýlené informace a to, co jsem zde na pokusech a omylech našel na jednom místě.

536
Lanzelot

Okna

Některé z výše uvedených hodnot jsou snadno dostupné z příslušného rozhraní API WIN32, pouze je zde uvedu pro úplnost. Ostatní je však třeba získat z knihovny Performance Data Helper (PDH), která je trochu „neintuitivní“ a vyžaduje hodně bolestivých pokusů a omylů, aby mohla začít pracovat. (Aspoň mi to trvalo docela dlouho, možná jsem byl jen trochu hloupý ...)

Poznámka: Pro přehlednost byla z následujícího kódu vynechána veškerá kontrola chyb. Zkontrolujte kontrolní kódy ...!


  • Celková virtuální paměť:

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

    Poznámka: Název „TotalPageFile“ je zde trochu zavádějící. Ve skutečnosti tento parametr uvádí „velikost virtuální paměti“, což je velikost odkládacího souboru plus nainstalovaná RAM.

  • Aktuálně používaná virtuální paměť:

    Stejný kód jako v "Celková virtuální paměť" a poté

    DWORDLONG virtualMemUsed = memInfo.ullTotalPageFile - memInfo.ullAvailPageFile;
    
  • Virtuální paměť aktuálně používaná v aktuálním procesu:

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



  • Celková fyzická paměť (RAM):

    Stejný kód jako v "Celková virtuální paměť" a poté

    DWORDLONG totalPhysMem = memInfo.ullTotalPhys;
    
  • Momentálně používaná fyzická paměť:

    Same code as in "Total Virtual Memory" and then
    
    DWORDLONG physMemUsed = memInfo.ullTotalPhys - memInfo.ullAvailPhys;
    
  • Fyzická paměť aktuálně používaná v aktuálním procesu:

    Stejný kód jako v „Virtuální paměti aktuálně používané aktuálním procesem“ a poté

    SIZE_T physMemUsedByMe = pmc.WorkingSetSize;
    



  • Aktuálně používaný procesor:

    #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 aktuálně používaný aktuálním procesem:

    #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

V Linuxu bylo na první pohled zřejmé, že bude používat POSIX API, jako je getrusage() atd. Strávil jsem nějaký čas pokusem o to, aby to fungovalo, ale nikdy jsem nezískal smysluplné hodnoty. Když jsem konečně zkontroloval samotné zdroje jádra, zjistil jsem, že tato API zřejmě ještě nejsou plně implementována jako Linuxové jádro 2.6 !?

Nakonec jsem získal všechny hodnoty kombinací čtení pseudosouborového systému /proc a volání jádra.

  • Celková virtuální paměť:

    #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;
    
  • Aktuálně používaná virtuální paměť:

    Stejný kód jako v "Celková virtuální paměť" a poté

    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;
    
  • Virtuální paměť aktuálně používaná v aktuálním procesu:

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



  • Celková fyzická paměť (RAM):

    Stejný kód jako v "Celková virtuální paměť" a poté

    long long totalPhysMem = memInfo.totalram;
    //Multiply in next statement to avoid int overflow on right hand side...
    totalPhysMem *= memInfo.mem_unit;
    
  • Momentálně používaná fyzická paměť:

    Stejný kód jako v "Celková virtuální paměť" a poté

    long long physMemUsed = memInfo.totalram - memInfo.freeram;
    //Multiply in next statement to avoid int overflow on right hand side...
    physMemUsed *= memInfo.mem_unit;
    
  • Fyzická paměť aktuálně používaná v aktuálním procesu:

    Změňte getValue () v části „Virtuální paměť aktuálně používaná v aktuálním procesu“ následujícím způsobem:

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



  • Aktuálně používaný procesor:

    #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 aktuálně používaný aktuálním procesem:

    #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: Jiné platformy

Předpokládal bych, že některý z linuxových kódů funguje také pro Unixy, s výjimkou částí, které čtou pseudo-souborový systém/proc. Možná na Unixu mohou být tyto části nahrazeny getrusage() a podobnými funkcemi? Pokud by někdo s unixovým know-how mohl tuto odpověď upravit a vyplnit podrobnosti ?!

587
Lanzelot

Mac OS X

Doufal jsem, že naleznu podobné informace i pro Mac OS X. Protože to tu nebylo, vyšel jsem ven a vykopal si to sám. Zde jsou některé z věcí, které jsem našel. Pokud má někdo nějaké další návrhy, rád bych je slyšel.

Celková virtuální paměť

Tento je složitý v systému Mac OS X, protože nepoužívá přednastavený odkládací oddíl nebo soubor, jako je Linux. Zde je položka z dokumentace společnosti Apple:

Poznámka: Na rozdíl od většiny operačních systémů založených na Unixu, Mac OS X nepoužívá předem přidělený odkládací oddíl pro virtuální paměť. Místo toho využívá veškerý dostupný prostor v zaváděcí oblasti zařízení.

Pokud tedy chcete vědět, kolik virtuální paměti je stále k dispozici, musíte získat velikost kořenového oddílu. Můžete to udělat takto:

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

Celkový počet virtuálně používaných v současné době

Volání systcl pomocí klíče „vm.swapusage“ poskytuje zajímavé informace o využití swapu:

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

Ne, že zde zobrazené celkové využití swapů se může změnit, pokud je potřeba více swapů, jak je vysvětleno v části výše. Takže součet je ve skutečnosti současný swapový součet. V C++ mohou být tato data dotazována tímto způsobem:

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\",...)" );
}

Všimněte si, že "xsw_usage", deklarované v sysctl.h, se zdá být zdokumentováno a domnívám se, že existuje více přenosný způsob přístupu k těmto hodnotám.

Virtuální paměť aktuálně používaná v mém procesu

Můžete získat statistiky o vašem aktuálním procesu pomocí funkce task_info. To zahrnuje aktuální rezidentní velikost vašeho procesu a aktuální virtuální velikost.

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

Celkem RAM k dispozici

Množství fyzického RAM dostupného ve vašem systému je k dispozici pomocí systémové funkce sysctl:

#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 v současné době používá

Obecnou statistiku paměti získáte ze systémové funkce Host_statistics.

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

Jedna věc, kterou je třeba poznamenat, je, že v systému Mac OS X existuje pět typů paměťových stránek. Jsou to následující:

  1. Kabelové stránky, které jsou zamčené na místě a nelze je zaměnit
  2. Aktivní stránky, které se načítají do fyzické paměti a bylo by poměrně obtížné je vyměnit
  3. Neaktivní stránky, které jsou načteny do paměti, ale nebyly nedávno použity a nemusí být vůbec potřeba. Toto jsou potenciální kandidáti na výměnu. Tato paměť by pravděpodobně musela být propláchnuta.
  4. V mezipaměti stránky, které byly některé z toho, jak jsou v mezipaměti pravděpodobně znovu snadno použity. Paměť s mezipamětí by pravděpodobně nevyžadovala návaly. Stále je možné znovu aktivovat stránky v mezipaměti
  5. Zdarma stránky, které jsou zcela zdarma a připravené k použití.

Je dobré si uvědomit, že právě proto, že Mac OS X může občas ukázat velmi málo skutečné volné paměti, nemusí to být dobrým ukazatelem toho, kolik je připraveno k použití v krátké době.

RAM v současné době používá můj proces

Podívejte se na výše uvedenou část „Virtuální paměť aktuálně používaná mým procesem“. Platí stejný kód.

135
Michael Taylor

Linux

V systému Linux jsou tyto informace k dispozici v systému souborů/proc. Nejsem velkým fanouškem použitého formátu textového souboru, protože každá distribuce v systému Linux přizpůsobuje alespoň jeden důležitý soubor. Rychlý pohled jako zdroj „ps“ odhaluje nepořádek.

Zde však najdete informace, které hledáte:

/proc/meminfo obsahuje většinu informací o systému, které hledáte. Tady to vypadá jako na mém systému; Myslím, že vás zajímá MemTotal , MemFree , SwapTotal a 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

Pro využití CPU musíte udělat trochu práce. Linux zpřístupňuje celkové využití procesoru od spuštění systému; asi to není to, co vás zajímá. Pokud chcete vědět, jaké bylo využití CPU za poslední sekundu nebo 10 sekund, pak je třeba informace vyhledat a vypočítat je sami.

Informace jsou k dispozici v /proc/stat , což je zdokumentováno celkem dobře na http://www.linuxhowtos.org/System/ procstat.htm ; jak to vypadá na mé čtyřjádrové krabici:

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

Nejprve musíte určit, kolik procesorů (nebo procesorů nebo procesorových jader) je v systému k dispozici. Chcete-li to provést, spočítejte počet položek 'cpuN', kde N začíná na 0 a přírůstcích. Nepočítejte linku 'cpu', která je kombinací linek cpuN. V mém příkladu můžete vidět cpu0 až cpu3 pro celkem 4 procesory. Od této chvíle můžete ignorovat cpu0..cpu3 a zaměřit se pouze na řádek 'cpu'.

Dále musíte vědět, že čtvrté číslo v těchto řádcích je mírou nečinnosti, a tedy čtvrté číslo v řádku 'cpu' je celková doba nečinnosti všech procesorů od doby spuštění. Tentokrát se měří v Linuxu „jiffies“, které mají každý 1/100 sekundy.

Ale nezajímá vás celková doba nečinnosti; staráte se o dobu nečinnosti v daném období, např. poslední sekundu. Vypočítejte to, musíte si přečíst tento soubor dvakrát, 1 sekundu od sebe. Pak můžete udělat rozdíl čtvrté hodnoty řádku. Pokud například odeberete vzorek a získáte:

cpu  2330047 0 2365006 1063853632 9035 9463 96114 0

O sekundu později získáte tento vzorek:

cpu  2330047 0 2365007 1063854028 9035 9463 96114 0

Odečtěte dvě čísla a dostanete rozdíl 396, což znamená, že váš CPU byl nečinný 3,96 sekundy z posledních 1,00 sekundy. Trik je samozřejmě v tom, že se musíte dělit počtem procesorů. 3,96/4 = 0,99, a tam je vaše nečinné procento; 99% nečinnosti a 1% práce.

V mém kódu mám kruhový buffer 360 záznamů a tento soubor jsem četl každou sekundu. To mi umožňuje rychle vypočítat využití procesoru po dobu 1 sekundy, 10 sekund atd. Až do 1 hodiny.

Pro informace specifické pro proces musíte hledat /proc/pid ; pokud vám záleží na vaší pid, můžete se podívat do/proc/self.

Procesor používaný vaším procesem je k dispozici v /proc/self/stat . Toto je podivný soubor skládající se z jednoho řádku; například:

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

Důležitá data jsou zde 13. a 14. token (0 a 770 zde). 13. token je počet jiffů, které proces provedl v uživatelském režimu, a 14. je počet jiffů, které proces provedl v režimu jádra. Sečte je dohromady a získáte celkové využití CPU.

Znovu budete muset tento soubor periodicky vzorkovat a vypočítat rozdíl, abyste mohli v průběhu času určit využití procesoru.

Edit: nezapomeňte, že při výpočtu využití procesoru ve vašem procesu musíte vzít v úvahu 1) počet vláken ve vašem procesu a 2) počet procesorů v systému. Například pokud proces s jedním vláknem používá pouze 25% CPU, mohlo by to být dobré nebo špatné. Dobré pro jednoprocesorový systém, ale špatné pro čtyřprocesorový systém; to znamená, že váš proces běží nepřetržitě a využívá 100% dostupných cyklů CPU.

Chcete-li získat informace o paměti specifické pro proces, musíte se podívat na/proc/self/status, který vypadá takto:

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

Zajímavé jsou položky začínající na „Vm“:

  • VmPeak je maximální prostor virtuální paměti používaný procesem v kB (1024 bajtů).
  • VmSize je aktuální prostor virtuální paměti používaný procesem v kB. V mém příkladu je to docela velké: 651 352 kB, nebo asi 636 megabajtů.
  • VmRss je množství paměti, která byla mapována do adresního prostoru procesu, nebo její rezidentní velikost sady. To je podstatně menší (420 296 kB, neboli přibližně 410 megabajtů). Rozdíl: můj program mapoval 636 MB prostřednictvím mmap (), ale zpřístupnil jej pouze 410 MB, a proto mu bylo přiřazeno pouze 410 MB stránek.

Jediná položka, o které si nejsem jistý, je Odkládací prostor, který se momentálně používá v mém procesu . Nevím, jestli je to k dispozici.

61

v systému Windows můžete získat využití procesoru kódem níže:

#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

Přenosný způsob čtení čísel paměti a zatížení je sysinfocall

Používání

   #include <sys/sysinfo.h>

   int sysinfo(struct sysinfo *info);

POPIS

   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

Protože se jedná o „wikipage kódu“, chci přidat nějaký kód z QNX Knowledge Base (poznámka: toto není moje práce, ale zkontroloval jsem ji a v mém systému to funguje dobře):

Jak získat využití procesoru v%: 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();
}

Jak získat volnou (!) Paměť: 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

Celkové využití CPU:

Z Načíst systémové informace o 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;
}
1
souch

Pro Linux Můžete také použít/proc/self/statm k získání jediného řádku čísel obsahujících klíčové informace o procesní paměti, která je rychlejší než zpracování dlouhým seznamem hlášených informací, jak se dostanete z proc/self/status

Viz 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

Následující kód jsem použil v mém projektu C++ a fungovalo to dobře:

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