IT-Swarm.Net

Πώς να προσδιορίσετε την κατανάλωση CPU και μνήμης μέσα από μια διαδικασία;

Κάποτε είχα το καθήκον να προσδιορίσω τις ακόλουθες παραμέτρους απόδοσης μέσα σε μια τρέχουσα εφαρμογή:

  • Συνολική διαθέσιμη εικονική μνήμη
  • Η εικονική μνήμη που χρησιμοποιείται σήμερα
  • Εικονική μνήμη που χρησιμοποιείται σήμερα από τη διαδικασία μου
  • Συνολική διαθέσιμη RAM
  • RAM που χρησιμοποιείται σήμερα
  • RAM που χρησιμοποιείται σήμερα από τη διαδικασία μου
  • % CPU που χρησιμοποιείται σήμερα
  • % CPU που χρησιμοποιείται αυτή τη στιγμή από τη διαδικασία μου

Ο κώδικας έπρεπε να τρέχει σε Windows και Linux. Παρόλο που αυτό φαίνεται να είναι ένα τυπικό καθήκον, η εύρεση των απαραίτητων πληροφοριών στα εγχειρίδια (WIN32 API, GNU docs) καθώς και στο Διαδίκτυο μου πήρε αρκετές μέρες, επειδή υπάρχουν τόσα ελλιπή/λανθασμένα/ξεπερασμένα πληροφορίες σχετικά με αυτό το θέμα θα βρεθούν εκεί.

Προκειμένου να σωθούν οι άλλοι από το ίδιο πρόβλημα, σκέφτηκα ότι θα ήταν καλή ιδέα να συλλέξω όλες τις διάσπαρτες πληροφορίες συν αυτό που βρήκα με δοκιμή και λάθος εδώ σε ένα μέρος.

536
Lanzelot

Windows

Ορισμένες από τις παραπάνω τιμές είναι εύκολα διαθέσιμες από το κατάλληλο API WIN32, αναφέρω τις εδώ για πληρότητα. Άλλοι, όμως, πρέπει να αποκτηθούν από τη βιβλιοθήκη "Performance Data Helper" (PDH), η οποία είναι λίγο "απροσδιόριστη" και απαιτεί πολλές δοκιμές και σφάλματα για να φτάσουμε στη δουλειά. (Τουλάχιστον μου πήρε αρκετό καιρό, ίσως ήμουν μόνο λίγο ανόητος ...)

Σημείωση: για λόγους σαφήνειας, ο έλεγχος σφάλματος έχει παραλειφθεί από τον ακόλουθο κώδικα. Ελέγξτε τους κωδικούς επιστροφής ...!


  • Συνολική εικονική μνήμη:

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

    Σημείωση: Το όνομα "TotalPageFile" είναι κάπως παραπλανητικό εδώ. Στην πραγματικότητα αυτή η παράμετρος δίνει το "μέγεθος εικονικής μνήμης", το μέγεθος του αρχείου ανταλλαγής συν την εγκατεστημένη μνήμη RAM.

  • Εικονική μνήμη που χρησιμοποιείται σήμερα:

    Ο ίδιος κώδικας με τον όρο "Συνολική εικονική μνήμη" και στη συνέχεια

    DWORDLONG virtualMemUsed = memInfo.ullTotalPageFile - memInfo.ullAvailPageFile;
    
  • Εικονική μνήμη που χρησιμοποιείται σήμερα από την τρέχουσα διαδικασία:

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



  • Συνολική φυσική μνήμη (RAM):

    Ο ίδιος κώδικας με τον όρο "Συνολική εικονική μνήμη" και στη συνέχεια

    DWORDLONG totalPhysMem = memInfo.ullTotalPhys;
    
  • Φυσική μνήμη που χρησιμοποιείται σήμερα:

    Same code as in "Total Virtual Memory" and then
    
    DWORDLONG physMemUsed = memInfo.ullTotalPhys - memInfo.ullAvailPhys;
    
  • Φυσική μνήμη που χρησιμοποιείται σήμερα από την τρέχουσα διαδικασία:

    Ο ίδιος κώδικας με τον "Εικονική μνήμη που χρησιμοποιείται σήμερα από την τρέχουσα διαδικασία" και στη συνέχεια

    SIZE_T physMemUsedByMe = pmc.WorkingSetSize;
    



  • CPU που χρησιμοποιείται σήμερα:

    #include "TCHAR.h"
    #include "pdh.h"
    
    static PDH_HQUERY cpuQuery;
    static PDH_HCOUNTER cpuTotal;
    
    void init(){
        PdhOpenQuery(NULL, NULL, &cpuQuery);
        // You can also use L"\\Processor(*)\\% Processor Time" and get individual CPU values with PdhGetFormattedCounterArray()
        PdhAddEnglishCounter(cpuQuery, L"\\Processor(_Total)\\% Processor Time", NULL, &cpuTotal);
        PdhCollectQueryData(cpuQuery);
    }
    
    double getCurrentValue(){
        PDH_FMT_COUNTERVALUE counterVal;
    
        PdhCollectQueryData(cpuQuery);
        PdhGetFormattedCounterValue(cpuTotal, PDH_FMT_DOUBLE, NULL, &counterVal);
        return counterVal.doubleValue;
    }
    
  • CPU που χρησιμοποιείται σήμερα από την τρέχουσα διαδικασία:

    #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, η επιλογή που φαινόταν προφανής στην αρχή ήταν να χρησιμοποιήσει τα API POSIX όπως getrusage() κ.λπ. Πέρασα λίγο χρόνο προσπαθώντας να το βάλω σε δουλειά, αλλά ποτέ δεν πήρα νόημα. Όταν έλεγξα τελικά τις πηγές του πυρήνα τους, ανακάλυψα ότι προφανώς αυτά τα API δεν έχουν ακόμη εφαρμοστεί πλήρως από τον πυρήνα του Linux 2.6 !?

Στο τέλος πήρα όλες τις τιμές μέσω ενός συνδυασμού ανάγνωσης του /proc συστήματος ψευδο-αρχείων και των κλήσεων του πυρήνα.

  • Συνολική εικονική μνήμη:

    #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;
    
  • Εικονική μνήμη που χρησιμοποιείται σήμερα:

    Ο ίδιος κώδικας με τον όρο "Συνολική εικονική μνήμη" και στη συνέχεια

    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;
    
  • Εικονική μνήμη που χρησιμοποιείται σήμερα από την τρέχουσα διαδικασία:

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



  • Συνολική φυσική μνήμη (RAM):

    Ο ίδιος κώδικας με τον όρο "Συνολική εικονική μνήμη" και στη συνέχεια

    long long totalPhysMem = memInfo.totalram;
    //Multiply in next statement to avoid int overflow on right hand side...
    totalPhysMem *= memInfo.mem_unit;
    
  • Φυσική μνήμη που χρησιμοποιείται σήμερα:

    Ο ίδιος κώδικας με τον όρο "Συνολική εικονική μνήμη" και στη συνέχεια

    long long physMemUsed = memInfo.totalram - memInfo.freeram;
    //Multiply in next statement to avoid int overflow on right hand side...
    physMemUsed *= memInfo.mem_unit;
    
  • Φυσική μνήμη που χρησιμοποιείται σήμερα από την τρέχουσα διαδικασία:

    Αλλάξτε getValue () στην "Εικονική μνήμη που χρησιμοποιείται σήμερα από την τρέχουσα διαδικασία" ως εξής:

    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 που χρησιμοποιείται σήμερα:

    #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 που χρησιμοποιείται σήμερα από την τρέχουσα διαδικασία:

    #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: Άλλες πλατφόρμες

Θα υποθέσω ότι ορισμένος κώδικας Linux λειτουργεί επίσης για τους Unixes, εκτός από τα μέρη που διαβάζουν το/proc pseudo-fileystem. Ίσως στο Unix αυτά τα μέρη μπορούν να αντικατασταθούν από getrusage() και παρόμοιες λειτουργίες; Αν κάποιος με τεχνογνωσία του Unix μπορούσε να επεξεργαστεί αυτή την απάντηση και να συμπληρώσει τις λεπτομέρειες ;!

587
Lanzelot

Mac OS X

Ελπίζω να βρω παρόμοιες πληροφορίες για το Mac OS X επίσης. Δεδομένου ότι δεν ήταν εδώ, βγήκα έξω και έσκαψα τον εαυτό μου. Εδώ είναι μερικά από τα πράγματα που βρήκα. Αν κάποιος έχει άλλες προτάσεις, θα ήθελα πολύ να τις ακούσω.

Συνολική εικονική μνήμη

Αυτό είναι δύσκολο για Mac OS X επειδή δεν χρησιμοποιεί ένα προκαθορισμένο διαμέρισμα swap ή αρχείο όπως το Linux. Ακολουθεί μια καταχώρηση από την τεκμηρίωση της Apple:

Σημείωση: Σε αντίθεση με τα περισσότερα λειτουργικά συστήματα που βασίζονται σε Unix, το Mac OS X δεν χρησιμοποιεί ένα προεγκατεστημένο διαμέρισμα swap για εικονική μνήμη. Αντ 'αυτού, χρησιμοποιεί όλο το διαθέσιμο χώρο στο διαμέρισμα εκκίνησης του μηχανήματος.

Επομένως, εάν θέλετε να μάθετε πόση εικονική μνήμη είναι ακόμα διαθέσιμη, πρέπει να πάρετε το μέγεθος του ριζικού διαμερίσματος. Μπορείτε να το κάνετε έτσι:

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

Σύνολο εικονικών που χρησιμοποιούνται σήμερα

Η κλήση του systcl με το πλήκτρο "vm.swapusage" παρέχει ενδιαφέρουσες πληροφορίες σχετικά με τη χρήση της ανταλλαγής:

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

Όχι ότι η συνολική χρήση ανταλλαγής που εμφανίζεται εδώ μπορεί να αλλάξει εάν απαιτείται περισσότερη εναλλαγή όπως εξηγείται στην παραπάνω ενότητα. Έτσι, το σύνολο είναι στην πραγματικότητα το τρέχον σύνολο swap. Στην C++, τα δεδομένα αυτά μπορούν να ερωτηθούν με αυτόν τον τρόπο:

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

Σημειώστε ότι το xsw_usage που δηλώθηκε στο sysctl.h δεν φαίνεται τεκμηριωμένο και υποψιάζομαι ότι υπάρχει ένας πιο φορητός τρόπος πρόσβασης σε αυτές τις τιμές.

Η εικονική μνήμη που χρησιμοποιείται σήμερα από τη διαδικασία μου

Μπορείτε να λάβετε στατιστικά στοιχεία σχετικά με την τρέχουσα διαδικασία χρησιμοποιώντας τη συνάρτηση task_info. Αυτό περιλαμβάνει το τρέχον μέγεθος κατοίκου της διαδικασίας σας και το τρέχον εικονικό μέγεθος.

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

Συνολική διαθέσιμη RAM

Η ποσότητα της φυσικής RAM που είναι διαθέσιμη στο σύστημά σας είναι διαθέσιμη χρησιμοποιώντας τη λειτουργία συστήματος 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 που χρησιμοποιείται σήμερα

Μπορείτε να λάβετε στατιστικά στοιχεία γενικής μνήμης από τη λειτουργία συστήματος 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;
}

Ένα πράγμα που πρέπει να σημειωθεί εδώ είναι ότι υπάρχουν πέντε τύποι σελίδων μνήμης στο Mac OS X. Είναι οι εξής:

  1. Ενσύρματες σελίδες που είναι κλειδωμένες στη θέση τους και δεν μπορούν να μεταφερθούν
  2. Active σελίδες που φορτώνουν στη φυσική μνήμη και θα ήταν σχετικά δύσκολο να ανταλλάξουν
  3. Inactive σελίδες που έχουν φορτωθεί στη μνήμη, αλλά δεν έχουν χρησιμοποιηθεί πρόσφατα και ίσως να μην χρειαστούν καθόλου. Αυτοί είναι πιθανοί υποψήφιοι για ανταλλαγή. Αυτή η μνήμη θα πρέπει πιθανώς να ξεπλυθεί.
  4. Cached σελίδες που έχουν μερικούς τρόπους με τους οποίους είναι προσωρινά αποθηκευμένες στο cache, οι οποίες είναι πιθανό να επαναχρησιμοποιηθούν εύκολα. Η αποθηκευμένη μνήμη πιθανόν να μην απαιτεί έξαψη. Είναι ακόμα δυνατή η επανενεργοποίηση των προσωρινά αποθηκευμένων σελίδων
  5. Δωρεάν σελίδες που είναι εντελώς δωρεάν και έτοιμες για χρήση.

Είναι καλό να σημειωθεί ότι μόνο και μόνο επειδή το Mac OS X μπορεί να δείχνει πολύ λίγη πραγματική ελεύθερη μνήμη σε στιγμές που μπορεί να μην είναι μια καλή ένδειξη για το πόσο είναι έτοιμο να χρησιμοποιηθεί σε σύντομο χρονικό διάστημα.

RAM που χρησιμοποιείται σήμερα από τη διαδικασία μου

Ανατρέξτε στην ενότητα "Εικονική μνήμη που χρησιμοποιείται σήμερα από τη διαδικασία μου" παραπάνω. Ισχύει ο ίδιος κώδικας.

135
Michael Taylor

Linux

Στο Linux, αυτές οι πληροφορίες είναι διαθέσιμες στο σύστημα αρχείων/proc. Δεν είμαι μεγάλος οπαδός της μορφής αρχείου κειμένου που χρησιμοποιείται, καθώς κάθε διανομή Linux φαίνεται να προσαρμόζει τουλάχιστον ένα σημαντικό αρχείο. Μια γρήγορη εμφάνιση ως πηγή για το "ps" αποκαλύπτει το χάος.

Αλλά εδώ μπορείτε να βρείτε τις πληροφορίες που αναζητάτε:

/proc/meminfo περιέχει την πλειονότητα των πληροφοριών που αναζητάτε σε όλο το σύστημα. Εδώ μοιάζει με το σύστημά μου. Νομίζω ότι σας ενδιαφέρει το MemTotal , MemFree , SwapTotal και 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, πρέπει να κάνετε λίγη δουλειά. Το Linux καθιστά διαθέσιμη τη συνολική αξιοποίηση της CPU από την αρχή του συστήματος. αυτό πιθανότατα δεν είναι αυτό που σας ενδιαφέρει. Αν θέλετε να μάθετε ποια ήταν η χρήση της CPU για το τελευταίο δευτερόλεπτο, ή για 10 δευτερόλεπτα, τότε θα πρέπει να αναζητήσετε τις πληροφορίες και να τις υπολογίσετε μόνοι σας.

Οι πληροφορίες είναι διαθέσιμες στο /proc/stat , το οποίο τεκμηριώνεται αρκετά καλά στο http://www.linuxhowtos.org/System/procstat.htm . εδώ είναι αυτό που μοιάζει με το κουτί μου 4 πυρήνων:

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

Πρώτον, πρέπει να καθορίσετε πόσες CPU (ή επεξεργαστές ή πυρήνες επεξεργασίας) είναι διαθέσιμες στο σύστημα. Για να γίνει αυτό, μετρήστε τον αριθμό των καταχωρήσεων 'cpuN', όπου το N ξεκινά από το 0 και τα βήματα. Μην μετράτε τη γραμμή "CPU", η οποία είναι ένας συνδυασμός των γραμμών cpuN. Στο παράδειγμά μου, μπορείτε να δείτε cpu0 μέσω cpu3, ​​για ένα σύνολο 4 επεξεργαστών. Από εδώ και πέρα, μπορείτε να αγνοήσετε το cpu0..cpu3 και να εστιάσετε μόνο στη γραμμή 'cpu'.

Στη συνέχεια, πρέπει να γνωρίζετε ότι ο τέταρτος αριθμός σε αυτές τις γραμμές είναι ένα μέτρο του χρόνου αδράνειας και έτσι ο τέταρτος αριθμός στη γραμμή CPU είναι ο συνολικός χρόνος αδράνειας για όλους τους επεξεργαστές από τον χρόνο εκκίνησης. Αυτή τη φορά μετράται στο Linux "jiffies", τα οποία είναι 1/100 ενός δευτερολέπτου το καθένα.

Αλλά δεν σας ενδιαφέρει ο συνολικός χρόνος αδράνειας? σας ενδιαφέρει ο χρόνος αδράνειας σε μια δεδομένη περίοδο, π.χ. το τελευταίο δευτερόλεπτο. Υπολογίστε αυτό, πρέπει να διαβάσετε αυτό το αρχείο δύο φορές, 1 δευτερόλεπτο apart.Then μπορείτε να κάνετε μια διαφορά της τέταρτης τιμής της γραμμής. Για παράδειγμα, αν πάρετε ένα δείγμα και λάβετε:

cpu  2330047 0 2365006 1063853632 9035 9463 96114 0

Στη συνέχεια, ένα δευτερόλεπτο αργότερα θα λάβετε αυτό το δείγμα:

cpu  2330047 0 2365007 1063854028 9035 9463 96114 0

Αφαιρέστε τους δύο αριθμούς και θα έχετε διαφορά 396, πράγμα που σημαίνει ότι ο επεξεργαστής σας ήταν αδρανής για 3,96 δευτερόλεπτα από το τελευταίο 1,00 δευτερόλεπτο. Το τέχνασμα, φυσικά, είναι ότι πρέπει να διαιρέσετε τον αριθμό των επεξεργαστών. 3.96/4 = 0.99, και υπάρχει το ποσοστό αδράνειας σας? 99% σε κατάσταση αναμονής και 1% σε απασχολημένο.

Στον κώδικα μου, έχω ένα δαχτυλίδι buffer 360 εγγραφών, και διάβασα αυτό το αρχείο κάθε δευτερόλεπτο. Αυτό μου επιτρέπει να υπολογίσω γρήγορα τη χρήση της CPU για 1 δευτερόλεπτο, 10 δευτερόλεπτα κ.λπ., μέχρι το τέλος της ώρας.

Για τις πληροφορίες που αφορούν τη συγκεκριμένη διαδικασία, πρέπει να αναζητήσετε σε /proc/pid ; αν δεν ενδιαφέρεσαι να φτάσεις στο pid, μπορείς να δεις στο/proc/self.

Η CPU που χρησιμοποιείται από τη διαδικασία σας είναι διαθέσιμη σε /proc/self/stat . Πρόκειται για ένα περίεργο αρχείο που αποτελείται από μία μόνο γραμμή. για παράδειγμα:

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

Τα σημαντικά δεδομένα εδώ είναι η 13η και η 14η μάρκα (0 και 770 εδώ). Το 13ο διακριτικό είναι ο αριθμός των jiffies που έχει εκτελέσει η διαδικασία σε κατάσταση χρήστη και ο 14ος είναι ο αριθμός των jiffies που έχει εκτελέσει η διαδικασία σε λειτουργία πυρήνα. Προσθέστε τα δύο μαζί και έχετε τη συνολική χρήση της CPU.

Και πάλι, θα πρέπει να δοκιμάσετε αυτό το αρχείο περιοδικά, και να υπολογίσετε την diff, προκειμένου να προσδιορίσετε τη χρήση της CPU της διαδικασίας με την πάροδο του χρόνου.

Edit: να θυμάστε ότι όταν υπολογίζετε τη χρήση της CPU της διαδικασίας σας, πρέπει να λάβετε υπόψη 1) τον αριθμό των νημάτων στη διαδικασία σας και 2) τον αριθμό των επεξεργαστών στο σύστημα . Για παράδειγμα, εάν η διαδικασία με ένα μόνο σπείρωμα χρησιμοποιεί μόνο το 25% της CPU, αυτό θα μπορούσε να είναι καλό ή κακό. Καλά σε ένα σύστημα επεξεργαστή, αλλά κακό σε ένα σύστημα 4 επεξεργαστών. αυτό σημαίνει ότι η διαδικασία σας λειτουργεί συνεχώς και χρησιμοποιώντας το 100% των κύκλων της CPU που διαθέτει.

Για τις πληροφορίες της μνήμης που αφορούν τη διαδικασία, μπορείτε να δείτε το/proc/self/status, το οποίο μοιάζει με αυτό:

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' είναι οι ενδιαφέρουσες:

  • VmPeak είναι ο μέγιστος χώρος εικονικής μνήμης που χρησιμοποιείται από τη διαδικασία, σε kB (1024 bytes).
  • VmSize είναι ο τρέχων χώρος εικονικής μνήμης που χρησιμοποιείται από τη διαδικασία, σε kB. Στο παράδειγμά μου, είναι αρκετά μεγάλο: 651.352 kB, ή περίπου 636 megabytes.
  • VmRss είναι η ποσότητα της μνήμης που έχουν χαρτογραφηθεί στο χώρο διευθύνσεων της διεργασίας ή το καθορισμένο μέγεθος διαμονής της. Αυτό είναι σημαντικά μικρότερο (420,296 kB ή περίπου 410 megabyte). Η διαφορά: το πρόγραμμά μου έχει χαρτογραφήσει 636 MB μέσω mmap (), αλλά έχει πρόσβαση μόνο 410 MB από αυτό, και έτσι έχουν εκχωρηθεί μόνο 410 MB σελίδων.

Το μόνο στοιχείο που δεν είμαι σίγουρος είναι Swapspace που χρησιμοποιείται σήμερα από τη διαδικασία μου . Δεν ξέρω αν αυτό είναι διαθέσιμο.

61
Martin Del Vecchio

στα παράθυρα μπορείτε να πάρετε τη χρήση CPU με τον παρακάτω κώδικα:

#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
sayyed mohsen zahraee

Linux

Ένας φορητός τρόπος ανάγνωσης αριθμών μνήμης και φόρτωσης είναι η sysinfocall

Χρήση

   #include <sys/sysinfo.h>

   int sysinfo(struct sysinfo *info);

ΠΕΡΙΓΡΑΦΗ

   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

Δεδομένου ότι αυτό είναι σαν ένα "wikipage κώδικα" θέλω να προσθέσω κάποιο κώδικα από τη βάση γνώσεων QNX (σημείωση: αυτό δεν είναι δουλειά μου, αλλά το έλεγξα και λειτουργεί καλά στο σύστημά μου):

Πώς να χρησιμοποιήσετε τη CPU σε%: 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();
}

Πώς να αποκτήσετε την ελεύθερη (!) Μνήμη: 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

Συνολική χρήση της CPU:

Από Ανάκτηση πληροφοριών συστήματος στο 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

Για το Linux Μπορείτε επίσης να χρησιμοποιήσετε το/proc/self/statm για να αποκτήσετε μια ενιαία γραμμή αριθμών που περιέχουν τις βασικές πληροφορίες της μνήμης διαδικασίας, κάτι που είναι πιο γρήγορο για να επεξεργαστείτε παρά να περάσετε από μια μακρά λίστα αναφερόμενων πληροφοριών όπως μπορείτε να αποκτήσετε από το proc/self/status

Βλέπε 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++ και αυτό λειτούργησε καλά:

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