Cómo averiguo cuánta memoria libre queda en GNU C++ en Linux

Question

Estoy escribiendo un programa en C++ (compilado con gcc y ejecutándolo en RedHat Linux). El programa necesita saber en tiempo de ejecución cuánto espacio queda en la pila y cuánto queda en el montón. Me doy cuenta de que puede que no haya una respuesta definitiva a esta pregunta (sobre el montón), así que alternativamente, podría usar la cantidad de memoria ya asignada del montón. ¿Hay una llamada de función de biblioteca/sistema que me dé esta información?

Me gustaría agregar que solo necesito esto para la depuración, y solo necesito cálculos aproximados, para que las soluciones rápidas y sucias sean perfectamente aceptables. Sin embargo, necesito consultar el uso de la memoria con mucha frecuencia, por lo que me desvío a una utilidad cmd-line de Unix y no es aceptable analizar su resultado.

Answer 1

Probablemente pueda crear sus propias funciones nuevas y eliminar que encapsulan a los operadores nuevos y eliminar y tomar nota del uso de la memoria al mismo tiempo.

Para la pila, hay un truco en C donde se echa un vistazo a la dirección de la primera variable local definida en su función actual para tener una idea aproximada de dónde está el puntero de pila en este momento. Supongo que debería funcionar en C++ pero no lo he probado.

Answer 2

Puede verificar en el espacio de nombres/proc los archivos/proc/< pid>/smaps y/proc/< pid>/maps, donde < pid> es la identificación del proceso actual.

Verificar this blogpost salir.

Answer 3

La herramienta Massig de Valgrind admite tanto stack como heap profiling. Es posible que desee comprobar su código fuente para ver cómo lo hace.

Answer 4

en Linux se puede leer/proc/pid/estado

Answer 5

Tenga en cuenta que en los sistemas de 32 bits, la pila crece hacia abajo y la pila crece hacia arriba, y los dos podría reunirse en algún lugar en el medio. El espacio podría, por lo tanto, asignarse a la pila o al montón, pero no a ambos al mismo tiempo. Tenga en cuenta que los segmentos de memoria compartida (si los usa) complican el mapa de memoria. Lo mismo ocurre con las bibliotecas cargadas dinámicamente (compartidas).

+------------+ 
| stack | high addresses 
|  |  | 
|  v  | 
+------------+ 
|   | 
| unused | 
|   | 
+------------+ 
|   | 
| ^ | 
|  |  | 
| heap | 
|   | 
+------------+ 
|   | 
|  bss | 
|   | 
+------------+ 
|   | 
| data | 
|   | 
+------------+ 
|   | 
| text | 
|   | low addresses 
+------------+ 

En un sistema de 64 bits, no hay suficiente espacio de direcciones que se queda sin memoria real y virtual antes de que ocurran las colisiones.

Además, tenga en cuenta que (al menos algunas versiones de) Linux están dispuestas a decir que se puede asignar más memoria de la que realmente pueden admitir: se comprometen demasiado. Eso no es muy bueno. Significa que los experimentos prácticos como las asignaciones de memoria de prueba pueden darle una falsa sensación de seguridad.

Lo más probable es que prefiera preguntar "¿queda el x MB (GB?) De espacio libre", en lugar de "cuántos MB (GB?) De espacio quedan". Otras personas señalaron el sistema de archivos /proc como fuente de información sobre la cantidad de memoria que se está utilizando. No estoy seguro de si le informa de manera confiable sobre la cantidad de memoria disponible para captar.

Answer 6

Para la parte del montón, tal vez está alcanzando un límite de recursos. Consulte this.

Puede usar Valgrind para crear perfiles de pila, pero ¿qué va a hacer con él? Stack no es como Heap. Usted dice que quiere hacer esto para fines de depuración. Si su programa funciona bien, entonces no hay problema de pila (relacionado con su tamaño al menos).

Puede establecer el tamaño de la pila para los hilos que ha creado e inspeccionar el valor del puntero de la pila mirando las direcciones de la variable local (que no debe optimizarse). Solo haga algunos cálculos utilizando el tamaño inicial, el valor del puntero de la pila inicial y el valor actual del puntero de la pila, obtendrá algunos buenos números. Simplemente no te olvides de averiguar la dirección de la pila primero. Esto puede cambiar de una plataforma a otra.

Creo que si te preocupas tanto por el uso del montón, entonces tu programa probablemente pierda memoria. En este caso, Valgrind puede indicarle la dirección correcta. Valgrind

Answer 7

getrlimit con un parámetro de RLIMIT_STACK le dirá cuánto espacio de pila hay en total. Con un parámetro de RLIMIT_AS, puede averiguar cuánta memoria virtual hay.

Para obtener más información vistazo a http://linux.die.net/man/2/getrlimit

Answer 8

Ésta es una función C para volver la cantidad de memoria libre en el Raspberry Pi. Funciona leyendo el/proc/meminfo. No estoy seguro de si funciona para otros sistemas.

#include <stdio.h> 
#include <string.h> 
// Return the amount of free memory in kbytes. 
// Returns -1 if something went wrong. 
int getfreememory() 
{ 
    int returnValue; 
    const int BUFFER_SIZE = 1000; 
    char buffer[BUFFER_SIZE]; 
    FILE *fInput; 
    int loop; 
    int len; 
    char ch; 
    returnValue = -1; 
    fInput = fopen("/proc/meminfo","r"); 
    if (fInput != NULL) 
    { 
    while (!feof(fInput)) 
    { 
     fgets(buffer,BUFFER_SIZE-1,fInput); 
     if (feof(fInput)) 
     { 
     break; 
     } 
     buffer[BUFFER_SIZE-1] = 0; 
     // Look for serial number 
     if (strncmp(buffer,"MemFree:",8)==0) 
     { 
     // Extract mem free from the line. 
     for(loop=0;loop<BUFFER_SIZE;loop++) 
     { 
      ch = buffer[loop]; 
      if (ch == ':') 
      { 
      returnValue = 0; 
      continue; 
      } 
      if (ch == 0) 
      { 
       break; 
      } 
      if (returnValue >=0) 
      { 
      if (ch >='A') 
      { 
       break; 
      } 
      if ((ch >='0') && (ch <='9')) 
      { 
       returnValue = returnValue * 10 + (ch-'0'); 
      } 
      } 
     } 
     break; 
     } 
    } 
    fclose(fInput); 
    } 
    return returnValue; 
}