resueltos - memorias dinamicas en c

Uso de memoria del proceso actual en C

Question

Necesito obtener el uso de memoria del proceso actual en C. ¿Puede alguien ofrecer un ejemplo de código de cómo hacer esto en una plataforma Linux?

Soy consciente del método cat /proc/<your pid>/status para obtener el uso de la memoria, pero no tengo idea de cómo capturar eso en C.

Por cierto, es para una extensión de PHP que estoy modificando (concedido, soy un novato en C). Si hay accesos directos disponibles dentro de la extensión de la API de PHP, eso sería aún más útil.

Answer 1

Esta es una forma terriblemente fea y no portátil de obtener el uso de la memoria, pero como el seguimiento de la memoria de getrusage () es esencialmente inútil en Linux, leer / proc // statm es la única forma que conozco para obtener información sobre Linux .

Si alguien sabe de formas más limpias, o preferiblemente más cruzadas de Unix, de rastrear el uso de la memoria, estaría muy interesado en saber cómo.

typedef struct {
    unsigned long size,resident,share,text,lib,data,dt;
} statm_t;

void read_off_memory_status(statm_t& result)
{
  unsigned long dummy;
  const char* statm_path = "/proc/self/statm";

  FILE *f = fopen(statm_path,"r");
  if(!f){
    perror(statm_path);
    abort();
  }
  if(7 != fscanf(f,"%ld %ld %ld %ld %ld %ld %ld",
    &result.size,&result.resident,&result.share,&result.text,&result.lib,&result.data,&result.dt))
  {
    perror(statm_path);
    abort();
  }
  fclose(f);
}

De la página de manual proc (5):

   /proc/[pid]/statm
          Provides information about memory usage, measured in pages.  
          The columns are:

              size       total program size
                         (same as VmSize in /proc/[pid]/status)
              resident   resident set size
                         (same as VmRSS in /proc/[pid]/status)
              share      shared pages (from shared mappings)
              text       text (code)
              lib        library (unused in Linux 2.6)
              data       data + stack
              dt         dirty pages (unused in Linux 2.6)

Answer 2

La estructura anterior fue tomada de 4.3BSD Reno. No todos los campos son significativos bajo Linux. En Linux 2.4 solo se mantienen los campos ru_utime, ru_stime, ru_minflt y ru_majflt. Desde Linux 2.6, ru_nvcsw y ru_nivcsw también se mantienen.

http://www.atarininja.org/index.py/tags/code

Answer 3

La función de biblioteca getrusage devuelve una estructura que contiene una gran cantidad de datos sobre el proceso actual, incluidos estos:

long   ru_ixrss;         /* integral shared memory size */
long   ru_idrss;         /* integral unshared data size */
long   ru_isrss;         /* integral unshared stack size */

Sin embargo, la documentación más actualizada de Linux dice acerca de estos 3 campos

(unmaintained) This field is currently unused on Linux

Ver getrusage(2)

Answer 4

Llego tarde a la fiesta, pero esto puede ser útil para cualquier otra persona que busque los recuerdos residentes y virtuales (y sus valores máximos hasta ahora) en Linux.

Probablemente es bastante terrible, pero hace el trabajo.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


/*
 * Measures the current (and peak) resident and virtual memories
 * usage of your linux C process, in kB
 */
void getMemory(
    int* currRealMem, int* peakRealMem,
    int* currVirtMem, int* peakVirtMem) {

    // stores each word in status file
    char buffer[1024] = "";

    // linux file contains this-process info
    FILE* file = fopen("/proc/self/status", "r");

    // read the entire file
    while (fscanf(file, " %1023s", buffer) == 1) {

        if (strcmp(buffer, "VmRSS:") == 0) {
            fscanf(file, " %d", currRealMem);
        }
        if (strcmp(buffer, "VmHWM:") == 0) {
            fscanf(file, " %d", peakRealMem);
        }
        if (strcmp(buffer, "VmSize:") == 0) {
            fscanf(file, " %d", currVirtMem);
        }
        if (strcmp(buffer, "VmPeak:") == 0) {
            fscanf(file, " %d", peakVirtMem);
        }
    }
    fclose(file);
}

Answer 5

Me encontré con este post: http://appcrawler.com/wordpress/2013/05/13/simple-example-of-tracking-memory-using-getrusage/

Versión simplificada:

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

int main() {
  struct rusage r_usage;
  getrusage(RUSAGE_SELF,&r_usage);
  // Print the maximum resident set size used (in kilobytes).
  printf("Memory usage: %ld kilobytes/n",r_usage.ru_maxrss);
  return 0;
}

(probado en Linux 3.13)

Answer 6

Siempre puede abrir los ''archivos'' en el sistema /proc como lo haría con un archivo normal (usando el enlace simbólico ''self'' para que no tenga que buscar su propio pid):

FILE* status = fopen( "/proc/self/status", "r" );

Por supuesto, ahora tiene que analizar el archivo para seleccionar la información que necesita.

Answer 7

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

errno = 0;
struct rusage* memory = malloc(sizeof(struct rusage));
getrusage(RUSAGE_SELF, memory);
if(errno == EFAULT)
    printf("Error: EFAULT/n");
else if(errno == EINVAL)
    printf("Error: EINVAL/n");
printf("Usage: %ld/n", memory->ru_ixrss);
printf("Usage: %ld/n", memory->ru_isrss);
printf("Usage: %ld/n", memory->ru_idrss);
printf("Max: %ld/n", memory->ru_maxrss);

Usé este código, pero por alguna razón obtengo 0 todo el tiempo para los 4 printf ()