如何衡量应用程序或进程的实际内存使用情况？

时间：2008-09-25 03:19:17

标签： linux memory process

这个问题非常详细地介绍了here。

如何衡量Linux中应用程序或进程的内存使用情况？

在Understanding memory usage on Linux的博客文章中，ps不是用于此意图的准确工具。

  

为什么ps“错误”

     

根据您的查看方式，ps未报告进程的实际内存使用情况。它真正做的是显示每个进程占用多少实内存如果它是唯一运行的进程。当然，典型的Linux机器在任何给定时间都有几十个进程在运行，这意味着ps报告的VSZ和RSS数字几乎肯定是错误的。

33 个答案:

答案 0 :(得分：332)

使用ps或类似工具，您只能获得该进程分配的内存页数。这个数字是正确的，但是：

  • 不反映应用程序使用的实际内存量，只反映为其保留的内存量

    • 如果页面是共享的，

  • 可能会产生误导，例如通过多个线程或使用动态链接库

如果您真的想知道应用程序实际使用的内存量，则需要在分析器中运行它。例如，valgrind可以让您了解所使用的内存量，更重要的是，可以了解程序中可能存在的内存泄漏情况。 valgrind的堆分析器工具称为“massif”：

  

Massif是一个堆分析器。它通过获取程序堆的常规快照来执行详细的堆分析。它生成一个图表，显示随时间变化的堆使用情况，包括有关程序的哪些部分负责大多数内存分配的信息。该图由文本或HTML文件补充，该文件包含用于确定分配最多内存的位置的更多信息。 Massif运行程序比正常情况慢20倍。

如valgrind documentation中所述，您需要通过valgrind运行程序：

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

Massif写了一个内存使用快照转储（例如massif.out.12345）。它们提供（1）内存使用的时间线，（2）每个快照，记录程序内存的分配位置。 用于分析这些文件的优秀图形工具是massif-visualizer。但我发现ms_print是valgrind附带的一个简单的基于文本的工具，已经给了我很大的帮助。

要查找内存泄漏，请使用valgrind的（默认）memcheck工具。

答案 1 :(得分：265)

尝试pmap命令：

sudo pmap -x <process pid>

答案 2 :(得分：187)

很难说清楚，但这里有两个可以帮助的“近距离”事物。

$ ps aux

将为您提供虚拟尺寸（VSZ）

您还可以转到/proc/$pid/status

，从/ proc文件系统获取详细的统计信息

最重要的是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

答案 3 :(得分：127)

在最近的linux版本中，使用 smaps 子系统。例如，对于PID为1234的进程：

cat /proc/1234/smaps

它会告诉你当时正在使用多少内存。更重要的是，它会将内存划分为私有和共享，因此您可以判断程序的实例使用了多少内存，而不包括程序的多个实例之间共享的内存。

答案 4 :(得分：123)

没有简单的方法来计算它。但有些人试图得到一些好的答案：

答案 5 :(得分：96)

使用smem，它是 ps 的替代方案，它可以计算每个进程的USS和PSS。你想要的可能是PSS。

  • USS - 独特的套装尺寸。这是该进程特有的非共享内存量（将其视为 U 唯一内存）。它不包括共享内存。因此，这将 - 报告进程使用的内存量，但在您想忽略共享内存时非常有用。

  • PSS - 比例集大小。这就是你想要的。它将唯一内存（USS）以及其共享内存的一部分除以共享该内存的其他进程的数量加在一起。因此，它将准确地表示每个进程使用多少实际物理内存 - 共享内存真正表示为共享。想想 P 属于物理内存。

如何与 ps 和其他实用程序报告的RSS进行比较：

  • RSS - 居民集大小。这是每个进程使用的共享内存量和非共享内存量。如果任何进程共享内存，则 over - 报告实际使用的内存量，因为同一共享内存将被多次计数 - 在共享相同内存的每个其他进程中再次出现。因此它相当不可靠，特别是当高内存进程有很多分支时 - 这在服务器中很常见，例如Apache或PHP（fastcgi / FPM）进程。

注意：smem还可以（可选）输出饼图等图形。 IMO你不需要任何这些。如果您只想在命令行中使用它，就像使用ps -A v一样，那么您不需要安装python-matplotlib推荐的依赖项。

答案 6 :(得分：75)

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]

答案 7 :(得分：63)

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

答案 8 :(得分：38)

这是对工具和问题的精彩总结：archive.org link

我会引用它，以便更多的开发者真正阅读它。

  

如果要分析整个系统的内存使用情况或彻底分析一个应用程序的内存使用情况（而不仅仅是其堆使用情况），请使用 exmap 。对于整个系统分析，找到具有最高有效使用率的进程，它们在实践中占用最多内存，找到具有最高可写用量的​​进程，它们创建大多数数据（因此可能泄漏或在其数据使用中非常无效）。选择此类应用程序并在第二个列表视图中分析其映射。有关详细信息，请参阅exmap部分。还可以使用 xrestop 来检查X资源的高使用率，尤其是在X服务器的进程占用大量内存的情况下。有关详细信息，请参阅xrestop部分。

     

如果您想检测泄漏，请使用 valgrind 或可能 kmtrace 。

     

如果要分析应用程序的堆（malloc等）使用情况，请在 memprof 或 kmtrace 中运行，分析应用程序并搜索函数调用最大分配的树。有关详细信息，请参阅他们的部分。

答案 9 :(得分：26)

除了你的答案中列出的解决方案，你可以使用Linux命令＆＃34; top＆＃34 ;;它提供了运行系统的动态实时视图，它为整个系统以及每个程序提供CPU和内存使用百分比：

top

按程序pid过滤：

top -p <PID>

按程序名称过滤：

top | grep <PROCESS NAME>

＆＃34;顶部＆＃34;还提供了一些字段，例如：

VIRT - 虚拟映像（kb）：任务使用的虚拟内存总量

RES - 驻留大小（kb）：任务使用的非交换物理内存; RES = CODE + DATA。

数据 - 数据+堆栈大小（kb）：专用于可执行代码以外的物理内存量，也称为“数据驻留集”＆＃39;大小或DRS。

SHR - 共享内存大小（kb）：任务使用的共享内存量。它只是反映了可能与其他进程共享的内存。

参考here。

答案 10 :(得分：19)

对此没有一个答案，因为您无法准确指出进程使用的内存量。 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)

你可以说它们是由其他进程共享的，但是如果没有加载它们就不能在系统上运行。

此外，如果您需要知道进程在进行容量规划时需要多少内存，则必须计算该进程的每个其他副本使用的内存量。我认为/ proc / PID / status可能会一次给你足够的内存使用信息。另一方面，valgrind将在程序的整个生命周期内为您提供更好的内存使用情况

答案 11 :(得分：16)

如果您的代码是C或C ++，您可以使用getrusage()，它会返回有关您的流程的内存和时间使用情况的各种统计信息。

并非所有平台都支持此功能，并且将为内存使用选项返回0值。

相反，您可以查看在/proc/[pid]/statm中创建的虚拟文件（其中[pid]将替换为您的进程ID。您可以从getpid()获取此信息。）

此文件看起来像一个包含7个整数的文本文件。您可能对此文件中的第一个（所有内存使用）和第六个（数据内存使用）数字最感兴趣。

答案 12 :(得分：12)

Valgrind 可以显示详细信息，但显着减慢目标应用程序，并且大部分时间它会改变应用程序的行为。
Exmap 是我还不知道的，但似乎您需要一个内核模块来获取信息，这可能是一个障碍。

我假设每个人都想知道WRT“内存使用情况”如下...
在linux中，单个进程可能使用的物理内存量大致可分为以下几类。

  • M.a匿名映射内存

    • .p私有
      • .d dirty == malloc / mmapped堆和堆栈分配和写入内存
      • .c clean == malloc / mmapped堆和堆栈内存一旦分配，写入，然后释放，但尚未回收
    • .s分享
      • .d dirty == malloc / mmaped堆可以进行写时复制并在进程间共享（已编辑）
      • .c clean == malloc / mmaped堆可以进行写时复制并在进程间共享（已编辑）

  • M.n命名映射内存

    • .p私有
      • .d dirty == file mmapped write memory private
      • .c clean ==映射程序/库文本私有映射
    • .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

答案 13 :(得分：9)

我正在使用htop;它是一个非常好的控制台程序，类似于Windows任务管理器。

答案 14 :(得分：9)

如果你有时间运行它，Valgrind会很棒。 valgrind --tool=massif是正确的解决方案。

但是，我开始运行更大的示例，并且使用valgrind已不再实用。有没有办法告诉程序的最大内存使用量（模数页面大小和共享页面）？

在真正的unix系统上，/usr/bin/time -v有效。但是，在Linux上，这不会 工作。

答案 15 :(得分：9)

还有三种尝试方法：

  1. ps aux --sort pmem
    它按%MEM对输出进行排序。
  2. ps aux | awk '{print $2, $4, $11}' | sort -k2r | head -n 15
    它使用管道排序。
  3. top -a
    它按%MEM
    4. 开始排序

    （摘自here）

答案 16 :(得分：8)

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

答案 17 :(得分：6)

对“更真实”用法的一个很好的测试是打开应用程序，然后运行vmstat -s并检查“活动内存”统计信息。关闭应用程序，等待几秒钟再次运行vmstat -s。然而，应用程序明显使用了很多活动内存。

答案 18 :(得分：5)

我正在使用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
=============================================

答案 19 :(得分：5)

命令行下方将为您提供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 :(得分：5)

如果进程没有消耗太多内存（或者因为你预计会出现这种情况，或者某些其他命令已经给出了这个初始指示），并且该进程可以承受短时间停止，那么你可以尝试使用gcore命令。 

gcore <pid>

检查生成的核心文件的大小，以便了解特定进程正在使用多少内存。

如果进程使用数百个megs或gigs，这将无法正常工作，因为核心生成可能需要几秒钟或几分钟才能创建，具体取决于I / O性能。在核心创建过程中，过程停止（或者＃34;冻结＆＃34;）以防止内存更改。所以要小心。

还要确保生成核心的挂载点具有足够的磁盘空间，并且系统不会对在该特定目录中创建的核心文件产生负面反应。

答案 21 :(得分：4)

获得valgrind。给它你的程序运行，它会告诉你很多关于它的内存使用情况。

这仅适用于运行一段时间并停止的程序。我不知道valgrind是否可以在已经运行的进程上运行，或者不应该停止守护进程等进程。

答案 22 :(得分：3)

编辑：仅在内存消耗增加时才能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;

这将不断寻找变化并打印出来。

enter image description here

答案 23 :(得分：3)

如果你想要比使用Valgrind进行分析更快的东西并且你的内核更老并且你不能使用smaps，那么带有显示进程的常驻集合的选项的ps（使用ps -o rss,command）可以给你一个快速合理地_aproximation_使用的实际数量的非交换内存。

答案 24 :(得分：2)

检查shell脚本以检查memory usage by application in linux。 也可在github和版本without paste and bc上使用。

答案 25 :(得分：2)

我建议你使用atop。您可以在this page找到有关它的所有信息。它能够为您的流程提供所有必需的KPI，并且还可以捕获到文件。

答案 26 :(得分：1)

虽然这个问题似乎是关于检查当前正在运行的进程，但我希望看到应用程序从头到尾使用的峰值内存。除了valgrind，你可以使用tstime，这更简单。它测量“高水位”内存使用情况（RSS和虚拟）。来自this answer。

答案 27 :(得分：1)

此处有的另一次投票，但我想补充一点，您可以使用像Alleyoop这样的工具来帮助您解释valgrind生成的结果。

我一直使用这两种工具，并始终使用精简，无泄漏的代码来自豪地展示它;）

答案 28 :(得分：0)

使用内置的＆＃39; 系统监视器＆＃39; ubuntu中提供的GUI工具

答案 29 :(得分：0)

根据对相关question的回答。

您可以使用SNMP获取网络中特定设备中进程的内存和CPU使用情况：）

<强>要求：

  • 运行该进程的设备应安装并运行snmp
  • snmp应配置为接受下面运行脚本的请求（可以在snmpd.conf中配置）
  • 您应该知道要监控的流程的流程ID（pid）

备注：

  • HOST-RESOURCES-MIB :: hrSWRunPerfCPU 是此进程占用的系统总CPU资源的厘秒数。请注意，在多处理器系统上，此值可能会在实际（挂钟）时间的一厘米内增加超过一厘秒。

  • 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

答案 30 :(得分：0)

/ prox / xxx / numa_maps给出了一些信息：N0 = ??? N1 = ???。但是这个结果可能低于实际结果，因为它只计算那些被触摸的结果。

答案 31 :(得分：0)

  • 最后但并非最不重要的是使用htop。
$ sudo apt-get update
$ sudo apt-get install htop
  • 使用以下命令运行htop。
$ htop
  • 新手注意：美元符号用于表示我们正在终端上运行命令

答案 32 :(得分：0)

给出一些答案，以获取单个应用程序的实际交换空间和RAM，我想出以下内容，说我们想知道'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}'

这将为您提供以MB为单位的总数；

swap = 0 PSS = 2096.92
swap = 224.75 PSS = 421.455

相关问题
最新问题