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

这个问题在这里详细介绍。

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

从Linux上理解内存使用的博客文章中， ps并不是一个准确的工具。

为什么ps是“错误的”

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

Answer 1

使用ps或类似的工具，你只会得到该进程分配的内存页面的数量。 这个数字是正确的，但是：

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

• 如果页面被共享，例如通过多个线程或通过使用dynamic链接的库，可能会引起误解

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

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

正如valgrind文档中所解释的，您需要通过valgrind运行该程序：

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

Massif写入内存使用快照的转储（例如， massif.out.12345 ）。 这些提供（1）内存使用的时间线，（2）对于每个快照，logging程序存储器中的哪个分配。 分析这些文件的一个很好的graphics工具是massif-visualizer 。 但是我发现ms_print是valgrind附带的一个简单的基于文本的工具，已经有了很大的帮助。

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

Answer 2

试试pmap命令：

 sudo pmap -x <process pid> 

Answer 3

很难说清楚，但这里有两个“接近”的东西，可以帮助。

 $ ps aux 

会给你虚拟大小（VSZ）

您也可以通过/proc/$pid/status从/ proc文件系统获取详细的统计信息

最重要的是VmSize，它应该接近ps aux给出的值。

 / proc / 19420 $ cat状态
名称：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 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
主题：8
信号：0/16382
 SigPnd：0000000000000000
 ShdPnd：0000000000000000
 SigBlk：0000000000000000
信号：0000000020001000
 SigCgt：000000018000442f
 CapInh：0000000000000000
 CapPrm：0000000000000000
 CapEff：0000000000000000
 Cpus_allowed：03
 Mems_allowed：1
 volunte_ctxt_switches：63422
 nonvoluntary_ctxt_switches：7171

Answer 4

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

 cat /proc/1234/smaps 

它会告诉你到底有多less内存正在使用。 更重要的是，它会将内存分成私有的和共享的，这样就可以告诉程序实例正在使用多less内存，而不包括程序多个实例之间共享的内存。

Answer 5

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

• ps_mem.py
• 在github上的ps_mem.py

Answer 6

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

• USS – 独特的大小。 这是该进程独有的非共享内存数量（将其视为唯一内存的U ）。 它不包括共享内存。 因此，这将报告进程使用的内存量，但是当您想要忽略共享内存时会有帮助。

• PSS – 比例组大小。 这是你想要的。 它将独特的内存（USS）以及共享内存的一部分除以共享内存的其他进程的数量。 因此，它将为您准确地表示每个进程正在使用多less实际物理内存 – 共享内存真正表示为共享。 想想P是物理内存。

这与ps和其他utils报告的RSS相比如何：

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

注意：smem也可以（可选）输出graphics，如饼图等。 国际海事组织你不需要任何的。 如果你只是想从命令行使用它，就像你可能使用ps -A v，那么你不需要安装python-matplotlib推荐的依赖项。

Answer 7

这是一个很好的工具和问题总结： archive.org链接

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

如果您想分析整个系统的内存使用情况，或者彻底分析一个应用程序的内存使用情况（不仅仅是堆使用情况），请使用exmap 。 对于整个系统分析来说，find最有效的使用方法，它们在实践中占用最多的内存，find最高可写用法的进程，创build最多的数据（因此可能会泄漏或者在数据使用方面非常无效）。 select这样的应用程序，并在第二个列表视图中分析它的映射。 有关更多详细信息，请参阅exmap部分 另外使用xrestop检查X资源的高使用率，特别是如果X服务器的进程需要大量内存。 有关详细信息，请参阅xrestop部分。

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

如果要分析应用程序的堆（malloc等）使用情况，可以在memprof或kmtrace中运行它，分析应用程序并在函数调用树中search最大分配。 看到他们的部分了解更多细节。

Answer 8

什么time ？

不是Bash内置的time而是你可以在which timefind的，例如/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 

Answer 9

除了答案中列出的解决scheme之外，您可以使用Linux命令“top”; 它提供了正在运行的系统的dynamic实时视图，它为整个系统提供了CPU和内存的使用情况，并为每个程序提供了百分比：

 top 

通过程序进行过滤pid：

 top -p <PID> 

按程序名称过滤：

 top | grep <PROCESS NAME> 

“顶”也提供了一些领域，如：

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

RES – 常驻大小（kb）：任务已使用的未交换物理内存; RES = CODE + DATA。

DATA – 数据+堆栈大小（kb）：专用于非可执行代码的物理内存量，也称为“数据驻留集”大小或DRS。

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

在这里引用。

Answer 10

 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] 

Answer 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'不能在没有加载的情况下在系统上运行。

另外，如果您需要知道进程需要多less内存来执行容量计划，则必须计算每个额外的进程副本使用的数量。 我认为/ proc / PID / status可能会给你足够的内存使用情况信息。 另一方面，valgrind会在程序的整个生命周期中给你更好的内存使用情况

Answer 12

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

不是所有的平台都支持这个，并且会为内存使用选项返回0值。

相反，你可以看看在/proc/[pid]/statm创build的虚拟文件（其中[pid]被你的进程idreplace。你可以从getpid()获得这个文件。

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

Answer 13

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

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

• 马匿名映射内存

  • 私人
    • .d脏== malloc / mmapped堆栈和堆栈分配和写入的内存
    • .c clean == malloc / mmapped堆和内存一旦分配，写入，然后释放，但还没有回收
  • .s共享
    • .d脏== malloc / mmaped堆可以得到写时复制和进程之间共享 （编辑）
    • .c clean == malloc / mmaped堆可以得到写入时复制和进程之间共享 （编辑）

• Mn命名映射的内存

  • 私人
    • .d脏==文件mmapped写入内存私人
    • .c干净==映射的程序/库文本私有映射
  • .s共享
    • .d脏==文件共享的mmapped写入内存
    • .c干净==映射库文本共享映射

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 

Answer 14

如果你有足够的时间来运行，Valgrind是非常棒的。 valgrind --tool=massif是正确的解决scheme。

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

在一个真正的Unix系统上， /usr/bin/time -v工作。 但是，在Linux上，这不起作用。

Answer 15

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

Answer 16

我使用htop ; 这是一个类似于Windows任务pipe理器的非常好的控制台程序。

Answer 17

对“真实世界”用法的更好testing是打开应用程序，然后运行vmstat -s并检查“活动内存”统计信息。 closures应用程序，等待几秒钟，然后再次运行vmstat -s 。 然而，被释放的许多活动内存显然被应用程序使用。

Answer 18

在命令行下面会给你在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}' 

Answer 19

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

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

Answer 20

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

 gcore <pid> 

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

This won't work too well if process is using hundreds of megs, or gigs, as the core generation could take several seconds or minutes to be created depending on I/O performance. During the core creation the process is stopped (or "frozen") to prevent memory changes. 所以要小心。

Also make sure the mount point where the core is generated has plenty of disk space and that the system will not react negatively to the core file being created in that particular directory.

Answer 21

If you want something quicker than profiling with Valgrind and your kernel is older and you can't use smaps, a ps with the options to show the resident set of the process (with ps -o rss,command ) can give you a quick and reasonable _aproximation_ of the real amount of non-swapped memory being used.

Answer 22

Three more methods to try:

1. ps aux --sort pmem
   It sorts the output by %MEM .
2. ps aux | awk '{print $2, $4, $11}' | sort -k2r | head -n 15
   It sorts using pipes.
3. top -a
   It starts top sorting by %MEM

(Extracted from here )

Answer 23

Check shell script to check memory usage by application in linux . Also available on github and in a version without paste and bc .

Answer 24

Edit: this works 100% well only when memory consumption increases

If you want to monitor memory usage by given process (or group of processed sharing common name, eg google-chrome , you can use my 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; 

this will continously look for changes and print them.

Answer 25

Another vote for valgrind here, but I would like to add that you can use a tool like Alleyoop to help you interpret the results generated by valgrind.

I use the two tools all the time and always have lean, non-leaky code to proudly show for it 😉

Answer 26

While this question seems to be about examining currently running processes, I wanted to see the peak memory used by an application from start to finish. Besides valgrind, you can use tstime , which is much simpler. It measures the "highwater" memory usage (RSS and virtual). From this answer .

Answer 27

I would suggest that you use atop. You can find everything about it on this page . It is capable of providing all the necessary KPI for your processes and it can also capture to a file.

Answer 28

Use the in-built ' system monitor ' GUI tool available in ubuntu

Answer 29

Based on answer to a related question .

You may use SNMP to get the memory and cpu usage of a process in a particular device in network 🙂

要求：

• the device running the process should have snmp installed and running
• snmp should be configured to accept requests from where you will run the script below(it may be configured in snmpd.conf)
• you should know the process id(pid) of the process you want to monitor

笔记：

• HOST-RESOURCES-MIB::hrSWRunPerfCPU is the number of centi-seconds of the total system's CPU resources consumed by this process. Note that on a multi-processor system, this value may increment by more than one centi-second in one centi-second of real (wall clock) time.

• HOST-RESOURCES-MIB::hrSWRunPerfMem is the total amount of real system memory allocated to this process.

**

Process monitoring 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 

Answer 30

/prox/xxx/numa_maps gives some info there: N0=??? N1=???. But this result might be lower than the actual result, as it only count those which have been touched.