Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- # 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
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement