Cette question est traitée ici en détail.

Comment mesurez-vous l'utilisation de la mémoire d'une application ou d'un processus sous Linux?

De l'article de blog Comprendre l'utilisation de la mémoire sous Linux , psn'est pas un outil précis à utiliser à cette fin.

Pourquoi psest "faux"

Selon la façon dont vous le regardez, psne rapporte pas l'utilisation réelle de la mémoire des processus. Ce qu'il fait réellement, c'est montrer combien de mémoire réelle chaque processus prendrait s'il était le seul processus en cours d'exécution . Bien sûr, une machine Linux typique a plusieurs dizaines de processus en cours d'exécution à tout moment, ce qui signifie que les numéros VSZ et RSS signalés par pssont presque certainement faux .

Avec psou des outils similaires, vous n'obtiendrez que la quantité de pages mémoire allouées par ce processus. Ce nombre est correct, mais:

• ne reflète pas la quantité réelle de mémoire utilisée par l'application, uniquement la quantité de mémoire qui lui est réservée

• peut être trompeur si les pages sont partagées, par exemple par plusieurs threads ou en utilisant des bibliothèques liées dynamiquement

Si vous voulez vraiment savoir quelle quantité de mémoire votre application utilise réellement, vous devez l'exécuter dans un profileur. Par exemple, valgrindpeut vous donner des informations sur la quantité de mémoire utilisée et, plus important encore, sur les éventuelles fuites de mémoire dans votre programme. L'outil profileur de tas de valgrind est appelé «massif»:

Massif est un profileur de tas. Il effectue un profilage de tas détaillé en prenant des instantanés réguliers du tas d'un programme. Il produit un graphique montrant l'utilisation du tas au fil du temps, y compris des informations sur les parties du programme qui sont responsables de la plupart des allocations de mémoire. Le graphique est complété par un fichier texte ou HTML qui comprend plus d'informations pour déterminer où la plus grande quantité de mémoire est allouée. Massif exécute des programmes environ 20 fois plus lentement que la normale.

Comme expliqué dans la documentation de valgrind , vous devez exécuter le programme via valgrind:

valgrind --tool=massif <executable> <arguments>

Massif écrit un cliché des instantanés d'utilisation de la mémoire (par exemple massif.out.12345). Ceux-ci fournissent, (1) une chronologie de l'utilisation de la mémoire, (2) pour chaque instantané, un enregistrement de l'emplacement dans la mémoire de votre programme qui a été alloué. Un excellent outil graphique pour analyser ces fichiers est le massif-visualizer . Mais j'ai trouvé ms_print, un outil simple basé sur du texte livré avec valgrind, déjà très utile.

Pour trouver les fuites de mémoire, utilisez l' memcheckoutil (par défaut) de valgrind.

Essayez la commande pmap :

sudo pmap -x <process pid>

Difficile à dire avec certitude, mais voici deux choses "proches" qui peuvent aider.

$ ps aux 

vous donnera la taille virtuelle (VSZ)

Vous pouvez également obtenir des statistiques détaillées à partir du système de fichiers / proc en allant sur /proc/$pid/status

Le plus important est le VmSize, qui devrait être proche de ce qui ps auxdonne.

/ proc / 19420 $ statut de chat
Nom: firefox
État: S (endormi)
Tgid: 19420
Pid: 19420
PPid: 1
TracerPid: 0
Uid: 1000 1000 1000 1000
Gid: 1000 1000 1000 1000
FDSize: 256
Groupes: 4 6 20 24 25 29 30 44 46107109115114 1000 
VmPeak: 222956 kB
VmSize: 212520 kB
VmLck: 0 ko
VmHWM: 127912 kB
VmRSS: 118768 ko
VmData: 170180 kB
VmStk: 228 kB
VmExe: 28 ko
VmLib: 35424 ko
VmPTE: 184 ko
Fils: 8
SigQ: 0/16382
SigPnd: 0000000000000000
ShdPnd: 0000000000000000
SigBlk: 0000000000000000
SigIgn: 0000000020001000
SigCgt: 000000018000442f
CapInh: 0000000000000000
CapPrm: 0000000000000000
CapEff: 0000000000000000
Cpus_allowed: 03
Mems_allowed: 1
volontaire_ctxt_switches: 63422
nonvoluntary_ctxt_switches: 7171

Dans les versions récentes de linux, utilisez le sous-système smaps . Par exemple, pour un processus avec un PID de 1234:

cat /proc/1234/smaps

Il vous dira exactement combien de mémoire il utilise à ce moment-là. Plus important encore, il divisera la mémoire en privé et partagé, de sorte que vous pouvez indiquer la quantité de mémoire utilisée par votre instance du programme, sans inclure la mémoire partagée entre plusieurs instances du programme.

Il n'y a pas de moyen simple de calculer cela. Mais certaines personnes ont essayé d'obtenir de bonnes réponses:

• ps_mem.py
• ps_mem.py sur github

Utilisez smem , qui est une alternative à ps qui calcule l'USS et le PSS par processus. Ce que vous voulez, c'est probablement le PSS.

• USS - Taille d'ensemble unique. Il s'agit de la quantité de mémoire non partagée unique à ce processus (pensez-y comme U pour mémoire unique ). Il n'inclut pas la mémoire partagée. Ainsi, cela sous- indiquera la quantité de mémoire utilisée par un processus, mais est utile lorsque vous souhaitez ignorer la mémoire partagée.

• PSS - Taille de jeu proportionnelle. Voici ce que tu veux. Il additionne la mémoire unique (USS), ainsi qu'une proportion de sa mémoire partagée divisée par le nombre de processus partageant cette mémoire. Ainsi, il vous donnera une représentation précise de la quantité de mémoire physique réelle utilisée par processus - avec une mémoire partagée réellement représentée comme partagée. Pensez au P étant pour la mémoire physique .

Comment cela se compare au RSS tel que rapporté par ps et d'autres utilitaires:

• RSS - Taille de l'ensemble résident. Il s'agit de la quantité de mémoire partagée plus la mémoire non partagée utilisée par chaque processus. Si des processus se partagent la mémoire, ce sera plus -Rapport la quantité de mémoire réellement utilisée, parce que la même mémoire partagée sera compté plus d'une fois - apparaissant à nouveau dans l'autre processus qui partage la même mémoire. Ainsi, il est assez peu fiable, en particulier lorsque les processus à haute mémoire ont beaucoup de fourches - ce qui est courant dans un serveur, avec des choses comme Apache ou PHP (fastcgi / FPM).

Remarque: smem peut également (en option) générer des graphiques tels que des graphiques circulaires et similaires. OMI, vous n'avez besoin de rien de tout cela. Si vous souhaitez simplement l'utiliser à partir de la ligne de commande comme vous pourriez utiliser ps -A v, vous n'avez pas besoin d'installer la dépendance recommandée par python-matplotlib.

ps -eo size,pid,user,command --sort -size | \
    awk '{ hr=$1/1024 ; printf("%13.2f Mb ",hr) } { for ( x=4 ; x<=NF ; x++ ) { printf("%s ",$x) } print "" }' |\
    cut -d "" -f2 | cut -d "-" -f1

Utilisez-le en tant que root et vous pouvez obtenir une sortie claire pour l'utilisation de la mémoire par chaque processus.

EXEMPLE DE SORTIE:

     0.00 Mb COMMAND 
  1288.57 Mb /usr/lib/firefox
   821.68 Mb /usr/lib/chromium/chromium 
   762.82 Mb /usr/lib/chromium/chromium 
   588.36 Mb /usr/sbin/mysqld 
   547.55 Mb /usr/lib/chromium/chromium 
   523.92 Mb /usr/lib/tracker/tracker
   476.59 Mb /usr/lib/chromium/chromium 
   446.41 Mb /usr/bin/gnome
   421.62 Mb /usr/sbin/libvirtd 
   405.11 Mb /usr/lib/chromium/chromium 
   302.60 Mb /usr/lib/chromium/chromium 
   291.46 Mb /usr/lib/chromium/chromium 
   284.56 Mb /usr/lib/chromium/chromium 
   238.93 Mb /usr/lib/tracker/tracker
   223.21 Mb /usr/lib/chromium/chromium 
   197.99 Mb /usr/lib/chromium/chromium 
   194.07 Mb conky 
   191.92 Mb /usr/lib/chromium/chromium 
   190.72 Mb /usr/bin/mongod 
   169.06 Mb /usr/lib/chromium/chromium 
   155.11 Mb /usr/bin/gnome
   136.02 Mb /usr/lib/chromium/chromium 
   125.98 Mb /usr/lib/chromium/chromium 
   103.98 Mb /usr/lib/chromium/chromium 
    93.22 Mb /usr/lib/tracker/tracker
    89.21 Mb /usr/lib/gnome
    80.61 Mb /usr/bin/gnome
    77.73 Mb /usr/lib/evolution/evolution
    76.09 Mb /usr/lib/evolution/evolution
    72.21 Mb /usr/lib/gnome
    69.40 Mb /usr/lib/evolution/evolution
    68.84 Mb nautilus
    68.08 Mb zeitgeist
    60.97 Mb /usr/lib/tracker/tracker
    59.65 Mb /usr/lib/evolution/evolution
    57.68 Mb apt
    55.23 Mb /usr/lib/gnome
    53.61 Mb /usr/lib/evolution/evolution
    53.07 Mb /usr/lib/gnome
    52.83 Mb /usr/lib/gnome
    51.02 Mb /usr/lib/udisks2/udisksd 
    50.77 Mb /usr/lib/evolution/evolution
    50.53 Mb /usr/lib/gnome
    50.45 Mb /usr/lib/gvfs/gvfs
    50.36 Mb /usr/lib/packagekit/packagekitd 
    50.14 Mb /usr/lib/gvfs/gvfs
    48.95 Mb /usr/bin/Xwayland :1024 
    46.21 Mb /usr/bin/gnome
    42.43 Mb /usr/bin/zeitgeist
    42.29 Mb /usr/lib/gnome
    41.97 Mb /usr/lib/gnome
    41.64 Mb /usr/lib/gvfs/gvfsd
    41.63 Mb /usr/lib/gvfs/gvfsd
    41.55 Mb /usr/lib/gvfs/gvfsd
    41.48 Mb /usr/lib/gvfs/gvfsd
    39.87 Mb /usr/bin/python /usr/bin/chrome
    37.45 Mb /usr/lib/xorg/Xorg vt2 
    36.62 Mb /usr/sbin/NetworkManager 
    35.63 Mb /usr/lib/caribou/caribou 
    34.79 Mb /usr/lib/tracker/tracker
    33.88 Mb /usr/sbin/ModemManager 
    33.77 Mb /usr/lib/gnome
    33.61 Mb /usr/lib/upower/upowerd 
    33.53 Mb /usr/sbin/gdm3 
    33.37 Mb /usr/lib/gvfs/gvfsd
    33.36 Mb /usr/lib/gvfs/gvfs
    33.23 Mb /usr/lib/gvfs/gvfs
    33.15 Mb /usr/lib/at
    33.15 Mb /usr/lib/at
    30.03 Mb /usr/lib/colord/colord 
    29.62 Mb /usr/lib/apt/methods/https 
    28.06 Mb /usr/lib/zeitgeist/zeitgeist
    27.29 Mb /usr/lib/policykit
    25.55 Mb /usr/lib/gvfs/gvfs
    25.55 Mb /usr/lib/gvfs/gvfs
    25.23 Mb /usr/lib/accountsservice/accounts
    25.18 Mb /usr/lib/gvfs/gvfsd 
    25.15 Mb /usr/lib/gvfs/gvfs
    25.15 Mb /usr/lib/gvfs/gvfs
    25.12 Mb /usr/lib/gvfs/gvfs
    25.10 Mb /usr/lib/gnome
    25.10 Mb /usr/lib/gnome
    25.07 Mb /usr/lib/gvfs/gvfsd 
    24.99 Mb /usr/lib/gvfs/gvfs
    23.26 Mb /usr/lib/chromium/chromium 
    22.09 Mb /usr/bin/pulseaudio 
    19.01 Mb /usr/bin/pulseaudio 
    18.62 Mb (sd
    18.46 Mb (sd
    18.30 Mb /sbin/init 
    18.17 Mb /usr/sbin/rsyslogd 
    17.50 Mb gdm
    17.42 Mb gdm
    17.09 Mb /usr/lib/dconf/dconf
    17.09 Mb /usr/lib/at
    17.06 Mb /usr/lib/gvfs/gvfsd
    16.98 Mb /usr/lib/at
    16.91 Mb /usr/lib/gdm3/gdm
    16.86 Mb /usr/lib/gvfs/gvfsd
    16.86 Mb /usr/lib/gdm3/gdm
    16.85 Mb /usr/lib/dconf/dconf
    16.85 Mb /usr/lib/dconf/dconf
    16.73 Mb /usr/lib/rtkit/rtkit
    16.69 Mb /lib/systemd/systemd
    13.13 Mb /usr/lib/chromium/chromium 
    13.13 Mb /usr/lib/chromium/chromium 
    10.92 Mb anydesk 
     8.54 Mb /sbin/lvmetad 
     7.43 Mb /usr/sbin/apache2 
     6.82 Mb /usr/sbin/apache2 
     6.77 Mb /usr/sbin/apache2 
     6.73 Mb /usr/sbin/apache2 
     6.66 Mb /usr/sbin/apache2 
     6.64 Mb /usr/sbin/apache2 
     6.63 Mb /usr/sbin/apache2 
     6.62 Mb /usr/sbin/apache2 
     6.51 Mb /usr/sbin/apache2 
     6.25 Mb /usr/sbin/apache2 
     6.22 Mb /usr/sbin/apache2 
     3.92 Mb bash 
     3.14 Mb bash 
     2.97 Mb bash 
     2.95 Mb bash 
     2.93 Mb bash 
     2.91 Mb bash 
     2.86 Mb bash 
     2.86 Mb bash 
     2.86 Mb bash 
     2.84 Mb bash 
     2.84 Mb bash 
     2.45 Mb /lib/systemd/systemd
     2.30 Mb (sd
     2.28 Mb /usr/bin/dbus
     1.84 Mb /usr/bin/dbus
     1.46 Mb ps 
     1.21 Mb openvpn hackthebox.ovpn 
     1.16 Mb /sbin/dhclient 
     1.16 Mb /sbin/dhclient 
     1.09 Mb /lib/systemd/systemd 
     0.98 Mb /sbin/mount.ntfs /dev/sda3 /media/n0bit4/Data 
     0.97 Mb /lib/systemd/systemd 
     0.96 Mb /lib/systemd/systemd 
     0.89 Mb /usr/sbin/smartd 
     0.77 Mb /usr/bin/dbus
     0.76 Mb su 
     0.76 Mb su 
     0.76 Mb su 
     0.76 Mb su 
     0.76 Mb su 
     0.76 Mb su 
     0.75 Mb sudo su 
     0.75 Mb sudo su 
     0.75 Mb sudo su 
     0.75 Mb sudo su 
     0.75 Mb sudo su 
     0.75 Mb sudo su 
     0.74 Mb /usr/bin/dbus
     0.71 Mb /usr/lib/apt/methods/http 
     0.68 Mb /bin/bash /usr/bin/mysqld_safe 
     0.68 Mb /sbin/wpa_supplicant 
     0.66 Mb /usr/bin/dbus
     0.61 Mb /lib/systemd/systemd
     0.54 Mb /usr/bin/dbus
     0.46 Mb /usr/sbin/cron 
     0.45 Mb /usr/sbin/irqbalance 
     0.43 Mb logger 
     0.41 Mb awk { hr=$1/1024 ; printf("%13.2f Mb ",hr) } { for ( x=4 ; x<=NF ; x++ ) { printf("%s ",$x) } print "" } 
     0.40 Mb /usr/bin/ssh
     0.34 Mb /usr/lib/chromium/chrome
     0.32 Mb cut 
     0.32 Mb cut 
     0.00 Mb [kthreadd] 
     0.00 Mb [ksoftirqd/0] 
     0.00 Mb [kworker/0:0H] 
     0.00 Mb [rcu_sched] 
     0.00 Mb [rcu_bh] 
     0.00 Mb [migration/0] 
     0.00 Mb [lru
     0.00 Mb [watchdog/0] 
     0.00 Mb [cpuhp/0] 
     0.00 Mb [cpuhp/1] 
     0.00 Mb [watchdog/1] 
     0.00 Mb [migration/1] 
     0.00 Mb [ksoftirqd/1] 
     0.00 Mb [kworker/1:0H] 
     0.00 Mb [cpuhp/2] 
     0.00 Mb [watchdog/2] 
     0.00 Mb [migration/2] 
     0.00 Mb [ksoftirqd/2] 
     0.00 Mb [kworker/2:0H] 
     0.00 Mb [cpuhp/3] 
     0.00 Mb [watchdog/3] 
     0.00 Mb [migration/3] 
     0.00 Mb [ksoftirqd/3] 
     0.00 Mb [kworker/3:0H] 
     0.00 Mb [kdevtmpfs] 
     0.00 Mb [netns] 
     0.00 Mb [khungtaskd] 
     0.00 Mb [oom_reaper] 
     0.00 Mb [writeback] 
     0.00 Mb [kcompactd0] 
     0.00 Mb [ksmd] 
     0.00 Mb [khugepaged] 
     0.00 Mb [crypto] 
     0.00 Mb [kintegrityd] 
     0.00 Mb [bioset] 
     0.00 Mb [kblockd] 
     0.00 Mb [devfreq_wq] 
     0.00 Mb [watchdogd] 
     0.00 Mb [kswapd0] 
     0.00 Mb [vmstat] 
     0.00 Mb [kthrotld] 
     0.00 Mb [ipv6_addrconf] 
     0.00 Mb [acpi_thermal_pm] 
     0.00 Mb [ata_sff] 
     0.00 Mb [scsi_eh_0] 
     0.00 Mb [scsi_tmf_0] 
     0.00 Mb [scsi_eh_1] 
     0.00 Mb [scsi_tmf_1] 
     0.00 Mb [scsi_eh_2] 
     0.00 Mb [scsi_tmf_2] 
     0.00 Mb [scsi_eh_3] 
     0.00 Mb [scsi_tmf_3] 
     0.00 Mb [scsi_eh_4] 
     0.00 Mb [scsi_tmf_4] 
     0.00 Mb [scsi_eh_5] 
     0.00 Mb [scsi_tmf_5] 
     0.00 Mb [bioset] 
     0.00 Mb [kworker/1:1H] 
     0.00 Mb [kworker/3:1H] 
     0.00 Mb [kworker/0:1H] 
     0.00 Mb [kdmflush] 
     0.00 Mb [bioset] 
     0.00 Mb [kdmflush] 
     0.00 Mb [bioset] 
     0.00 Mb [jbd2/sda5
     0.00 Mb [ext4
     0.00 Mb [kworker/2:1H] 
     0.00 Mb [kauditd] 
     0.00 Mb [bioset] 
     0.00 Mb [drbd
     0.00 Mb [irq/27
     0.00 Mb [i915/signal:0] 
     0.00 Mb [i915/signal:1] 
     0.00 Mb [i915/signal:2] 
     0.00 Mb [ttm_swap] 
     0.00 Mb [cfg80211] 
     0.00 Mb [kworker/u17:0] 
     0.00 Mb [hci0] 
     0.00 Mb [hci0] 
     0.00 Mb [kworker/u17:1] 
     0.00 Mb [iprt
     0.00 Mb [iprt
     0.00 Mb [kworker/1:0] 
     0.00 Mb [kworker/3:0] 
     0.00 Mb [kworker/0:0] 
     0.00 Mb [kworker/2:0] 
     0.00 Mb [kworker/u16:0] 
     0.00 Mb [kworker/u16:2] 
     0.00 Mb [kworker/3:2] 
     0.00 Mb [kworker/2:1] 
     0.00 Mb [kworker/1:2] 
     0.00 Mb [kworker/0:2] 
     0.00 Mb [kworker/2:2] 
     0.00 Mb [kworker/0:1] 
     0.00 Mb [scsi_eh_6] 
     0.00 Mb [scsi_tmf_6] 
     0.00 Mb [usb
     0.00 Mb [bioset] 
     0.00 Mb [kworker/3:1] 
     0.00 Mb [kworker/u16:1] 

Et alors time?

Pas le Bash intégré timemais celui que vous pouvez trouver avec which time, par exemple/usr/bin/time

Voici ce qu'il couvre, sur un simple ls:

$ /usr/bin/time --verbose ls
(...)
Command being timed: "ls"
User time (seconds): 0.00
System time (seconds): 0.00
Percent of CPU this job got: 0%
Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.00
Average shared text size (kbytes): 0
Average unshared data size (kbytes): 0
Average stack size (kbytes): 0
Average total size (kbytes): 0
Maximum resident set size (kbytes): 2372
Average resident set size (kbytes): 0
Major (requiring I/O) page faults: 1
Minor (reclaiming a frame) page faults: 121
Voluntary context switches: 2
Involuntary context switches: 9
Swaps: 0
File system inputs: 256
File system outputs: 0
Socket messages sent: 0
Socket messages received: 0
Signals delivered: 0
Page size (bytes): 4096
Exit status: 0

Ceci est un excellent résumé des outils et des problèmes: lien archive.org

Je vais le citer, afin que plus de développeurs le lisent.

Si vous souhaitez analyser l'utilisation de la mémoire de l'ensemble du système ou analyser en profondeur l'utilisation de la mémoire d'une application (et pas seulement son utilisation en tas), utilisez exmap . Pour l'analyse de l'ensemble du système, trouvez les processus avec l'utilisation efficace la plus élevée, ils prennent le plus de mémoire dans la pratique, trouvez les processus avec l'utilisation en écriture la plus élevée, ils créent le plus de données (et donc peuvent éventuellement fuir ou sont très inefficaces dans leur utilisation des données). Sélectionnez une telle application et analysez ses mappages dans la deuxième liste. Voir la section exmap pour plus de détails. Utilisez également xrestop pour vérifier une utilisation élevée des ressources X, surtout si le processus du serveur X prend beaucoup de mémoire. Voir la section xrestop pour plus de détails.

Si vous souhaitez détecter des fuites, utilisez valgrind ou éventuellement kmtrace .

Si vous souhaitez analyser l'utilisation en tas (malloc, etc.) d'une application, exécutez-la dans memprof ou avec kmtrace , profilez l'application et recherchez dans l'arborescence d'appels de fonction les allocations les plus importantes. Voir leurs sections pour plus de détails.

En plus des solutions listées dans tes réponses, tu peux utiliser la commande Linux "top"; Il fournit une vue dynamique en temps réel du système en cours d'exécution, il donne l'utilisation du CPU et de la mémoire, pour l'ensemble du système ainsi que pour chaque programme, en pourcentage:

top

filtrer par un programme pid:

top -p <PID>

filtrer par nom de programme:

top | grep <PROCESS NAME>

"top" fournit également des champs tels que:

VIRT - Virtual Image (kb): la quantité totale de mémoire virtuelle utilisée par la tâche

RES - Taille résidente (Ko): La mémoire physique non permutée qu'une tâche a utilisée; RES = CODE + DONNÉES.

DATA - Data + Stack size (kb): La quantité de mémoire physique consacrée à un code autre que le code exécutable, également connu sous le nom de «data resident set» size ou DRS.

SHR - Shared Mem size (kb): quantité de mémoire partagée utilisée par une tâche. Il reflète simplement la mémoire qui pourrait être potentiellement partagée avec d'autres processus.

Référence ici .

Il n'y a pas de réponse unique à cela, car vous ne pouvez pas déterminer avec précision la quantité de mémoire utilisée par un processus. La plupart des processus sous Linux utilisent des bibliothèques partagées. Par exemple, supposons que vous souhaitiez calculer l'utilisation de la mémoire pour le processus «ls». Comptez-vous uniquement la mémoire utilisée par l'exécutable 'ls' (si vous pouviez l'isoler)? Et la libc? Ou toutes ces autres bibliothèques nécessaires pour exécuter «ls»?

linux-gate.so.1 =>  (0x00ccb000)
librt.so.1 => /lib/librt.so.1 (0x06bc7000)
libacl.so.1 => /lib/libacl.so.1 (0x00230000)
libselinux.so.1 => /lib/libselinux.so.1 (0x00162000)
libc.so.6 => /lib/libc.so.6 (0x00b40000)
libpthread.so.0 => /lib/libpthread.so.0 (0x00cb4000)
/lib/ld-linux.so.2 (0x00b1d000)
libattr.so.1 => /lib/libattr.so.1 (0x00229000)
libdl.so.2 => /lib/libdl.so.2 (0x00cae000)
libsepol.so.1 => /lib/libsepol.so.1 (0x0011a000)

Vous pourriez faire valoir qu'ils sont partagés par d'autres processus, mais «ls» ne peut pas être exécuté sur le système sans qu'ils soient chargés.

De plus, si vous avez besoin de connaître la quantité de mémoire dont un processus a besoin pour planifier la capacité, vous devez calculer la quantité utilisée par chaque copie supplémentaire du processus. Je pense que / proc / PID / status pourrait vous donner suffisamment d'informations sur l'utilisation de la mémoire à la fois. D'autre part, valgrind vous donnera un meilleur profil de l'utilisation de la mémoire tout au long de la durée de vie du programme

Si votre code est en C ou C ++, vous pourriez être en mesure d'utiliser getrusage()ce qui vous renvoie diverses statistiques sur la mémoire et l'utilisation du temps de votre processus.

Cependant, toutes les plates-formes ne prennent pas en charge cela et renverront 0 valeurs pour les options d'utilisation de la mémoire.

Au lieu de cela, vous pouvez regarder le fichier virtuel créé dans /proc/[pid]/statm(où [pid]est remplacé par votre identifiant de processus. Vous pouvez l'obtenir auprès de getpid()).

Ce fichier ressemblera à un fichier texte avec 7 entiers. Vous êtes probablement le plus intéressé par les premiers (utilisation de toute la mémoire) et sixième (utilisation de la mémoire de données) de ce fichier.

Valgrind peut afficher des informations détaillées mais il ralentit considérablement l'application cible et, la plupart du temps, il modifie le comportement de l'application.
Exmap était quelque chose que je ne savais pas encore, mais il semble que vous ayez besoin d'un module noyau pour obtenir les informations, ce qui peut être un obstacle.

Je suppose que ce que tout le monde veut savoir sur "l'utilisation de la mémoire" WRT est le suivant ...
Sous Linux, la quantité de mémoire physique qu'un seul processus peut utiliser peut être grossièrement divisée en catégories suivantes.

• Ma mémoire mappée anonyme

  • .p privé
    • .d dirty == malloc / mmapped tas et pile allouée et mémoire écrite
    • .c clean == malloc / mmapped tas et mémoire de la pile une fois allouée, écrite, puis libérée, mais pas encore récupérée
  • .s partagé
    • .d dirty == malloc / mmaped heap pourrait être copié sur écriture et partagé entre les processus (édité)
    • .c clean == malloc / mmaped heap pourrait être copié sur écriture et partagé entre les processus (édité)

• Mn nommée mémoire mappée

  • .p privé
    • .d sale == fichier mmappé mémoire écrite privée
    • .c clean == programme mappé / texte de bibliothèque mappé privé
  • .s partagé
    • .d dirty == fichier mmappé mémoire écrite partagée
    • .c clean == texte de bibliothèque mappé partagé mappé

L'utilitaire inclus dans Android appelé showmap est très utile

virtual                    shared   shared   private  private
size     RSS      PSS      clean    dirty    clean    dirty    object
-------- -------- -------- -------- -------- -------- -------- ------------------------------
       4        0        0        0        0        0        0 0:00 0                  [vsyscall]
       4        4        0        4        0        0        0                         [vdso]
      88       28       28        0        0        4       24                         [stack]
      12       12       12        0        0        0       12 7909                    /lib/ld-2.11.1.so
      12        4        4        0        0        0        4 89529                   /usr/lib/locale/en_US.utf8/LC_IDENTIFICATION
      28        0        0        0        0        0        0 86661                   /usr/lib/gconv/gconv-modules.cache
       4        0        0        0        0        0        0 87660                   /usr/lib/locale/en_US.utf8/LC_MEASUREMENT
       4        0        0        0        0        0        0 89528                   /usr/lib/locale/en_US.utf8/LC_TELEPHONE
       4        0        0        0        0        0        0 89527                   /usr/lib/locale/en_US.utf8/LC_ADDRESS
       4        0        0        0        0        0        0 87717                   /usr/lib/locale/en_US.utf8/LC_NAME
       4        0        0        0        0        0        0 87873                   /usr/lib/locale/en_US.utf8/LC_PAPER
       4        0        0        0        0        0        0 13879                   /usr/lib/locale/en_US.utf8/LC_MESSAGES/SYS_LC_MESSAGES
       4        0        0        0        0        0        0 89526                   /usr/lib/locale/en_US.utf8/LC_MONETARY
       4        0        0        0        0        0        0 89525                   /usr/lib/locale/en_US.utf8/LC_TIME
       4        0        0        0        0        0        0 11378                   /usr/lib/locale/en_US.utf8/LC_NUMERIC
    1156        8        8        0        0        4        4 11372                   /usr/lib/locale/en_US.utf8/LC_COLLATE
     252        0        0        0        0        0        0 11321                   /usr/lib/locale/en_US.utf8/LC_CTYPE
     128       52        1       52        0        0        0 7909                    /lib/ld-2.11.1.so
    2316       32       11       24        0        0        8 7986                    /lib/libncurses.so.5.7
    2064        8        4        4        0        0        4 7947                    /lib/libdl-2.11.1.so
    3596      472       46      440        0        4       28 7933                    /lib/libc-2.11.1.so
    2084        4        0        4        0        0        0 7995                    /lib/libnss_compat-2.11.1.so
    2152        4        0        4        0        0        0 7993                    /lib/libnsl-2.11.1.so
    2092        0        0        0        0        0        0 8009                    /lib/libnss_nis-2.11.1.so
    2100        0        0        0        0        0        0 7999                    /lib/libnss_files-2.11.1.so
    3752     2736     2736        0        0      864     1872                         [heap]
      24       24       24        0        0        0       24 [anon]
     916      616      131      584        0        0       32                         /bin/bash
-------- -------- -------- -------- -------- -------- -------- ------------------------------
   22816     4004     3005     1116        0      876     2012 TOTAL

Trois autres méthodes à essayer:

1. ps aux --sort pmem
   Il trie la sortie par %MEM.
2. ps aux | awk '{print $2, $4, $11}' | sort -k2r | head -n 15
   Il trie à l'aide de tuyaux.
3. top -a
   Il commence le tri par %MEM

(Extrait d' ici )

#!/bin/ksh
#
# Returns total memory used by process $1 in kb.
#
# See /proc/NNNN/smaps if you want to do something
# more interesting.
#

IFS=$'\n'

for line in $(</proc/$1/smaps)
do
   [[ $line =~ ^Size:\s+(\S+) ]] && ((kb += ${.sh.match[1]}))
done

print $kb

J'utilise htop; c'est un très bon programme de console similaire au Gestionnaire des tâches de Windows.

Si le processus n'utilise pas trop de mémoire (soit parce que vous vous attendez à ce que ce soit le cas, soit parce qu'une autre commande a donné cette indication initiale), et que le processus peut résister à un arrêt pendant une courte période, vous pouvez essayer de utilisez la commande gcore.

gcore <pid>

Vérifiez la taille du fichier core généré pour avoir une bonne idée de la quantité de mémoire utilisée par un processus particulier.

Cela ne fonctionnera pas trop bien si le processus utilise des centaines de mégaoctets ou des concerts, car la génération du noyau peut prendre plusieurs secondes ou minutes pour être créée en fonction des performances d'E / S. Pendant la création du noyau, le processus est arrêté (ou "gelé") pour empêcher les changements de mémoire. Donc sois prudent.

Assurez-vous également que le point de montage où le core est généré a beaucoup d'espace disque et que le système ne réagira pas négativement au fichier core créé dans ce répertoire particulier.

J'utilise Arch Linux et il y a ce merveilleux paquet appelé ps_mem

ps_mem -p <pid>

Exemple de sortie

$ ps_mem -S -p $(pgrep firefox)

Private   +   Shared  =  RAM used   Swap used   Program

355.0 MiB +  38.7 MiB = 393.7 MiB    35.9 MiB   firefox
---------------------------------------------
                        393.7 MiB    35.9 MiB
=============================================

La ligne de commande ci-dessous vous donnera la mémoire totale utilisée par les différents processus en cours d'exécution sur la machine Linux en Mo

ps -eo size,pid,user,command --sort -size | awk '{ hr=$1/1024 ; printf("%13.2f Mb ",hr) } { for ( x=4 ; x<=NF ; x++ ) { printf("%s ",$x) } print "" }' | awk '{total=total + $1} END {print total}'

Un bon test de l'utilisation la plus "réelle" est d'ouvrir l'application, puis d'exécuter vmstat -set de vérifier la statistique "mémoire active". Fermez l'application, attendez quelques secondes et exécutez à vmstat -snouveau. Cependant, une grande partie de la mémoire active libérée était de toute évidence utilisée par l'application.

Obtenez valgrind. donnez-lui votre programme à exécuter, et il vous en dira beaucoup sur son utilisation de la mémoire.

Cela ne s'appliquerait que dans le cas d'un programme qui s'exécute pendant un certain temps et s'arrête. Je ne sais pas si valgrind peut mettre la main sur un processus déjà en cours ou ne devrait pas arrêter des processus tels que les démons.

Edit: cela ne fonctionne à 100% que lorsque la consommation de mémoire augmente

Si vous souhaitez surveiller l'utilisation de la mémoire par un processus donné (ou un groupe de noms communs de partage traités, par exemple google-chrome, vous pouvez utiliser mon script bash:

while true; do ps aux | awk ‚{print $5, $11}’ | grep chrome | sort -n > /tmp/a.txt; sleep 1; diff /tmp/{b,a}.txt; mv /tmp/{a,b}.txt; done;

cela recherchera continuellement les modifications et les imprimera.

Si vous voulez quelque chose de plus rapide que le profilage avec Valgrind et que votre noyau est plus ancien et que vous ne pouvez pas utiliser de smaps, un ps avec les options pour montrer l'ensemble résident du processus (avec ps -o rss,command) peut vous donner un aperçu rapide et raisonnable _aproximation_de la quantité réelle de mémoire non échangée utilisée.

Je suggère que vous utilisiez au sommet. Vous pouvez tout trouver sur cette page . Il est capable de fournir tous les KPI nécessaires à vos processus et peut également être capturé dans un fichier.

Vérifier le script shell pour vérifier utilisation de la mémoire par application sous Linux . Aussi disponible sur github et dans une version sans pâte ni bc .

Un autre vote pour valgrindici, mais je voudrais ajouter que vous pouvez utiliser un outil comme Alleyoop pour vous aider à interpréter les résultats générés par valgrind.

J'utilise les deux outils tout le temps et j'ai toujours du code allégé et sans fuite pour le montrer fièrement;)

Bien que cette question semble concerner l'examen des processus en cours d'exécution, je voulais voir le pic de mémoire utilisé par une application du début à la fin. Outre valgrind, vous pouvez utiliser tstime , qui est beaucoup plus simple. Il mesure l'utilisation de la mémoire "highwater" (RSS et virtuelle). De cette réponse .

Basé sur la réponse à une question connexe .

Vous pouvez utiliser SNMP pour obtenir la mémoire et l'utilisation du processeur d'un processus dans un périphérique particulier du réseau :)

Exigences:

• le périphérique exécutant le processus doit avoir installé et exécuté snmp
• snmp doit être configuré pour accepter les demandes d'où vous exécuterez le script ci-dessous (il peut être configuré dans snmpd.conf)
• vous devez connaître l'ID de processus (pid) du processus que vous souhaitez surveiller

Remarques:

• HOST-RESOURCES-MIB :: hrSWRunPerfCPU est le nombre de centi-secondes des ressources CPU totales du système consommées par ce processus. Notez que sur un système multiprocesseur, cette valeur peut augmenter de plus d'un centième de seconde en un centième de seconde en temps réel (horloge murale).

• HOST-RESOURCES-MIB :: hrSWRunPerfMem est la quantité totale de mémoire système réelle allouée à ce processus.

**

Script de surveillance des processus:

**

echo "IP: "
read ip
echo "specfiy pid: "
read pid
echo "interval in seconds:"
read interval

while [ 1 ]
do
    date
    snmpget -v2c -c public $ip HOST-RESOURCES-MIB::hrSWRunPerfCPU.$pid
    snmpget -v2c -c public $ip HOST-RESOURCES-MIB::hrSWRunPerfMem.$pid
    sleep $interval;
done

/ prox / xxx / numa_maps y donne quelques informations: N0 = ??? N1 = ???. Mais ce résultat peut être inférieur au résultat réel, car il ne compte que ceux qui ont été touchés.

Utilisez l' outil graphique intégré du « moniteur système » disponible dans Ubuntu