How To Analyse Output Of /proc/meminfo | Linux

 

The /proc filesystem is pseudo filesystem. It does not exist on a disk. Instead, the kernel creates it in memory. It is used to provide information about the system (originally about processes, hence the name).
The ‘/proc/meminfo’ is used by to report the amount of free and used memory (both physical and swap) on the system as well as the shared memory and buffers used by the kernel.
The /proc filesystem is described in more detail in the proc manual page.

Example Output:
Example 1:

# cat /proc/meminfo
MemTotal: 16344972 kB
MemFree: 13634064 kB
Buffers: 3656 kB
Cached: 1195708 kB
SwapCached: 0 kB
Active: 891636 kB
Inactive: 1077224 kB
HighTotal: 15597528 kB
HighFree: 13629632 kB
LowTotal: 747444 kB
LowFree: 4432 kB
SwapTotal: 0 kB
SwapFree: 0 kB
Dirty: 968 kB
Writeback: 0 kB
Mapped: 280372 kB
Slab: 684068 kB
Committed_AS: 1576424 kB
PageTables: 24448 kB
ReverseMaps: 1080904
VmallocTotal: 112216 kB
VmallocUsed: 428 kB
VmallocChunk: 111088 kB

Example 2:

$ cat /proc/meminfo
MemTotal: 16464260 kB
MemFree: 5206868 kB
Buffers: 17980 kB
Cached: 7395552 kB
SwapCached: 114124 kB
Active: 5590956 kB
Inactive: 4426264 kB
Active(anon): 2191992 kB
Inactive(anon): 416676 kB
Active(file): 3398964 kB
Inactive(file): 4009588 kB
Unevictable: 32204 kB
Mlocked: 13808 kB
SwapTotal: 2096476 kB
SwapFree: 1264996 kB
Dirty: 144 kB
Writeback: 0 kB
AnonPages: 2547488 kB
Mapped: 55404 kB
Shmem: 56 kB
Slab: 956820 kB
SReclaimable: 884568 kB
SUnreclaim: 72252 kB
KernelStack: 4792 kB
PageTables: 44052 kB
NFS_Unstable: 0 kB
Bounce: 0 kB
WritebackTmp: 0 kB
CommitLimit: 10328604 kB
Committed_AS: 3304140 kB
VmallocTotal: 34359738367 kB
VmallocUsed: 307816 kB
VmallocChunk: 34359426296 kB
HardwareCorrupted: 0 kB
AnonHugePages: 1689600 kB
HugePages_Total: 0
HugePages_Free: 0
HugePages_Rsvd: 0
HugePages_Surp: 0
Hugepagesize: 2048 kB
DirectMap4k: 7488 kB
DirectMap2M: 16764928 kB

Above output information devided into two high and low-statistics. At the top you see a summary of the most common values people would like to look at.

High-Statistics

MemTotal: Total usable ram (i.e. physical ram minus a few reserved bits and the kernel binary code)
MemFree: Is sum of LowFree+HighFree (overall stat)
MemShared: 0; is here for compat reasons but always zero.
Buffers: Memory in buffer cache. mostly useless as metric nowadays Relatively temporary storage for raw disk blocks shouldn’t get tremendously large (20MB or so)
Cached: Memory in the pagecache (diskcache) minus SwapCache, Doesn’t include SwapCached
SwapCache: Memory that once was swapped out, is swapped back in but still also is in the swapfile (if memory is needed it doesn’t need to be swapped out AGAIN because it is already in the swapfile. This saves I/O )

Detailed Statistics

VM Statistics
VM splits the cache pages into “active” and “inactive” memory. The idea is that if you need memory and some cache needs to be sacrificed for that, you take it from inactive since that’s expected to be not used. The vm checks what is used on a regular basis and moves stuff around.

When you use memory, the CPU sets a bit in the pagetable and the VM checks that bit occasionally, and based on that, it can move pages back to active. And within active there’s an order of “longest ago not used” (roughly, it’s a little more complex in reality). The longest-ago used ones can get moved to inactive. Inactive is split into two in the above kernel (2.4.18-24.8.0). Some have it three.

The statistics are:
Active: Memory that has been used more recently and usually not reclaimed unless absolut necessary.
Inact_dirty: Dirty means “might need writing to disk or swap.” Takes more work to free. Example might be files that have not been written to yet. They aren’t written to memory too soon in order to keep the I/O down. For instance, if you’re writing logs, it might be better to wait until you have a complete log ready before sending it to disk.
Inact_clean: Assumed to be easily freeable. The kernel will try to keep some clean stuff around always to have a bit of breathing room.
Inact_target: Just a goal metric the kernel uses for making sure there are enough inactive pagesaround. When exceeded, the kernel will not do work to move pages from active to inactive. A page can also get inactive in a few other ways, e.g. if you do a long sequential I/O, the kernel assumes you’re not going to use that memory and makes it inactive preventively. So you can get more inactive pages than the target because the kernel marks some cache as “more likely to be never used” and lets it cheat in the “last used” order.

Memory Statistics

HighTotal: is the total amount of memory in the high region. Highmem is all memory above (approx) 860MB of physical RAM. Kernel uses indirect tricks to access the high memory region. Data cache can go in this memory region.
LowTotal: The total amount of non-highmem memory.
LowFree: The amount of free memory of the low memory region. This is the memory the kernel can address directly. All kernel datastructures need to go into low memory.
SwapTotal: Total amount of physical swap memory.
SwapFree: Total amount of swap memory free. Memory which has been evicted from RAM, and is temporarily on the disk
Dirty: Memory which is waiting to get written back to the disk
Writeback: Memory which is actively being written back to the disk
Mapped: files which have been mmaped, such as libraries
Slab: in-kernel data structures cache
Committed_AS: An estimate of how much RAM you would need to make a 99.99% guarantee that there never is OOM (out of memory) for this workload. Normally the kernel will overcommit memory. That means, say you do a 1GB malloc, nothing happens,really. Only when you start USING that malloc memory you will get real memory on demand, and just as much as you use. So you sort of take a mortgage and hope the bank doesn’t go bust. Other cases might include when you mmap a file that’s shared only when you write to it and you get a private copy of that data. While it normally is shared between processes. The Committed_AS is a guesstimate of how much RAM/swap you would need worst-case.
PageTables: amount of memory dedicated to the lowest level of page tables.
ReverseMaps: number of reverse mappings performed
VmallocTotal: total size of vmalloc memory area
VmallocUsed: amount of vmalloc area which is used
VmallocChunk: largest contigious block of vmalloc area which is free
Estimating the resource usage, especially the memory consumption of processes is by far more complicated than it looks like at a first glance. The philosophy is an unused resource is a wasted resource.The kernel therefore will use as much RAM as it can to cache information from your local and remote filesystems/disks. This builds up over time as reads and writes are done on the system
trying to keep the data stored in RAM as relevant as possible to the processes that have been running on your system. If there is free RAM available, more caching will be performed and thus more memory ‘consumed’. However this doesn’t really count as resource usage, since this cached memory is available in case some other process needs it. The cache is reclaimed, not at the time of process exit (you might start up another process soon that needs the same data), but upon demand.

When you start a process that needs a lot of memory to run, the OS kernel will reclaim memory that had been storing cached data and give it to the new process.

The system numbers normally are trust, but even they can be misinterpreted quite easily i.e.: using ‘top’

00 processes: 397 sleeping, 2 running, 1 zombie, 0 stopped
CPU0 states: 0.1% user, 0.3% system, 0.0% nice, 99.1% idle
CPU1 states: 0.3% user, 2.0% system, 0.0% nice, 97.1% idle
CPU2 states: 2.3% user, 8.1% system, 0.0% nice, 88.4% idle
CPU3 states: 100.0% user, 0.0% system, 0.0% nice, 0.0% idle
Mem: 16167672K av, 16124948K used, 42724K free, 1710184K shrd, 351304K buff
Swap: 12582608K av, 15892K used, 12566716K free 13326028K cache

Example 2:

top - 05:49:20 up 59 days, 19:01, 36 users,  load average: 3.00, 3.05, 3.01
Tasks: 344 total,   3 running, 340 sleeping,   0 stopped,   1 zombie
Cpu(s):  7.0%us, 27.8%sy,  0.0%ni, 64.7%id,  0.4%wa,  0.0%hi,  0.1%si,  0.0%st
Mem:  16464260k total, 11263872k used,  5200388k free,    18148k buffers
Swap:  2096476k total,   831480k used,  1264996k free,  7400016k cached

What sometimes confuses people is the buffer and cache on Linux:

Mem: 16167672K av, 16124948K used, 42724K free, 1710184K shrd, 351304K buff
Swap: 12582608K av, 15892K used, 12566716K free 13326028K cache

Looking at 16124948K used, This means the you system is buffering and caching 15Gb of RAM and in case this RAM is available for any process that need it.

$ free
total used free shared buffers cached
Mem: 16167672 16129820 37852 1710184 351312 13330324
-/+ buffers/cache: 2448184 13719488
Swap: 12582608 15892 12566716
Looking at the third line:
-/+ buffers/cache: 2448184 13719488

 

The system is using 2448184K (= 2GB) for your applications/process and it has a potentially free RAM of 13Gb. This one used for buffering & caching. In order to evaluate the memory process consumption you should use the ‘free’ command before, during and after running process doing this several time you can to get an average of what you are searching for.

If you want to know per process memory consumption you can also use commands below:

$ cat /proc/<pid>/maps
...
$ cat /proc/<pid>/status

 

In case of any ©Copyright or missing credits issue please check CopyRights page for faster resolutions.