Jak uzyskać dostępną pamięć C++ / g++?

W systemach operacyjnych uniksopodobnych istnieje sysconf .

#include <unistd.h>

unsigned long long getTotalSystemMemory()
{
    long pages = sysconf(_SC_PHYS_PAGES);
    long page_size = sysconf(_SC_PAGE_SIZE);
    return pages * page_size;
}

W systemie Windows jest GlobalMemoryStatusEx:

#include <windows.h>

unsigned long long getTotalSystemMemory()
{
    MEMORYSTATUSEX status;
    status.dwLength = sizeof(status);
    GlobalMemoryStatusEx(&status);
    return status.ullTotalPhys;
}

Istnieją powody, dla których warto to zrobić w HPC dla oprogramowania naukowego. (Nie gier, stron internetowych, oprogramowania biznesowego lub wbudowanego). Oprogramowanie naukowe rutynowo przejść przez terabajty danych, aby uzyskać przez jednego obliczenia (lub uruchomić) (i uruchomić przez godziny lub tygodnie) - z których wszystkie nie mogą być przechowywane w pamięci (i jeśli pewnego dnia powiesz mi terabajt jest standardem dla każdego komputera PC lub tabletu lub telefonu będzie to przypadek, że oprogramowanie naukowe będzie oczekiwać obsługi petabajtów lub więcej). Ilość pamięci może również dyktować rodzaj metody / algorytmu, który ma sens. Użytkownik nie zawsze chce decydować o pamięci i metodzie-ma inne zmartwienia. Tak więc programista powinien mieć dobry pomysł na to, co jest dostępne (4GB lub 8Gb lub 64GB lub mniej więcej w dzisiejszych czasach), aby zdecydować, czy metoda będzie działać automatycznie, czy też należy wybrać bardziej pracochłonną metodę. Dysk jest używany, ale pamięć jest preferowana. I użytkownicy takiego oprogramowania nie są zachęcani do robienia zbyt wielu rzeczy na swoich komputer podczas uruchamiania takiego oprogramowania-w rzeczywistości często używają dedykowanych maszyn/serwerów.

Nie ma na to sposobu niezależnego od platformy, różne systemy operacyjne wykorzystują różne strategie zarządzania pamięcią.

Inne pytania dotyczące przepełnienia stosu pomogą:

• Jak uzyskać zużycie pamięci w czasie wykonywania w c++?
• C / C++ wykorzystanie pamięci API w Linuksie / Windows

Powinieneś jednak uważać: notorycznie trudno jest uzyskać "rzeczywistą" wartość dostępnej pamięci w Linuksie. Co wyświetla system operacyjny używany przez proces nie jest gwarancją tego, co jest faktycznie przydzielone dla procesu.

Jest to częsty problem podczas tworzenia wbudowanych systemów linux, takich jak routery, gdzie chcesz buforować tyle, ile pozwala na to sprzęt. Oto link do przykładu pokazującego, jak uzyskać te informacje w Linuksie (w C):

• http://www.unix.com/programming/25035-determining-free-available-memory-mv-linux.html

Przykład Mac OS X przy użyciu sysctl (man 3 sysctl):

#include <stdio.h>
#include <stdint.h>
#include <sys/types.h>
#include <sys/sysctl.h>

int main(void)
{
    int mib[2] = { CTL_HW, HW_MEMSIZE };
    u_int namelen = sizeof(mib) / sizeof(mib[0]);
    uint64_t size;
    size_t len = sizeof(size);

    if (sysctl(mib, namelen, &size, &len, NULL, 0) < 0)
    {
        perror("sysctl");
    }
    else
    {
        printf("HW.HW_MEMSIZE = %llu bytes\n", size);
    }
    return 0;
}

(może działać również na innych systemach operacyjnych podobnych do BSD ?)

"oficjalną" funkcją jest std::get_temporary_buffer(). Możesz jednak sprawdzić, czy Twoja platforma ma przyzwoitą implementację. Rozumiem, że nie wszystkie platformy zachowują się zgodnie z życzeniem.

Poniższy kod podaje całkowitą i wolną pamięć w megabajtach. Działa na FreeBSD, ale powinieneś być w stanie używać tych samych / podobnych tunabli sysctl na swojej platformie i robić to samo (Linux i OS X mają przynajmniej sysctl)

#include <stdio.h>
#include <errno.h>

#include <sys/types.h>
#include <sys/sysctl.h>
#include <sys/vmmeter.h>

int main(){
    int rc;
    u_int page_size;
    struct vmtotal vmt;
    size_t vmt_size, uint_size; 

    vmt_size = sizeof(vmt);
    uint_size = sizeof(page_size);

    rc = sysctlbyname("vm.vmtotal", &vmt, &vmt_size, NULL, 0);
    if (rc < 0){
       perror("sysctlbyname");
       return 1;
    }

    rc = sysctlbyname("vm.stats.vm.v_page_size", &page_size, &uint_size, NULL, 0);
    if (rc < 0){
       perror("sysctlbyname");
       return 1;
    }

    printf("Free memory       : %ld\n", vmt.t_free * (u_int64_t)page_size);
    printf("Available memory  : %ld\n", vmt.t_avm * (u_int64_t)page_size);

    return 0;
}

Poniżej znajduje się wyjście programu, w porównaniu z wyjściem vmstat(8) w moim systemie.

~/code/memstats % cc memstats.c 
~/code/memstats % ./a.out 
Free memory       : 5481914368
Available memory  : 8473378816
~/code/memstats % vmstat 
 procs      memory      page                    disks     faults         cpu
 r b w     avm    fre   flt  re  pi  po    fr  sr ad0 ad1   in   sy   cs us sy id
 0 0 0   8093M  5228M   287   0   1   0   304 133   0   0  112 9597 1652  2  1 97

Zamiast zgadywać, czy rozważyłeś pozwolenie użytkownikowi na skonfigurowanie ilości pamięci do wykorzystania w buforach, a także założenie nieco konserwatywnych domyślnych wartości? W ten sposób możesz nadal działać (prawdopodobnie nieco wolniej) bez nadpisywania, ale jeśli użytkownik wie, że dostępna jest pamięć X dla aplikacji, może poprawić wydajność, konfigurując tę ilość.