Como medir o uso de memória real de um aplicativo ou processo?
https://stackoverflow.com/questions/131303
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Esta questão é coberto aqui em grande detalhe.
Como você mede o uso de memória de um aplicativo ou processo no Linux?
A partir do artigo do blog da uso de memória Entendimento sobre Linux , ps não é uma ferramenta precisa para usar para este fim.
Por
psé "errado"Dependendo de como você olha para ele,
psnão está relatando o uso de memória real dos processos. O que está realmente fazendo é mostrando o quanto memória real cada processo ocuparia se fosse o único processo em execução . Claro, uma máquina Linux típico tem vários processos dúzia executando a qualquer momento, o que significa que os números VSZ e RSS relatados porpssão quase definitivamente errado .
Solução
Com ps ou ferramentas similares você só vai conseguir a quantidade de páginas de memória alocadas por esse processo. Este número está correto, mas:
-
não reflete a real quantidade de memória usada pelo aplicativo, apenas a quantidade de memória reservada para ele
-
pode ser enganosa se as páginas são compartilhadas, por exemplo, por vários tópicos ou usando bibliotecas ligadas dinamicamente
Se você realmente quer saber o que quantidade de memória seu aplicativo realmente usa, você precisa executá-lo dentro de um profiler. Por exemplo, valgrind pode lhe dar insights sobre a quantidade de memória utilizada, e, mais importante, sobre possíveis vazamentos de memória no seu programa. A ferramenta pilha profiler de valgrind é chamado de 'maciço':
Massif é um profiler pilha. Ele realiza detalhado pilha de perfis tomando instantâneos regulares de pilha de um programa. Ela produz um gráfico que mostra o uso de heap ao longo do tempo, incluindo informações sobre quais partes do programa são responsáveis ??pela maioria das alocações de memória. O gráfico é complementado por um arquivo de texto ou HTML que inclui mais informações para determinar onde o mais memória está sendo alocado. Massif executa programas cerca de 20x mais lento do que o normal.
Como explicado na valgrind documentação , você precisa executar o programa através valgrind:
valgrind --tool=massif <executable> <arguments>
Massif escreve um despejo de instantâneos de uso de memória (por exemplo massif.out.12345). Estes fornecem, (1) um cronograma de uso de memória, (2) para cada instantâneo, um registro de onde em sua memória programa foi alocado.
Uma ótima ferramenta gráfica para analisar esses arquivos é maciço-visualizador . Mas eu achei ms_print, uma ferramenta baseada em texto simples fornecido com valgrind, para ser de grande ajuda já.
Para encontrar vazamentos de memória, use o (padrão) ferramenta memcheck de valgrind.
Outras dicas
Tente o href="http://linux.die.net/man/1/pmap" rel="noreferrer"> comando :
sudo pmap -x <process pid>
É difícil dizer com certeza, mas aqui estão dois "fechar" as coisas que podem ajudar.
$ ps aux
lhe dará Virtual Size (VSZ)
Você também pode obter estatísticas detalhadas de / sistema de arquivos proc, indo para /proc/$pid/status
O mais importante é o VmSize, que deve ser perto do que ps aux dá.
/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
Em versões recentes do Linux, use o smaps subsistema. Por exemplo, para um processo com um PID de 1234:
cat /proc/1234/smaps
Ele vai dizer exatamente o quanto de memória ele está usando naquele momento. Mais importante, ele vai dividir a memória em privados e partilhados, assim você pode dizer quanta memória o seu exemplo do programa é usando, sem incluir a memória compartilhada entre várias instâncias do programa.
Não há nenhuma maneira fácil de calcular isso. Mas algumas pessoas têm tentado obter algumas boas respostas:
Use smem , que é uma alternativa ao ps que calcula o USS e PSS por processo. O que você quer é provavelmente o PSS.
-
USS - Único Set Size. Esta é a quantidade de memória não compartilhada única para esse processo (pense nisso como U para única de memória). Não inclui memória compartilhada. Assim, esta vontade em , diz jornal a quantidade de memória que um processo usos, mas é útil quando você quer ignorar memória compartilhada.
-
PSS - Proporcional Tamanho do conjunto. Isso é o que você quer. Acrescenta juntos a memória único (USS), juntamente com uma proporção de sua memória compartilhada dividido pelo número de outros processos que compartilham essa memória. Assim, ele vai te dar uma representação precisa da quantidade de memória física real está sendo usado por processo - com memória compartilhada verdadeiramente representada como compartilhada. Pense no P ser para física memória.
Como isso se compara a RSS como relatado por PS e outros utilties:
- RSS - Residente Set Size. Esta é a quantidade de memória compartilhada além de memória não compartilhada usado por cada processo. Se qualquer memória share processos, isso vai mais , diz jornal a quantidade de memória realmente usado, porque a mesma memória compartilhada será contado mais de uma vez - aparecendo novamente em outro processo que compartilha a mesma memória. Assim, é muito não confiável, especialmente quando processos de alta de memória tem um monte de garfos -. Que é comum em um servidor, com coisas como Apache ou processos PHP (fastcgi / FPM)
Aviso: smem podem também (opcionalmente) de saída gráficos, tais como gráficos e outros semelhantes. IMO você não precisa de nada disso. Se você só quer usá-lo a partir da linha de comando como você pode usar ps -A v, então você não precisa instalar o python-matplotlib dependência recomendado.
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
Use isso como raiz e você pode obter uma saída clara para o uso de memória por cada processo.
SAÍDA exemplo:
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]
E sobre time?
Não é o Bash builtin time mas o que você pode encontrar com which time, por exemplo /usr/bin/time
Aqui está o que ele cobre, em uma ls simples:
$ /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
Este é um excelente resumo das ferramentas e problemas: archive.org ligação
Vou citá-lo, para que mais devs vai realmente lê-lo.
Se você quer analisar o uso de memória de todo o sistema ou para analisar cuidadosamente o uso de memória de um aplicativo (e não apenas o seu uso do heap), uso Exmap . Para a análise de todo o sistema, encontrar processos com o maior uso eficaz, eles tomam mais memória na prática, encontrar processos com o maior uso gravável, eles criam a maioria dos dados (e, portanto, possivelmente vazar ou são muito ineficazes em seu uso de dados). Selecione essa aplicação e analisar seus mapeamentos no segundo listview. Consulte a seção Exmap para mais detalhes. Também use xrestop para verificar alto uso de recursos X, especialmente se o processo do servidor X tem um monte de memória. Veja xrestop seção para detalhes.
Se você quiser detectar vazamentos, uso valgrind ou possivelmente kmtrace .
Se você quer analisar pilha (malloc etc.) o uso de um aplicativo, executá-lo em memprof ou com kmtrace , o perfil do aplicativo e procure a chamada de função árvore para maiores alocações. Veja suas seções para mais detalhes.
Além das soluções listadas nas tuas respostas, você pode usar o comando "top" Linux; Ele fornece uma dinâmica visão em tempo real do sistema de execução, ele dá a CPU e uso de memória, para todo o sistema, juntamente com para cada programa, em porcentagem:
top
Para filtrar por um pid programa:
top -p <PID>
Para filtrar por um nome de programa:
top | grep <PROCESS NAME>
"top" fornece também alguns campos, tais como:
VIRT - Imagem Virtual (kb): A quantidade total de memória virtual usada pela tarefa
RES - tamanho residente (KB): A memória não trocou física uma tarefa tem usado; RES = Código + DATA.
Dados - o tamanho de dados + Stack (kb):. A ??quantidade de memória física dedicada à excepção do código executável, também conhecido como o 'conjunto de dados residente' tamanho ou DRS
SHR - tamanho Mem Shared (kb): A quantidade de memória compartilhada usada por uma tarefa. Ele simplesmente reflete memória que poderia ser potencialmente compartilhada com outros processos.
aqui .
Não há uma única resposta para isso, porque você não pode fixar o ponto precisamente a quantidade de memória que um processo usos. A maioria dos processos sob uso linux bibliotecas compartilhadas. Por exemplo, digamos que você deseja calcular o uso de memória para o processo dos ls '. Você conta apenas a memória usada pelos 'ls' executáveis ??(se você poderia isolá-lo)? Como cerca de libc? Ou todas essas outras bibliotecas que são necessárias para executar '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)
Você pode argumentar que eles são compartilhados por outros processos, mas 'ls' não pode ser executado no sistema sem que eles sejam carregados.
Além disso, se você precisa saber quanta memória Um processo precisa, a fim de fazer o planejamento de capacidade, você tem que calcular o quanto cada cópia adicional dos usos de processo. Eu acho que / proc / PID / status pode dar-lhe informação suficiente do uso de memória em uma única vez. Por outro lado, valgrind lhe dará um melhor perfil do uso de memória durante toda a vida do programa
Se o seu código é em C ou C ++ que você pode ser capaz de usar getrusage() que retorna várias estatísticas sobre memória e tempo de uso do seu processo.
Nem todas as plataformas suportam esta embora e retornará 0 valores para as opções de memória de uso.
Em vez disso você pode olhar para o arquivo virtual criado no /proc/[pid]/statm (onde [pid] é substituído pelo seu ID de processo. Você pode obter isso getpid()).
Este arquivo será semelhante a um arquivo de texto com 7 números inteiros. Você provavelmente está mais interessado no primeiro (todo o uso de memória) e sexta (uso de memória de dados) números neste arquivo.
Valgrind pode mostrar informações detalhadas mas desacelera o aplicativo de destino de forma significativa, e na maioria das vezes ele muda o comportamento do aplicativo.
Exmap foi algo que eu não sabia ainda, mas parece que você precisa de um kernel do módulo para obter as informações, o que pode ser um obstáculo.
Eu assumo o que todo mundo quer saber "uso de memória" WRT é o seguinte ...
No Linux, a quantidade de memória física de um único processo pode usar pode ser dividido em categorias seguintes.
-
M. A anônimo memória mapeada
- .P privada
- sujo .d == malloc / mmapped pilha e pilha de memória alocada e escrito
- limpa == malloc / mmapped pilha e pilha de memória .c uma vez atribuída, por escrito, em seguida, libertado, mas não recuperou ainda
- .s compartilhada
- sujo .d == malloc / mmaped pilha poderia começar copy-on-write e compartilhados entre processos (editado)
- .c limpo == malloc / mmaped pilha poderia começar copy-on-write e compartilhados entre processos (editado)
- .P privada
-
M.n chamado memória mapeada
- .P privada
- memória arquivo .d sujo == mmapped escrita privada
- .c limpo == mapeados programa / text biblioteca privada mapeados
- .s compartilhada
- arquivo .d sujo == mmapped memória escrita compartilhada
- .c limpo == mapeados texto biblioteca compartilhada mapeada
- .P privada
Utility incluído no Android chamado showmap é bastante útil
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
Eu estou usando htop; é um programa muito bom de console semelhante ao Gerenciador de Tarefas do Windows.
Valgrind é incrível se você tem o tempo para executá-lo. valgrind --tool=massif é a solução certa.
No entanto, eu estou começando a correr exemplos maiores, e usando valgrind não é mais prático. Existe uma maneira de dizer o uso máximo de memória (tamanho da página modulo e páginas compartilhadas) de um programa?
Em um sistema UNIX real, /usr/bin/time -v funciona. No Linux, no entanto, isso faz não trabalho.
Mais três métodos para tentar:
-
ps aux --sort pmem
Ele classifica a saída por%MEM. -
ps aux | awk '{print $2, $4, $11}' | sort -k2r | head -n 15
Ele classifica usando tubos. -
top -a
Começa classificação superior por%MEM
(Extraído do aqui )
#!/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
Um bom teste do uso mais "mundo real" é abrir o aplicativo, vmstat -s em seguida, executar e verificar a estatística "memória ativa". Fechar a aplicação, aguarde alguns segundos e executar vmstat -s novamente. No entanto memória muito ativo foi libertado estava evidentemente em uso pelo aplicativo.
Se o processo não está usando muita memória (ou porque você espera que este seja o caso, ou algum outro comando deu esta indicação inicial), eo processo pode resistir a ser parado por um curto período de tempo, você pode tentar usar o comando gcore.
gcore <pid>
Verifique o tamanho do arquivo core gerado para obter uma boa idéia de quanto de memória um determinado processo está usando.
Isso não vai funcionar muito bem se o processo está usando centenas de megas, ou shows, como a geração núcleo pode levar vários segundos ou minutos para serem criados / O desempenho dependendo I. Durante a criação do núcleo o processo é interrompido (ou "congelado") para evitar alterações de memória. Portanto, tenha cuidado.
Certifique-se também o ponto em que o núcleo é gerado montagem tem muito espaço em disco e que o sistema não vai reagir negativamente para o arquivo de núcleo que está sendo criado no diretório particular.
Abaixo da linha de comando lhe dará o total de memória utilizada pelo vários processos em execução na máquina Linux em MB
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}'
Eu estou usando Arch Linux e há este pacote maravilhoso chamado ps_mem
ps_mem -p <pid>
Exemplo de Saída
$ 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
=============================================
Get valgrind. dar-lhe o seu programa para ser executado, e ele vai lhe dizer muito sobre seu uso de memória.
Isso se aplica apenas para o caso de um programa que é executado por algum tempo e paradas. Eu não sei se valgrind pode obter suas mãos em um processo já em execução ou shouldn't-stop processos tais como daemons.
Editar: isso funciona 100% bem apenas quando o consumo de memória aumenta
Se você deseja monitorar o uso de memória por determinado processo (ou grupo de nome comum de partilha processado, por exemplo google-chrome, você pode usar o meu bash-script:
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;
este será continuamente olhar para as mudanças e imprimi-los.
Se você quiser algo mais rápido do que perfilar com Valgrind e seu kernel é mais velho e você não pode usar smaps, um ps com as opções para mostrar o conjunto residente do processo (com ps -o rss,command) pode dar-lhe uma _aproximation_ rápida e razoável da quantidade real de memória não trocou a ser utilizado.
Gostaria de sugerir que você usa no topo. Você pode encontrar tudo sobre ele em desta página . Ele é capaz de fornecer todo o KPI necessária para seus processos e também pode captura para um arquivo.
roteiro check shell para verificar href="http://www.linoxide.com/linux-shell-script/linux-memory-usage-program/" uso de memória por aplicação em linux . Também disponível no github e em uma versão sem pasta e bc .
Enquanto esta questão parece ser sobre o exame de processos em execução no momento, eu queria ver a memória de pico usado por um aplicativo do início ao fim. Além valgrind, você pode usar tstime , que é muito mais simples. Ele mede o uso de memória "highwater" (RSS e virtual). De esta resposta .
Use o embutido ' monitor do sistema ' ferramenta gráfica disponível no Ubuntu
Com base na resposta a uma relacionados questão .
Você pode usar o SNMP para obter o uso de memória e CPU de um processo em um determinado dispositivo na rede:)
Requisitos:
- o dispositivo executando o processo deveria ter SNMP instalado e em execução
- snmp deve ser configurado para aceitar solicitações de onde você irá executar o script abaixo (pode ser configurado em snmpd.conf)
- você deve saber o ID do processo (PID) do processo que você deseja monitorar
Notas:
-
HOST-RECURSOS-MIB :: hrSWRunPerfCPU é o número de centi-segundos de recursos da CPU do sistema total consumida por este processo. Note-se que em um sistema multi-processador, este valor pode aumentar em mais de um centi-segundo em um centi-segundo de tempo real (relógio de parede).
-
HOST-RECURSOS-MIB :: hrSWRunPerfMem é a quantidade total de memória sistema real atribuído a este processo.
**
script de monitoramento de processo:
**
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
