web-dev-qa-db-fra.com

Utilisation de la mémoire du processus en cours en C

Je dois connaître l'utilisation de la mémoire du processus en cours en C. Quelqu'un peut-il offrir un exemple de code expliquant comment procéder sur une plate-forme Linux?

Je connais la méthode cat /proc/<your pid>/status pour obtenir l'utilisation de la mémoire, mais je ne sais pas comment capturer cela en C.

Au fait, c'est pour une extension PHP que je modifie (d'accord, je suis un débutant en C). S'il existe des raccourcis disponibles dans l'API d'extension PHP, cela serait encore plus utile.

clinuxmemorymemory-managementphp-extension
19
scotts

Vous pouvez toujours simplement ouvrir les 'fichiers' dans le système /proc comme vous le feriez avec un fichier normal (en utilisant le lien symbolique 'self' pour ne pas avoir à chercher votre propre pid):

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

Bien sûr, vous devez maintenant analyser le fichier pour choisir les informations dont vous avez besoin.

25
CB Bailey

La fonction de bibliothèque getrusage renvoie une structure contenant de nombreuses données sur le processus en cours, notamment:

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

Cependant, la documentation la plus récente de Linux dit à propos de ces 3 champs

(unmaintained) This field is currently unused on Linux

Voir getrusage (2)

24
caf

C’est un moyen terriblement laide et non portable d’obtenir l’utilisation de la mémoire, mais comme le suivi de la mémoire de getrusage () est essentiellement inutile sur Linux, la lecture de/proc // statm est le seul moyen que je connaisse pour obtenir les informations sur Linux. .

Si quelqu'un connaissait des méthodes plus propres ou plus communes pour suivre l'utilisation de la mémoire sous Unix, cela m'intéresserait beaucoup d'apprendre comment.

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

Depuis la page de manuel 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)
12
James
#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);

J'ai utilisé ce code mais pour une raison quelconque, je reçois 0 tout le temps pour les 4 printf ()

7
Jeff

Je suis tombé sur ce post: http://appcrawler.com/wordpress/2013/05/13/simple-example-of-tracking-memory-using-getrusage/

Version simplifiée:

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

(testé sous Linux 3.13)

6
lepe

Je suis en retard à la fête, mais cela pourrait être utile à quiconque recherchant les mémoires des résidents et des mémoires virtuelles (et leurs valeurs maximales jusqu'à présent) sur Linux.

C'est probablement terrible, mais le travail est fait.

#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);
}
4
Anti Earth

La structure ci-dessus a été prise à partir de 4.3BSD Reno. Tous les champs ne sont pas méchants - Sous Linux. Sous Linux 2.4, seuls les champs ru_utime, ru_stime, Ru_minflt et ru_majflt sont conservés. Depuis Linux 2.6, ru_nvcsw et Ru_nivcsw sont également conservés.

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

0
mellthy