document.write('
Data hosted with ♥ by Pastebin.com - Download Raw - See Original
  1. # source:
  2. # http://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/tree/Documentation/filesystems/proc.txt#n800
  3. #
  4. MemTotal: Total usable ram (i.e. physical ram minus a few reserved
  5. bits and the kernel binary code)
  6. MemFree: The sum of LowFree+HighFree
  7. MemAvailable: An estimate of how much memory is available for starting new
  8. applications, without swapping. Calculated from MemFree,
  9. SReclaimable, the size of the file LRU lists, and the low
  10. watermarks in each zone.
  11. The estimate takes into account that the system needs some
  12. page cache to function well, and that not all reclaimable
  13. slab will be reclaimable, due to items being in use. The
  14. impact of those factors will vary from system to system.
  15. Buffers: Relatively temporary storage for raw disk blocks
  16. shouldn't get tremendously large (20MB or so)
  17. Cached: in-memory cache for files read from the disk (the
  18. pagecache). Doesn't include SwapCached
  19. SwapCached: Memory that once was swapped out, is swapped back in but
  20. still also is in the swapfile (if memory is needed it
  21. doesn't need to be swapped out AGAIN because it is already
  22. in the swapfile. This saves I/O)
  23. Active: Memory that has been used more recently and usually not
  24. reclaimed unless absolutely necessary.
  25. Inactive: Memory which has been less recently used. It is more
  26. eligible to be reclaimed for other purposes
  27. HighTotal:
  28. HighFree: Highmem is all memory above ~860MB of physical memory
  29. Highmem areas are for use by userspace programs, or
  30. for the pagecache. The kernel must use tricks to access
  31. this memory, making it slower to access than lowmem.
  32. LowTotal:
  33. LowFree: Lowmem is memory which can be used for everything that
  34. highmem can be used for, but it is also available for the
  35. kernel's use for its own data structures. Among many
  36. other things, it is where everything from the Slab is
  37. allocated. Bad things happen when you're out of lowmem.
  38. SwapTotal: total amount of swap space available
  39. SwapFree: Memory which has been evicted from RAM, and is temporarily
  40. on the disk
  41. Dirty: Memory which is waiting to get written back to the disk
  42. Writeback: Memory which is actively being written back to the disk
  43. AnonPages: Non-file backed pages mapped into userspace page tables
  44. AnonHugePages: Non-file backed huge pages mapped into userspace page tables
  45. Mapped: files which have been mmaped, such as libraries
  46. Slab: in-kernel data structures cache
  47. SReclaimable: Part of Slab, that might be reclaimed, such as caches
  48. SUnreclaim: Part of Slab, that cannot be reclaimed on memory pressure
  49. PageTables: amount of memory dedicated to the lowest level of page
  50. tables.
  51. NFS_Unstable: NFS pages sent to the server, but not yet committed to stable
  52. storage
  53. Bounce: Memory used for block device "bounce buffers"
  54. WritebackTmp: Memory used by FUSE for temporary writeback buffers
  55. CommitLimit: Based on the overcommit ratio ('vm.overcommit_ratio'),
  56. this is the total amount of memory currently available to
  57. be allocated on the system. This limit is only adhered to
  58. if strict overcommit accounting is enabled (mode 2 in
  59. 'vm.overcommit_memory').
  60. The CommitLimit is calculated with the following formula:
  61. CommitLimit = ('vm.overcommit_ratio' * Physical RAM) + Swap
  62. For example, on a system with 1G of physical RAM and 7G
  63. of swap with a `vm.overcommit_ratio` of 30 it would
  64. yield a CommitLimit of 7.3G.
  65. For more details, see the memory overcommit documentation
  66. in vm/overcommit-accounting.
  67. Committed_AS: The amount of memory presently allocated on the system.
  68. The committed memory is a sum of all of the memory which
  69. has been allocated by processes, even if it has not been
  70. "used" by them as of yet. A process which malloc()'s 1G
  71. of memory, but only touches 300M of it will show up as
  72. using 1G. This 1G is memory which has been "committed" to
  73. by the VM and can be used at any time by the allocating
  74. application. With strict overcommit enabled on the system
  75. (mode 2 in 'vm.overcommit_memory'),allocations which would
  76. exceed the CommitLimit (detailed above) will not be permitted.
  77. This is useful if one needs to guarantee that processes will
  78. not fail due to lack of memory once that memory has been
  79. successfully allocated.
  80. VmallocTotal: total size of vmalloc memory area
  81. VmallocUsed: amount of vmalloc area which is used
  82. VmallocChunk: largest contiguous block of vmalloc area which is free
');