Mémoire utilisée par le processus courant. Episode 1 : MacOS X

gu — Tue, 21 Apr 2009 15:38:43 +0000

C’est le morceau de code que j’aime bien avoir sous la main quand je commence à développer quelque chose de conséquent : voir l’augmentation de la mémoire utilisée après chaque instruction.

A la base, sous MacOS X, on se dit qu’on va pouvoir utiliser la méthode Unix classique à base de getrusage. Mais hélas, par cette méthode on n’obtient que des usages mémoire nuls. Ce qui est normal vu que dans la structure rusage, seules les infos de temps sont remplies, et tout le reste est simplement défini mais laissé nul. L’explication est dans sys/resource.h :

/*
 * A structure representing an accounting of resource utilization.  The
 * address of an instance of this structure is the second parameter to
 * getrusage().
 *
 * Note: All values other than ru_utime and ru_stime are implementaiton
 *       defined and subject to change in a future release.  Their use
 *       is discouraged for standards compliant programs.
 */
struct   rusage {
   struct timeval ru_utime;   /* user time used (PL) */
   struct timeval ru_stime;   /* system time used (PL) */
#if defined(_POSIX_C_SOURCE) && !defined(_DARWIN_C_SOURCE)
   long  ru_opaque[14];    /* implementation defined */
#else /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
   /*
    * Informational aliases for source compatibility with programs
    * that need more information than that provided by standards,
    * and which do not mind being OS-dependent.
    */
   long  ru_maxrss;     /* max resident set size (PL) */
#define  ru_first ru_ixrss /* internal: ruadd() range start */
   long  ru_ixrss;      /* integral shared memory size (NU) */
   long  ru_idrss;      /* integral unshared data (NU)  */
   long  ru_isrss;      /* integral unshared stack (NU) */
   long  ru_minflt;     /* page reclaims (NU) */
   long  ru_majflt;     /* page faults (NU) */
   long  ru_nswap;      /* swaps (NU) */
   long  ru_inblock;    /* block input operations (atomic) */
   long  ru_oublock;    /* block output operations (atomic) */
   long  ru_msgsnd;     /* messages sent (atomic) */
   long  ru_msgrcv;     /* messages received (atomic) */
   long  ru_nsignals;      /* signals received (atomic) */
   long  ru_nvcsw;      /* voluntary context switches (atomic) */
   long  ru_nivcsw;     /* involuntary " */
#define  ru_last     ru_nivcsw   /* internal: ruadd() range end */
#endif   /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
};

Sachant cela, on n’a plus qu’à trouver comment le noyau Darwin nous donne l’info. Réponse dans les sources du kernel, ou plus aisément dans la documentation des interfaces. Il existe effectivement une structure d’informations sur un processus dans mach/task_info.h :

struct task_basic_info {
        integer_t       suspend_count;  /* suspend count for task */
        vm_size_t       virtual_size;   /* virtual memory size (bytes) */
        vm_size_t       resident_size;  /* resident memory size (bytes) */
        time_value_t    user_time;      /* total user run time for
                                           terminated threads */
        time_value_t    system_time;    /* total system run time for
                                           terminated threads */
	policy_t	policy;		/* default policy for new threads */
};

et une méthode task_info pour l’obtenir.

Le code qui va bien !

La fonction qui, au final, me sert à lire l’occupation mémoire du processus courant est la suivante :

#include    /* pour mach_task_self() */
#include
#include 
 
size_t getusedmem_macosx( size_t *res_size, size_t *virt_size )
{
    struct task_basic_info t_info ;
    mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT ;
 
    if( KERN_SUCCESS != task_info( mach_task_self(),
        TASK_BASIC_INFO, (task_info_t)&t_info, &t_info_count ) )
    {
        return -1 ;
    }
    *res_size = t_info.resident_size ;
    *virt_size = t_info.virtual_size ;
    return 0 ;
}

std::cout << "toto" ;

Mémoire utilisée par le processus courant. Episode 1 : MacOS X

Le code qui va bien !