Essayez le pmap "151930920 de la commande":

sudo pmap -x <process pid>

Difficile à dire, mais voici deux "fermer" les choses qui peuvent aider.

$ ps aux 

vous donnera la taille virtuelle (VSZ)

vous pouvez également obtenir des statistiques détaillées de /proc file-system en allant à /proc/$pid/status

le plus important est le 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 procédé avec un PID de 1234:

cat /proc/1234/smaps

Il vous dira exactement combien de mémoire, il est utilisé à l'époque. Plus important encore, il divisera la mémoire en privé et partagé, de sorte que vous pouvez dire combien de mémoire votre instance du programme utilise, sans inclure la mémoire partagée entre plusieurs instances du programme.

il n'y a pas de méthode facile pour calculer cela. Mais certaines personnes ont essayé d'obtenir quelques bonnes réponses:

• ps_mem.py
• ps_mem.py à github

utiliser smem , qui est une alternative à ps qui calcule le USS et le PSS par processus. Ce que tu veux, c'est probablement les PSS.

• USS - Taille de jeu Unique. C'est la quantité de mémoire non partagée unique à ce processus (pensez-y comme U pour unique mémoire). Il ne comprend pas partagé mémoire. Ainsi, ce sera sous - signaler la quantité de mémoire qu'un processus utilise, mais est utile quand vous voulez ignorer la mémoire partagée.

• PSS Proportionnelle à la Taille de l'Ensemble. C'est ce que vous voulez. Il additionne la mémoire unique (USS), ainsi qu'une proportion de sa mémoire partagée divisée par le nombre d'autres processus partageant cette mémoire. Ainsi il vous donnera une représentation précise de combien physique réelle de mémoire utilisée par un processus de mémoire partagée représentait réellement partagé. Pensez au P étant pour physique mémoire.

Comment cela se compare à un flux RSS tel que rapporté par ps et d'autres utilties:

• RSS - résident Set Size. C'est la quantité de mémoire partagée plus la mémoire non partagée utilisée par chaque processus. Si des processus partagent de la mémoire, cela sur - reportez la quantité de mémoire réellement utilisée, parce que la même mémoire partagée sera comptée plus d'une fois - apparaissant à nouveau dans chaque autre processus qui partage la même mémoire. Ainsi, il est assez peu fiable, surtout lorsque les processus à haute mémoire ont beaucoup de fourches-ce qui est commun dans un serveur, avec des choses comme Apache ou PHP(fastcgi/FPM) processus.

Remarque: smem peut également (optionnellement) des graphiques de sortie tels que des diagrammes circulaires et similaires. OMI, vous n'avez pas besoin de tout cela. Si vous souhaitez les utiliser à partir de la ligne de commande que vous pouvez utiliser ps -v, alors vous n'avez pas besoin d'installer python-matplotlib recommandé de dépendance.

et time ?

pas le Bash builtin 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

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

Utiliser comme racine 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=/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] 

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

je vais le citer, pour que plus de devs le lisent.

si vous souhaitez analyser l'utilisation de la mémoire de l'ensemble du système ou analyser à fond l'utilisation de la mémoire d'une application (pas seulement son utilisation en tas), utilisez exmap . Pour l'analyse de l'ensemble du système, trouver des processus avec l'utilisation la plus efficace, ils prendre le plus de mémoire dans la pratique, trouver des processus avec le plus d'utilisation possible en écriture, ils créent le plus de données (et donc peut-être fuient ou sont très inefficaces dans leur utilisation de données). Sélectionnez cette application et analysez ses correspondances dans la seconde listview. Voir la section exmap pour plus de détails. Utilisez également xrestop pour vérifier l'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 voulez détecter des fuites, utilisez valgrind ou éventuellement kmtrace .

si vous souhaitez analyser des tas (malloc etc.) utilisation d'une application, soit l'exécuter dans memprof ou avec kmtrace , profil de l'application et la recherche dans l'arbre de fonction pour les plus grandes allocations. Voir leurs sections pour plus de détails.

outre les solutions énumérées dans tes réponses, vous pouvez utiliser la commande Linux "top"; elle fournit une vue dynamique en temps réel du système en cours d'exécution, elle donne L'utilisation CPU et mémoire, pour l'ensemble du système avec pour chaque programme, en pourcentage:

top

filtrer par un pid programme:

top -p <PID>

pour filtrer par un nom de programme:

top | grep <PROCESS NAME>

"top" fournit également certains champs tels que:

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

RES -- Resident size (kb): la mémoire physique non échangé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 à autre que le code exécutable, également connu sous le nom de "data resident set" size ou DRS.

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

référence ici .

il n'y a pas une seule réponse pour cela parce que vous ne pouvez pas indiquer précisément la quantité de mémoire qu'un processus utilise. La plupart des processus sous linux utilisent des bibliothèques partagées. Par exemple, disons que vous voulez calculer l'utilisation de la mémoire pour le "ls". Comptez-vous seulement la mémoire utilisée par l'exécutable " ls " (si vous pouvez l'isoler) ? Comment à propos de la libc? Ou tous ces autres libs qui sont nécessaires pour lancer '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 argumenter qu'ils sont partagés par d'autres processus, mais 'ls' ne peuvent pas être exécutés sur le système sans qu'ils soient chargés.

en outre, si vous avez besoin de savoir combien de mémoire un processus a besoin pour faire la planification de capacité, vous devez calculer combien chaque copie supplémentaire du processus utilise. Je pense que / proc/PID / status pourrait vous donner assez 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 vie du programme

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

toutes les plates-formes ne supportent pas cela cependant et retourneront des valeurs 0 pour les options d'utilisation de la mémoire.

à la place, vous pouvez regarder le fichier virtuel créé dans /proc/[pid]/statm (où [pid] est remplacé par votre identifiant de processus. Vous pouvez l'obtenir à partir de getpid() ).

Ce fichier ressemblera à un fichier texte de 7 entiers. Vous êtes probablement plus intéressé par les premiers (tous les usages de la mémoire) et sixième (l'usage de la mémoire de données) nombres dans ce dossier.

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 que vous ayez besoin d'un module du noyau pour obtenir les informations, ce qui peut être un obstacle.

je suppose ce que tout le monde veut savoir WRT "l'utilisation de la mémoire" 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.

• M. A anonymous mapped memory

  • .p privé
    • .d sale == malloc/mmapped tas et de la pile allouée et écrit de mémoire
    • .c clean = = malloc / mmapped tas et pile de mémoire une fois attribuée, écrite, puis libérée, mais pas encore récupérée
  • .s partagé
    • .d sale == malloc/mmaped tas pu obtenir de copie sur écriture et partagées entre les processus (édité)
    • .c clean == malloc/mmaped tas pu obtenir de copie sur écriture et partagées entre les processus (édité)

• M. N named mapped memory

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

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 à Windows Task Manager.

Valgrind est étonnant, si vous avez le temps pour l'exécuter. valgrind --tool=massif est la bonne Solution.

cependant, je commence à courir des exemples plus grands, et l'utilisation de valgrind n'est plus pratique. Existe-t-il un moyen de connaître l'utilisation maximale de mémoire (Taille de page modulo et pages partagées) d'un programme?

sur un vrai système unix, /usr/bin/time -v fonctionne. Sur Linux, cependant, cela ne pas travail.

trois autres méthodes à essayer:

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

(extrait de ici )

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

IFS=$'\n'

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

print $kb

un bon test de l'usage plus" réel "est d'ouvrir l'application, puis exécuter vmstat -s et vérifier la statistique" mémoire active". Fermez l'application, attendez quelques secondes et relancez vmstat -s . Cependant beaucoup de mémoire active a été libéré a été visiblement utilisés par l'application.

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

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

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

, Cela s'applique seulement pour 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.

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 de temps, vous pouvez essayer d'utiliser la commande gcoré.

gcore <pid>

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

cela ne fonctionnera pas trop bien si le processus est en utilisant des centaines de megs, ou gigs, comme la génération de noyau pourrait prendre plusieurs secondes ou minutes pour être créé en fonction de la performance 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, soyez prudent.

aussi s'assurer que le point de montage où le noyau 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.

Edit: cela fonctionne à 100%, bien que lorsque augmentations de consommation de mémoire

si vous voulez surveiller l'utilisation de la mémoire par un processus donné (ou un groupe de traitement partageant un nom commun, par exemple google-chrome , vous pouvez utiliser mon script bash:

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

cela va chercher continuellement des changements et les imprimer.

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 pour montrer l'ensemble résident du processus (avec ps -o rss,command ) peut vous donner un _aproximation_ rapide et raisonnable de la quantité réelle de mémoire non échangée utilisée.

Vérifier script shell case l'utilisation de la mémoire par l'application sous linux . Également disponible sur github et dans une version sans pâte et bc .

je vous suggère d'utiliser atop. Vous pouvez tout trouver à ce sujet sur cette page . Il est capable de fournir tous les KPI nécessaires pour vos processus et il peut également capturer dans un fichier.

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
=============================================

un Autre vote pour valgrind 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 le code lean, non-leaky pour le montrer fièrement;)

bien que cette question semble être sur l'examen des processus en cours, je voulais voir la mémoire de pointe utilisée par une application du début à la fin. En plus de 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 .

utiliser l'outil GUI intégré " System monitor 'disponible en ubuntu

D'après la réponse à une question connexe .

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

exigences:

• le dispositif qui exécute le processus doit avoir snmp installé et en cours d'exécution
• snmp doit être configuré pour accepter les requêtes depuis où vous exécutez le script ci-dessous(il peut être configuré en snmpd.conf)
• vous devez connaître l'identifiant du processus(pid) du processus que vous voulez surveiller

Notes:

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

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

**

suivi du Processus de script:

* *

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