it-swarm-tr.com

Bir işlemin içindeki CPU ve bellek tüketimi nasıl belirlenir?

Bir keresinde, çalışan bir uygulamanın içinden aşağıdaki performans parametrelerini belirleme görevim vardı:

  • Toplam sanal bellek mevcut
  • Şu anda kullanılan sanal bellek
  • İşlemim tarafından şu anda kullanılan sanal bellek
  • Toplam RAM mevcut
  • Şu anda kullanılan RAM
  • İşlemim tarafından şu anda kullanılan RAM
  • Şu anda kullanılan% CPU
  • Şu anda işlemim tarafından kullanılan% CPU

Kodun Windows ve Linux'ta çalışması gerekiyordu. Bu standart bir görev gibi görünse de, el kitaplarında (WIN32 API, GNU docs) gerekli bilgileri internette olduğu gibi bulmak da birkaç gün sürdü, çünkü çok eksik/yanlış/modası geçmiş orada bulunacak bu konuda bilgi.

Başkalarının da aynı sıkıntıdan kurtulmasını önlemek için, tüm dağınık bilgileri ve buradaki deneme yanılma ile bulduklarımın tek bir yerde toplamanın iyi bir fikir olacağını düşündüm.

536
Lanzelot

, Windows

Yukarıdaki değerlerden bazıları uygun WIN32 API'sinden kolayca elde edilebilir, sadece bunları tamlık için burada listeliyorum. Bununla birlikte, diğerleri, biraz "sezgisel" olmayan ve işe yaraması için çok fazla acı gerektiren deneme yanılma olan Performans Veri Yardımcısı kütüphanesinden (PDH) edinilmelidir. (En azından biraz zaman aldı, belki de sadece biraz aptal oldum ...)

Not: Netlik açısından, tüm hata kontrolleri aşağıdaki koddan çıkarılmıştır. Dönüş kodlarını kontrol et.


  • Toplam Sanal Bellek:

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

    Not: "TotalPageFile" adı burada biraz yanıltıcıdır. Gerçekte bu parametre, takas dosyasının boyutu artı kurulu RAM olan "Sanal Bellek Boyutu" nu verir.

  • Şu anda kullanılan Sanal Bellek:

    "Toplam Sanal Bellek" deki kodla aynı

    DWORDLONG virtualMemUsed = memInfo.ullTotalPageFile - memInfo.ullAvailPageFile;
    
  • Şu anda geçerli işlem tarafından kullanılan Sanal Bellek:

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



  • Toplam Fiziksel Bellek (RAM):

    "Toplam Sanal Bellek" deki kodla aynı

    DWORDLONG totalPhysMem = memInfo.ullTotalPhys;
    
  • Şu anda kullanılan Fiziksel Bellek:

    Same code as in "Total Virtual Memory" and then
    
    DWORDLONG physMemUsed = memInfo.ullTotalPhys - memInfo.ullAvailPhys;
    
  • Şu anda mevcut işlem tarafından kullanılan Fiziksel Bellek:

    "Şu anda mevcut işlem tarafından kullanılan Sanal Bellek" ile aynı kod ve sonra

    SIZE_T physMemUsedByMe = pmc.WorkingSetSize;
    



  • Şu anda kullanılan CPU:

    #include "TCHAR.h"
    #include "pdh.h"
    
    static PDH_HQUERY cpuQuery;
    static PDH_HCOUNTER cpuTotal;
    
    void init(){
        PdhOpenQuery(NULL, NULL, &cpuQuery);
        // You can also use L"\\Processor(*)\\% Processor Time" and get individual CPU values with PdhGetFormattedCounterArray()
        PdhAddEnglishCounter(cpuQuery, L"\\Processor(_Total)\\% Processor Time", NULL, &cpuTotal);
        PdhCollectQueryData(cpuQuery);
    }
    
    double getCurrentValue(){
        PDH_FMT_COUNTERVALUE counterVal;
    
        PdhCollectQueryData(cpuQuery);
        PdhGetFormattedCounterValue(cpuTotal, PDH_FMT_DOUBLE, NULL, &counterVal);
        return counterVal.doubleValue;
    }
    
  • Şu anda mevcut işlem tarafından kullanılan 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

Linux'ta ilk başta açık görünen seçenek, getrusage() vs. gibi POSIX API'lerini kullanmaktı. Bunu işe almak için biraz zaman harcadım, ancak anlamlı değerler alamadım. Sonunda çekirdek kaynaklarını kendileri kontrol ettiğimde, bu API'lerin Linux çekirdeği 2.6'dan itibaren henüz tam olarak uygulanmadığını öğrendim !?

Sonunda, sözde dosya sistemini /proc ve çekirdek çağrılarını okuyarak bir araya getirerek tüm değerleri elde ettim.

  • Toplam Sanal Bellek:

    #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;
    
  • Şu anda kullanılan Sanal Bellek:

    "Toplam Sanal Bellek" deki kodla aynı

    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;
    
  • Şu anda geçerli işlem tarafından kullanılan Sanal Bellek:

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



  • Toplam Fiziksel Bellek (RAM):

    "Toplam Sanal Bellek" deki kodla aynı

    long long totalPhysMem = memInfo.totalram;
    //Multiply in next statement to avoid int overflow on right hand side...
    totalPhysMem *= memInfo.mem_unit;
    
  • Şu anda kullanılan Fiziksel Bellek:

    "Toplam Sanal Bellek" deki kodla aynı

    long long physMemUsed = memInfo.totalram - memInfo.freeram;
    //Multiply in next statement to avoid int overflow on right hand side...
    physMemUsed *= memInfo.mem_unit;
    
  • Şu anda mevcut işlem tarafından kullanılan Fiziksel Bellek:

    "Geçerli işlem tarafından kullanılmakta olan Sanal Bellek" bölümündeki getValue () işlevini aşağıdaki gibi değiştirin:

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



  • Şu anda kullanılan CPU:

    #include "stdlib.h"
    #include "stdio.h"
    #include "string.h"
    
    static unsigned long long lastTotalUser, lastTotalUserLow, lastTotalSys, lastTotalIdle;
    
    void init(){
        FILE* file = fopen("/proc/stat", "r");
        fscanf(file, "cpu %llu %llu %llu %llu", &lastTotalUser, &lastTotalUserLow,
            &lastTotalSys, &lastTotalIdle);
        fclose(file);
    }
    
    double getCurrentValue(){
        double percent;
        FILE* file;
        unsigned long long totalUser, totalUserLow, totalSys, totalIdle, total;
    
        file = fopen("/proc/stat", "r");
        fscanf(file, "cpu %llu %llu %llu %llu", &totalUser, &totalUserLow,
            &totalSys, &totalIdle);
        fclose(file);
    
        if (totalUser < lastTotalUser || totalUserLow < lastTotalUserLow ||
            totalSys < lastTotalSys || totalIdle < lastTotalIdle){
            //Overflow detection. Just skip this value.
            percent = -1.0;
        }
        else{
            total = (totalUser - lastTotalUser) + (totalUserLow - lastTotalUserLow) +
                (totalSys - lastTotalSys);
            percent = total;
            total += (totalIdle - lastTotalIdle);
            percent /= total;
            percent *= 100;
        }
    
        lastTotalUser = totalUser;
        lastTotalUserLow = totalUserLow;
        lastTotalSys = totalSys;
        lastTotalIdle = totalIdle;
    
        return percent;
    }
    
  • Şu anda mevcut işlem tarafından kullanılan 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: Diğer Platformlar

Linux kodunun bir kısmının,/proc sözde dosya sistemini okuyan kısımlar dışında, Unix'ler için de işe yaradığını varsayardım. Belki de Unix'te bu parçalar getrusage() ve benzeri işlevlerle değiştirilebilir. Unix bilgisine sahip biri bu cevabı düzenleyip detayları girebilir mi ?!

587
Lanzelot

Mac OS X

Mac OS X için de benzer bilgiler bulmayı umuyordum. Burada olmadığı için dışarı çıktım ve kendim çıkardım. İşte bulduğum bazı şeyler. Başka bir önerisi varsa, duymak isterim.

Toplam Sanal Bellek

Bu, Mac OS X'te daha zor, çünkü önceden belirlenmiş bir takas bölümünü ya da Linux gibi bir dosyayı kullanmıyor. İşte Apple'ın belgelerinden bir giriş:

Not: Çoğu Unix tabanlı işletim sisteminden farklı olarak, Mac OS X, sanal bellek için önceden tahsis edilmiş bir takas alanı kullanmaz. Bunun yerine, makinenin önyükleme bölümündeki tüm kullanılabilir alanı kullanır.

Bu nedenle, ne kadar sanal belleğin hala kullanılabilir olduğunu bilmek istiyorsanız, kök bölümün boyutunu almanız gerekir. Bunu böyle yapabilirsin:

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

Şu Anda Kullanılan Toplam Sanal

Systcl'nin "vm.swapusage" tuşuyla çağrılması, takas kullanımı hakkında ilginç bilgiler sağlar:

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

Burada görüntülenen toplam takas kullanımının, yukarıdaki bölümde açıklandığı gibi daha fazla takas gerektiğinde değişmemesi. Yani toplam aslında geçerli takas toplamıdır. C++ 'da, bu veriler şu şekilde sorgulanabilir:

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

Sysctl.h başlık dosyasında bildirilen "xsw_usage" ifadesinin belgelenmemiş gibi göründüğünü ve bu değerlere erişmenin daha taşınabilir bir yolu olduğundan şüpheleniyorum.

İşlemim Tarafından Kullanılmakta Olan Sanal Bellek

task_info işlevini kullanarak geçerli işleminizle ilgili istatistikleri alabilirsiniz. Bu, işleminizin mevcut yerleşik boyutunu ve mevcut sanal boyutunu içerir.

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

Toplam RAM mevcut

Sisteminizde mevcut olan fiziksel RAM miktarı şunun gibi sysctl sistem işlevi kullanılarak kullanılabilir:

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

Şu Anda Kullanılan RAM

Genel bellek istatistiklerini Host_statistics sistem işlevinden alabilirsiniz.

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

Burada dikkat edilmesi gereken bir nokta, Mac OS X'te beş tür bellek sayfasının olmasıdır. Bunlar şöyledir:

  1. Wired kilitli olan ve yerinden çıkarılamayan sayfalar
  2. Aktif fiziksel belleğe yüklenen ve yerinden çıkması nispeten zor olan sayfalar
  3. Etkin değil belleğe yüklenen, ancak son zamanlarda kullanılmamış ve hiç de gerekli olmayabilir. Bunlar takas için potansiyel adaylardır. Bu hafızanın muhtemelen temizlenmesi gerekiyor.
  4. Cached Önbelleğe alınan sayfaların kolayca yeniden kullanılması muhtemel olan sayfalar. Önbelleğe alınmış hafıza muhtemelen temizleme gerektirmez. Önbelleğe alınmış sayfaların yeniden etkinleştirilmesi hala mümkündür
  5. Ücretsiz tamamen ücretsiz ve kullanıma hazır olan sayfalar.

Sadece Mac OS X'in kısa sürede kullanılmaya ne kadar hazır olduğunun iyi bir göstergesi olamayacağına dair zaman zaman çok az miktarda gerçek boş bellek gösterebileceği unutulmamalıdır.

İşlemim Tarafından Kullanılan RAM

Yukarıdaki "İşlemim Tarafından Kullanılmakta Olan Sanal Bellek" konusuna bakın. Aynı kod geçerlidir.

135
Michael Taylor

Linux

Linux'ta, bu bilgi/proc dosya sisteminde bulunur. Kullanılan her bir Linux dağıtımı en az bir önemli dosyayı kişiselleştirdiği için kullanılan metin dosyasının büyük bir hayranı değilim. 'Ps' kaynağı olarak hızlı bir bakış karışıklığı ortaya koymaktadır.

Ancak, aradığınız bilgiyi burada bulabilirsiniz:

/proc/meminfo , aradığınız sistem genelindeki bilgilerin çoğunu içerir. İşte sistemimdeki gibi görünüyor; İlgilendiğinizi düşünüyorum MemTotal , MemFree , SwapTotal ve 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

CPU kullanımı için küçük bir iş yapmanız gerekiyor. Linux, sistem başladığından beri genel CPU kullanımını mümkün kılar; Bu muhtemelen ilgilendiğiniz şey değil. Eğer CPU kullanımının son saniye veya 10 saniye ne olduğunu bilmek istiyorsanız, bilgileri sorgulamanız ve kendiniz hesaplamanız gerekir.

Bilgi http://www.linuxhowtos.org/System/) adresinde oldukça iyi belgelendirilmiş /proc/stat . procstat.htm ; 4 çekirdekli kutumda göründüğü gibi:

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

İlk olarak, sistemde kaç tane CPU (veya işlemci veya işlemci çekirdeği) bulunduğunu belirlemeniz gerekir. Bunu yapmak için, 'cpuN' girişlerinin sayısını, N'nin 0'dan başladığı ve artanları sayın. CpuN satırlarının bir birleşimi olan 'cpu' satırını saymayın. Benim örneğimde, toplam 4 işlemci için cpu0 ile cpu3'ü görebilirsiniz. Bundan sonra, cpu0..cpu3'ü yok sayabilir ve yalnızca 'cpu' hattına odaklanabilirsiniz.

Daha sonra, bu satırlardaki dördüncü sayının boşta kalma zamanının bir ölçüsü olduğunu bilmeniz gerekir ve bu nedenle 'cpu' satırındaki dördüncü sayının tüm işlemciler için önyükleme zamanından bu yana toplam boşta kalma süresi olduğunu belirtirsiniz. Bu süre, her biri saniyenin 1/100'ü olan Linux'ta "jiffies" ile ölçülür.

Ancak toplam boşta kalma süresi umrunda değil; boşta kalma sürelerini belirli bir periyodda, örneğin son saniyede. Bunu hesaplayın, bu dosyayı iki saniye, 1 saniye aralıklarla okumanız gerekir. Sonra satırın dördüncü değerinin bir farkını yapabilirsiniz. Örneğin, bir örnek alıp şunları alırsanız:

cpu  2330047 0 2365006 1063853632 9035 9463 96114 0

Sonra bir saniye sonra bu örneği alırsınız:

cpu  2330047 0 2365007 1063854028 9035 9463 96114 0

İki sayıyı çıkarın ve 396'lık bir fark elde edersiniz, bu işlemcinizin son 1.00 saniyeden 3.96 saniye boşta kaldığı anlamına gelir. İşin püf noktası, elbette, işlemci sayısına bölmek zorunda olmanız. 3.96/4 = 0.99 ve boşta yüzdesiniz var; % 99 boşta ve% 1 meşgul.

Kodumda 360 girişli bir halka arabelleğim var ve her saniye bu dosyayı okudum. Bu, CPU kullanımını 1 saniye, 10 saniye vb. İçin 1 saate kadar hızla hesaplamama izin veriyor.

İşleme özel bilgiler için, /proc/pid ; Pidinizi umursamıyorsanız,/proc/self ifadesine bakabilirsiniz.

İşleminiz tarafından kullanılan CPU /proc/self/stat 'de mevcuttur. Bu tek bir satırdan oluşan tuhaf görünümlü bir dosyadır; Örneğin:

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

Buradaki önemli veriler 13. ve 14. simgelerdir (burada 0 ve 770). 13. belirteç, işlemin kullanıcı modunda yürüttüğü ceza sayısı ve 14. işlemin çekirdek modunda yürüttüğü ceza sayısıdır. İkisini bir araya getirdiğinizde toplam CPU kullanımına sahip olursunuz.

Yine, işlemin CPU kullanımını zaman içinde belirlemek için bu dosyayı periyodik olarak örneklemeniz ve farkı hesaplamanız gerekir.

Düzenleme: işleminizin CPU kullanımını hesaplarken, 1) işleminizdeki iş parçacıklarının sayısını dikkate almanız gerektiğini unutmayın. sistemdeki işlemci sayısı. Örneğin, tek iş parçacıklı işleminiz CPU'nun yalnızca% 25'ini kullanıyorsa, bu iyi veya kötü olabilir. Tek işlemcili bir sistemde iyi, 4 işlemcili bir sistemde kötü; Bu, işleminizin sürekli çalıştığı ve kullanılabilir CPU işlemlerinin% 100'ünü kullandığı anlamına gelir.

İşleme özel hafıza bilgileri için,/proc/self/status ifadesine bakmalısınız:

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

'Vm' ile başlayan girişler ilginç olanlar:

  • VmPeak , işlem tarafından kB (1024 bayt) cinsinden kullanılan maksimum sanal bellek alanıdır.
  • VmSize , işlem tarafından kB olarak kullanılan geçerli sanal bellek alanıdır. Örneğimde oldukça büyük: 651,352 kB veya yaklaşık 636 megabayt.
  • VmRss , işlemin adres alanına veya yerleşik ayar boyutuna eşlenmiş bellek miktarıdır. Bu önemli ölçüde daha küçüktür (420,296 kB veya yaklaşık 410 megabayt). Fark: programım mmap () üzerinden 636 MB ile eşleşti, ancak yalnızca 410 MB'a erişti ve bu nedenle yalnızca 410 MB'a sayfa atandı.

Emin değilim tek şey Şu anda benim işlem tarafından kullanılan Swapspace . Bunun uygun olup olmadığını bilmiyorum.

61

Windows'ta aşağıdaki kodla cpu kullanımı alabilirsiniz:

#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

Belleği ve yükleme numaralarını okumanın taşınabilir bir yolu sysinfo call

Kullanım

   #include <sys/sysinfo.h>

   int sysinfo(struct sysinfo *info);

AÇIKLAMA

   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

Bu bir "kod atlama" gibi olduğundan QNX Bilgi tabanından bazı kodlar eklemek istiyorum (not: bu benim işim değil ama onu kontrol ettim ve sistemimde iyi çalışıyor):

CPU kullanımı% cinsinden nasıl elde edilir: 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();
}

Boş (!) Belleği nasıl elde edersiniz: http://www.qnx.com/support/knowledgebase.html?id=50130000000000bb

#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

Genel CPU kullanımı:

MacOS X’te sistem bilgilerini al? :

#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

Linux için/proc/self/statm komutunu, proc/self/status'dan aldığınız uzun bir raporlanmış bilgi listesinden geçmekten daha hızlı bir işlem olan anahtar işlem bellek bilgilerini içeren tek bir sayı satırını almak için de kullanabilirsiniz.

Bakınız 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

C++ projemde bu kodu kullandım ve iyi çalıştı:

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