Wie erhalte ich die aktuelle CPU- und RAM-Auslastung in C++?

Ist es in C++ möglich, die aktuelle RAM- und CPU-Auslastung abzurufen? Gibt es einen plattformunabhängigen Funktionsaufruf?

Leider hängen diese Dinge stark vom zugrunde liegenden Betriebssystem ab, daher gibt es keine plattformunabhängigen Aufrufe. (Vielleicht gibt es einige Wrapper-Frameworks, aber ich kenne keine.)

Unter Linux könntest du dir das anschauen getrusage() Funktionsaufruf, unter Windows können Sie verwenden GetProcessMemoryInfo() für die RAM-Nutzung. Schauen Sie sich auch die anderen Funktionen im an Prozessstatus-API von Windows.

Es gibt eine Open-Source-Bibliothek, die diese (und weitere Systeminformationen) für viele Plattformen bereitstellt: SIGAR-API

Ich habe es in ziemlich großen Projekten verwendet und es funktioniert gut (außer in bestimmten Eckfällen unter OS X usw.).

Eine plattformunabhängige Funktion dafür ist mir nicht bekannt. WENN Sie vorhaben, mehrere Windows-Versionen anzusprechen, beachten Sie, dass die Implementierung in einigen Versionen unterschiedlich ist. Ich bin auf dieses Problem gestoßen, als ich zum Beispiel eine App unter NT 3.51 getestet habe … (archaisch, ich weiß).

Hier ist ein Code, den ich für die Speicherseite der Dinge verwendet habe. Dies funktioniert nicht auf anderen Plattformen als Windows und gibt nur 0 zurück, wenn es ohne die WIN32-Definition kompiliert wird:

BEARBEITEN: Ich habe vergessen zu erwähnen, dieser Code teilt und rundet auf das nächste MB ab, daher die >> 20 überall.

// get memory info...
int getTotalRAM()
{
    int ret = 0;
#ifdef WIN32
    DWORD v = GetVersion();
    DWORD major =  (DWORD)(LOBYTE(LOWORD(v)));
    DWORD minor =  (DWORD)(HIBYTE(LOWORD(v)));
    DWORD build;
    if (v < 0x80000000) build = (DWORD)(HIWORD(v));
    else build = 0;

    // because compiler static links the function...
    BOOL (__stdcall*GMSEx)(LPMEMORYSTATUSEX) = 0;

    HINSTANCE hIL = LoadLibrary(L"kernel32.dll");
    GMSEx = (BOOL(__stdcall*)(LPMEMORYSTATUSEX))GetProcAddress(hIL, "GlobalMemoryStatusEx");

    if(GMSEx)
    {
        MEMORYSTATUSEX m;
        m.dwLength = sizeof(m);
        if(GMSEx(&m))
        {
            ret = (int)(m.ullTotalPhys>>20);
        }
    }
    else
    {
        MEMORYSTATUS m;
        m.dwLength = sizeof(m);
        GlobalMemoryStatus(&m);
        ret = (int)(m.dwTotalPhys>>20);
    }
#endif
    return ret;
}

int getAvailRAM()
{
    int ret = 0;
#ifdef WIN32
    DWORD v = GetVersion();
    DWORD major =  (DWORD)(LOBYTE(LOWORD(v)));
    DWORD minor =  (DWORD)(HIBYTE(LOWORD(v)));
    DWORD build;
    if (v < 0x80000000) build = (DWORD)(HIWORD(v));
    else build = 0;

    // because compiler static links the function...
    BOOL (__stdcall*GMSEx)(LPMEMORYSTATUSEX) = 0;

    HINSTANCE hIL = LoadLibrary(L"kernel32.dll");
    GMSEx = (BOOL(__stdcall*)(LPMEMORYSTATUSEX))GetProcAddress(hIL, "GlobalMemoryStatusEx");

    if(GMSEx)
    {
        MEMORYSTATUSEX m;
        m.dwLength = sizeof(m);
        if(GMSEx(&m))
        {
            ret = (int)(m.ullAvailPhys>>20);
        }
    }
    else
    {
        MEMORYSTATUS m;
        m.dwLength = sizeof(m);
        GlobalMemoryStatus(&m);
        ret = (int)(m.dwAvailPhys>>20);
    }
#endif
    return ret;
}

int getTotalMemory()
{
    int ret = 0;
#ifdef WIN32
    DWORD v = GetVersion();
    DWORD major =  (DWORD)(LOBYTE(LOWORD(v)));
    DWORD minor =  (DWORD)(HIBYTE(LOWORD(v)));
    DWORD build;
    if (v < 0x80000000) build = (DWORD)(HIWORD(v));
    else build = 0;

    // because compiler static links the function...
    BOOL (__stdcall*GMSEx)(LPMEMORYSTATUSEX) = 0;

    HINSTANCE hIL = LoadLibrary(L"kernel32.dll");
    GMSEx = (BOOL(__stdcall*)(LPMEMORYSTATUSEX))GetProcAddress(hIL, "GlobalMemoryStatusEx");

    if(GMSEx)
    {
        MEMORYSTATUSEX m;
        m.dwLength = sizeof(m);
        if(GMSEx(&m))
        {
            ret = (int)(m.ullTotalPhys>>20) + (int)(m.ullTotalVirtual>>20);
        }
    }
    else
    {
        MEMORYSTATUS m;
        m.dwLength = sizeof(m);
        GlobalMemoryStatus(&m);
        ret = (int)(m.dwTotalPhys>>20) + (int)(m.dwTotalVirtual>>20);
    }
#endif
    return ret;
}

int getAvailMemory()
{
    int ret = 0;
#ifdef WIN32
    DWORD v = GetVersion();
    DWORD major =  (DWORD)(LOBYTE(LOWORD(v)));
    DWORD minor =  (DWORD)(HIBYTE(LOWORD(v)));
    DWORD build;
    if (v < 0x80000000) build = (DWORD)(HIWORD(v));
    else build = 0;

    // because compiler static links the function...
    BOOL (__stdcall*GMSEx)(LPMEMORYSTATUSEX) = 0;

    HINSTANCE hIL = LoadLibrary(L"kernel32.dll");
    GMSEx = (BOOL(__stdcall*)(LPMEMORYSTATUSEX))GetProcAddress(hIL, "GlobalMemoryStatusEx");

    if(GMSEx)
    {
        MEMORYSTATUSEX m;
        m.dwLength = sizeof(m);
        if(GMSEx(&m))
        {
            ret = (int)(m.ullAvailPhys>>20) + (int)(m.ullAvailVirtual>>20);
        }
    }
    else
    {
        MEMORYSTATUS m;
        m.dwLength = sizeof(m);
        GlobalMemoryStatus(&m);
        ret = (int)(m.dwAvailPhys>>20) + (int)(m.dwAvailVirtual>>20);
    }
#endif
    return ret;
}

Nein, gibt es nicht, nicht im Standard.

Wenn Sie diese Informationen wirklich benötigen, müssen Sie plattformspezifische #ifdefs schreiben oder mit einer Bibliothek verknüpfen, die sie bereitstellt.

Unter Linux wird dies /proc/self/status verwenden. Um daraus eine Zahl zu machen, bedarf es weiterer Arbeit. Ich finde dies jedoch nützlich, um die Speichernutzung direkt als Zeichenfolge auf dem Bildschirm auszugeben.

static string memory_usage() {
        ostringstream mem;
        PP("hi");
        ifstream proc("/proc/self/status");
        string s;
        while(getline(proc, s), !proc.fail()) {
                if(s.substr(0, 6) == "VmSize") {
                        mem << s;
                        return mem.str();
                }
        }
        return mem.str();
}

Es gibt keine plattformunabhängige Möglichkeit, dies zu tun. Obwohl Sie für Windows die CPU-Nutzungs- und Leistungsmetriken abrufen können, indem Sie PDH.dll (Performance Data Helper) und die zugehörigen APIs in Ihrem Code verwenden.

Hier erfahren Sie mehr zur Verwendung.

Nicht direkt.

Sie können jedoch eine Bibliothek verwenden, die das Betriebssystem abstrahiert (z. B. ACE).
Dies könnte jedoch etwas schwer sein, wenn Sie nur CPU und Speicher benötigen.