Этот вопрос освещен здесь очень подробно.

Как вы измеряете использование памяти приложением или процессом в Linux?

Из блога статьи Понимание использования памяти в Linux , psне является точным инструментом для использования для этого намерения.

Почему ps"неправильно"

В зависимости от того, как вы на это смотрите, psне сообщается о реальном использовании памяти процессами. На самом деле он показывает, сколько реальной памяти занимал бы каждый процесс, если бы он был единственным запущенным процессом . Конечно, на типичном компьютере с Linux в каждый момент времени выполняется несколько десятков процессов, а это означает, что сообщаемые номера VSZ и RSS psпочти наверняка неверны .

С помощью psподобных инструментов вы получите только количество страниц памяти, выделенных этим процессом. Этот номер правильный, но:

• не отражает фактический объем памяти, используемой приложением, только объем памяти, зарезервированный для него

• может вводить в заблуждение, если страницы совместно используются, например, несколькими потоками или с использованием динамически связанных библиотек

Если вы действительно хотите знать, какой объем памяти фактически использует ваше приложение, вам нужно запустить его в профилировщике. Например, valgrindможет дать вам представление об объеме используемой памяти и, что более важно, о возможных утечках памяти в вашей программе. Инструмент профилирования кучи Valgrind называется «массив»:

Массив это куча профилировщик. Он выполняет подробное профилирование кучи, делая регулярные снимки кучи программы. Он создает график, показывающий использование кучи с течением времени, включая информацию о том, какие части программы отвечают за наибольшее количество выделенной памяти. График дополняется текстовым или HTML-файлом, который содержит больше информации для определения того, где больше всего памяти выделяется. Массив запускает программы примерно в 20 раз медленнее, чем обычно.

Как объясняется в документации по valgrind , вам нужно запустить программу через valgrind:

valgrind --tool=massif <executable> <arguments>

Massif записывает дамп снимков использования памяти (например massif.out.12345). Они обеспечивают, (1) график использования памяти, (2) для каждого снимка, запись о том, где в вашей программе была выделена память. Отличным графическим инструментом для анализа этих файлов является массив-визуализатор . Но я обнаружил ms_print, что простой текстовый инструмент, поставляемый с valgrind, уже очень помог.

Чтобы найти утечки памяти, используйте (по умолчанию) memcheckинструмент valgrind.

Попробуйте команду pmap :

sudo pmap -x <process pid>

Трудно сказать наверняка, но вот две «близкие» вещи, которые могут помочь.

$ 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
Гид: 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 кБ
VmPTE: 184 кБ
Темы: 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
добровольные переключатели: 63422
nonvoluunte_ctxt_switches: 7171

В последних версиях Linux используйте подсистему smaps . Например, для процесса с PID 1234:

cat /proc/1234/smaps

Он точно скажет вам, сколько памяти он использует в то время. Что еще более важно, он разделит память на приватную и разделяемую, чтобы вы могли определить, сколько памяти использует ваш экземпляр программы, без учета памяти, разделяемой между несколькими экземплярами программы.

Нет простого способа рассчитать это. Но некоторые люди пытались получить хорошие ответы:

• ps_mem.py
• ps_mem.py в github

Используйте smem , который является альтернативой ps, который вычисляет USS и PSS для процесса. То, что вы хотите, это, вероятно, PSS.

• USS - уникальный размер набора. Это количество неразделенной памяти, уникальной для этого процесса (представьте, что это U для уникальной памяти). Он не включает общую память. Таким образом , это будет под -report объем памяти процесса , использование, но полезно , если вы хотите игнорировать общую память.

• PSS - Размер пропорционального набора. Это то, что вы хотите. Он складывает уникальную память (USS) вместе с долей общей памяти, деленной на количество процессов, совместно использующих эту память. Таким образом, это даст вам точное представление о том, сколько фактической физической памяти используется на процесс - с разделяемой памятью, действительно представленной как совместно используемая. Подумайте о том, что P для физической памяти.

Как это сравнивается с RSS, как сообщили PS и другие утилиты:

• RSS - размер резидентного набора. Это количество общей памяти плюс неразделенная память, используемая каждым процессом. Если какие-либо процессы совместно используют память, это приведет к переоценке объема фактически используемой памяти, потому что одна и та же общая память будет учитываться более одного раза - снова появляться в каждом другом процессе, который совместно использует одну и ту же память. Таким образом, это довольно ненадежно, особенно когда процессы с высокой памятью имеют много вилок - что характерно для сервера, с такими вещами, как процессы Apache или PHP (fastcgi / FPM).

Примечание: SEMM также может (необязательно) выводить графики, такие как круговые диаграммы и тому подобное. ИМО тебе ничего не нужно. Если вы просто хотите использовать его из командной строки, как если бы вы использовали ps -A v, вам не нужно устанавливать рекомендуемую зависимость 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

Используйте это как 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] 

Как насчет 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

Это отличная сводка инструментов и проблем: ссылка на archive.org

Я процитирую это, так, чтобы больше разработчиков фактически прочитало это.

Если вы хотите проанализировать использование памяти всей системой или полностью проанализировать использование памяти одним приложением (а не только его кучей), используйте exmap . Для анализа всей системы, найдите процессы с наиболее эффективным использованием, они занимают наибольший объем памяти на практике, находят процессы с самым высоким уровнем записи, они создают наибольшее количество данных (и, следовательно, возможно, имеют утечку или очень неэффективны при использовании данных). Выберите такое приложение и проанализируйте его отображения во втором просмотре списка. Смотрите раздел exmap для более подробной информации. Также используйте xrestop чтобы проверить интенсивное использование ресурсов X, особенно если процесс сервера X занимает много памяти. Смотрите раздел xrestop для деталей.

Если вы хотите обнаружить утечки, используйте valgrind или, возможно, kmtrace .

Если вы хотите проанализировать использование приложения кучей (malloc и т. Д.), Либо запустите его в memprof или с помощью kmtrace , профилируйте приложение и найдите в дереве вызовов функций самые большие выделения. Смотрите их разделы для более подробной информации.

Помимо решений, перечисленных в ваших ответах, вы можете использовать команду Linux "top"; Он обеспечивает динамическое представление работающей системы в режиме реального времени, дает информацию об использовании процессора и памяти для всей системы, а также для каждой программы, в процентах:

top

фильтровать по pid программы:

top -p <PID>

фильтровать по имени программы:

top | grep <PROCESS NAME>

«top» предоставляет также некоторые поля, такие как:

VIRT - Virtual Image (kb): общий объем виртуальной памяти, используемой задачей

RES - Резидентный размер (КБ): физическая память без перестановки, используемая задачей; RES = КОД + ДАННЫЕ.

ДАННЫЕ - Данные + размер стека (КБ): объем физической памяти, выделенный для выполнения, отличного от исполняемого кода, также известный как размер «резидентного набора данных» или DRS.

SHR - Размер общей памяти (КБ): объем общей памяти, используемой задачей. Он просто отражает память, которая потенциально может использоваться другими процессами.

Ссылка здесь .

На это нет однозначного ответа, потому что вы не можете точно определить объем памяти, используемый процессом. Большинство процессов в 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 целыми числами. Вероятно, вас больше всего интересуют первое (все использование памяти) и шестое (использование памяти данных) числа в этом файле.

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 частный
    • .d dirty == файл mmapped записан в память
    • .c clean == сопоставленный текст программы / библиотеки private mapped
  • .s поделился
    • .d dirty == файл mmapped совместно используемая память
    • .c clean == сопоставленный текст библиотеки

Утилита, включенная в 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

Еще три способа попробовать:

1. ps aux --sort pmem
   Сортирует вывод по %MEM.
2. ps aux | awk '{print $2, $4, $11}' | sort -k2r | head -n 15
   Сортировка с использованием труб.
3. top -a
   Начинается сортировка сверху %MEM

(Извлечено отсюда )

#!/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.

Если процесс не использует слишком много памяти (или потому, что вы ожидаете, что это так, или какая-то другая команда дала это начальное указание), и процесс может выдержать остановку на короткий период времени, вы можете попробовать используйте команду gcore.

gcore <pid>

Проверьте размер сгенерированного файла ядра, чтобы понять, сколько памяти использует конкретный процесс.

Это не будет работать слишком хорошо, если процесс использует сотни мегабайт или гигабайтов, поскольку генерация ядра может занять несколько секунд или минут в зависимости от производительности ввода-вывода. Во время создания ядра процесс останавливается (или «замораживается»), чтобы предотвратить изменения памяти. Так что будь осторожен.

Также убедитесь, что в точке монтирования, где генерируется ядро, достаточно места на диске и что система не будет негативно реагировать на файл ядра, создаваемый в этом конкретном каталоге.

Я использую 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, в МБ.

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снова. Тем не менее, очевидно, что приложение активно использовало много активной памяти.

Получить Вальгринд. дайте ему свою программу для запуска, и она расскажет вам много об использовании памяти.

Это относится только к случаю программы, которая работает некоторое время и останавливается. Я не знаю, сможет ли valgrind получить доступ к уже запущенному процессу или не должен останавливать такие процессы, как демоны.

Редактировать: это работает на 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, а ваше ядро ​​старше и вы не можете использовать smaps, ps с опциями отображения резидентного набора процесса (с ps -o rss,command) может дать вам быстрое и разумное _aproximation_представление о реальном количестве используется не подкачанная память.

Я хотел бы предложить вам использовать поверх. Вы можете найти все об этом на этой странице . Он способен обеспечить все необходимые KPI для ваших процессов, а также может записывать в файл.

Проверьте сценарий оболочки, чтобы проверить использование памяти приложением в Linux . Также доступно на GitHub и в версии без вставки и до н .

Еще один голос за Valgrindздесь, но я хотел бы добавить, что вы можете использовать такой инструмент, как Alleyoop, чтобы помочь вам интерпретировать результаты, сгенерированные valgrind.

Я использую эти два инструмента все время, и у меня всегда есть скудный код без утечек, чтобы гордо показать его;)

Хотя этот вопрос, похоже, касается проверки запущенных в данный момент процессов, я хотел увидеть пиковую память, используемую приложением от начала до конца. Помимо valgrind, вы можете использовать tstime , что намного проще. Он измеряет использование высокопроизводительной памяти (RSS и виртуальная). Из этого ответа .

Основано на ответе на связанный вопрос .

Вы можете использовать SNMP, чтобы получить память и процессорное использование процесса на определенном устройстве в сети :)

Требования:

• на устройстве, на котором запущен процесс, должна быть установлена ​​и запущена snmp
• snmp должен быть настроен на прием запросов от того, где вы будете запускать скрипт ниже (он может быть настроен в snmpd.conf)
• вы должны знать идентификатор процесса (pid) процесса, который вы хотите отслеживать

Ноты:

• HOST-RESOURCES-MIB :: hrSWRunPerfCPU - это количество сантисекунд общих ресурсов ЦП системы, потребляемых этим процессом. Обратите внимание, что в многопроцессорной системе это значение может увеличиваться более чем на одну сантисекунду за одну сантисекунду реального времени (настенных часов).

• HOST-RESOURCES-MIB :: hrSWRunPerfMem - это общий объем реальной системной памяти, выделенной для этого процесса.

**

Скрипт мониторинга процесса:

**

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

/ prox / xxx / numa_maps дает некоторую информацию там: N0 = ??? N1 = ???. Но этот результат может быть ниже, чем фактический результат, поскольку он учитывает только те, которые были затронуты.

Используйте встроенный инструмент GUI для системного монитора , доступный в Ubuntu