Linux 内存管理机制

1.内存空间布局：

    对于提供了MMU（存储管理器，辅助操作系统进行内存管理，提供虚实地址转换等硬件支持）的处理器而言，Linux提供了复杂的存储管理系统，使得进程所能访问的内存达到4GB。

进程的4GB内存空间被人为的分为两个部分--用户空间与内核空间。用户空间地址分布从0到3GB(PAGE_OFFSET，在0x86中它等于0xC0000000)，3GB到4GB为内核空间。

 内核空间中，从3G到vmalloc_start这段地址是物理内存映射区域（该区域中包含了内核镜像、物理页框表mem_map等等），比如我们使用 的 VMware虚拟系统内存是160M，那么3G～3G+160M这片内存就应该映射物理内存。在物理内存映射区之后，就是vmalloc区域。对于 160M的系统而言，vmalloc_start位置应在3G+160M附近（在物理内存映射区与vmalloc_start期间还存在一个8M的gap 来防止跃界），vmalloc_end的位置接近4G(最后位置系统会保留一片128k大小的区域用于专用页面映射)

对于32bit Linux系统来说，一般留给用户态空间是3GB，高地址的1GB  0xC0000000~0xFFFFFFFF是留给kernel的。

并且一般采用分页，分段，段页式的方式。一页大小一般为2^12=4096=4KB的大小。一般是10+10+12

2.内存管理基本机制；分段，分页，段页。

3.linux系统一般内存管理方法：两种算法相配合

内存结构是：NUMA（Non-Uniform Memory Acess Architecture）架构，Numa下分布式的一个内存节点成为Node，我们常用的单击系统，是UMA（Uniform Acess Architecture）就是一个NODE，因此可以理解为一台机器就是一个NODE，每个NODE下物理内存分成几个的ZONE（区域），Zone内再对物理页进行管理。因此内存的整个管理结构是：

分布式集群——Node——Zone——Page

集群系统   ——本地一台机器——BUDDY算法——SLAB或（SLUB）算法。。。。不同区域对应的管理算法。

其中Zone的结构可以通过 /proc/buddyinfo来查看。

Node 0, zone DMA 4 4 3 3 3 3 2 1 0 0 2
Node 0, zone DMA32 0 1 1 1 1 1 1 0 3 3 699
Node 0, zone Normal 1180 748 514 83 18 26 21 7 2 0 1899
Node 1, zone Normal 258 1634 379 135 47 10 2 1 1 1 2965

上面可以看到，本地一共分为两个Node，其中Node 0，包括Zone DMA，Zone DMA32，Zone Normal。。。Node 1 只有Zone Normal。。。

但是传统的X86系统包括三个Zone,DMA,Normal,HIGHMEM最后一个是高端内存区域，指的是896MB~（最大1GB）。

①BUDDY算法概述，伙伴系统，就是一开始就把内存分为1,2，4,8，...个页面，然后用链连起来，一般定义MAX_ORDER为11，也就是最大可以分配2^10=1024个page，当调用allocate_pages()，他分配2^order个连续的物理页，返回一个指针，指向第一个页，失败了返回NULL。

另外，在gfp.h中定义的几个宏定义需要说一下：

GFP_KERNEL,GFP_aTOMIC,GFP_NOIO,GFP_NOFS,GFP_USER,GFP_HIGHUSER,GFP_IO,GFP_FS,

一般最常用的就是Kernel选项，会引起阻塞，普通优先级。然后再中断情况下，就必须使用非阻塞的标志Atomic，一般内核编程主要使用则两个。

 

②Solaris-SLAB算法，用高速缓存来描述不同的对象，每种对象对应一个高速缓存。高速缓存由SLAB来管理对象的内存分配。每个SLAB是一个或多个连续的物理页（这个是从buddy算法分配而来的）一般运行在BUDDY的下层。有Slab_full Slab_partial,Slab_empty,三种。通过查看/proc/slabinfo可以看到slab的使用情况。另外，由于很多进程刚开始创建时，内存格式占用大小都差不多，系统经常需要创建和销毁进程，这样导致效率很低，slab算法，每次分配相同类型的内存时，就从相应的SLAB中去取已经划分好的对象。SLAB释放的内核空间，并没有完全释放，可以留给下次分配用。。。slab的实现大都放在  mm/slab.c中。  通过查看/proc/slabinfo可以看到，

name <active_objs> <num_objs> <objsize> <objperslab> <pagesperslab> : tunables <limit> <batchcount> <sharedfactor> : slabdata <active_slabs> <num_slabs> 

size-131072 2 2 131072 1 32 : tunables 8 4 0 : slabdata 2 2 0
size-65536(DMA) 0 0 65536 1 16 : tunables 8 4 0 : slabdata 0 0 0
size-65536 1 1 65536 1 16 : tunables 8 4 0 : slabdata 1 1 0
size-32768 4 4 32768 1 8 : tunables 8 4 0 : slabdata 4 4 0
size-16384 31 31 16384 1 4 : tunables 8 4 0 : slabdata 31 31 0
size-8192 573 573 8192 1 2 : tunables 8 4 0 : slabdata 573 573 0
size-4096 875 877 4096 1 1 : tunables 24 12 8 : slabdata 875 877 0
size-2048 759 812 2048 2 1 : tunables 24 12 8 : slabdata 406 406 1
size-1024 2744 2916 1024 4 1 : tunables 54 27 8 : slabdata 729 729 0
size-512 1335 1552 512 8 1 : tunables 54 27 8 : slabdata 194 194 2
size-256 3611 3735 256 15 1 : tunables 120 60 8 : slabdata 249 249 2
size-64 11054 11859 64 59 1 : tunables 120 60 8 : slabdata 201 201 0
size-128 6392 6570 128 30 1 : tunables 120 60 8 : slabdata 219 219 0
size-32 96304 96992 32 112 1 : tunables 120 60 8 : slabdata 866 866 3
kmem_cache 150 150 2688 1 1 : tunables 24 12 8 : slabdata 150 150 0

 

第一个参数是name，这个那么其实就是 调用函数  kmem_cache_creat（）传递的第一个参数，后面要讲这个函数。可以看到objsize乘以objperslab得到中总的大小，基本接近于分配的页大小，比如2048*2=4096正好等于一个页，当然384*10=3840也是接近于一个页，可能是还没有分配出去，也有一部分是slab自身的结构占用了一些空间，最后一项显示，这样的slab一共有多少个。

下面来看一下kmem_cache_creat(const char *name,size_t size,size_t align,unsigned long flag,void(*ctor)(void*,struct kmem_cache *,unsigned long));

第一个参数就是制定这个高速缓存的名称，会出现在slabinfo的第一项，因为申请的一块高速缓存，是有slab来管理的。

第二项，分配的大小，对应上面就是2048,384,768等。如果是首次分配，那么开辟一个页，以后该对象的地址被回收之后，还可以由其他该类对象使用。

第三项，对齐方式，一般为0.标准对齐。

第四项，flag，SLAB_HWCACHE_ALIGN，使用slab内的对象按硬件的cache line进行对齐，提高性能，但是浪费内存多些。。

第五项，构造函数，传递的是函数的地址，以前还有dtor，2.6.30以后的版本中已经没有了。

调用成功，就返回一个指向该高速缓存结构的指针，然后就可以通过kmem_cache_alloc进行内存对象的分配了。

kmalloc函数-__do_kmalloc(size_t size,gfp_t flags,void *caller).

这个函数很简单，首先从高速缓存中找到一个kmem_cache，能够满足size大小，然后从这个kmem_cache中分配内存对象，而这些size实际上就是在slabinfo中的大小。

kmalloc(50,GFP_KERNEL)那么就从上面的size-64的slab中进行分配的。上面有那么的标示已经分配给其他对象了。使用kmalloc将会从未分配的高速缓存块中，分配一个能满足要求的最小高速缓存块。而这些size-xxx的slab是系统在内存初始化的时候㐇预先建立一组预定义大小的kmem_cache，从32字节开始，一直增加到131072个字节，也就是2^32，unsigned int;

另外内存分配还定义了一些其他函数，比如kzalloc():和malloc类似，但是分配的空间置0。 kcalloc(size_t n,size_t size gfp_t flag):for array。滴啊用kzalloc（n*size,flag）,地址赋值为0；

 

最后我们来看一下内存映射，mmap,munmap,msync;

mmap()系统调用使得进程之间通过映射同一个普通文件实现共享内存。普通文件被映射到进程地址空间后，进程可以像访问普通内存一样对文件进行访问，不必再调用read()，write（）等操作。 
注：实际上，mmap()系统调用并不是完全为了用于共享内存而设计的。它本身提供了不同于一般对普通文件的访问方式，进程可以像读写内存一样对普通文件的操作。而Posix或系统V的共享内存IPC则纯粹用于共享目的，当然mmap()实现共享内存也是其主要应用之一。 （来自百度百科）

 

void *mmap(void *,size_t length,int prot,int flag,int fd,off_t offset);

void *unmap(void * addr,size_t length)

第一项：参考虚拟地址，一般为NULL，自动生成。

第二项：字节数。

第三项：映射属性，PROT_EXEC，PROT_READ，PROT_WRITE，PROT_NONE。可以比特或。同时读写执行。

第四项：映射的操作，MAP_SHARED，MAP_PRIVATE，MAP_ANONYMOUS，前两个是共享内存或者私有映射，对内存的操作都是基于copy-on write，写实复制，只用调用munmap,或者msync的时候，才能保证写回文件。

如果指定为MAP——ANONYMOUS，标示匿名映射，不映射到任何文件中，致死后fd和offset不起作用，mmap返回一块初始化为0的匿名映射内存区域块。使用malloc函数分配虚拟内存时，小于128K的的用brk（）系统调用增长堆的大小，大于128kb的直接用MAP_ANONYMOUS的方式，映射一个匿名地址空间。开发人员可以用这种方法预先建立一个大的虚拟地址空间，实现自己的内存管理。

 

其他：

内存分配  kmalloc与malloc与vmalloc的关系（转自http://blog.youkuaiyun.com/macrossdzh/article/details/5958368）

简单的说：

1. kmalloc和vmalloc是分配的是内核的内存,malloc分配的是用户的内存
2. kmalloc保证分配的内存在物理上是连续的,vmalloc保证的是在虚拟地址空间上的连续,malloc不保证任何东西(这点是自己猜测的,不一定正确)
3. kmalloc能分配的大小有限,vmalloc和malloc能分配的大小相对较大
4. 内存只有在要被DMA访问的时候才需要物理上连续
5. vmalloc比kmalloc要慢

详细的解释：

      kmalloc和get_free_page申请的内存位于物理内存映射区域，而且在物理上也是连续的，它们与真实的物理地址只有一个固定的偏移，因此存在较简单的转换关系，virt_to_phys()可以实现内核虚拟地址转化为物理地址：

而vmalloc申请的内存则位于vmalloc_start～vmalloc_end之间，与物理地址没有简单的转换关系，虽然在逻辑上它们也是连续的，但是在物理上它们不要求连续。

 vm_struct链表，将free的内存链接起来，记录vmalloc说得到的所有的块。

转载于:https://www.cnblogs.com/xindufresne/p/4769921.html