Ответ 1

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

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

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

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

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

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

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

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

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

Ответ 2

Попробуйте выполнить команду pmap:

sudo pmap -x <process pid>

Ответ 3

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

$ ps aux 

предоставит вам виртуальный размер (VSZ)

Вы также можете получить подробную статистику из файловой системы /proc, перейдя в /proc/$pid/status

Наиболее важным является VmSize, который должен быть близок к тому, что дает ps aux.

/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

Ответ 4

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

cat /proc/1234/smaps

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

Ответ 5

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

• ps_mem.py
• ps_mem.py в github

Ответ 6

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

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

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

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

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

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

Ответ 7

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] 

Ответ 8

Как насчет time?

Не Bash builtin 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

Ответ 9

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

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

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

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

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

Ответ 10

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

top

для фильтрации с помощью программы pid:

top -p <PID>

для фильтрации по имени программы:

top | grep <PROCESS NAME>

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

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

RES - размер резидента (kb): необработанная физическая память, в которой используется задача; RES = CODE + DATA.

DATA - данные + размер стека (kb): объем физической памяти, который отличается от исполняемого кода, также известный как размер резидентного набора данных или DRS.

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

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

Ответ 11

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

Ответ 12

Если ваш код находится на C или С++, вы можете использовать getrusage(), который возвращает вам различные статистические данные о памяти и времени использования вашего процесса.

Не все платформы поддерживают это, и возвращают 0 значений для опций использования памяти.

Вместо этого вы можете посмотреть виртуальный файл, созданный в /proc/[pid]/statm (где [pid] заменяется идентификатором процесса. Вы можете получить это из getpid()).

Этот файл будет выглядеть как текстовый файл с 7 целыми числами. Вероятно, вас больше всего интересуют первые (все использование памяти) и шестое (использование памяти данных) в этом файле.

Ответ 13

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

Я предполагаю, что все хотят знать использование памяти WRT следующим образом... В linux количество физической памяти, которую может использовать один процесс, можно условно разделить на следующие категории.

• M.a анонимная отображаемая память

  • .p частный
    • .d dirty == malloc/mmapped куча и выделенная и записанная память
    • .c clean == malloc/mmapped куча и стек памяти после выделения, написания, затем освобождения, но еще не восстановленного
  • .s shared
    • .d dirty == malloc/mmaped heap может получать копии на запись и совместно использовать процессы (отредактировано)
    • .c clean == malloc/mmaped heap может получать копии на запись и совместно использовать процессы (отредактировано)

• Mn названная карта памяти

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

Ответ 14

Valgrind поражает, если у вас есть время запустить его. valgrind --tool=massif - правильное решение.

Однако я начинаю запускать более крупные примеры, и использование valgrind больше не практично. Можно ли указать максимальное использование памяти (размер страницы и общие страницы) программы?

В реальной системе unix работает /usr/bin/time -v. Однако в Linux это не работает.

Ответ 15

Я использую htop; это очень хорошая консольная программа, аналогичная диспетчеру задач Windows.

Ответ 16

Еще три метода:

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

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

Ответ 17

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

Ответ 18

Хорошим тестом более "реального мира" является открытие приложения, затем запуск vmstat -s и проверка статистики "активной памяти". Закройте приложение, подождите несколько секунд и снова запустите vmstat -s. Однако значительная часть активной памяти была явно использована приложением.

Ответ 19

Ниже командной строки вы получите общую память, используемую различным процессом, запущенным на машине Linux в 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}'

Ответ 20

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

gcore <pid>

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

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

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

Ответ 21

Я использую 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
=============================================

Ответ 22

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

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

Ответ 23

Если вам нужно что-то более быстрое, чем профилирование с помощью Valgrind, а ваше ядро ​​старше, и вы не можете использовать smaps, ps с параметрами для отображения резидентного набора процесса (с ps -o rss,command) может дать вам быстрый и разумный _aproximation_ реального объема неиспользуемой памяти.

Ответ 24

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

Ответ 25

Изменить: это работает на 100% наилучшим образом только при увеличении потребления памяти

Если вы хотите отслеживать использование памяти с помощью данного процесса (или группы общего имени совместного использования совместного доступа, например google-chrome), вы можете использовать мой 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;

это будет постоянно искать изменения и печатать их.

Ответ 26

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

Ответ 27

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

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

Ответ 28

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

Ответ 29

Использовать встроенный " системный монитор". Инструмент GUI доступен в ubuntu

Ответ 30

На основе ответа на связанный question.

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

Требования:

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

Примечания:

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

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

**

Мониторинг процесса 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