Comment mesurer l'utilisation réelle de la mémoire d'une application ou d'un processus?

712

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 .

ksuralta
la source
6
Cette question appartient probablement à serverfault.com à la place de nos jours, bien qu'elle me dise qu'elle est "trop ​​vieille pour migrer". Je ne veux pas vraiment le fermer ...
thomasrutter
Référez-vous à cette question. stackoverflow.com/questions/669438/…
Bloodmoon
2
En psfait, ne montre même pas cela - il montre les numéros de mémoire virtuelle et résidente, où virtuel est la quantité maximale de mémoire que le processus pourrait théoriquement utiliser, c'était le seul processus (jamais), utilisé chaque page allouée (ne se produit jamais) et n'a mappé ou démappé aucune page (peu probable). Tandis que résident montre combien de mémoire virtuelle est mappée en physique en ce moment. En règle générale virt > usage > rescependant sur un système 64 bits , virt ~= res*10il est une gamme très large.
Dima Tisnek
5
L'extrait de l'article lié est un non-sens total. Le RSS est la mémoire physique réellement utilisée et le VSZ peut ou non se traduire par une utilisation de la mémoire physique même si le processus était le seul en cours d'exécution.
David Schwartz

Réponses:

356

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.

ypnos
la source
44
Pour interpréter les résultats générés par valgrind, je peux recommander alleyoop. Il n'est pas trop sophistiqué et vous indique simplement ce que vous devez savoir pour localiser les sources de fuites. Une belle paire d'utilitaires.
Dan
6
Le point (a) est correct. Il y a une différence entre les pages utilisées et la mémoire réellement allouée par l'application via les appels à malloc (), new, etc.
jcoffland
63
Cela ne dit pas vraiment comment utiliser la mémoire en utilisant valgrind?
Matt Joiner
11
l'outil valgrind par défaut, memcheck, est utile pour détecter les fuites de mémoire, mais ce n'est pas vraiment un profileur de mémoire. Pour cela, vous voulez valgrind --tool = massif.
Todd a libéré le
3
@DavidSchwartz Je ne vois pas en quoi votre déclaration contredit la mienne. J'ai le sentiment que vous vous souciez trop de votre point de vue de me tromper que de lire ce que je dis. Mon point ici est que RSS est une mesure inappropriée pour l'utilisation réelle de la mémoire de l'application, et vous faites la même remarque dans vos deux dernières phrases. Vraiment, à votre avis, quelle était la raison pour laquelle j'ai évoqué la diminution du flux RSS en premier lieu? Pour que vous me le répétiez pour me prouver que je me trompe par la chose exacte à laquelle je fais référence? Votre attitude envers moi est fastidieuse.
ypnos
280

Essayez la commande pmap :

sudo pmap -x <process pid>
Anil
la source
45
exécuter avec sudo ou il ne donne aucune erreur et ne montre aucune mémoire consommée.
Matt
22
N'existe pas sur OSX (pour tous ceux qui viennent ici de Google)
jcollum
3
Voilà une réponse complète à la question! ps. Dans ma coquille, pmap peut lire le processus sans sudo.
MasterControlProgram
7
Concernant OS X (apparemment pas le souci du PO), vous pouvez voir des données similaires en utilisant vmmap (1)
jrg
note: donne une réponse complètement différente degnome-system-monitor
ribamar
190

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

DustinB
la source
21
Suis-je en train de manquer quelque chose? La question demandait comment mieux mesurer l'utilisation de la mémoire par un processus, étant donné que VSZ et RSS signalés en ps sont trompeurs. Votre réponse détaille comment rechercher le VSZ - la même valeur qui a été mentionnée comme étant trompeuse.
thomasrutter
16
@thomasrutter Oui, il vous manque la question d'origine (rev 1), elle a été éditée plusieurs fois et est assez ancienne (2008). La question d'origine vient de demander comment mesurer l'utilisation de la mémoire d'un processus. N'hésitez pas à modifier les questions et réponses, si les choses sont obsolètes. :)
DustinB
1
note: donne une réponse complètement différente degnome-system-monitor
ribamar
131

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.

Paul Biggar
la source
je suppose que pmapc'est une interface plus simple.
ribamar
126

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

Frapper
la source
nice affiche une liste claire de la mémoire et du processus
Rubytastic
Très sympa, avec un regroupement assez intelligent.
Rohmer
Ouais, vraiment sympa en effet. Je trouve ps_memet smemtrès utile pour les mesures des utilisateurs finaux, par exemple. pmapLa sortie très détaillée est orientée vers les développeurs ... permet de récupérer l'utilisation de la mémoire de Firefox pour chaque police, addon, bibliothèque par exemple. Merci à tous, exp. @Bash, @thomasruther.
tuk0z
celui-ci est jusqu'à présent le seul à correspondre à la sortie degnome-system-monitor
ribamar
110

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.

thomasrutter
la source
2
Un point critique sur RSS est que la plupart des applications partagent de nos jours beaucoup de pages de codes. Chaque bibliothèque partagée (par exemple libc et libstdc ++) sera comptée pour chaque processus l'utilisant. Et s'il y a plusieurs instances d'un processus en cours d'exécution, tout ce code sera compté deux fois.
David C.
1
Précisément, c'est pourquoi RSS sur-rapporte en termes de mémoire physique réelle par processus.
thomasrutter
3
smem est ce dont j'avais besoin. En l'exécutant avec -t chaque fois que je démarre une nouvelle instance de processus, je peux voir la mémoire consommée par chaque instance. Pour chrome: smem -t -P '/ opt / google / chrome'
xtian
J'ai du mal à trouver de la documentation pour smem .. est-ce qu'il sort en octets, kilo-octets ou mégaoctets par défaut ??
ZN13
4
TL; DR: USS = quantité de mémoire physique qui sera libérée si le processus est tué, PSS = quantité de mémoire physique dont ce processus a besoin du système si aucun processus existant ne sera tué, RSS = quantité de mémoire physique accessible par ce processus (mais pas toujours un accès exclusif).
Mikko Rantalainen
95
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] 
Lokendra Singh Rawat
la source
1
Est-il possible de filtrer la liste afin de n'avoir que des processus qui utilisent plus de 25% de mémoire par exemple pendant 30s? J'essaie de voir les processus de fuite, comme le navigateur Chrome lors de l'utilisation d'un débogueur PHPEclipse.
Stephane
ce filtre serait génial
aleix
1
Je posterai cela dès que possible.
Lokendra Singh Rawat
2
Génial! Mais la boucle devrait commencer x=2à sortir également pid et user.
Boris Brodski
70

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
Enfant de lune
la source
Je suis aussi. C'est la façon dont j'utilise pour profiler les tâches dans powercron.eu :)
Moonchild
5
brew install gnu-timepuis utilisez gtimesi vous êtes sur macOS.
Nobu
4
Inconvénient: n'obtiendra les résultats que lorsque le processus aura terminé son exécution. Ne peut pas être utilisé pour la surveillance en temps réel du processus en cours d'exécution.
Makesh
/ usr / bin / time -f '% M'
infomaniac
1
Vous pouvez également l'appeler en utilisant \ time (avec une barre oblique inverse pour éviter d'utiliser l'heure interne du shell).
Raúl Salinas-Monteagudo
39

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.

phoku
la source
28

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 .

Yahya Yahyaoui
la source
20

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

Dprado
la source
j'essaye de trouver combien de mémoire un processus prend sur une VM et je veux l'utiliser pour configurer la limite de mémoire dans kubernetes, je suis d'accord sur cette réponse, donc j'utiliserai la mémoire montrée parpmap
Deepak Deore
16

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.

Vache à lait
la source
Notez que cela n'est pas pris en charge sur toutes les plateformes.
CashCow
Selon la page de manuel Linux ( linux.die.net/man/2/getrusage ), getrusage fait partie des spécifications SVr4, 4.3BSD et POSIX.1-2001 (en notant que POSIX ne spécifie que les champs utime et stime.) I ne s'attendrait pas à ce qu'il fonctionne sur des plates-formes non UNIX (sauf, peut-être, via un environnement comme Cygwin qui fournit des capacités UNIX pour d'autres plates-formes.)
David C.
@DavidC. l'OP pose des questions sur Linux.
Alexis Wilke
@CashCow, vouliez-vous dire getpid(), parce que je ne connais pas de getprocessid()fonction en C / C ++ sous Linux.
Alexis Wilke
12

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
holmes
la source
10

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 )

Thomas Shaiker
la source
2
topet probablement les autres ne donnent pas une représentation précise de la mémoire réellement utilisée par le processus. Par exemple, j'ai 64 Go de RAM, et j'ai 10 postgresprocessus rapportant chacun 16 Go de RES et 25% de MEM. Bien sûr, ils ne peuvent pas tous utiliser 25% ... Chacun a également 15GiB SHR, et il semble qu'ils partagent cela.
sudo
8
#!/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
pokute
la source
5
ksh est un shell standard. Il n'est peut-être pas installé par défaut sur les distributions Linux pour les utilisateurs de bureau ou à des fins minimalistes, mais ce n'est qu'à une seule commande dans presque tous les systèmes d'exploitation Unix / Linux. (c'est-à-dire sur tous les BSD, sur tous les vrais UNIX, sur RHEL, sur SLES, sur Debian, sur Ubuntu, sur OSX)
Florian Heigl
Ce fichier est accessible, par défaut, uniquement à l'utilisateur root.
Dmitry Ginzburg
Ce qui suit est juste réécrit sed | awket fonctionne dans Busybox v1.23.2: sed -n 's/^Size:\s\+\(\S\+\) .*/\1/p' /proc/$1/smaps | awk '{s+=$1} END {print s}'
Ján Sáreník
1
@Catskul - Le standard POSIX spécifie son shell standard comme un sous-ensemble strict du shell Korn, une version améliorée du shell Bourne.
ceph3us
8

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

Tomasz Dzięcielewski
la source
J'ai utilisé htopet c'est mieux que top, mais il vous montrera toujours tous les threads de différentes applications sans les regrouper, ce qui le rend presque aussi inutile que top.
sorin
1
$ htop -p $ (pgrep <votre nom de processus> | xargs | tr '' ',')
AAAfarmclub
6

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.

Rocco Corsi
la source
6

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
=============================================
GypsyCosmonaut
la source
5

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}'
Vineeth
la source
5

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.

Nick W.
la source
3
Comment serait-ce mieux que ps ?? Il est livré avec toutes les limitations de ps et est encore plus inexact ...
Lester Cheung
Un système Unix typique a de nombreux processus qui démarrent et se terminent tout le temps. Vous ne pouvez pas prévoir votre RAM gratuite.
Raúl Salinas-Monteagudo du
4

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.

DarenW
la source
Non, il n'est pas possible «d'attacher» valgrind à un processus en cours d'exécution. C'est par conception.
Dima Tisnek
3

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.

entrez la description de l'image ici

test30
la source
3

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.

juanjux
la source
3

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.

Jain Rach
la source
2
Pour afficher le lancement PSIZE ["taille de mémoire proportionnelle de ce processus (ou utilisateur)] à l'aide de atop -R. Pour afficher une poussée récapitulative par utilisateur p, pour trier par utilisation de la mémoire, appuyez sur" M "de l'intérieur au sommet. Cela donne des nombres similaires à smem.
Markus Strauss
1

Un autre vote pour ici, 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;)

Dan
la source
1

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 .

jtpereyda
la source
La plupart des applications - c'est-à-dire celles qui utilisent malloc () et des bibliothèques de mémoire de type malloc - ne renvoient pas de pages au système d'exploitation avant la fin du processus. Ainsi, le montant que vous voyez avec PS (ou tout autre outil qui ne creuse pas dans le tas du processus) sera le point culminant.
David C.
0

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
Roselyn Verbo Domingo
la source
0

/ 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.

ptan
la source
-1

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

Sudheesh.MS
la source
1
Au moins depuis le 16.04, cela fonctionne très bien. C'est très similaire au top cependant, la mémoire utilisée n'est pas extrêmement précise ...
Alexis Wilke