memcache slabs .

http://blog.csdn.net/benbendy1984/article/details/6216453

  memcache 使用slab机制对内存进行分配和管理的。

 

一 整体结构

 

       把内存分成多个层次，在每个层次中，可以有多个page, 所有层次的page大小基本是一直的（为什么不相同，后面介绍），每个page中又分成相同大小的item，里面有多少个item，取决于page大小和item所在的层次，其中相邻层次直接item大小具有如下关系

                                     size(item: n+1 )  = size( item: n) * grow_factor  

       其中的grow_factor 是可配置的参数。

       在内存分配时，如果需要大小为k的空间，那么就从第n个层次中得到一个item ,其中n需要满足

                                           size(item:n-1)  <   k  <=  size(item:n)

       那么从n个层次中的这么多个item中取哪个？所有被取光了怎么办？使用完了释放了怎么办？ 这些都会在后面进行详细的介绍

 

 

二 结构成员

 

[cpp:collapse] + expand sourceview plaincopyprint?

1. typedef struct {  
2.     unsigned int size;          /* 每个item大小, sizes of items */  
3.     unsigned int perslab;       /* 每个page中包含多少个item , how many items per slab */  
4.   
5.     void **slots;               /* 空闲的item指针, list of item ptrs */  
6.     unsigned int sl_total;      /* 以分配空闲的item 个数, size of previous array */  
7.     unsigned int sl_curr;       /* 当前空闲的item位置(也就是实际空闲item个数)，从后往前的， first free slot */  
8.   
9.     void *end_page_ptr;         /* 指向最后一个页面中空闲的item开始位置, pointer to next free item at end of page, or 0 */  
10.     unsigned int end_page_free; /* 最后一个页面，item个数, number of items remaining at end of last alloced page */  
11.   
12.     unsigned int slabs;         /* 实际使用slab(page)个数 how many slabs were allocated for this class */  
13.   
14.     void **slab_list;           /* 所有page的指针, array of slab pointers */  
15.     unsigned int list_size;     /* 已经分配page指针个数，size of prev array */  
16.   
17.     unsigned int killing;       /* index+1 of dying slab, or zero if none */  
18.     size_t requested;           /* 所有被使用了的内存的大小, The number of requested bytes */  
19. } slabclass_t;  

typedef struct { unsigned int size; /* 每个item大小, sizes of items */ unsigned int perslab; /* 每个page中包含多少个item , how many items per slab */ void **slots; /* 空闲的item指针, list of item ptrs */ unsigned int sl_total; /* 以分配空闲的item 个数, size of previous array */ unsigned int sl_curr; /* 当前空闲的item位置(也就是实际空闲item个数)，从后往前的， first free slot */ void *end_page_ptr; /* 指向最后一个页面中空闲的item开始位置, pointer to next free item at end of page, or 0 */ unsigned int end_page_free; /* 最后一个页面，item个数, number of items remaining at end of last alloced page */ unsigned int slabs; /* 实际使用slab(page)个数 how many slabs were allocated for this class */ void **slab_list; /* 所有page的指针, array of slab pointers */ unsigned int list_size; /* 已经分配page指针个数，size of prev array */ unsigned int killing; /* index+1 of dying slab, or zero if none */ size_t requested; /* 所有被使用了的内存的大小, The number of requested bytes */} slabclass_t;

 

三 函数介绍

 

3.1 slabs_clsid()

[cpp] view plaincopyprint?

1. /* 
2.  * Figures out which slab class (chunk size) is required to store an item of 
3.  * a given size. 
4.  * 
5.  * Given object size, return id to use when allocating/freeing memory for object 
6.  * 0 means error: can't store such a large object 
7.  * 根据大小，返回满足条件的item所在的层次  
8.  */  
9.   
10. unsigned int slabs_clsid(const size_t size) {  
11.     int res = POWER_SMALLEST;  
12.   
13.     if (size == 0)  
14.         return 0;  
15.     while (size > slabclass[res].size)  
16.         if (res++ == power_largest)     /* won't fit in the biggest slab */  
17.             return 0;  
18.     return res;  
19. }  

/* * Figures out which slab class (chunk size) is required to store an item of * a given size. * * Given object size, return id to use when allocating/freeing memory for object * 0 means error: can't store such a large object * 根据大小，返回满足条件的item所在的层次 */unsigned int slabs_clsid(const size_t size) { int res = POWER_SMALLEST; if (size == 0) return 0; while (size > slabclass[res].size) if (res++ == power_largest) /* won't fit in the biggest slab */ return 0; return res;}

 

3.2 slabs_init

[cpp:collapse] + expand sourceview plaincopyprint?

1. /** 
2.  * Determines the chunk sizes and initializes the slab class descriptors 
3.  * accordingly. 
4.  * slabs 初始化   1 如果需要预先分配的，那就预先分配内存 2 
5.  * 对每个类别的slab，初始化该slab中每个item大小，item个数  3 
6.  * 调用slabs_preallocate 预先分配slabs(给每个层次创建一个page)  
7.  */  
8. void slabs_init(const size_t limit, const double factor, const bool prealloc) {  
9.     int i = POWER_SMALLEST - 1;  
10.     unsigned int size = sizeof(item) + settings.chunk_size;  
11.   
12.     mem_limit = limit;  
13.   
14.     if (prealloc) {  
15.         //预先分配内存，并把开始地址和可使用空间大小记录  
16.         /* Allocate everything in a big chunk with malloc */  
17.         mem_base = malloc(mem_limit);  
18.         if (mem_base != NULL) {  
19.             mem_current = mem_base;  
20.             mem_avail = mem_limit;  
21.         } else {  
22.             fprintf(stderr, "Warning: Failed to allocate requested memory in"  
23.                     " one large chunk./nWill allocate in smaller chunks/n");  
24.         }  
25.     }  
26.   
27.     memset(slabclass, 0, sizeof(slabclass));  
28.   
29.     while (++i < POWER_LARGEST && size <= settings.item_size_max / factor) {  
30.         /* Make sure items are always n-byte aligned */  
31.         //对齐   
32.         if (size % CHUNK_ALIGN_BYTES)  
33.             size += CHUNK_ALIGN_BYTES - (size % CHUNK_ALIGN_BYTES);  
34.         //每个item大小以及item个数   
35.         slabclass[i].size = size;  
36.         slabclass[i].perslab = settings.item_size_max / slabclass[i].size;  
37.         size *= factor;  
38.         if (settings.verbose > 1) {  
39.             fprintf(stderr, "slab class %3d: chunk size %9u perslab %7u/n",  
40.                     i, slabclass[i].size, slabclass[i].perslab);  
41.         }  
42.     }  
43.     //最后一个slab   
44.     power_largest = i;  
45.     slabclass[power_largest].size = settings.item_size_max;  
46.     slabclass[power_largest].perslab = 1;  
47.     if (settings.verbose > 1) {  
48.         fprintf(stderr, "slab class %3d: chunk size %9u perslab %7u/n",  
49.                 i, slabclass[i].size, slabclass[i].perslab);  
50.     }  
51.   
52.     /* for the test suite:  faking of how much we've already malloc'd */  
53.     {  
54.         char *t_initial_malloc = getenv("T_MEMD_INITIAL_MALLOC");  
55.         if (t_initial_malloc) {  
56.             mem_malloced = (size_t)atol(t_initial_malloc);  
57.         }  
58.   
59.     }  
60.   
61. #ifndef DONT_PREALLOC_SLABS  
62.     {  
63.         char *pre_alloc = getenv("T_MEMD_SLABS_ALLOC");  
64.   
65.         if (pre_alloc == NULL || atoi(pre_alloc) != 0) {  
66.             slabs_preallocate(power_largest);  
67.         }  
68.     }  
69. #endif   
70. }  

/** * Determines the chunk sizes and initializes the slab class descriptors * accordingly. * slabs 初始化 1 如果需要预先分配的，那就预先分配内存 2 * 对每个类别的slab，初始化该slab中每个item大小，item个数 3 * 调用slabs_preallocate 预先分配slabs(给每个层次创建一个page) */void slabs_init(const size_t limit, const double factor, const bool prealloc) { int i = POWER_SMALLEST - 1; unsigned int size = sizeof(item) + settings.chunk_size; mem_limit = limit; if (prealloc) { //预先分配内存，并把开始地址和可使用空间大小记录 /* Allocate everything in a big chunk with malloc */ mem_base = malloc(mem_limit); if (mem_base != NULL) { mem_current = mem_base; mem_avail = mem_limit; } else { fprintf(stderr, "Warning: Failed to allocate requested memory in" " one large chunk./nWill allocate in smaller chunks/n"); } } memset(slabclass, 0, sizeof(slabclass)); while (++i < POWER_LARGEST && size <= settings.item_size_max / factor) { /* Make sure items are always n-byte aligned */ //对齐 if (size % CHUNK_ALIGN_BYTES) size += CHUNK_ALIGN_BYTES - (size % CHUNK_ALIGN_BYTES); //每个item大小以及item个数 slabclass[i].size = size; slabclass[i].perslab = settings.item_size_max / slabclass[i].size; size *= factor; if (settings.verbose > 1) { fprintf(stderr, "slab class %3d: chunk size %9u perslab %7u/n", i, slabclass[i].size, slabclass[i].perslab); } } //最后一个slab power_largest = i; slabclass[power_largest].size = settings.item_size_max; slabclass[power_largest].perslab = 1; if (settings.verbose > 1) { fprintf(stderr, "slab class %3d: chunk size %9u perslab %7u/n", i, slabclass[i].size, slabclass[i].perslab); } /* for the test suite: faking of how much we've already malloc'd */ { char *t_initial_malloc = getenv("T_MEMD_INITIAL_MALLOC"); if (t_initial_malloc) { mem_malloced = (size_t)atol(t_initial_malloc); } }#ifndef DONT_PREALLOC_SLABS { char *pre_alloc = getenv("T_MEMD_SLABS_ALLOC"); if (pre_alloc == NULL || atoi(pre_alloc) != 0) { slabs_preallocate(power_largest); } }#endif}

 

3.3 slabs_preallocate

[cpp:collapse] + expand sourceview plaincopyprint?

1. //对于每个层次的slab，预先分配一个page   
2. static void slabs_preallocate (const unsigned int maxslabs) {  
3.     int i;  
4.     unsigned int prealloc = 0;  
5.   
6.     /* pre-allocate a 1MB slab in every size class so people don't get 
7.        confused by non-intuitive "SERVER_ERROR out of memory" 
8.        messages.  this is the most common question on the mailing 
9.        list.  if you really don't want this, you can rebuild without 
10.        these three lines.  */  
11.   
12.     for (i = POWER_SMALLEST; i <= POWER_LARGEST; i++) {  
13.         if (++prealloc > maxslabs)  
14.             return;  
15.         do_slabs_newslab(i);  
16.     }  
17.   
18. }  

//对于每个层次的slab，预先分配一个pagestatic void slabs_preallocate (const unsigned int maxslabs) { int i; unsigned int prealloc = 0; /* pre-allocate a 1MB slab in every size class so people don't get confused by non-intuitive "SERVER_ERROR out of memory" messages. this is the most common question on the mailing list. if you really don't want this, you can rebuild without these three lines. */ for (i = POWER_SMALLEST; i <= POWER_LARGEST; i++) { if (++prealloc > maxslabs) return; do_slabs_newslab(i); }}

 

3.4  grow_slab_list

 

[cpp:collapse] + expand sourceview plaincopyprint?

1. /确保page指针空间有空闲空间。如果可使用的空间满了，那么扩大成原来的两倍  
2. static int grow_slab_list (const unsigned int id) {  
3.     slabclass_t *p = &slabclass[id];  
4.     if (p->slabs == p->list_size) {  
5.         size_t new_size =  (p->list_size != 0) ? p->list_size * 2 : 16;  
6.         void *new_list = realloc(p->slab_list, new_size * sizeof(void *));  
7.         if (new_list == 0) return 0;  
8.         p->list_size = new_size;  
9.         p->slab_list = new_list;  
10.     }  
11.     return 1;  
12. }  

/确保page指针空间有空闲空间。如果可使用的空间满了，那么扩大成原来的两倍static int grow_slab_list (const unsigned int id) { slabclass_t *p = &slabclass[id]; if (p->slabs == p->list_size) { size_t new_size = (p->list_size != 0) ? p->list_size * 2 : 16; void *new_list = realloc(p->slab_list, new_size * sizeof(void *)); if (new_list == 0) return 0; p->list_size = new_size; p->slab_list = new_list; } return 1;}

 

 

3.5 do_slabs_newslab

[cpp:collapse] + expand sourceview plaincopyprint?

1. //分配一个类别id为id的page   
2. //1 分配空间 2 最后page赋值，以及该page空闲item个数  3 page数目++  
3. //，把page指针指向当前page    
4. static int do_slabs_newslab(const unsigned int id) {  
5.     slabclass_t *p = &slabclass[id];  
6.     int len = p->size * p->perslab;  
7.     char *ptr;  
8.     // 1有内存限制并且超过了限制  2 并且确认page指针空间失败 3 分配一个page的内存空间失败  
9.     if ((mem_limit && mem_malloced + len > mem_limit && p->slabs > 0) ||  
10.         (grow_slab_list(id) == 0) ||  
11.         ((ptr = memory_allocate((size_t)len)) == 0)) {  
12.   
13.         MEMCACHED_SLABS_SLABCLASS_ALLOCATE_FAILED(id);  
14.         return 0;  
15.     }  
16.       
17.     memset(ptr, 0, (size_t)len);  
18.     p->end_page_ptr = ptr;  
19.     p->end_page_free = p->perslab;  
20.   
21.     p->slab_list[p->slabs++] = ptr;  
22.     mem_malloced += len;  
23.     MEMCACHED_SLABS_SLABCLASS_ALLOCATE(id);  
24.   
25.     return 1;  
26. }  

//分配一个类别id为id的page//1 分配空间 2 最后page赋值，以及该page空闲item个数 3 page数目++//，把page指针指向当前page static int do_slabs_newslab(const unsigned int id) { slabclass_t *p = &slabclass[id]; int len = p->size * p->perslab; char *ptr; // 1有内存限制并且超过了限制 2 并且确认page指针空间失败 3 分配一个page的内存空间失败 if ((mem_limit && mem_malloced + len > mem_limit && p->slabs > 0) || (grow_slab_list(id) == 0) || ((ptr = memory_allocate((size_t)len)) == 0)) { MEMCACHED_SLABS_SLABCLASS_ALLOCATE_FAILED(id); return 0; } memset(ptr, 0, (size_t)len); p->end_page_ptr = ptr; p->end_page_free = p->perslab; p->slab_list[p->slabs++] = ptr; mem_malloced += len; MEMCACHED_SLABS_SLABCLASS_ALLOCATE(id); return 1;}

 

 

3.6  do_slabs_alloc

[cpp:collapse] + expand sourceview plaincopyprint?

1. //根据id，返回对应类别的一个item空间   
2. //按照下面优先级进行分配： 1 首先从空闲的空间(回收的) 2 从最后的page中获取 3  
3. //新分配一个page     
4. static void *do_slabs_alloc(const size_t size, unsigned int id) {  
5.     slabclass_t *p;  
6.     void *ret = NULL;  
7.   
8.     if (id < POWER_SMALLEST || id > power_largest) {  
9.         MEMCACHED_SLABS_ALLOCATE_FAILED(size, 0);  
10.         return NULL;  
11.     }  
12.   
13.     p = &slabclass[id];  
14.     assert(p->sl_curr == 0 || ((item *)p->slots[p->sl_curr - 1])->slabs_clsid == 0);  
15.   
16. #ifdef USE_SYSTEM_MALLOC   
17.     if (mem_limit && mem_malloced + size > mem_limit) {  
18.         MEMCACHED_SLABS_ALLOCATE_FAILED(size, id);  
19.         return 0;  
20.     }  
21.     mem_malloced += size;  
22.     ret = malloc(size);  
23.     MEMCACHED_SLABS_ALLOCATE(size, id, 0, ret);  
24.     return ret;  
25. #endif   
26.   
27.     /* fail unless we have space at the end of a recently allocated page, 
28.        we have something on our freelist, or we could allocate a new page */  
29.     // 1 最后面的页面有空间 2 空闲的地方有空间 3 分配一个新的页面  
30.     if (! (p->end_page_ptr != 0 || p->sl_curr != 0 ||  
31.            do_slabs_newslab(id) != 0)) {  
32.         /* We don't have more memory available */  
33.         ret = NULL;  
34.     } else if (p->sl_curr != 0) {  
35.         /* return off our freelist */  
36.         //从空闲(回收)地方分配   
37.         ret = p->slots[--p->sl_curr];  
38.     } else {  
39.         /* if we recently allocated a whole page, return from that */  
40.         assert(p->end_page_ptr != NULL);  
41.         ret = p->end_page_ptr;  
42.         if (--p->end_page_free != 0) {  
43.             p->end_page_ptr = ((caddr_t)p->end_page_ptr) + p->size;  
44.         } else {  
45.             p->end_page_ptr = 0;  
46.         }  
47.     }  
48.   
49.     if (ret) {  
50.         p->requested += size;  
51.         MEMCACHED_SLABS_ALLOCATE(size, id, p->size, ret);  
52.     } else {  
53.         MEMCACHED_SLABS_ALLOCATE_FAILED(size, id);  
54.     }  
55.   
56.     return ret;  
57. }  

//根据id，返回对应类别的一个item空间//按照下面优先级进行分配： 1 首先从空闲的空间(回收的) 2 从最后的page中获取 3//新分配一个page static void *do_slabs_alloc(const size_t size, unsigned int id) { slabclass_t *p; void *ret = NULL; if (id < POWER_SMALLEST || id > power_largest) { MEMCACHED_SLABS_ALLOCATE_FAILED(size, 0); return NULL; } p = &slabclass[id]; assert(p->sl_curr == 0 || ((item *)p->slots[p->sl_curr - 1])->slabs_clsid == 0);#ifdef USE_SYSTEM_MALLOC if (mem_limit && mem_malloced + size > mem_limit) { MEMCACHED_SLABS_ALLOCATE_FAILED(size, id); return 0; } mem_malloced += size; ret = malloc(size); MEMCACHED_SLABS_ALLOCATE(size, id, 0, ret); return ret;#endif /* fail unless we have space at the end of a recently allocated page, we have something on our freelist, or we could allocate a new page */ // 1 最后面的页面有空间 2 空闲的地方有空间 3 分配一个新的页面 if (! (p->end_page_ptr != 0 || p->sl_curr != 0 || do_slabs_newslab(id) != 0)) { /* We don't have more memory available */ ret = NULL; } else if (p->sl_curr != 0) { /* return off our freelist */ //从空闲(回收)地方分配 ret = p->slots[--p->sl_curr]; } else { /* if we recently allocated a whole page, return from that */ assert(p->end_page_ptr != NULL); ret = p->end_page_ptr; if (--p->end_page_free != 0) { p->end_page_ptr = ((caddr_t)p->end_page_ptr) + p->size; } else { p->end_page_ptr = 0; } } if (ret) { p->requested += size; MEMCACHED_SLABS_ALLOCATE(size, id, p->size, ret); } else { MEMCACHED_SLABS_ALLOCATE_FAILED(size, id); } return ret;}

 

3.7 do_slabs_free

[c-sharp] view plaincopyprint?

1. //释放一个item空间   
2. //把释放的空间放到空闲的slot中，不过有可能出现空闲slot不够的情况，对slot进行扩大  
3. static void do_slabs_free(void *ptr, const size_t size, unsigned int id) {  
4.     slabclass_t *p;  
5.   
6.     assert(((item *)ptr)->slabs_clsid == 0);  
7.     assert(id >= POWER_SMALLEST && id <= power_largest);  
8.     if (id < POWER_SMALLEST || id > power_largest)  
9.         return;  
10.   
11.     MEMCACHED_SLABS_FREE(size, id, ptr);  
12.     p = &slabclass[id];  
13.  
14. #ifdef USE_SYSTEM_MALLOC   
15.     mem_malloced -= size;  
16.     free(ptr);  
17.     return;  
18. #endif   
19.     //空闲slot空间不够，进行扩大   
20.     if (p->sl_curr == p->sl_total) { /* need more space on the free list */  
21.         int new_size = (p->sl_total != 0) ? p->sl_total * 2 : 16;  /* 16 is arbitrary */  
22.         void **new_slots = realloc(p->slots, new_size * sizeof(void *));  
23.         if (new_slots == 0)  
24.             return;  
25.         p->slots = new_slots;  
26.         p->sl_total = new_size;  
27.     }  
28.     p->slots[p->sl_curr++] = ptr;  
29.     p->requested -= size;  
30.     return;  
31. }  

//释放一个item空间//把释放的空间放到空闲的slot中，不过有可能出现空闲slot不够的情况，对slot进行扩大static void do_slabs_free(void *ptr, const size_t size, unsigned int id) { slabclass_t *p; assert(((item *)ptr)->slabs_clsid == 0); assert(id >= POWER_SMALLEST && id <= power_largest); if (id < POWER_SMALLEST || id > power_largest) return; MEMCACHED_SLABS_FREE(size, id, ptr); p = &slabclass[id];#ifdef USE_SYSTEM_MALLOC mem_malloced -= size; free(ptr); return;#endif //空闲slot空间不够，进行扩大 if (p->sl_curr == p->sl_total) { /* need more space on the free list */ int new_size = (p->sl_total != 0) ? p->sl_total * 2 : 16; /* 16 is arbitrary */ void **new_slots = realloc(p->slots, new_size * sizeof(void *)); if (new_slots == 0) return; p->slots = new_slots; p->sl_total = new_size; } p->slots[p->sl_curr++] = ptr; p->requested -= size; return;}

 

四 总结

 

优点：  通过不同层次的item，以及空闲item维护，可以降低请求过程中内存的分配和释放，提高效率

 

缺点： 1 每次使用的item可能大于时间需求空间量，导致内存浪费。

 

 

 

五 参考

 

http://blogold.chinaunix.net/u1/56406/showart_2331017.html     memcache探索之slabs

 

http://tech.idv2.com/2008/07/11/memcached-002/    理解memcache内存机制