内存管理[4]

     slab分配器扮演了通用数据结构缓存层的角色。

    slab分配器的概念首先在Sun Microsystem的SunOS 5.4操作系统中得以实现。Linux数据结构缓存层分享了它的名字和基本设计思想。

   slab分配器试图在几个基本原则之间寻求一种平衡：

频繁使用的数据结构也会频繁的分配和是否，因此应当适当缓存它们。

频繁分配和回收必然会导致内存碎片。为了避免这种现象，空闲链表的缓存会连续地存放。因为已释放的数据结构又会放回空闲链表，因此不会导致碎片。

回收的对象可以立即投入下一次分配，因此对于频繁的分配和释放，空闲链表能够提高其性能。

如果分配器知道对象大小、页大小和总的高速缓存的大小这样的概念，它会做出更明智的决策。

如果让部分缓存专属于单个处理器，那么，分配和释放和就可以在不加SMP锁的情况下进行。

如果分配器是NUMA相关的，它就可以从相同的内存节点为请求者进行分配。

对存放的对象进行着色，以防止多个对象映射到相同的高速缓存行。

• slab层的设计

   slab层把不同的对象划分为所谓高速缓存组，其中每个高速缓存都存放不同类型的对象。每种对象类型对应一个高速缓存。kmalloc()接口建立在slab层之上，使用了一组通用高速缓存。即，kmalloc()分配的内存是从通用高速缓存中分配的。

   然后，这些高速缓存又被划分为slab。slab由一个或多个物理上连续的页组成。一般情况下，slab就仅仅由一页组成。每个高速缓存可以由多个slab组成。

    每个slab都包含一些对象成员，这里的对象指的是被缓存的数据结构。每个slab处于三种状态之一：满、部分满或空。一个满的slab没有空闲对象，一个空的slab没有分配出任何对象，一部分满的slab有一些对象已经分配出去还有些对象空闲中。当内核的某一部分需要一个新的对象时，先从部分满的slab中进行分配。如果没有部分满的slab就从空的slab进行分配。如果没有空的slab，就要创建一个slab了。

高速缓存、slab和对象之间的关系如下所示：

 

1. 在<Slab.c(mm)>中
2. /*
3.  * struct kmem_cache
4.  *
5.  * manages a cache.
6.  */
8. struct kmem_cache {
9. /* 1) per-cpu data, touched during every alloc/free */
10.     struct array_cache *array[NR_CPUS];
11. /* 2) Cache tunables. Protected by cache_chain_mutex */
12.     unsigned int batchcount;
13.     unsigned int limit;
14.     unsigned int shared;
16.     unsigned int buffer_size;
17.     u32 reciprocal_buffer_size;
18. /* 3) touched by every alloc & free from the backend */
19.     struct kmem_list3 *nodelists[MAX_NUMNODES];
21.     unsigned int flags;     /* constant flags */
22.     unsigned int num;       /* # of objs per slab */
24. /* 4) cache_grow/shrink */
25.     /* order of pgs per slab (2^n) */
26.     unsigned int gfporder;
28.     /* force GFP flags, e.g. GFP_DMA */
29.     gfp_t gfpflags;
31.     size_t colour;          /* cache colouring range */
32.     unsigned int colour_off;    /* colour offset */
33.     struct kmem_cache *slabp_cache;
34.     unsigned int slab_size;
35.     unsigned int dflags;        /* dynamic flags */
37.     /* constructor func */
38.     void (*ctor) (void *, struct kmem_cache *, unsigned long);
40.     /* de-constructor func */
41.     void (*dtor) (void *, struct kmem_cache *, unsigned long);
43. /* 5) cache creation/removal */
44.     const char *name;
45.     struct list_head next;
47. /* 6) statistics */
48. #if STATS
49.     unsigned long num_active;
50.     unsigned long num_allocations;
51.     unsigned long high_mark;
52.     unsigned long grown;
53.     unsigned long reaped;
54.     unsigned long errors;
55.     unsigned long max_freeable;
56.     unsigned long node_allocs;
57.     unsigned long node_frees;
58.     unsigned long node_overflow;
59.     atomic_t allochit;
60.     atomic_t allocmiss;
61.     atomic_t freehit;
62.     atomic_t freemiss;
63. #endif
64. #if DEBUG
65.     /*
66.      * If debugging is enabled, then the allocator can add additional
67.      * fields and/or padding to every object. buffer_size contains the total
68.      * object size including these internal fields, the following two
69.      * variables contain the offset to the user object and its size.
70.      */
71.     int obj_offset;
72.     int obj_size;
73. #endif
74. };

  每个高速缓存都是用kmem_cache_t结构来表示。这个结构包含三个链表slabs_full，slabs_partial和slabs_empty，均存放在kmem_list3结构内。这些链表包含高速缓存中的所有slab。

2. /*
3.  * The slab lists for all objects.
4.  */
5. struct kmem_list3 {
6.     struct list_head slabs_partial; /* partial list first, better asm code */
7.     struct list_head slabs_full;
8.     struct list_head slabs_free;
9.     unsigned long free_objects;
10.     unsigned int free_limit;
11.     unsigned int colour_next;   /* Per-node cache coloring */
12.     spinlock_t list_lock;
13.     struct array_cache *shared; /* shared per node */
14.     struct array_cache **alien; /* on other nodes */
15.     unsigned long next_reap;    /* updated without locking */
16.     int free_touched;       /* updated without locking */
17. };

以下是slab的定义：

2. /*
3.  * struct slab
4.  *
5.  * Manages the objs in a slab. Placed either at the beginning of mem allocated
6.  * for a slab, or allocated from an general cache.
7.  * Slabs are chained into three list: fully used, partial, fully free slabs.
8.  */
9. struct slab {
10.     struct list_head list;
11.     unsigned long colouroff;
12.     void *s_mem;        /* including colour offset */
13.     unsigned int inuse; /* num of objs active in slab */
14.     kmem_bufctl_t free;
15.     unsigned short nodeid;
16. };

  slab描述符要么在slab之外另行分配，要么放在slab自身最开始的地方。如果slab描述符很小或者slab内部有足够的空间容纳slab描述符，那么描述符就存放在slab里面。

  slab分配器可以创建新的slab，这是通过alloc_pages_node()低级内核页分配器进行的：

 

2. /*
3.  * Interface to system's page allocator. No need to hold the cache-lock.
4.  *
5.  * If we requested dmaable memory, we will get it. Even if we
6.  * did not request dmaable memory, we might get it, but that
7.  * would be relatively rare and ignorable.
8.  */
9. static void *kmem_getpages(struct kmem_cache *cachep, gfp_t flags, int nodeid)
10. {
11.     struct page *page;
12.     int nr_pages;
13.     int i;
15. #ifndef CONFIG_MMU
16.     /*
17.      * Nommu uses slab's for process anonymous memory allocations, and thus
18.      * requires __GFP_COMP to properly refcount higher order allocations
19.      */
20.     flags |= __GFP_COMP;
21. #endif
23.     flags |= cachep->gfpflags;
25.     page = alloc_pages_node(nodeid, flags, cachep->gfporder);
26.     if (!page)
27.         return NULL;
29.     nr_pages = (1 << cachep->gfporder);
30.     if (cachep->flags & SLAB_RECLAIM_ACCOUNT)
31.         add_zone_page_state(page_zone(page),
32.             NR_SLAB_RECLAIMABLE, nr_pages);
33.     else
34.         add_zone_page_state(page_zone(page),
35.             NR_SLAB_UNRECLAIMABLE, nr_pages);
36.     for (i = 0; i < nr_pages; i++)
37.         __SetPageSlab(page + i);
38.     return page_address(page);
39. }

  slab层只有当给定的高速缓存中既没有部分满也没有空的slab时才会调用页分配函数。而只有在下列情况下才会调用释放函数：当可用内存变得紧缺时，系统试图释放出更多内存以供使用，或者当高速缓存显式的被摧毁时。