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