Comment mesurer l'utilisation réelle de la mémoire d'une application ou d'un processus?
https://stackoverflow.com/questions/131303
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Cette question est couverte ici en détail.
Comment mesurez-vous l'utilisation de la mémoire d'une application ou d'un processus sous Linux?
Extrait de l'article de blog Utilisation de la mémoire sous Linux , ps n'est pas un outil précis à utiliser à cette fin.
Pourquoi
psest-il incorrect?Selon votre perception,
psne signale pas l'utilisation réelle de la mémoire par les processus. En réalité, il montre combien de mémoire réelle chaque processus occuperait s'il était le seul processus en cours d'exécution . Bien entendu, une machine Linux typique compte plusieurs dizaines de processus en cours d'exécution, ce qui signifie que les numéros VSZ et RSS signalés parpssont presque définitivement erronés .
La solution
Avec ps ou des outils similaires, vous obtiendrez uniquement la quantité de pages de mémoire allouée par ce processus. Ce nombre est correct, mais:
-
ne reflète pas la quantité réelle de mémoire utilisée par l'application, mais uniquement la quantité de mémoire réservée pour celle-ci
-
peut être trompeur si les pages sont partagées, par exemple par plusieurs threads ou en utilisant des bibliothèques liées de manière dynamique
Si vous voulez vraiment connaître la quantité de mémoire réellement utilisée par votre application, vous devez l'exécuter dans un profileur. Par exemple, valgrind peut 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 de profilage de tas de valgrind s’appelle 'massif':
Massif est un profileur de tas. Il effectue un profilage détaillé des segments en prenant des instantanés réguliers du segment de mémoire d'un programme. Il génère un graphique montrant l'utilisation du segment de mémoire au fil du temps, y compris des informations sur les parties du programme responsables du plus grand nombre d'allocations de mémoire. Le graphique est complété par un fichier texte ou HTML qui inclut 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 valgrind , vous devez exécuter le programme via valgrind:
valgrind --tool=massif <executable> <arguments>
Massif écrit une copie instantanée d'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 de la mémoire de votre programme.
Le massif-visualizer est un excellent outil graphique pour analyser ces fichiers. Mais j’ai trouvé que ms_print , un simple outil texte fourni avec valgrind, était déjà d’une grande aide.
Pour rechercher les fuites de mémoire, utilisez l'outil (par défaut) memcheck de valgrind.
Autres conseils
Essayez la commande pmap :
sudo pmap -x <process pid>
Difficile à dire avec certitude, mais en voici deux "proches" choses 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 à / proc / $ pid / status
Le plus important est VmSize, qui devrait être proche de ce que ps aux donne.
/proc/19420$ cat status Name: firefox State: S (sleeping) Tgid: 19420 Pid: 19420 PPid: 1 TracerPid: 0 Uid: 1000 1000 1000 1000 Gid: 1000 1000 1000 1000 FDSize: 256 Groups: 4 6 20 24 25 29 30 44 46 107 109 115 124 1000 VmPeak: 222956 kB VmSize: 212520 kB VmLck: 0 kB VmHWM: 127912 kB VmRSS: 118768 kB VmData: 170180 kB VmStk: 228 kB VmExe: 28 kB VmLib: 35424 kB VmPTE: 184 kB Threads: 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 voluntary_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 mémoire privée et partagée afin que vous puissiez connaître 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’existe pas de moyen facile de calculer cela. Mais certaines personnes ont essayé d'obtenir de bonnes réponses:
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 de jeu unique. Il s'agit de la quantité de mémoire non partagée unique pour ce processus (considérez-la comme U pour une mémoire unique ). Cela n'inclut pas la mémoire partagée. Ainsi, sous -indiquez la quantité de mémoire utilisée par un processus, mais elle est utile lorsque vous souhaitez ignorer la mémoire partagée.
-
PSS : taille de l'ensemble proportionnel. Voici ce que vous voulez. Il ajoute la mémoire unique (USS) à une partie de la mémoire partagée divisée par le nombre d'autres processus partageant cette mémoire. Ainsi, cela vous donnera une représentation précise de la quantité de mémoire physique réelle utilisée par processus - la mémoire partagée étant réellement représentée comme partagée. Pensez au P comme étant pour la mémoire physique .
Comment cela se compare-t-il au RSS tel que rapporté par ps et d'autres outils:
- RSS : taille de l'ensemble de résidents. 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 partagent la mémoire, sur , ils indiqueront la quantité de mémoire réellement utilisée, car la même mémoire partagée sera comptée plus d'une fois - elle apparaîtra à nouveau dans chaque processus partageant la même mémoire. Ainsi, il est relativement peu fiable, en particulier lorsque les processus à mémoire vive ont beaucoup de forks, ce qui est courant sur un serveur, avec des processus comme Apache ou PHP (fastcgi / FPM).
Remarque: smem peut également (éventuellement) générer des graphiques tels que des camemberts, etc. OMI, vous n'en avez pas besoin. Si vous souhaitez simplement l'utiliser à partir de la ligne de commande, de la même manière que 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 pour 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]
Qu'en est-il de heure ?
Pas le Bash heure intégré, mais celui que vous pouvez trouver avec quel temps , 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
Il s'agit d'un excellent résumé des outils et des problèmes: lien archive.org
Je vais le citer, pour que plus de développeurs le lisent réellement.
Si vous souhaitez analyser l'utilisation de la mémoire de l'ensemble du système ou analyser de manière approfondie l'utilisation de la mémoire d'une application (pas seulement son utilisation de segment de mémoire), utilisez exmap . Pour l'analyse de l'ensemble du système, recherchez les processus les plus efficaces, ils utilisent le plus de mémoire possible, recherchent les processus les plus inscriptibles, créent le plus de données (et donc éventuellement des fuites ou une utilisation très inefficace). Sélectionnez cette application et analysez ses correspondances dans la deuxième liste. Voir la section exmap pour plus de détails. Utilisez également xrestop pour contrôler l'utilisation intensive des ressources X, en particulier si le processus du serveur X utilise 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 d'une application par le tas (malloc, etc.), exécutez-la dans memprof ou avec kmtrace , profilez l'application et recherchez l'appel de fonction. arbre pour les plus grandes allocations. Voir leurs sections pour plus de détails.
Outre les solutions énumérées dans vos réponses, vous pouvez utiliser la commande Linux "top" ;; Il fournit une vue dynamique en temps réel du système en fonctionnement, il donne l'utilisation du processeur 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; top " fournit également des champs tels que:
VIRT - Image virtuelle (ko): quantité totale de mémoire virtuelle utilisée par la tâche
RES - Taille du résident (Ko): mémoire physique non permutée qu'une tâche a utilisée; RES = CODE + DATA.
DATA - Données + taille de pile (kb): quantité de mémoire physique consacrée à un code autre que le code exécutable, également appelée taille de "groupe de données résidents" ou DRS.
SHR - Taille de mémoire partagée (Ko): quantité de mémoire partagée utilisée par une tâche. Cela reflète simplement la mémoire qui pourrait éventuellement être partagée avec d’autres processus.
Référence ici .
Il n’existe pas une seule réponse à cette question 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". Ne comptez-vous que la mémoire utilisée par l'exécutable 'ls' (si vous pouviez l'isoler)? Que diriez-vous de la libc? Ou toutes ces autres bibliothèques qui sont 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 pouvez affirmer qu'ils sont partagés par d'autres processus, mais que "ls" ne peut pas être exécuté sur le système sans les charger.
De même, si vous devez connaître la quantité de mémoire requise par un processus pour pouvoir 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 en une fois. Par contre, valgrind vous donnera un meilleur profil de l’utilisation de la mémoire tout au long du programme
Si votre code est en C ou C ++, vous pourrez peut-être utiliser getrusage () , qui vous renvoie diverses statistiques sur l'utilisation de la mémoire et du temps d'utilisation de votre processus.
Cependant, toutes les plates-formes ne le supportent pas et renverront 0 valeur pour les options d'utilisation de la mémoire.
À la place, vous pouvez consulter le fichier virtuel créé dans / proc / [pid] / statm (où [pid] est remplacé par votre identifiant de processus. Vous pouvez obtenir ceci à partir de getpid () ).
Ce fichier ressemblera à un fichier texte avec 7 entiers. Vous êtes probablement le plus intéressé par les premier (dans l’utilisation de la mémoire) et par le sixième (utilisation de la mémoire de données) dans ce fichier.
Valgrind peut afficher des informations détaillées, mais il ralentit l'application cible de manière significative, 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 qu'il vous faut un module de noyau pour obtenir les informations, ce qui peut constituer un obstacle.
Je suppose que tout le monde veut savoir WRT " utilisation de la mémoire " est la suivante ...
Sous Linux, la quantité de mémoire physique qu'un processus peut utiliser peut être grossièrement divisée en catégories suivantes.
-
M.a mémoire mappée anonyme
- .p private
- .d dirty == mémoire malloc / mmapped et pile allouée et écrite
- .c clean == Malloc / mmMap mémoire de pile et mémoire allouée, écrite, puis libérée, mais pas encore récupérée
- .s partagé
- .d dirty == Le tas malloc / mmaped peut être copié sur écriture et partagé entre processus (modifié)
- .c clean == Le tas malloc / mmaped peut obtenir une copie sur écriture et être partagé entre les processus (modifié)
- .p private
-
M.n a nommé la mémoire mappée
- .p private
- .d sale == fichier mappé mémoire privée
- .c clean == texte mappé privé du programme / bibliothèque mappé
- .s partagé
- .d sale == fichier mémoire partagée mappée
- .c clean == texte de bibliothèque mappé partagé mappé
- .p private
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
J'utilise htop ; c'est un très bon programme de console similaire au gestionnaire de tâches Windows.
Valgrind est incroyable si vous avez le temps de le lancer. valgrind --tool = massif est la bonne solution.
Cependant, je commence à utiliser des exemples plus volumineux et l'utilisation de valgrind n'est plus pratique. Existe-t-il un moyen d'indiquer l'utilisation maximale de la mémoire (taille de page modulo et pages partagées) d'un programme?
Sur un système Unix réel, / usr / bin / time -v fonctionne. Sous Linux, cependant, cela ne fonctionne pas .
Trois autres méthodes à essayer:
-
ps aux --sort pmem
Il trie la sortie par% MEM. -
ps aux | awk '{print $ 2, 4 $, 11 $}' | trier -k2r | head -n 15
Il trie en utilisant des tuyaux. -
haut -a
Il commence le premier tri par% MEM
(Extrait de 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
Un bon test du plus "& vrai" monde réel " L’utilisation consiste à ouvrir l’application, puis exécutez vmstat -s , puis cochez la case "Mémoire active". statistique. Fermez l'application, attendez quelques secondes et exécutez à nouveau vmstat -s . Cependant, beaucoup de mémoire active libérée était évidemment utilisée par l'application.
Si le processus n'utilise pas trop de mémoire (soit parce que vous vous attendez à ce que ce soit le cas, soit à l'aide d'une autre commande ayant donné cette indication initiale), et si le processus peut supporter d'être arrêté pendant une courte période, vous peut essayer d'utiliser la commande gcore.
gcore <pid>
Vérifiez la taille du fichier core généré pour avoir une idée précise de la quantité de mémoire utilisée par un processus particulier.
Cela ne fonctionnera pas très bien si le processus utilise des centaines de mégas, ou de concerts, car la génération de base peut prendre plusieurs secondes ou minutes à être créée, en fonction des performances d’entrée / sortie. Lors de la création du noyau, le processus est arrêté (ou "figé") pour empêcher les modifications de la mémoire. Alors faites attention.
Assurez-vous également que le point de montage où le noyau est généré dispose de beaucoup d'espace disque et que le système ne réagira pas négativement au fichier principal créé dans ce répertoire particulier.
La ligne de commande ci-dessous vous indiquera 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}'
J'utilise Arch Linux et ce merveilleux paquet nommé 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
=============================================
Obtenez valgrind. donnez-lui votre programme à exécuter et il vous en dira beaucoup sur son utilisation de la mémoire.
Ceci s’appliquerait uniquement 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.
Modifier: cela fonctionne à 100% uniquement lorsque la consommation de mémoire augmente
. Si vous souhaitez surveiller l'utilisation de la mémoire par processus donné (ou par groupe de noms de partage partagés 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;
Ceci 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 smaps, un ps avec les options permettant d'afficher le groupe de résidents du processus (avec ps -o rss, commande ) peut vous donner un _aproximation _ rapide et raisonnable de la quantité réelle de mémoire non échangée utilisée.
Je suggérerais que vous utilisiez au sommet. Vous trouverez toutes les informations à ce sujet sur cette page . Il est capable de fournir tous les indicateurs de performance clés nécessaires à vos processus et peut également être enregistré dans un fichier.
Vérifiez le script shell pour vérifier utilisation de la mémoire par application sous Linux . Aussi disponible sur github et dans une version sans coller et bc .
Bien que cette question semble concerner l’examen des processus en cours, je souhaitais connaître le volume de mémoire maximal utilisé par une application, du début à la fin. Outre valgrind, vous pouvez utiliser tstime , qui est beaucoup plus simple. Il mesure le "highwater" " utilisation de la mémoire (RSS et virtuelle). De cette réponse .
Utiliser l'outil graphique intégré System Monitor 'disponible dans ubuntu
.Sur la base de la réponse à un question .
Vous pouvez utiliser SNMP pour obtenir l'utilisation de la mémoire et du processeur d'un processus dans un périphérique particulier du réseau:)
Conditions requises:
- le périphérique exécutant le processus doit avoir installé et exécuter snmp
- snmp doit être configuré pour accepter les demandes d'où vous allez exécuter le script ci-dessous (il peut être configuré dans snmpd.conf)
- vous devez connaître l'identifiant du processus que vous souhaitez surveiller (pid)
Remarques:
-
MOST 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 incrémenter de plus d'un centième de seconde sur un centième de temps réel (horloge murale).
-
MOST HOST-RESOURCES-MIB :: hrSWRunPerfMem est la quantité totale de mémoire système réelle allouée à ce processus.
**
Script de suivi 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
