Comment mesurer l'utilisation réelle de la mémoire d'une application ou d'un processus?
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?
D'après l'article de blog Comprendre l'utilisation de la mémoire sous Linux , ps n'est pas un outil précis à utiliser à cette fin.
Pourquoi
psest "faux"Selon la manière dont vous le regardez,
psne signale pas l'utilisation réelle de la mémoire par les 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 entendu, une machine Linux typique compte plusieurs dizaines de processus en cours d'exécution, ce qui signifie que les nombres VSZ et RSS rapportés parpssont presque définitivement incorrects .
Avec ps ou des outils similaires, vous n'obtiendrez que 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 à cette application
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 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 tas 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 le documentation de valgrind , vous devez exécuter le programme via valgrind:
valgrind --tool=massif <executable> <arguments>
Massif écrit une sauvegarde 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 de la mémoire de votre programme. Un excellent outil graphique pour analyser ces fichiers est massif-visualizer . Mais j’ai trouvé que ms_print, un simple outil texte fourni avec valgrind, était déjà d’une grande aide.
Pour rechercher des fuites de mémoire, utilisez l'outil (par défaut) memcheck 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 VmSize, qui devrait être proche de ce que ps aux donne.
/proc/19420 $ statut de chat Nom: firefox État: S (dormir) 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 46 107 109 115 124 1000 VmPeak: 222956 kB VmTaille: 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 Discussions: 8 SigQ: 0/16382 Signd: 0000000000000000 ShdPnd: 0000000000000000 SigBlk: 0000000000000000 SigIgn: 0000000020001000 SigCgt: 000000018000442f CapInh: 0000000000000000 CapPrm: 0000000000000000 CapEff: 0000000000000000 Cpus_allowed: 03 : 1 Volunteer_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 déterminer 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 facile de calculer cela. Mais certaines personnes ont essayé d'obtenir de bonnes réponses:
Utilisez smem , qui est une alternative à ps qui calcule le USS et le PSS par processus. Ce que vous voulez, c'est probablement le PSS.
USS - Taille unique. C'est la quantité de mémoire non partagée unique à ce processus (imaginez-la comme U pour nique mémoire). Cela n'inclut pas la mémoire partagée. Ainsi, nder - indique la quantité de mémoire utilisée par un processus, mais est utile lorsque vous souhaitez ignorer la mémoire partagée.
PSS - Taille du jeu proportionnel. Voici ce que tu veux. Il ajoute la mémoire unique (USS) à une partie de la mémoire partagée divisée par le nombre de processus partageant cette mémoire. Ainsi, cela vous donnera une représentation précise de la quantité de mémoire physique réellement utilisée par processus - la mémoire partagée étant réellement représentée comme partagée. Pensez à la mémoire P étant pour physique.
Comment cela se compare-t-il au RSS tel que rapporté par ps et d'autres fonctions:
- 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 partagent la mémoire, cela indique over - indique la quantité de mémoire réellement utilisée, car la même mémoire partagée est comptée plus d'une fois. Elle apparaît à nouveau dans chaque processus partageant la même mémoire. Ainsi, il est assez 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 (facultativement) 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 façon 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 ceci 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]
Qu'en est-il de time?
Pas le Bash intégré time mais 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
C’est un excellent résumé des outils et des problèmes: archive.org link
Je le citerai pour 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 (pas seulement son utilisation de tas), 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 risquent donc de fuir ou sont très inefficaces dans leur utilisation). 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 vérifier une utilisation élevée 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 tas (malloc, etc.), exécutez-la dans memprof ou avec . kmtrace , profilez l’application et recherchez dans l’arborescence des appels de fonctions les attributions les plus importantes. 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" 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 (kb): 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ésidant" ou DRS.
SHR - Taille de la 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 être potentiellement partagée avec d'autres processus.
Référence ici .
Il n’ya pas une seule réponse à cela, car vous ne pouvez pas déterminer précisément 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 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 les charger.
De même, si vous avez besoin de connaître la quantité de mémoire nécessaire à 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 AT en une seule fois. D'autre part, valgrind vous donnera un meilleur profil de l'utilisation de la mémoire tout au long de la vie du programme.
Si votre code est en C ou C++, vous pourrez peut-être utiliser getrusage(), qui vous renvoie diverses statistiques sur la mémoire et l'utilisation du temps de votre processus.
Cependant, toutes les plates-formes ne le prennent pas en charge et renverront 0 pour les options d’utilisation de la mémoire.
Au lieu de cela, vous pouvez consulter le fichier virtuel créé dans /proc/[pid]/statm (où [pid] est remplacé par votre ID de processus. Vous pouvez l'obtenir auprès de getpid()).
Ce fichier ressemblera à un fichier texte avec 7 nombres entiers. Vous êtes probablement plus intéressé par le premier (utilisation de la mémoire uniquement) et le sixième (utilisation de la mémoire de données) de ce fichier.
Valgrind peut afficher des informations détaillées mais ralentit l'application cible de manière significative, et la plupart du temps, elle 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 du noya 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" de WRT est le suivant ...
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 anonyme mappée
- .p privé
- .d dirty == malloc/mmapped tas et pile alloué et mémoire écrite
- .c clean == malloc/mmMap mémoire de pile et mémoire allouée, écrite, puis libérée, mais non encore récupérée
- .s partagé
- .d dirty == le tas malloc/mmaped peut être copié sur écriture et partagé entre processus (édité)
- .c clean == le tas malloc/mmaped peut être copié sur écriture et partagé entre processus (édité)
- .p privé
M.n a nommé la mémoire mappée
- .p privé
- .d sale == fichier mémoire mappée mémoire privée
- .c clean == texte de programme/bibliothèque mappé privé mappé
- .s partagé
- .d sale == fichier mémoire partagée mappée
- .c clean == texte de bibliothèque mappé partagé mappé
- .p privé
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:
ps aux --sort pmem
Il trie la sortie par%MEM.ps aux | awk '{print $2, $4, $11}' | sort -k2r | head -n 15
Il trie en utilisant des tuyaux.top -a
Il commence le tri en haut par%MEM
(extrait de ici )
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 l'exécuter. 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 vrai système unix, /usr/bin/time -v fonctionne. Sous Linux, cependant, cela fonctionne pas.
#!/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 de l'utilisation plus "réelle" consiste à ouvrir l'application, puis à exécuter vmstat -s et à vérifier la statistique "mémoire active". 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.
J'utilise Arch Linux et il y a 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
=============================================
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}'
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 supporter d'être 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 idée précise de la quantité de mémoire utilisée par un processus donné.
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'E/S. Lors de la création du noyau, le processus est arrêté (ou "gelé") pour empêcher les modifications de la mémoire. Donc sois prudent.
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 à la création du fichier principal créé dans ce répertoire particulier.
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 dure depuis un certain temps et qui 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 fonctionne à 100% seulement 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;
cela recherchera continuellement les modifications et les imprimera.
Je suggère que vous utilisez au sommet. Vous pouvez trouver tout ce dont vous avez besoin 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.
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 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.
Vérifiez le script Shell pour vérifier tilisation de la mémoire par application sous Linux . Egalement 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 maximum de mémoire utilisée par une application, du début à la fin. Outre valgrind, vous pouvez utiliser tstime , ce qui est beaucoup plus simple. Il mesure l'utilisation de la mémoire "highwater" (RSS et virtuelle). De cette réponse .
Utilisez l'outil graphique 'moniteur du système' intégré dans ubuntu
/ prox/xxx/numa_maps donne quelques informations ici: N0 = ??? N1 = ???. Mais ce résultat pourrait être inférieur au résultat réel, car il ne compte que ceux qui ont été touchés.
Basé sur la réponse à un question . lié
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écuté 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'ID de processus (pid) du processus que vous souhaitez surveiller
Notes:
Host-RESOURCES-MIB :: hrSWRunPerfCPU est le nombre de centi-secondes de la CPU totale du système. ressources 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).
Host-RESOURCES-MIB :: hrSWRunPerfMem est la quantité totale de mémoire système réelle allouée à ce processus. .
**
Script de surveillance du 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