¿Cómo determinar el consumo de CPU y memoria desde el interior de un proceso?


593

Una vez tuve la tarea de determinar los siguientes parámetros de rendimiento desde una aplicación en ejecución:

  • Memoria virtual total disponible
  • Memoria virtual utilizada actualmente
  • Memoria virtual utilizada actualmente por mi proceso
  • RAM total disponible
  • RAM utilizada actualmente
  • RAM utilizada actualmente por mi proceso
  • % De CPU utilizada actualmente
  • % De CPU utilizada actualmente por mi proceso

El código tuvo que ejecutarse en Windows y Linux. Aunque esto parece ser una tarea estándar, encontrar la información necesaria en los manuales (API WIN32, documentos GNU) y en Internet me llevó varios días, porque hay mucha información incompleta / incorrecta / desactualizada sobre este tema. descubierto por ahí.

Para evitar que otros pasen por el mismo problema, pensé que sería una buena idea recopilar toda la información dispersa más lo que encontré por prueba y error aquí en un solo lugar.


13
"Memoria virtual total disponible" no tiene sentido en los sistemas operativos modernos.
David Schwartz

29
¿Por qué no tiene sentido? ¿Invalida la respuesta aquí? stackoverflow.com/questions/3296211/… ... por favor no deje a los cliffhangers al comentar, no es un programa de televisión.
Mindaugas Bernatavičius

3
@ MindaugasBernatavičius: La pregunta vinculada es sobre "memoria física total", que es un hecho de hardware conocido por el sistema operativo. Obtiene el total sumando los tamaños de todos los módulos de memoria. "Memoria virtual total disponible", por otro lado, ¿qué significa eso? ¿Es ese el espacio de direcciones virtuales combinado de todos los procesos que teóricamente podrían crearse? Ese número sería de alrededor de 2 ^ 80 bytes, por lo que ciertamente no tiene sentido.
MSalters

2
@MSalters: gracias por participar. Creo que preguntar qué tenía el OP en mente es mucho más amable y saludable que afirmar que algo no tiene sentido (sin una explicación). Si observa, las respuestas también están asumiendo una posición particular con respecto a esto: memoria virtual = RAM + SWAP (o PAGEFILE), que es una suposición razonable. De esto sabemos que no tiene sentido, ya que hay una interpretación particular de este término (que, podría no ser el más técnicamente correcto, un coloquismo) que tiene significado.
Mindaugas Bernatavičius

2
@ MindaugasBernatavičius: Eso ignora los archivos de memoria mapeados y el código que no está paginado. Linux tiene asignaciones de memoria no comprometidas (no respaldadas por RAM o intercambio) y Windows tiene pilas no comprometidas.
MSalters

Respuestas:


644

Ventanas

Algunos de los valores anteriores están fácilmente disponibles en la API WIN32 apropiada, solo los enumero aquí para completar. Sin embargo, otros deben obtenerse de la biblioteca Performance Data Helper (PDH), que es un poco "poco intuitiva" y requiere muchas pruebas y errores dolorosos para llegar al trabajo. (Al menos me llevó bastante tiempo, tal vez he sido un poco estúpido ...)

Nota: para mayor claridad, todas las comprobaciones de errores se han omitido del siguiente código. ¡Verifique los códigos de retorno ...!


  • Memoria virtual total:

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

    Nota: El nombre "TotalPageFile" es un poco engañoso aquí. En realidad, este parámetro proporciona el "Tamaño de memoria virtual", que es el tamaño del archivo de intercambio más la RAM instalada.

  • Memoria virtual actualmente utilizada:

    Mismo código que en "Memoria virtual total" y luego

    DWORDLONG virtualMemUsed = memInfo.ullTotalPageFile - memInfo.ullAvailPageFile;
  • Memoria virtual utilizada actualmente por el proceso actual:

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



  • Memoria física total (RAM):

    Mismo código que en "Memoria virtual total" y luego

    DWORDLONG totalPhysMem = memInfo.ullTotalPhys;
  • Memoria física utilizada actualmente:

    Same code as in "Total Virtual Memory" and then
    
    DWORDLONG physMemUsed = memInfo.ullTotalPhys - memInfo.ullAvailPhys;
  • Memoria física utilizada actualmente por el proceso actual:

    Mismo código que en "Memoria virtual utilizada actualmente por el proceso actual" y luego

    SIZE_T physMemUsedByMe = pmc.WorkingSetSize;



  • CPU utilizada actualmente:

    #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 utilizada actualmente por el proceso actual:

    #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

En Linux, la elección que parecía obvia al principio era usar las API POSIX como getrusage()etc. Pasé un tiempo tratando de hacer que esto funcionara, pero nunca obtuve valores significativos. Cuando finalmente verifiqué las fuentes del kernel, descubrí que aparentemente estas API aún no están completamente implementadas a partir del kernel 2.6 de Linux.

Al final obtuve todos los valores a través de una combinación de leer el pseudo-sistema de archivos /procy las llamadas del kernel.

  • Memoria virtual total:

    #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;
  • Memoria virtual actualmente utilizada:

    Mismo código que en "Memoria virtual total" y luego

    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;
  • Memoria virtual utilizada actualmente por el proceso actual:

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



  • Memoria física total (RAM):

    Mismo código que en "Memoria virtual total" y luego

    long long totalPhysMem = memInfo.totalram;
    //Multiply in next statement to avoid int overflow on right hand side...
    totalPhysMem *= memInfo.mem_unit;
  • Memoria física utilizada actualmente:

    Mismo código que en "Memoria virtual total" y luego

    long long physMemUsed = memInfo.totalram - memInfo.freeram;
    //Multiply in next statement to avoid int overflow on right hand side...
    physMemUsed *= memInfo.mem_unit;
  • Memoria física utilizada actualmente por el proceso actual:

    Cambie getValue () en "Memoria virtual utilizada actualmente por el proceso actual" de la siguiente manera:

    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 utilizada actualmente:

    #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 utilizada actualmente por el proceso actual:

    #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: Otras plataformas

Supongo que parte del código de Linux también funciona para los Unix, a excepción de las partes que leen el pseudo-sistema de archivos / proc. ¿Quizás en Unix estas partes pueden ser reemplazadas por getrusage()funciones similares? ¿Si alguien con conocimientos de Unix pudiera editar esta respuesta y completar los detalles?


10
Advertencia: en PdhAddCounter la consulta debe estar localizada, de lo contrario solo se ejecutará en un sistema nativo de inglés. Para Vista / 2008 y sistemas posteriores, prefiera usar PdhAddEnglishCounter para evitar problemas de localización.
moala el

2
@NunoAniceto Al usarlo PROCESS_MEMORY_COUNTERS, ¿cómo está obteniendo la "Memoria virtual utilizada actualmente por el proceso actual"? PrivateUsageno es miembro de PROCESS_MEMORY_COUNTERSes el error del compilador que recibo!
CinCout

2
¿Por qué utilizas "quotes like these"para incluir encabezados del sistema?
Carreras de ligereza en órbita

8
@CinCout necesita una conversión ... reemplace GetProcessMemoryInfo (GetCurrentProcess (), & pmc, sizeof (pmc)); con GetProcessMemoryInfo (GetCurrentProcess (), (PROCESS_MEMORY_COUNTERS *) y pmc, sizeof (pmc));
Sumia

3
@Lanzelot Desde entonces, estamos muy por encima de Linux Kernel 3.0. ¿Puedes actualizar tu respuesta de Linux a la API POSIX? Si es posible, corrija también la Respuesta de Windows reemplazándola GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc));conGetProcessMemoryInfo(GetCurrentProcess(), (PROCESS_MEMORY_COUNTERS*)&pmc, sizeof(pmc));
Dr. Xperience

140

Mac OS X

Esperaba encontrar información similar para Mac OS X también. Como no estaba aquí, salí y lo desenterré. Estas son algunas de las cosas que encontré. Si alguien tiene alguna otra sugerencia, me encantaría escucharla.

Memoria virtual total

Este es complicado en Mac OS X porque no usa una partición o archivo de intercambio preestablecido como Linux. Aquí hay una entrada de la documentación de Apple:

Nota: A diferencia de la mayoría de los sistemas operativos basados ​​en Unix, Mac OS X no utiliza una partición de intercambio preasignada para la memoria virtual. En cambio, usa todo el espacio disponible en la partición de arranque de la máquina.

Por lo tanto, si desea saber cuánta memoria virtual aún está disponible, debe obtener el tamaño de la partición raíz. Puedes hacer eso así:

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

Total virtual actualmente utilizado

Llamar a systcl con la tecla "vm.swapusage" proporciona información interesante sobre el uso de intercambio:

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

No es que el uso de intercambio total que se muestra aquí pueda cambiar si se necesita más intercambio, como se explica en la sección anterior. Entonces el total es en realidad el total de intercambio actual . En C ++, estos datos se pueden consultar de esta manera:

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

Tenga en cuenta que el "xsw_usage", declarado en sysctl.h, parece no estar documentado y sospecho que hay una forma más portátil de acceder a estos valores.

Memoria virtual utilizada actualmente por mi proceso

Puede obtener estadísticas sobre su proceso actual utilizando la task_infofunción. Eso incluye el tamaño de residente actual de su proceso y el tamaño virtual actual.

#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 total disponible

La cantidad de RAM física disponible en su sistema está disponible utilizando la sysctlfunción del sistema de esta manera:

#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 utilizada actualmente

Puede obtener estadísticas generales de la memoria desde la host_statisticsfunción del sistema.

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

Una cosa a tener en cuenta aquí es que hay cinco tipos de páginas de memoria en Mac OS X. Son las siguientes:

  1. Páginas cableadas que están bloqueadas en su lugar y no se pueden intercambiar
  2. Páginas activas que se cargan en la memoria física y que serían relativamente difíciles de intercambiar
  3. Páginas inactivas que se cargan en la memoria, pero que no se han utilizado recientemente y es posible que ni siquiera sean necesarias. Estos son candidatos potenciales para el intercambio. Este recuerdo probablemente necesitaría ser vaciado.
  4. Páginas almacenadas en caché que han sido almacenadas de alguna manera que probablemente se reutilizarán fácilmente. La memoria en caché probablemente no requeriría enjuague. Todavía es posible que las páginas en caché se reactiven
  5. Páginas gratuitas que son completamente gratuitas y listas para ser utilizadas.

Es bueno tener en cuenta que solo porque Mac OS X puede mostrar muy poca memoria libre real a veces, puede que no sea una buena indicación de cuánto está listo para usarse a corto plazo.

RAM utilizada actualmente por mi proceso

Consulte la "Memoria virtual utilizada actualmente por mi proceso" más arriba. Se aplica el mismo código.


Dejó #include <mach / mach.h> para definir task_info () en la sección "Memoria virtual utilizada actualmente por mi proceso". Este encabezado debe incluirse para definir esa función.
Dan Nissenbaum

44
¿Alguna idea sobre cómo usar la CPU?
Mihir Mehta

@Michael Taylor, Esto es genial, gracias, pero pregunta sobre la RAM que se usa actualmente para OS X, parece que está obteniendo estadísticas de VM, no memoria física. ¿Es ese realmente el caso aquí?
Edgar Aroutiounian

1
¿Cómo podemos calcular la memoria de la aplicación y la memoria caché como monitor de actividad? Utilicé vm_stats.inactive_page_count * page_size para calcular el Caché de archivo pero no está sincronizado con el Monitor de actividad. Gracias de antemano
Amit Khandelwal

1
El autor original parece estar confundido acerca de la "memoria virtual": en algunos contextos no se refiere a la memoria intercambiada en el disco, sino más bien al espacio de direcciones virtuales, que puede no estar completamente paginado. Encuentre un sistema que no esté utilizando ningún intercambio, y verá que la mayoría de los procesos tienen un tamaño "virt" mayor que el tamaño "rss". En la sección "Memoria virtual utilizada actualmente por mi proceso", a eso se refiere la "memoria virtual": espacio de direcciones, no memoria intercambiada a disco.
Pierce

63

Linux

En Linux, esta información está disponible en el sistema de archivos / proc. No soy un gran admirador del formato de archivo de texto utilizado, ya que cada distribución de Linux parece personalizar al menos un archivo importante. Una mirada rápida como la fuente de 'ps' revela el desorden.

Pero aquí es donde encontrar la información que busca:

/ proc / meminfo contiene la mayoría de la información de todo el sistema que busca. Aquí se ve como en mi sistema; Creo que estás interesado en MemTotal , MemFree , SwapTotal y 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

Para la utilización de la CPU, debe hacer un poco de trabajo. Linux pone a disposición la utilización general de la CPU desde el inicio del sistema; esto probablemente no es lo que le interesa. Si desea saber cuál fue la utilización de la CPU durante el último segundo, o 10 segundos, entonces necesita consultar la información y calcularla usted mismo.

La información está disponible en / proc / stat , que se documenta bastante bien en http://www.linuxhowtos.org/System/procstat.htm ; así es como se ve en mi caja de 4 núcleos:

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

Primero, debe determinar cuántas CPU (o procesadores o núcleos de procesamiento) están disponibles en el sistema. Para hacer esto, cuente el número de entradas 'cpuN', donde N comienza en 0 e incrementa. No cuente la línea 'cpu', que es una combinación de las líneas cpuN. En mi ejemplo, puede ver cpu0 a cpu3, ​​para un total de 4 procesadores. De ahora en adelante, puede ignorar cpu0..cpu3 y centrarse solo en la línea 'cpu'.

A continuación, debe saber que el cuarto número en estas líneas es una medida del tiempo de inactividad y, por lo tanto, el cuarto número en la línea 'cpu' es el tiempo de inactividad total para todos los procesadores desde el tiempo de arranque. Este tiempo se mide en "jiffies" de Linux, que son 1/100 de segundo cada uno.

Pero no te importa el tiempo de inactividad total; le importa el tiempo de inactividad en un período determinado, por ejemplo, el último segundo. Calcule eso, necesita leer este archivo dos veces, con 1 segundo de diferencia. Luego puede hacer una diferencia del cuarto valor de la línea. Por ejemplo, si toma una muestra y obtiene:

cpu  2330047 0 2365006 1063853632 9035 9463 96114 0

Luego, un segundo después, obtienes esta muestra:

cpu  2330047 0 2365007 1063854028 9035 9463 96114 0

Resta los dos números, y obtienes un diferencial de 396, lo que significa que tu CPU había estado inactiva durante 3.96 segundos de los últimos 1.00 segundos. El truco, por supuesto, es que necesitas dividir por la cantidad de procesadores. 3.96 / 4 = 0.99, y está su porcentaje de inactividad; 99% inactivo y 1% ocupado.

En mi código, tengo un buffer de anillo de 360 ​​entradas, y leo este archivo cada segundo. Eso me permite calcular rápidamente la utilización de la CPU durante 1 segundo, 10 segundos, etc., hasta 1 hora.

Para la información específica del proceso, debe buscar en / proc / pid ; Si no te importa tu pid, puedes buscar en / proc / self.

La CPU utilizada por su proceso está disponible en / proc / self / stat . Este es un archivo de aspecto extraño que consta de una sola línea; por ejemplo:

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

Los datos importantes aquí son los tokens 13 y 14 (0 y 770 aquí). El 13º token es el número de jiffies que el proceso ha ejecutado en modo usuario, y el 14 es el número de jiffies que el proceso ha ejecutado en modo kernel. Agregue los dos juntos, y tendrá su utilización total de la CPU.

Nuevamente, tendrá que muestrear este archivo periódicamente y calcular la diferencia para determinar el uso de la CPU del proceso a lo largo del tiempo.

Editar: recuerde que cuando calcula la utilización de la CPU de su proceso, debe tener en cuenta 1) la cantidad de subprocesos en su proceso y 2) la cantidad de procesadores en el sistema. Por ejemplo, si su proceso de subproceso único utiliza solo el 25% de la CPU, eso podría ser bueno o malo. Bueno en un sistema de un solo procesador, pero malo en un sistema de 4 procesadores; Esto significa que su proceso se ejecuta constantemente y utiliza el 100% de los ciclos de CPU disponibles.

Para la información de memoria específica del proceso, debe mirar / proc / self / status, que se ve así:

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

Las entradas que comienzan con 'Vm' son las interesantes:

  • VmPeak es el espacio de memoria virtual máximo utilizado por el proceso, en kB (1024 bytes).
  • VmSize es el espacio de memoria virtual actual utilizado por el proceso, en kB. En mi ejemplo, es bastante grande: 651,352 kB, o aproximadamente 636 megabytes.
  • VmRss es la cantidad de memoria que se ha asignado al espacio de direcciones del proceso, o su tamaño de conjunto residente. Esto es sustancialmente más pequeño (420,296 kB, o aproximadamente 410 megabytes). La diferencia: mi programa ha asignado 636 MB a través de mmap (), pero solo ha accedido a 410 MB y, por lo tanto, solo se le han asignado 410 MB de páginas.

El único elemento del que no estoy seguro es Swapspace actualmente utilizado por mi proceso . No sé si esto está disponible.


1
Gracias Martin, si hubiera reunido toda esta información en un solo lugar, me habría ahorrado un par de noches sin dormir ... Sin embargo, para la CPU del proceso actual, creo que la función times () es un enfoque más fácil y más confiable. Por cierto: Swapspace del proceso actual = VmSize - VmRSS, ¿no?
Lanzelot

14

en windows puede obtener el uso de la CPU por el siguiente código:

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

¿Se puede modificar esto para una función DLL externa que luego puedo llamar en C #?
Nico

11
El formateo de usage =es lo más creativo que he visto en mucho tiempo, no se puede leer en absoluto, sino creativa
ViRuSTriNiTy

Advertencia: la expresión en el código anterior que calcula el "uso" está muy lejos. Si el sistema estuviera inactivo, se dividiría por cero. En caso de que el tiempo de inactividad fuera igual al usuario + tiempo de kernel, produciría 0 en lugar de 50% como cabría esperar.
Andrei Belogortseff

¡También tenga en cuenta que según el MSDN actual, el tiempo del kernel también incluye el tiempo de inactividad!
Andrei Belogortseff

@sayyedmohsenzahraee: No he investigado la lógica, solo un comentario sobre el código en sí. 1) Utilice variables simples de 64 bits en lugar de una unión, es decir, ULONGLONGpara VS en lugar de ULARGE_INTEGER. 2) Estás complicando demasiado las cosas llamando CopyMemory(), solo hazlo ULONGLONG ul_sys_idle = *(ULONGLONG*)&ft_sys_idle;. Se traducirá en una sola instrucción de CPU mov(o lea).
ahmd0

12

Linux

Una forma portátil de leer memoria y cargar números es la sysinfollamada

Uso

   #include <sys/sysinfo.h>

   int sysinfo(struct sysinfo *info);

DESCRIPCIÓN

   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.

3

QNX

Como esto es como un "wikipage de código", quiero agregar algo de código de la base de conocimientos de QNX (nota: este no es mi trabajo, pero lo verifiqué y funciona bien en mi sistema):

Cómo obtener el uso de CPU en%: 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();
}

Cómo obtener la memoria libre (!): 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;
} 

1

Mac OS X - CPU

Uso general de la CPU:

¿Desde Recuperar información del sistema en 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;
}

0

Para Linux También puede usar / proc / self / statm para obtener una sola línea de números que contenga información clave de la memoria de proceso, que es más rápido de procesar que pasar por una larga lista de información reportada a medida que obtiene de proc / self / status

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

1
¿Alguien sabe qué tan confiable es el tamaño total informado en las páginas? ¿Es esta huella real en mem en páginas?
niken

-1

Usé el siguiente código en mi proyecto C ++ y funcionó bien:

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

¿No tiene valores como 0.00% y valores, más allá del 100% por este mecanismo?
Buddhika Chaturanga

¿Es esto para Mac OS?
RuLoViC

@RuLoViC Es para Windows.
rectangular
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.