Como determinar o consumo de CPU e memória de dentro de um processo?

593

Certa vez, tive a tarefa de determinar os seguintes parâmetros de desempenho de dentro de um aplicativo em execução:

  • Memória virtual total disponível
  • Memória virtual usada atualmente
  • Memória virtual usada atualmente pelo meu processo
  • RAM total disponível
  • RAM usada atualmente
  • RAM atualmente usada pelo meu processo
  • % De CPU atualmente usada
  • % De CPU atualmente usada pelo meu processo

O código teve que ser executado no Windows e Linux. Mesmo que isso pareça uma tarefa padrão, encontrar as informações necessárias nos manuais (API do WIN32, GNU docs) e na Internet levou vários dias, porque existem muitas informações incompletas / incorretas / desatualizadas sobre esse tópico. encontrado lá fora.

Para evitar que outras pessoas passem pelo mesmo problema, pensei que seria uma boa ideia coletar todas as informações dispersas, além do que encontrei por tentativa e erro aqui em um só lugar.

c++ c memory cpu Lanzelot
fonte
13
"Memória virtual total disponível" não faz sentido nos sistemas operacionais modernos.
David Schwartz
29
Por que não faz sentido? Invalida a resposta aqui? stackoverflow.com/questions/3296211/… ... não deixe cliffhangers ao comentar, não é um programa de TV.
Mindaugas Bernatavičius
3
@ MindaugasBernatavičius: A questão vinculada é sobre "memória física total", que é um fato de hardware conhecido pelo sistema operacional. Você obtém o total adicionando os tamanhos de todos os módulos de memória. "Memória virtual total disponível", por outro lado, o que isso significa? Esse é o espaço de endereço virtual combinado de todos os processos que teoricamente poderiam ser criados? Esse número seria de cerca de 2 ^ 80 bytes, portanto, sem sentido.
MSalters 15/08/19
2
@MSalters - obrigado por participar. Acredito que perguntar o que o OP tinha em mente é muito mais gentil e saudável do que afirmar que algo não tem sentido (sem explicação). Se você observar, as respostas também estão assumindo uma posição específica em relação a isso: Memória virtual = RAM + SWAP (ou PAGEFILE) - que é uma suposição razoável. A partir disso, sabemos que não tem sentido, pois existe uma interpretação particular desse termo (que, talvez não seja o mais tecnicamente correto, um coloquelismo) que tenha significado.
Mindaugas Bernatavičius
2
@ MindaugasBernatavičius: Isso ignora arquivos e códigos de memória mapeados que não são paginados. O Linux tem alocações de memória não confirmadas (não suportadas pela RAM ou troca) e o Windows tem pilhas não confirmadas.
MSalters

Respostas:

644

janelas

Alguns dos valores acima estão facilmente disponíveis na API WIN32 apropriada, basta listá-los aqui para garantir a integridade. Outros, no entanto, precisam ser obtidos na biblioteca Performance Data Helper (PDH), que é um pouco "pouco intuitiva" e requer muitas tentativas e erros dolorosos para chegar ao trabalho. (Pelo menos demorei um pouco, talvez eu tenha sido apenas um pouco estúpido ...)

Nota: para maior clareza, toda a verificação de erros foi omitida no código a seguir. Verifique os códigos de retorno ...!


  • Memória virtual total:

    #include "windows.h"

MEMORYSTATUSEX memInfo;
memInfo.dwLength = sizeof(MEMORYSTATUSEX);
GlobalMemoryStatusEx(&memInfo);
DWORDLONG totalVirtualMem = memInfo.ullTotalPageFile;

    Nota: O nome "TotalPageFile" é um pouco enganador aqui. Na realidade, este parâmetro fornece o "Tamanho da memória virtual", que é o tamanho do arquivo de troca mais a RAM instalada.

  • Memória virtual usada atualmente:

    O mesmo código que em "Memória virtual total" e depois

    DWORDLONG virtualMemUsed = memInfo.ullTotalPageFile - memInfo.ullAvailPageFile;

  • Memória virtual atualmente usada pelo processo atual:

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

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



  • Memória física total (RAM):

    O mesmo código que em "Memória virtual total" e depois

    DWORDLONG totalPhysMem = memInfo.ullTotalPhys;

  • Memória física atualmente usada:

    Same code as in "Total Virtual Memory" and then

DWORDLONG physMemUsed = memInfo.ullTotalPhys - memInfo.ullAvailPhys;

  • Memória física atualmente usada pelo processo atual:

    O mesmo código que em "Memória virtual atualmente usada pelo processo atual" e depois

    SIZE_T physMemUsedByMe = pmc.WorkingSetSize;



  • CPU usada atualmente:

    #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 atualmente usada pelo processo atual:

    #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

No Linux, a escolha que parecia óbvia a princípio foi usar as APIs do POSIX como getrusage()etc. Passei algum tempo tentando fazer com que isso funcionasse, mas nunca obtive valores significativos. Quando finalmente chequei as fontes do kernel, descobri que aparentemente essas APIs ainda não estão completamente implementadas no kernel 2.6 do Linux !?

No final, obtive todos os valores através de uma combinação de leitura do pseudo-sistema de arquivos /proce chamadas do kernel.

  • Memória 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;

  • Memória virtual usada atualmente:

    O mesmo código que em "Memória virtual total" e depois

    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;

  • Memória virtual atualmente usada pelo processo atual:

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



  • Memória física total (RAM):

    O mesmo código que em "Memória virtual total" e depois

    long long totalPhysMem = memInfo.totalram;
//Multiply in next statement to avoid int overflow on right hand side...
totalPhysMem *= memInfo.mem_unit;

  • Memória física atualmente usada:

    O mesmo código que em "Memória virtual total" e depois

    long long physMemUsed = memInfo.totalram - memInfo.freeram;
//Multiply in next statement to avoid int overflow on right hand side...
physMemUsed *= memInfo.mem_unit;

  • Memória física atualmente usada pelo processo atual:

    Altere getValue () em "Memória virtual usada atualmente pelo processo atual" da seguinte maneira:

    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 usada atualmente:

    #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 atualmente usada pelo processo atual:

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

Eu diria que parte do código do Linux também funciona para os Unixes, exceto as partes que lêem o pseudo-sistema de arquivos / proc. Talvez no Unix essas partes possam ser substituídas por getrusage()funções semelhantes? Se alguém com o conhecimento do Unix puder editar esta resposta e preencher os detalhes ?!

Lanzelot
fonte
10
Aviso: no PdhAddCounter a consulta deve ser localizada, caso contrário, ela será executada apenas em um sistema nativo em inglês. Para o sistema Vista / 2008 e posterior, prefira usar o PdhAddEnglishCounter para evitar problemas de localização.
Moala
2
@NunoAniceto Ao usar PROCESS_MEMORY_COUNTERS, como você está buscando a "Memória virtual atualmente usada pelo processo atual"? PrivateUsagenão é membro de PROCESS_MEMORY_COUNTERSé o erro do compilador que recebo!
CinCout
2
Por que você usa "quotes like these"para incluir cabeçalhos do sistema?
Lightness Races em órbita
8
@CinCout, você precisa de uma transmissão. Substitua GetProcessMemoryInfo (GetCurrentProcess (), & pmc, sizeof (pmc)); com GetProcessMemoryInfo (GetCurrentProcess (), (PROCESS_MEMORY_COUNTERS *) & pmc, sizeof (pmc));
Sumia 19/08/19
3
@Lanzelot Desde então, estamos muito acima do Linux Kernel 3.0. Você pode atualizar sua resposta do Linux para a API POSIX? Se possível, corrija a resposta do Windows também substituindo GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc));porGetProcessMemoryInfo(GetCurrentProcess(), (PROCESS_MEMORY_COUNTERS*)&pmc, sizeof(pmc));
Dr. Xperience
140

Mac OS X

Eu esperava encontrar informações semelhantes para o Mac OS X também. Como não estava aqui, eu saí e as desenterrei. Aqui estão algumas das coisas que encontrei. Se alguém tiver outras sugestões, eu adoraria ouvi-las.

Memória virtual total

Essa é complicada no Mac OS X porque não usa uma partição de troca predefinida ou arquivo como o Linux. Aqui está uma entrada da documentação da Apple:

Nota: Diferentemente da maioria dos sistemas operacionais baseados em Unix, o Mac OS X não usa uma partição de swap pré-alocada para memória virtual. Em vez disso, utiliza todo o espaço disponível na partição de inicialização da máquina.

Portanto, se você quiser saber quanta memória virtual ainda está disponível, é necessário obter o tamanho da partição raiz. Você pode fazer isso assim:

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

Total virtual usado atualmente

Chamar systcl com a chave "vm.swapusage" fornece informações interessantes sobre o uso de swap:

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

Não que o uso total da troca exibido aqui possa mudar se mais troca for necessária, conforme explicado na seção acima. Portanto, o total é realmente o total do swap atual . No C ++, esses dados podem ser consultados desta maneira:

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

Observe que o "xsw_usage", declarado em sysctl.h, não parece documentado e eu suspeito que exista uma maneira mais portátil de acessar esses valores.

Memória virtual atualmente usada pelo meu processo

Você pode obter estatísticas sobre seu processo atual usando a task_infofunção Isso inclui o tamanho atual do residente do seu processo e o tamanho virtual atual.

#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 disponível

A quantidade de RAM física disponível em seu sistema está disponível usando a sysctlfunção do sistema da seguinte maneira:

#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 usada atualmente

Você pode obter estatísticas gerais da memória a partir da host_statisticsfunção do 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;
}

Uma coisa a observar aqui é que existem cinco tipos de páginas de memória no Mac OS X. São as seguintes:

  1. Páginas com fio bloqueadas no lugar e não podem ser trocadas
  2. Páginas ativas que estão carregando na memória física e seriam relativamente difíceis de trocar
  3. Páginas inativas carregadas na memória, mas que não foram usadas recentemente e podem nem ser necessárias. Estes são potenciais candidatos à troca. Essa memória provavelmente precisaria ser liberada.
  4. Em cache páginas que foram de alguma forma em cache que são susceptíveis de ser facilmente reutilizados. A memória em cache provavelmente não exigiria liberação. Ainda é possível reativar as páginas em cache
  5. Gratuitos páginas que são completamente livres e pronto para ser usado.

É bom observar que, apenas porque o Mac OS X pode mostrar muito pouca memória livre real às vezes, pode não ser uma boa indicação de quanto está pronto para ser usado em pouco tempo.

RAM atualmente usada pelo meu processo

Consulte a "Memória virtual atualmente usada pelo meu processo" acima. O mesmo código se aplica.

Michael Taylor
fonte
Você deixou #include <mach / mach.h> para definir task_info () na seção "Memória virtual usada atualmente pelo meu processo". Este cabeçalho precisa ser incluído para definir essa função.
Dan Nissenbaum
4
Alguma idéia sobre como obter uso da CPU?
Mihir Mehta
@ Michael Taylor, isso é ótimo, obrigado, mas, na pergunta sobre a RAM atualmente usada no OS X, parece que você está recebendo estatísticas de VM, não memória física. Esse é realmente o caso aqui?
Edgar Aroutiounian
1
Como podemos calcular a memória do aplicativo e armazenar em cache a memória como um monitor de atividade? Usei vm_stats.inactive_page_count * page_size para calcular o cache de arquivos, mas não está sincronizado com o monitor de atividades. Obrigado antecipadamente
Amit Khandelwal
1
o autor original parece estar confuso sobre "memória virtual" - em alguns contextos, não se refere à memória trocada para disco, mas ao espaço de endereço virtual, que pode não ser totalmente paginado. Encontre um sistema que não esteja usando nenhuma troca e você verá que a maioria dos processos tem um tamanho "virt" maior que o tamanho "rss". Na seção "Memória virtual atualmente usada pelo meu processo", é a isso que a "memória virtual" se refere - espaço de endereço, não memória trocada para disco.
Pierce
63

Linux

No Linux, essas informações estão disponíveis no sistema de arquivos / proc. Não sou muito fã do formato de arquivo de texto usado, pois cada distribuição Linux parece personalizar pelo menos um arquivo importante. Uma rápida olhada na fonte do 'ps' revela a bagunça.

Mas aqui é onde encontrar as informações que você procura:

/ proc / meminfo contém a maioria das informações de todo o sistema que você procura. Aqui parece no meu sistema; Acho que você está interessado em MemTotal , MemFree , SwapTotal e 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 utilização da CPU, você precisa fazer um pouco de trabalho. O Linux disponibiliza a utilização geral da CPU desde o início do sistema; provavelmente não é disso que você está interessado. Se você quiser saber qual foi a utilização da CPU nos últimos segundos ou 10 segundos, precisará consultar as informações e calculá-las.

A informação está disponível em / proc / stat , que está bem documentada em http://www.linuxhowtos.org/System/procstat.htm ; aqui está o que parece na minha caixa 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

Primeiro, você precisa determinar quantas CPUs (ou processadores ou núcleos de processamento) estão disponíveis no sistema. Para fazer isso, conte o número de entradas 'cpuN', em que N começa em 0 e incrementa. Não conte a linha 'cpu', que é uma combinação das linhas cpuN. No meu exemplo, você pode ver cpu0 a cpu3, ​​para um total de 4 processadores. A partir de agora, você pode ignorar cpu0..cpu3 e focar apenas na linha 'cpu'.

Em seguida, você precisa saber que o quarto número nessas linhas é uma medida do tempo ocioso e, portanto, o quarto número na linha 'cpu' é o tempo total ocioso de todos os processadores desde o tempo de inicialização. Esse tempo é medido nos "jiffies" do Linux, que são 1/100 de segundo cada.

Mas você não se importa com o tempo total ocioso; você se importa com o tempo ocioso em um determinado período, por exemplo, o último segundo. Calcule isso, você precisará ler este arquivo duas vezes, com um segundo de diferença. Então, você pode fazer uma comparação do quarto valor da linha. Por exemplo, se você pegar uma amostra e obter:

cpu  2330047 0 2365006 1063853632 9035 9463 96114 0

Então, um segundo depois, você obtém esta amostra:

cpu  2330047 0 2365007 1063854028 9035 9463 96114 0

Subtraia os dois números e você obterá um diff de 396, o que significa que sua CPU ficou inativa por 3,96 segundos nos últimos 1,00 segundo. O truque, é claro, é que você precisa dividir pelo número de processadores. 3,96 / 4 = 0,99 e há sua porcentagem de inatividade; 99% ocioso e 1% ocupado.

No meu código, tenho um buffer de anel de 360 ​​entradas e leio esse arquivo a cada segundo. Isso permite calcular rapidamente a utilização da CPU por 1 segundo, 10 segundos etc., até 1 hora.

Para informações específicas do processo, você deve procurar em / proc / pid ; se você não se importa com o seu pid, pode procurar em / proc / self.

A CPU usada pelo seu processo está disponível em / proc / self / stat . Este é um arquivo de aparência estranha, composto por uma única linha; por exemplo:

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

Os dados importantes aqui são os 13º e 14º tokens (0 e 770 aqui). O 13º token é o número de jiffies que o processo executou no modo de usuário e o 14º é o número de jiffies que o processo executou no modo de kernel. Adicione os dois juntos e você terá sua utilização total da CPU.

Novamente, você terá que amostrar esse arquivo periodicamente e calcular o diff, a fim de determinar o uso da CPU do processo ao longo do tempo.

Editar: lembre-se de que, ao calcular a utilização da CPU do seu processo, é necessário levar em consideração 1) o número de threads no processo e 2) o número de processadores no sistema. Por exemplo, se seu processo de thread único estiver usando apenas 25% da CPU, isso poderá ser bom ou ruim. Bom em um sistema de processador único, mas ruim em um sistema de 4 processadores; isso significa que seu processo está em execução constante e usando 100% dos ciclos de CPU disponíveis.

Para as informações de memória específicas do processo, é necessário examinar / proc / self / status, que se parece com isso:

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

As entradas que começam com 'Vm' são as interessantes:

  • VmPeak é o espaço máximo de memória virtual usado pelo processo, em kB (1024 bytes).
  • VmSize é o espaço de memória virtual atual usado pelo processo, em kB. No meu exemplo, é bem grande: 651.352 kB, ou cerca de 636 megabytes.
  • VmRss é a quantidade de memória que foi mapeada no espaço de endereço do processo ou no tamanho do conjunto residente. Isso é substancialmente menor (420.296 kB, ou cerca de 410 megabytes). A diferença: meu programa mapeou 636 MB via mmap (), mas só acessou 410 MB e, portanto, apenas 410 MB de páginas foram atribuídos a ele.

O único item que não tenho certeza é o Swapspace atualmente usado pelo meu processo . Não sei se isso está disponível.

Martin Del Vecchio
fonte
1
Obrigado Martin, se eu tivesse todas essas informações coletadas em um só lugar, isso me salvaria algumas noites sem dormir ... No entanto, para a CPU do processo atual, acho que a função times () é uma abordagem mais fácil e confiável. BTW: Swapspace do processo atual = VmSize - VmRSS, não é?
Lanzelot
14

No Windows, você pode obter o uso da CPU pelo código abaixo:

#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;
    }
sayyed mohsen zahraee
fonte
isso pode ser modificado para uma função DLL externa que eu possa chamar mais tarde em c #?
Nico
11
A formatação de usage =é a coisa mais criativa que eu já vi em um tempo, não é legível em todos, mas criativo
ViRuSTriNiTy
Aviso: a expressão no código acima que calcula 'uso' está muito distante. Se o sistema estivesse ocioso, ele seria dividido por zero. Caso o tempo ocioso fosse igual ao tempo do usuário + do kernel, produziria 0 em vez de 50%, como seria de esperar.
Andrei Belogortseff 31/12/16
Lembre-se também de que, de acordo com o MSDN atual, o tempo do kernel também inclui o tempo ocioso!
Andrei Belogortseff 31/12/16
@sayyedmohsenzahraee: Não analisei a lógica, apenas um comentário sobre o próprio código. 1) Use variáveis ​​simples de 64 bits em vez de uma união, ou seja, ULONGLONGpara VS em vez de ULARGE_INTEGER. 2) Você está complicando demais as ligações CopyMemory(), basta fazer isso ULONGLONG ul_sys_idle = *(ULONGLONG*)&ft_sys_idle;. Será traduzido em uma única instrução de CPU mov(ou lea).
precisa saber é
12

Linux

Uma maneira portátil de ler números de memória e carregar é a sysinfochamada

Uso

   #include <sys/sysinfo.h>

   int sysinfo(struct sysinfo *info);

DESCRIÇÃO

   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.
Mark Lakata
fonte
3

QNX

Como isso é como uma "wikipage of code", quero adicionar algum código da base de dados de conhecimento do QNX (nota: este não é o meu trabalho, mas verifiquei-o e funciona bem no meu sistema):

Como obter o uso da CPU em%: 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();
}

Como obter a memória livre (!): 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;
}
Boernii
fonte
1

Mac OS X - CPU

Uso geral da CPU:

Em Recuperar informações do sistema no 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;
}
souch
fonte
0

Para Linux Você também pode usar / proc / self / statm para obter uma única linha de números contendo informações importantes sobre a memória do processo, o que é uma coisa mais rápida de processar do que passar por uma longa lista de informações relatadas conforme você obtém do proc / self / status

Veja 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)
Steven Warner
fonte
1
Alguém sabe o quão confiável é o tamanho total relatado nas páginas? Essa pegada real está em mem em páginas?
Niken
-1

Eu usei este código a seguir no meu projeto C ++ e funcionou bem:

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);
Salman Ghaffar
fonte
Você não obteve valores como 0,00% e valores, além de 100% por esse mecanismo?
Buddhika Chaturanga
Isso é para Mac OS?
RuLoViC
@RuLoViC É para Windows.
retangular