Linux – How to see nginx’s shared memory usage

What you're looking for is the output from "free":

$ free
             total       used       free     shared    buffers     cached
Mem:        775556     759456      16100          0      22132     592484
-/+ buffers/cache:     144840     630716
Swap:       500344      21972     478372

Here's a tour:

This is a box w/ 768MB of physical RAM and a 500344KB swap partition.

759456KB is "used" (second column, top row). Of this "used" memory, 23132KB is buffers (5th column, top row) and 592484KB (sixth column, top row) is cache, leaving 144840KB (2nd column, 2nd row) of physical memory that's being used by active processes.

When you consider that the memory used by buffers and cache could be used for processes, that leaves 630716KB (3rd column, 2nd row) of physical memory free.

The swap partition, as I said, is 500344KB (1st column, bottom row). 21972KB (2nd column, bottom row) of the swap file is in use, leaving 478372KB (3rd column, bottom row) free.

So, your definition of % free memory depends on whether you're counting buffers and cache or not, and whether you're counting swap or not.

That ought to give you enough to go on to calculate a percentage as you see fit.

Here's the output of top and free:

$ top -n1 | grep "used," ; free
Mem:    775556k total,   751472k used,    24084k free,    20776k buffers
Swap:   500344k total,    21972k used,   478372k free,   586648k cached

             total       used       free     shared    buffers     cached
Mem:        775556     751344      24212          0      20776     586648
-/+ buffers/cache:     143920     631636
Swap:       500344      21972     478372

You can see how top and free agree (albeit with a little difference-- this is a multi-user machine and the memory usage of the top and free programs are reflected in there).

Add a "-s" when you call vmstate, and you will see much the same output, just in a different form:

$ vmstat -s ; free
       775556  total memory
       759920  used memory
       674680  active memory
        18440  inactive memory
        15636  free memory
        21892  buffer memory
       594372  swap cache
       500344  total swap
        21972  used swap
       478372  free swap
       ... output truncated ...

             total       used       free     shared    buffers     cached
Mem:        775556     759920      15636          0      21892     594372
-/+ buffers/cache:     143656     631900
Swap:       500344      21972     478372

You can see that vmstat is showing all the same numbers as free.

In short:

• Virtual size: is the amount of address space that a process is managing. The virtual address space contains everything that the process can access through pointers (memory address references). For example, if your program gets access to the framebuffer of your video card, that memory is mapped to the process virtual space and receives an address that is stored to a pointer. Memory-mapped files and anonymous mappings are also accounted into the virtual address space size. Pretty much everything is in the virtual size. If you sum up the size of all address ranges listed in /proc/<pid>/maps, it should return you roughly the same value of the virtual size.

• Resident size: is the amount of memory that belongs specifically to that process that is currently resident in memory. That means, the amount of memory that is not in swap. Note that parts of the process can be in swap memory even when the process is running. The operating system will pull these regions from the swap when the process tries to access it. This should include the heap, the stacks of all threads and other private mappings. If you look in /proc/<pid>/maps, the [stack], [heap] and other anonymous mappings (those without file paths) are either swapped or accounted in the resident size.

• Shared size: is the amount of memory that may belong to multiple processes. For example, if you have four instances of the same application loaded in memory, you will have four instances of the heap and at least four stacks, one for each process (this is the resident memory), but you will have only one instance of the binary code of the program and its libraries. This is the shared space. Not only it includes the program binary code and its libraries, but also localization files, read-only program data, SysV and POSIX shared memory segments, semaphores, etc... If you look in /proc/<pid>/maps, most mappings tied to library and program files are shared.

Note that VIRT contains the union of RSS and SHR, and will always be greater than any one of them. There may be regions accounted as both RSS and SHR.