Comment déterminer la consommation de CPU et de mémoire à l'intérieur d'un processus?

Mac OS X

J'espérais trouver des informations similaires pour Mac OS X ainsi. Puisqu'il n'était pas là, je suis sorti et ai creusé moi-même. Voici certaines des choses que j'ai trouvé. Si quelqu'un a d'autres suggestions, je serais ravi de les entendre.

Mémoire Virtuelle Totale

Celui-ci est délicate sur Mac OS X, car il n'est pas utiliser un préréglage de la partition de swap ou d'un fichier comme Linux. Voici une entrée à partir de la documentation d'Apple:

Remarque: Contrairement à la plupart des systèmes d'exploitation Unix, Mac OS X ne pas utiliser un préaffectés partition de swap pour la mémoire virtuelle. Au lieu de cela, il utilise tout l'espace disponible sur la machine de la partition de démarrage.

Donc, si vous voulez savoir combien de mémoire virtuelle est toujours disponible, vous devez obtenir la taille de la partition racine. Vous pouvez le faire comme ceci:

struct statfs stats;
if (0 == statfs("/", &stats))
{
    myFreeSwap = (uint64_t)stats.f_bsize * stats.f_bfree;
}

Virtuelle Totale Actuellement Utilisé

Appel systcl avec la "machine virtuelle.swapusage" clé fournit des informations intéressantes sur l'utilisation de la swap:

sysctl -n vm.swapusage
vm.swapusage: total = 3072.00M  used = 2511.78M  free = 560.22M  (encrypted)

Pas que le total de pagination affiché ici peut changer si le swap est nécessaire, comme expliqué dans la section ci-dessus. Si le total est en réalité le actuel swap total. En C++, ces données peuvent être interrogées de cette façon:

xsw_usage vmusage = {0};
size_t size = sizeof(vmusage);
if( sysctlbyname("vm.swapusage", &vmusage, &size, NULL, 0)!=0 )
{
   perror( "unable to get swap usage by calling sysctlbyname(\"vm.swapusage\",...)" );
}

Noter que le "xsw_usage", a déclaré dans sysctl.h, ne semble pas documentée et j'ai l'impression que il n'y a plus de portable moyen d'accéder à ces valeurs.

De Mémoire virtuelle Utilisée Actuellement par mon Processus

Vous pouvez obtenir des statistiques à propos de votre processus actuel à l'aide de la task_info fonction. Qui inclut l'actuel résident de la taille de votre processus et le virtuel en cours de taille.

#include<mach/mach.h>

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;
}
//resident size is in t_info.resident_size;
//virtual size is in t_info.virtual_size;

Total de mémoire vive disponible

La quantité de RAM physique disponible dans votre système est disponible en utilisant la sysctl système de fonction comme ceci:

#include <sys/types.h>
#include <sys/sysctl.h>
...
int mib[2];
int64_t physical_memory;
mib[0] = CTL_HW;
mib[1] = HW_MEMSIZE;
length = sizeof(int64_t);
sysctl(mib, 2, &physical_memory, &length, NULL, 0);

RAM Actuellement Utilisé

Vous pouvez obtenir de la mémoire générale des statistiques de la host_statistics la fonction du système.

#include <mach/vm_statistics.h>
#include <mach/mach_types.h>
#include <mach/mach_init.h>
#include <mach/mach_host.h>

int main(int argc, const char * argv[]) {
    vm_size_t page_size;
    mach_port_t mach_port;
    mach_msg_type_number_t count;
    vm_statistics64_data_t vm_stats;

    mach_port = mach_host_self();
    count = sizeof(vm_stats) / sizeof(natural_t);
    if (KERN_SUCCESS == host_page_size(mach_port, &page_size) &&
        KERN_SUCCESS == host_statistics64(mach_port, HOST_VM_INFO,
                                        (host_info64_t)&vm_stats, &count))
    {
        long long free_memory = (int64_t)vm_stats.free_count * (int64_t)page_size;

        long long used_memory = ((int64_t)vm_stats.active_count +
                                 (int64_t)vm_stats.inactive_count +
                                 (int64_t)vm_stats.wire_count) *  (int64_t)page_size;
        printf("free memory: %lld\nused memory: %lld\n", free_memory, used_memory);
    }

    return 0;
}

Une chose à noter ici sont qu'il y a cinq types de pages de mémoire dans Mac OS X. Ils sont comme suit:

1. Filaire pages qui sont verrouillés et ne peuvent pas être échangées
2. Active pages qui sont chargés dans la mémoire physique, et serait relativement difficile à échanger des
3. Inactif pages qui sont chargés en mémoire, mais n'ont pas été utilisés récemment et peut même ne pas être nécessaire à tous. Ce sont des candidats potentiels pour l'échange. Ce mémoire aurait probablement besoin d'être vidé.
4. Cache pages qui ont été d'une façon ou mis en cache qui sont susceptibles d'être facilement réutilisés. La mémoire cache ne serait probablement pas besoin de rinçage. Il est encore possible pour les pages mises en cache pour être réactivé
5. Gratuit pages qui sont totalement gratuit et prêt à être utilisé.

Il est bon de noter que juste parce que Mac OS X peuvent montrer très peu de mémoire libre aux époques qu'il ne peut pas être une bonne indication de la façon dont une grande partie est prêt à être utilisé sur un court préavis.

RAM Actuellement Utilisé par mon Processus

Voir la "Mémoire Virtuelle Utilisée Actuellement par mon Processus" ci-dessus. Le même code s'applique.

Linux

Façon portable de lecture de la mémoire et de la charge des nombres est l' sysinfo appel

Utilisation

   #include <sys/sysinfo.h>
int sysinfo(struct sysinfo *info);

DESCRIPTION

   Until Linux 2.3.16, sysinfo() used to return information in the
following structure:
struct sysinfo {
long uptime;             /* Seconds since boot */
unsigned long loads[3];  /* 1, 5, and 15 minute load averages */
unsigned long totalram;  /* Total usable main memory size */
unsigned long freeram;   /* Available memory size */
unsigned long sharedram; /* Amount of shared memory */
unsigned long bufferram; /* Memory used by buffers */
unsigned long totalswap; /* Total swap space size */
unsigned long freeswap;  /* swap space still available */
unsigned short procs;    /* Number of current processes */
char _f[22];             /* Pads structure to 64 bytes */
};
and the sizes were given in bytes.
Since Linux 2.3.23 (i386), 2.3.48 (all architectures) the structure
is:
struct sysinfo {
long uptime;             /* Seconds since boot */
unsigned long loads[3];  /* 1, 5, and 15 minute load averages */
unsigned long totalram;  /* Total usable main memory size */
unsigned long freeram;   /* Available memory size */
unsigned long sharedram; /* Amount of shared memory */
unsigned long bufferram; /* Memory used by buffers */
unsigned long totalswap; /* Total swap space size */
unsigned long freeswap;  /* swap space still available */
unsigned short procs;    /* Number of current processes */
unsigned long totalhigh; /* Total high memory size */
unsigned long freehigh;  /* Available high memory size */
unsigned int mem_unit;   /* Memory unit size in bytes */
char _f[20-2*sizeof(long)-sizeof(int)]; /* Padding to 64 bytes */
};
and the sizes are given as multiples of mem_unit bytes.

Pour Linux
Vous pouvez également utiliser /proc/self/statm afin d'obtenir une ligne de nombres contenant les principaux processus de la mémoire de l'information qui est plus rapide chose à traiter que de passer par une longue liste de cas déclarés de l'information que vous obtenez de proc/self/statut

Voir http://man7.org/linux/man-pages/man5/proc.5.html

   /proc/[pid]/statm
Provides information about memory usage, measured in pages.
The columns are:
size       (1) total program size
(same as VmSize in /proc/[pid]/status)
resident   (2) resident set size
(same as VmRSS in /proc/[pid]/status)
shared     (3) number of resident shared pages (i.e., backed by a file)
(same as RssFile+RssShmem in /proc/[pid]/status)
text       (4) text (code)
lib        (5) library (unused since Linux 2.6; always 0)
data       (6) data + stack
dt         (7) dirty pages (unused since Linux 2.6; always 0)