memtotal

hightotal

lowtotal

swaptotal

memfree

highfree

lowfree

swapfree

memshared

cached

active

bigfree

buffers

swapcached

inactive

/proc/meminfo详细

(2010-10-13 04:10:22)

转载▼

标签：

杂谈

分类： linux

$cat /proc/meminfo

MemTotal: 2052440 kB //总内存

MemFree: 50004 kB //空闲内存

Buffers: 19976 kB //给文件的缓冲大小

Cached: 436412 kB //高速缓冲存储器(http://baike.baidu.com/view/496990.htm)使用的大小

SwapCached: 19864 kB //被高速缓冲存储用的交换空间大小

Active: 1144512 kB //活跃使用中的高速缓冲存储器页面文件大小

Inactive: 732788 kB //不经常使用的高速缓冲存储器页面文件大小

Active(anon): 987640 kB //anon：不久

Inactive(anon): 572512 kB

Active(file): 156872 kB

Inactive(file): 160276 kB

Unevictable: 8 kB

Mlocked: 8 kB

HighTotal: 1177160 kB //The total and free amount of memory, in kilobytes, that is not directly mapped into kernel space.

HighFree: 7396 kB // The HighTotal value can vary based on the type of kernel used.

LowTotal: 875280 kB // The total and free amount of memory, in kilobytes, that is directly mapped into kernel space. used.

LowFree: 42608 kB //The LowTotal value can vary based on the type of kernel

SwapTotal: 489940 kB //交换空间总大小

SwapFree: 450328 kB //空闲交换空间

Dirty: 104 kB //等待被写回到磁盘的大小

Writeback: 0 kB //正在被写回的大小

AnonPages: 1408256 kB //未映射的页的大小

Mapped: 131964 kB //设备和文件映射的大小

Slab: 37368 kB //内核数据结构缓存的大小，可减少申请和释放内存带来的消耗

SReclaimable: 14164 kB //可收回slab的大小

SUnreclaim: 23204 kB //不可收回的slab的大小23204+14164=37368

PageTables: 13308 kB //管理内存分页的索引表的大小

NFS_Unstable: 0 kB //不稳定页表的大小

Bounce: 0 kB //bounce:退回

WritebackTmp: 0 kB //

CommitLimit: 1516160 kB

Committed_AS: 2511900 kB

VmallocTotal: 122880 kB //虚拟内存大小

VmallocUsed: 28688 kB //已经被使用的虚拟内存大小

VmallocChunk: 92204 kB

HugePages_Total: 0 //大页面的分配

HugePages_Free: 0

HugePages_Rsvd: 0

HugePages_Surp: 0

Hugepagesize: 2048 kB

DirectMap4k: 10232 kB

DirectMap2M: 899072 kB

/proc/meminfo详解

/proc/meminfo Explained

"Free," "buffer," "swap," "dirty." What does it all mean? If you
said, "something to do with the Summer of '68", you may need a primer
on 'meminfo'.

The entries in the /proc/meminfo can help explain what's going on with your memory usage, if you know how to read it.

Example of "cat /proc/meminfo":

root:    total:        used:        free:          shared:    buffers:    cached:
Mem:      1055760384    1041887232    13873152    0    100417536     711233536
Swap:     1077501952      8540160     1068961792

MemTotal:        1031016 kB    
MemFree:        13548 kB
MemShared:        0 kB
Buffers:        98064 kB
Cached:            692320 kB
SwapCached:        2244 kB
Active:            563112 kB
Inact_dirty:        309584 kB
Inact_clean:        79508 kB
Inact_target:        190440 kB
HighTotal:        130992 kB
HighFree:        1876 kB
LowTotal:        900024 kB
LowFree:        11672 kB
SwapTotal:        1052248 kB
SwapFree:        1043908 kB
Committed_AS:        332340 kB

The information comes in the form of both high-level and low-level statistics. At the top you see a quick summary of the most common values people would like to look at. Below you find the individual values we will discuss. First we will discuss the high-level statistics.

High-Level 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
Cached: Memory in the pagecache (diskcache) minus SwapCache
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 Level 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.

Active: Memory that has been used more recently and usually not reclaimed unless absolutely necessary.
Inact_dirty: Dirty means "might need writing to disk or
swap." Takes more work to free. Examples 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 pages around. 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.
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.

在Linux下查看内存我们一般用free命令：
[root@scs-2 tmp]# free
             total       used       free     shared    buffers     cached
Mem:       3266180    3250004      16176          0     110652    2668236
-/+ buffers/cache:     471116    2795064
Swap:      2048276      80160    1968116

下面是对这些数值的解释：
total:总计物理内存的大小。
used:已使用多大。
free:可用有多少。
Shared:多个进程共享的内存总额。
Buffers/cached:磁盘缓存的大小。
第三行(-/+ buffers/cached):
used:已使用多大。
free:可用有多少。
第四行就不多解释了。
区
别：第二行(mem)的used/free与第三行(-/+ buffers/cache)
used/free的区别。这两个的区别在于使用的角度来看，第一行是从OS的角度来看，因为对于OS，buffers/cached
都是属于被使用，所以他的可用内存是16176KB,已用内存是3250004KB,其中包括，内核（OS）使用+Application(X,
oracle,etc)使用的+buffers+cached.
第三行所指的是从应用程序角度来看，对于应用程序来说，buffers/cached 是等于可用的，因为buffer/cached是为了提高文件读取的性能，当应用程序需在用到内存的时候，buffer/cached会很快地被回收。
所以从应用程序的角度来说，可用内存=系统free memory+buffers+cached。
如上例：
2795064=16176+110652+2668236

接下来解释什么时候内存会被交换，以及按什么方交换。当可用内存少于额定值的时候，就会开会进行交换。
如何看额定值：
cat /proc/meminfo

[root@scs-2 tmp]# cat /proc/meminfo
MemTotal:      3266180 kB
MemFree:         17456 kB
Buffers:        111328 kB
Cached:        2664024 kB
SwapCached:          0 kB
Active:         467236 kB
Inactive:      2644928 kB
HighTotal:           0 kB
HighFree:            0 kB
LowTotal:      3266180 kB
LowFree:         17456 kB
SwapTotal:     2048276 kB
SwapFree:      1968116 kB
Dirty:               8 kB
Writeback:           0 kB
Mapped:         345360 kB
Slab:           112344 kB
Committed_AS:   535292 kB
PageTables:       2340 kB
VmallocTotal: 536870911 kB
VmallocUsed:    272696 kB
VmallocChunk: 536598175 kB
HugePages_Total:     0
HugePages_Free:      0
Hugepagesize:     2048 kB

用free -m查看的结果：
[root@scs-2 tmp]# free -m
             total       used       free     shared    buffers     cached
Mem:          3189       3173         16          0        107       2605
-/+ buffers/cache:        460       2729
Swap:         2000         78       1921

查看/proc/kcore文件的大小（内存镜像）：
[root@scs-2 tmp]# ll -h /proc/kcore
-r-------- 1 root root 4.1G Jun 12 12:04 /proc/kcore

备注：

占用内存的测量

测量一个进程占用了多少内存，linux为我们提供了一个很方便的方法，/proc目录为我们提供了所有的信息，实际上top等工具也通过这里来获取相应的信息。

/proc/meminfo 机器的内存使用信息

/proc/pid/maps pid为进程号，显示当前进程所占用的虚拟地址。

/proc/pid/statm 进程所占用的内存

[root@localhost ~]# cat /proc/self/statm

654 57 44 0 0 334 0

输出解释

CPU 以及CPU0。。。的每行的每个参数意思（以第一行为例）为：

参数解释 /proc//status

Size (pages) 任务虚拟地址空间的大小 VmSize/4

Resident(pages) 应用程序正在使用的物理内存的大小 VmRSS/4

Shared(pages) 共享页数 0

Trs(pages) 程序所拥有的可执行虚拟内存的大小 VmExe/4

Lrs(pages) 被映像到任务的虚拟内存空间的库的大小 VmLib/4

Drs(pages) 程序数据段和用户态的栈的大小（VmData+ VmStk ）4

dt(pages) 04

查看机器可用内存

/proc/28248/>free

total used free shared buffers cached

Mem: 1023788 926400 97388 0 134668 503688

-/+ buffers/cache: 288044 735744

Swap: 1959920 89608 1870312

我们通过free命令查看机器空闲内存时，会发现free的值很小。这主要是因为，在linux中有这么一种思想，内存不用白不用，因此它尽可能的cache和buffer一些数据，以方便下次使用。但实际上这些内存也是可以立刻拿来使用的。

所以空闲内存=free+buffers+cached=total-used

转自：http://blog.chinaunix.net/u2/78225/showart_1727609.html