Artificial Limit C/C++ Memory Usage

Question

¿Hay alguna forma de limitar fácilmente una aplicación C/C++ a una cantidad específica de memoria (30 mb o menos)? Por ejemplo: si mi aplicación intenta completar la carga de un archivo de 50 mb en memoria, morirá/imprimirá un mensaje y saldrá de/etc.

Es cierto que puedo verificar constantemente el uso de memoria para la aplicación, pero sería un poco más fácil si simplemente muriera con un error si fuera más arriba.

¿Alguna idea?

La plataforma no es un gran problema, compilador de windows/linux/whatever.

Answer 1

Lea la página del manual para ulimit en los sistemas Unix. Hay un shell incorporado que puede invocar antes de ejecutar su ejecutable o (en la sección 3 del manual) una llamada API del mismo nombre.

Answer 2

Anule todas las API malloc y proporcione controladores para nuevo/eliminar, para que pueda reservar mantener el uso de memoria y lanzar excepciones cuando sea necesario.

No estoy seguro si esto es aún más fácil/ahorro de esfuerzo que solo hacer la supervisión de la memoria a través de las API proporcionadas por el sistema operativo.

Answer 3

En Windows, no puede establecer una cuota para el uso de memoria de un proceso directamente. Sin embargo, puede crear un objeto de trabajo de Windows, establecer la cuota para el objeto de trabajo y luego asignar el proceso a ese objeto de trabajo.

Answer 4

En bash, utilice el ulimit builtin:

bash$ ulimit -v 30000 
bash$ ./my_program 

El -v toma 1K bloques.

Actualización:

Si desea establecer esto desde dentro de su aplicación, utilice setrlimit. Tenga en cuenta que la página man para ulimit(3) dice explícitamente que está obsoleta.

Answer 5

Puede limitar el tamaño de la memoria virtual de su proceso utilizando los límites del sistema. Si procesa excede esta cantidad, se matará con una señal (creo que SIGBUS).

Usted puede usar algo como:

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

y luego usarlo como esa:

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

Esta aplicación parece un poco prolijo pero le permite configurar fácilmente y limpiamente diferentes límites (ver ulimit -a)