meminfo.sh

# source:
# http://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/tree/Documentation/filesystems/proc.txt#n800
#
#     MemTotal: Total usable ram (i.e. physical ram minus a few reserved
#               bits and the kernel binary code)
#      MemFree: The sum of LowFree+HighFree
# MemAvailable: An estimate of how much memory is available for starting new
#               applications, without swapping. Calculated from MemFree,
#               SReclaimable, the size of the file LRU lists, and the low
#               watermarks in each zone.
#               The estimate takes into account that the system needs some
#               page cache to function well, and that not all reclaimable
#               slab will be reclaimable, due to items being in use. The
#               impact of those factors will vary from system to system.
#      Buffers: Relatively temporary storage for raw disk blocks
#               shouldn't get tremendously large (20MB or so)
#       Cached: in-memory cache for files read from the disk (the
#               pagecache).  Doesn't include SwapCached
#   SwapCached: 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)
#       Active: Memory that has been used more recently and usually not
#               reclaimed unless absolutely necessary.
#     Inactive: Memory which has been less recently used.  It is more
#               eligible to be reclaimed for other purposes
#    HighTotal:
#     HighFree: Highmem is all memory above ~860MB of physical memory
#               Highmem areas are for use by userspace programs, or
#               for the pagecache.  The kernel must use tricks to access
#               this memory, making it slower to access than lowmem.
#     LowTotal:
#      LowFree: Lowmem is memory which can be used for everything that
#               highmem can be used for, but it is also available for the
#               kernel's use for its own data structures.  Among many
#               other things, it is where everything from the Slab is
#               allocated.  Bad things happen when you're out of lowmem.
#    SwapTotal: total amount of swap space available
#     SwapFree: 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
#    AnonPages: Non-file backed pages mapped into userspace page tables
# AnonHugePages: Non-file backed huge pages mapped into userspace page tables
#       Mapped: files which have been mmaped, such as libraries
#         Slab: in-kernel data structures cache
# SReclaimable: Part of Slab, that might be reclaimed, such as caches
#   SUnreclaim: Part of Slab, that cannot be reclaimed on memory pressure
#   PageTables: amount of memory dedicated to the lowest level of page
#               tables.
# NFS_Unstable: NFS pages sent to the server, but not yet committed to stable
# 	      storage
#       Bounce: Memory used for block device "bounce buffers"
# WritebackTmp: Memory used by FUSE for temporary writeback buffers
#  CommitLimit: Based on the overcommit ratio ('vm.overcommit_ratio'),
#               this is the total amount of  memory currently available to
#               be allocated on the system. This limit is only adhered to
#               if strict overcommit accounting is enabled (mode 2 in
#               'vm.overcommit_memory').
#               The CommitLimit is calculated with the following formula:
#               CommitLimit = ('vm.overcommit_ratio' * Physical RAM) + Swap
#               For example, on a system with 1G of physical RAM and 7G
#               of swap with a `vm.overcommit_ratio` of 30 it would
#               yield a CommitLimit of 7.3G.
#               For more details, see the memory overcommit documentation
#               in vm/overcommit-accounting.
# Committed_AS: The amount of memory presently allocated on the system.
#               The committed memory is a sum of all of the memory which
#               has been allocated by processes, even if it has not been
#               "used" by them as of yet. A process which malloc()'s 1G
#               of memory, but only touches 300M of it will show up as
# 	      using 1G. This 1G is memory which has been "committed" to
#               by the VM and can be used at any time by the allocating
#               application. With strict overcommit enabled on the system
#               (mode 2 in 'vm.overcommit_memory'),allocations which would
#               exceed the CommitLimit (detailed above) will not be permitted.
#               This is useful if one needs to guarantee that processes will
#               not fail due to lack of memory once that memory has been
#               successfully allocated.
# VmallocTotal: total size of vmalloc memory area
#  VmallocUsed: amount of vmalloc area which is used
# VmallocChunk: largest contiguous block of vmalloc area which is free