Ograniczenie sztucznej pamięci C/C++

Question

Czy istnieje sposób na łatwe ograniczenie aplikacji C/C++ do określonej ilości pamięci (około 30 MB)? Np .: jeśli moja aplikacja próbuje ukończyć załadowanie pliku 50mb do pamięci, umrze/wydrukuje komunikat i zakończy działanie/etc.

Wprawdzie mogę po prostu stale sprawdzać zużycie pamięci dla aplikacji, ale byłoby to trochę łatwiejsze, gdyby po prostu umarł z błędem, gdybym podszedł powyżej.

Wszelkie pomysły?

Platforma nie jest dużym problemem, Windows/Linux/jakiegokolwiek kompilatora.

Answer 1

Przeczytaj stronę podręcznika dla systemów ulimit na systemach unix. Jest wbudowana powłoka, w której możesz wywołać przed, uruchamiając twój plik wykonywalny lub (w sekcji 3 instrukcji) wywołanie API o tej samej nazwie.

Answer 2

Zastępuje wszystkie API malloc i udostępnia moduły obsługi nowego/usuwanego, dzięki czemu można zarezerwować przechowywanie pamięci i generowanie wyjątków w razie potrzeby.

Nie jestem pewien, czy jest to jeszcze łatwiejsze/oszczędza wysiłek, niż tylko monitorowanie pamięci za pośrednictwem interfejsów API dostarczanych przez system operacyjny.

Answer 3

W systemie Windows nie można ustawić limitu użycia pamięci bezpośrednio w procesie. Można jednak utworzyć obiekt zadania Windows, ustawić przydział dla obiektu zadania, a następnie przypisać proces do tego obiektu zadania.

Answer 4

W bash, użyj ulimit builtin:

bash$ ulimit -v 30000 
bash$ ./my_program 

-v trwa 1K bloków.

Aktualizacja:

Jeśli chcesz ustawić to z poziomu aplikacji, należy użyć setrlimit. Zwróć uwagę, że strona podręcznika dla ulimit(3) mówi wprost, że jest przestarzała.

Answer 5

Można ograniczyć wielkość pamięci wirtualnej procesu przy użyciu limitów systemowych. Jeśli przetwarzasz więcej niż ta kwota, zostanie zabity z sygnałem (myślę, że SIGBUS).

Można użyć coś takiego:

#include <sys/resource.h> 
#include <iostream> 

using namespace std; 

class RLimit { 
public: 
    RLimit(int cmd) : mCmd(cmd) { 
    } 

    void set(rlim_t value) { 
     clog << "Setting " << mCmd << " to " << value << endl; 
     struct rlimit rlim; 
     rlim.rlim_cur = value; 
     rlim.rlim_max = value; 
     int ret = setrlimit(mCmd, &rlim); 
     if (ret) { 
      clog << "Error setting rlimit" << endl; 
     } 
    } 

    rlim_t getCurrent() { 
     struct rlimit rlim = {0, 0}; 
     if (getrlimit(mCmd, &rlim)) { 
      clog << "Error in getrlimit" << endl; 
      return 0; 
     } 
     return rlim.rlim_cur; 
    } 
    rlim_t getMax() { 
     struct rlimit rlim = {0, 0}; 
     if (getrlimit(mCmd, &rlim)) { 
      clog << "Error in getrlimit" << endl; 
      return 0; 
     } 
     return rlim.rlim_max; 
    } 

private: 
    int mCmd; 
}; 

a następnie używać go tak:

RLimit dataLimit(RLIMIT_DATA); 
dataLimit.set(128 * 1024); // in kB 
clog << "soft: " << dataLimit.getCurrent() << " hard: " << dataLimit.getMax() << endl; 

Implementacja ta wydaje się nieco rozwlekły, ale pozwala łatwo i czysto ustawić różne limity (patrz ulimit -a).