Как измерить фактическое использование памяти приложения или процесса?
Этот вопрос освещен здесь очень подробно.
Как вы измеряете использование памяти приложением или процессом в Linux?
Из статьи в блоге " Понимание использования памяти в Linux"ps не является точным инструментом для этой цели.
Зачем
psнеправильно"В зависимости от того, как вы на это смотрите,
psне сообщает о реальном использовании памяти процессами. На самом деле он показывает, сколько реальной памяти занимал бы каждый процесс, если бы он был единственным запущенным процессом. Конечно, на обычном компьютере с Linux в любой момент времени выполняется несколько десятков процессов, а это означает, что номера VSZ и RSS сообщаютсяpsпочти наверняка не правы.
34 ответа
С ps или аналогичные инструменты вы получите только количество страниц памяти, выделенных этим процессом. Этот номер правильный, но:
не отражает фактический объем памяти, используемый приложением, только объем памяти, зарезервированный для него
может вводить в заблуждение, если страницы совместно используются, например, несколькими потоками или с использованием динамически связанных библиотек
Если вы действительно хотите знать, какой объем памяти фактически использует ваше приложение, вам нужно запустить его в профилировщике. Например, valgrind может дать вам представление об объеме используемой памяти и, что более важно, о возможных утечках памяти в вашей программе. Инструмент профилирования кучи Valgrind называется "массив":
Массив это куча профилировщик. Он выполняет подробное профилирование кучи, делая регулярные снимки кучи программы. Он создает график, показывающий использование кучи с течением времени, включая информацию о том, какие части программы отвечают за наибольшее количество выделенной памяти. График дополняется текстовым или HTML-файлом, который содержит больше информации для определения того, где выделяется наибольшее количество памяти. Массив запускает программы примерно в 20 раз медленнее, чем обычно.
Как объясняется в документации по valgrind, вам нужно запустить программу через valgrind:
valgrind --tool=massif <executable> <arguments>
Massif записывает дамп снимков использования памяти (например, massif.out.12345). Они обеспечивают, (1) график использования памяти, (2) для каждого снимка, запись о том, где в вашей программе была выделена память. Отличным графическим инструментом для анализа этих файлов является массив-визуализатор. Но я нашел ms_print, простой текстовый инструмент, поставляемый с valgrind, который уже может помочь.
Чтобы найти утечки памяти, используйте (по умолчанию) memcheck орудие валгринда.
Трудно сказать наверняка, но вот две "близкие" вещи, которые могут помочь.
$ ps aux
даст вам виртуальный размер (VSZ)
Вы также можете получить подробную статистику из файловой системы /proc, перейдя в /proc/$pid/status
Наиболее важным является VmSize, который должен быть близок к тому, что ps aux дает.
/proc / 19420 $ статус кошки Имя: firefox Состояние: S (спящий) Tgid: 19420 Pid: 19420 PPid: 1 TracerPid: 0 Uid: 1000 1000 1000 1000 Gid: 1000 1000 1000 1000 FDSize: 256 Группы: 4 6 20 24 25 29 30 44 46 107 109 115 124 1000 VmPeak: 222956 кБ VmSize: 212520 кБ VmLck: 0 кБ VmHWM: 127912 кБ VmRSS: 118768 кБ VmData: 170180 кБ VmStk: 228 кБ VmExe: 28 кБ VmLib: 35424 кБ VB4: 35424 КБ V4: 8 SigQ: 0/16382 SigPnd: 0000000000000000 ShdPnd: 0000000000000000 SigBlk: 0000000000000000 SigIgn: 0000000020001000 SigCgt: 000000018000442f CapInh: 0000000000000000 обороты:
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
Используйте это как root, и вы можете получить четкий вывод об использовании памяти каждым процессом.
ПРИМЕР ВЫХОДА:
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]
В последних версиях linux используйте подсистему smaps. Например, для процесса с PID 1234:
cat /proc/1234/smaps
Он точно скажет вам, сколько памяти он использует в то время. Что еще более важно, он разделит память на частную и общую, так что вы сможете определить, сколько памяти использует ваш экземпляр программы, без учета памяти, разделяемой между несколькими экземплярами программы.
Используйте smem, который является альтернативой ps, который вычисляет USS и PSS для процесса. То, что вы хотите, это, вероятно, PSS.
USS - уникальный размер набора. Это количество неразделенной памяти, уникальной для этого процесса (представьте, что это U для уникальной памяти). Он не включает общую память. Таким образом, это будет занижать объем памяти, используемый процессом, но полезно, когда вы хотите игнорировать разделяемую память.
PSS - Размер пропорционального набора. Это то, что вы хотите. Он складывает уникальную память (USS) вместе с долей общей памяти, деленной на количество других процессов, совместно использующих эту память. Таким образом, это даст вам точное представление о том, сколько фактической физической памяти используется на процесс - с разделяемой памятью, действительно представленной как совместно используемая. Подумайте о том, что P для физической памяти.
Как это сравнивается с RSS, как сообщили PS и другие утилиты:
- RSS - размер резидентного набора. Это количество общей памяти плюс неразделенная память, используемая каждым процессом. Если какие-либо процессы совместно используют память, это приведет к переоценке объема фактически используемой памяти, потому что одна и та же общая память будет учитываться более одного раза - снова появляться в каждом другом процессе, который совместно использует одну и ту же память. Таким образом, это довольно ненадежно, особенно когда процессы с высокой памятью имеют много разветвлений - что характерно для сервера, с такими процессами, как Apache или PHP(fastcgi/FPM).
Примечание: SEMM также может (необязательно) выводить графики, такие как круговые диаграммы и тому подобное. ИМО тебе ничего не нужно. Если вы просто хотите использовать его из командной строки, как если бы вы использовали ps -A v, вам не нужно устанавливать рекомендуемую зависимость python-matplotlib.
Нет простого способа рассчитать это. Но некоторые люди пытались получить хорошие ответы:
Как насчет time?
Не Bash встроенный time но тот, который вы можете найти с which time, например /usr/bin/time
Вот то, что это покрывает, на простом 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
Помимо решений, перечисленных в ваших ответах, вы можете использовать команду Linux "top"; Он обеспечивает динамическое представление работающей системы в режиме реального времени, дает информацию об использовании процессора и памяти для всей системы, а также для каждой программы, в процентах:
top
фильтровать по pid программы:
top -p <PID>
фильтровать по имени программы:
top | grep <PROCESS NAME>
"top" предоставляет также некоторые поля, такие как:
VIRT - виртуальный образ (КБ): общий объем виртуальной памяти, используемой задачей
RES - Резидентный размер (КБ): физическая память без перестановки, используемая задачей; RES = КОД + ДАННЫЕ.
ДАННЫЕ - Данные + размер стека (КБ): объем физической памяти, выделенный для другого, кроме исполняемого кода, также известного как размер "резидентного набора данных" или DRS.
SHR - Размер общей памяти (КБ): объем общей памяти, используемой задачей. Он просто отражает память, которая может потенциально использоваться другими процессами.
Ссылка здесь.
Это отличная сводка инструментов и проблем: ссылка на archive.org
Я процитирую это, так, чтобы больше разработчиков фактически прочитало это.
Если вы хотите проанализировать использование памяти всей системой или полностью проанализировать использование памяти одним приложением (а не только его кучей), используйте exmap. Для анализа всей системы, найдите процессы с наиболее эффективным использованием, они занимают больше всего памяти на практике, находят процессы с самым высоким уровнем записи, они создают наибольшее количество данных (и, следовательно, возможно, имеют утечку или очень неэффективны при использовании данных). Выберите такое приложение и проанализируйте его отображения во втором просмотре списка. Смотрите раздел exmap для более подробной информации. Также используйте xrestop, чтобы проверить интенсивное использование ресурсов X, особенно если процесс сервера X занимает много памяти. Смотрите секцию xrestop для деталей.
Если вы хотите обнаружить утечки, используйте valgrind или, возможно, kmtrace.
Если вы хотите проанализировать использование приложения кучей (malloc и т. Д.), Запустите его в memprof или с помощью kmtrace, профилируйте приложение и найдите в дереве вызовов функций самые большие выделения. Смотрите их разделы для более подробной информации.
Я использую Arch Linux и есть этот замечательный пакет под названием ps_mem
ps_mem -p <pid>
Пример вывода
$ 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
=============================================
На это нет однозначного ответа, потому что вы не можете точно определить объем памяти, используемый процессом. Большинство процессов в Linux используют разделяемые библиотеки. Например, допустим, вы хотите вычислить использование памяти для процесса 'ls'. Вы считаете только память, используемую исполняемым файлом 'ls' (если бы вы могли ее изолировать)? Как насчет libc? Или все эти другие библиотеки, которые необходимы для запуска "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)
Вы можете утверждать, что они используются другими процессами, но "ls" не может быть запущен в системе без их загрузки.
Кроме того, если вам нужно знать, сколько памяти требуется процессу для планирования емкости, вы должны рассчитать, сколько использует каждая дополнительная копия процесса. Я думаю, что /proc/PID/status может дать вам достаточно информации об использовании памяти за один раз. С другой стороны, valgrind предоставит вам лучший профиль использования памяти на протяжении всей жизни программы.
Если ваш код на C или C++, вы можете использовать getrusage() который возвращает вам различные статистические данные о памяти и времени использования вашего процесса.
Однако не все платформы поддерживают это и возвращают 0 значений для параметров использования памяти.
Вместо этого вы можете посмотреть на виртуальный файл, созданный в /proc/[pid]/statm (где [pid] заменяется вашим идентификатором процесса. Вы можете получить это от getpid()).
Этот файл будет выглядеть как текстовый файл с 7 целыми числами. Вероятно, вас больше всего интересуют первое (все использование памяти) и шестое (использование памяти данных) числа в этом файле.
Еще три способа попробовать:
ps aux --sort pmem
Сортирует вывод по%MEM,ps aux | awk '{print $2, $4, $11}' | sort -k2r | head -n 15
Сортировка с использованием труб.top -a
Начинается сортировка сверху%MEM
(Извлечено отсюда)
Valgrind может отображать подробную информацию, но значительно замедляет работу целевого приложения и в большинстве случаев меняет поведение приложения.
Exmap был тем, чего я еще не знал, но, похоже, вам нужен модуль ядра, чтобы получить информацию, что может стать препятствием.
Я предполагаю, что все хотят знать WRT "использование памяти" заключается в следующем...
В Linux объем физической памяти, который может использовать отдельный процесс, можно условно разделить на следующие категории.
Ма анонимная отображенная память
- .p частный
- .d dirty == malloc/mmapped куча и стек выделены и записана память
- .c clean == malloc/mmapped куча и память стека после выделения, записи, освобождения, но еще не восстановления
- .s поделился
- .d dirty == malloc / mmaped heap может копироваться при записи и совместно использоваться процессами (отредактировано)
- .c clean == malloc / mmaped heap может копироваться при записи и совместно использоваться процессами (отредактировано)
- .p частный
МН назвал отображенную память
- .p частный
- .d dirty == файл mmapped записан в память
- .c clean == сопоставленный текст программы / библиотеки private mapped
- .s поделился
- .d dirty == файл mmapped совместно используемая память
- .c clean == сопоставленный текст библиотеки
- .p частный
Утилита, включенная в Android под названием showmap, весьма полезна
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
Valgrind удивителен, если у вас есть время его запустить. valgrind --tool=massif правильное решение
Тем не менее, я начинаю запускать более крупные примеры, и использование valgrind больше не практично. Есть ли способ определить максимальное использование памяти (размер страницы по модулю и общие страницы) программы?
В реальной системе Unix, /usr/bin/time -v работает. Однако в Linux это не работает.
#!/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
Я использую htop; Это очень хорошая консольная программа, похожая на Windows Task Manager.
Изменить: это работает на 100% хорошо только при увеличении потребления памяти
Если вы хотите отслеживать использование памяти данным процессом (или группой обработанных, имеющих общее имя, например, google-chromeВы можете использовать мой 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;
это будет постоянно искать изменения и распечатывать их.
Получить Вальгринд. дайте ему свою программу для запуска, и она расскажет вам много об использовании памяти.
Это относится только к случаю, когда программа работает некоторое время и останавливается. Я не знаю, сможет ли valgrind получить доступ к уже запущенному процессу или не должен останавливать процессы, такие как демоны.
Ниже в командной строке вы увидите общий объем памяти, используемый различными процессами, работающими на компьютере с Linux, в МБ.
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}'
Хороший тест для более "реального мира" - открыть приложение, а затем запустить vmstat -s и проверьте статистику "активной памяти". Закройте приложение, подождите несколько секунд и запустите vmstat -s снова. Тем не менее, очевидно, что приложение активно использовало много активной памяти.
Если процесс не использует слишком много памяти (или потому, что вы ожидаете, что это так, или какая-то другая команда дала такое начальное указание), и процесс может выдержать остановку на короткий период времени, вы можете попробовать используйте команду gcore.
gcore <pid>
Проверьте размер сгенерированного файла ядра, чтобы понять, сколько памяти использует конкретный процесс.
Это не будет работать слишком хорошо, если процесс использует сотни мегабайт или гигабайтов, поскольку создание ядра может занять несколько секунд или минут в зависимости от производительности ввода-вывода. Во время создания ядра процесс останавливается (или "замораживается"), чтобы предотвратить изменения памяти. Так что будьте осторожны.
Также убедитесь, что в точке монтирования, где генерируется ядро, достаточно места на диске и что система не будет негативно реагировать на файл ядра, создаваемый в этом конкретном каталоге.
Я хотел бы предложить вам использовать поверх. Вы можете найти все об этом на этой странице. Он способен обеспечить все необходимые KPI для ваших процессов, а также может записывать в файл.
Если вы хотите что-то более быстрое, чем профилирование с помощью Valgrind, а ваше ядро старше и вы не можете использовать smaps, ps с параметрами, чтобы показать резидентный набор процесса (с ps -o rss,command) может дать вам быстрый и разумный _aproximation_ реального объема неиспользованной памяти, используемой.
Еще один голос за Valgrind здесь, но я хотел бы добавить, что вы можете использовать такой инструмент, как Alleyoop, чтобы помочь вам интерпретировать результаты, полученные Valgrind.
Я использую эти два инструмента все время и всегда имею скудный, не пропускающий код, чтобы гордо показать это;)
Учитывая некоторые ответы, чтобы получить фактический своп и оперативную память для одного приложения, я придумал следующее, скажем, мы хотим знать, что использует firefox.
sudo smem | awk '/firefox/{swap+=$5; pss+=$7;}END{print "swap = "swap/1024" PSS = "pss/1024}'
или для libvirt;
sudo smem | awk '/libvirt/{swap+=$5; pss+=$7;}END{print "swap = "swap/1024" PSS = "pss/1024}'
это даст вам общее количество в МБ, как показано ниже;
swap = 0 PSS = 2096.92
swap = 224.75 PSS = 421.455
Проверьте сценарий оболочки, чтобы проверить использование памяти приложением в Linux. Также доступно на github и в версии без вставки и до н.
Хотя этот вопрос, похоже, касается проверки запущенных в настоящее время процессов, я хотел увидеть пиковую память, используемую приложением от начала до конца. Помимо valgrind, вы можете использовать tstime, что намного проще. Он измеряет использование "высокой воды" (RSS и виртуальная). Из этого ответа.
- И последнее, но не менее важное: используйте htop.
$ sudo apt-get update
$ sudo apt-get install htop
- Запустите htop, используя команду ниже.
$ htop
- Примечание для новичков: символ доллара используется, чтобы показать, что мы выполняем команду на терминале.