glusterfs 内存管理方式

9AMC

　　glusterfs中的内存管理方式：
　　首先来看看glusterfs的内存管理结构吧：



1 struct mem_pool {
2         struct list_head  list;
3         int               hot_count;
4         int               cold_count;
5         gf_lock_t         lock;
6         unsigned long     padded_sizeof_type;
7         void             *pool;
8         void             *pool_end;
9         int               real_sizeof_type;
10         uint64_t          alloc_count;
11         uint64_t          pool_misses;
12         int               max_alloc;
13         int               curr_stdalloc;
14         int               max_stdalloc;
15         char             *name;
16         struct list_head  global_list;
17 };
　　管理结构的信息量很简单，核心的数据项是list，每个要分配的内存块被一个双向链表串连起来管理。
　　接下来是创建内存池的接口：



1 struct mem_pool *
2 mem_pool_new_fn (unsigned long sizeof_type,
3                  unsigned long count, char *name)
4 {
5         struct mem_pool  *mem_pool = NULL;
6         unsigned long     padded_sizeof_type = 0;
7         void             *pool = NULL;
8         int               i = 0;
9         int               ret = 0;
10         struct list_head *list = NULL;
11         glusterfs_ctx_t  *ctx = NULL;
12
13         if (!sizeof_type || !count) {
14                 gf_log_callingfn ("mem-pool", GF_LOG_ERROR, "invalid argument");
15                 return NULL;
16         }
17         padded_sizeof_type = sizeof_type + GF_MEM_POOL_PAD_BOUNDARY;
18
19         mem_pool = GF_CALLOC (sizeof (*mem_pool), 1, gf_common_mt_mem_pool);
20         if (!mem_pool)
21                 return NULL;
22
23         ret = gf_asprintf (&mem_pool->name, "%s:%s", THIS->name, name);
24         if (ret < 0)
25                 return NULL;
26
27         if (!mem_pool->name) {
28                 GF_FREE (mem_pool);
29                 return NULL;
30         }
31
32         LOCK_INIT (&mem_pool->lock);
33         INIT_LIST_HEAD (&mem_pool->list);
34         INIT_LIST_HEAD (&mem_pool->global_list);
35
36         mem_pool->padded_sizeof_type = padded_sizeof_type;
37         mem_pool->cold_count = count;
38         mem_pool->real_sizeof_type = sizeof_type;
39
40         pool = GF_CALLOC (count, padded_sizeof_type, gf_common_mt_long);
41         if (!pool) {
42                 GF_FREE (mem_pool->name);
43                 GF_FREE (mem_pool);
44                 return NULL;
45         }
46
47         for (i = 0; i < count; i++) {
48                 list = pool + (i * (padded_sizeof_type));
49                 INIT_LIST_HEAD (list);
50                 list_add_tail (list, &mem_pool->list);
51         }
52
53         mem_pool->pool = pool;
54         mem_pool->pool_end = pool + (count * (padded_sizeof_type));
55
56         /* add this pool to the global list */
57         ctx = THIS->ctx;
58         if (!ctx)
59                 goto out;
60
61         list_add (&mem_pool->global_list, &ctx->mempool_list);
62
63 out:
64         return mem_pool;
65 }
　　在第19行中申请了一个mem_pool内存管理结构，在初始化这个结构体后，40行申请了真正要使用的内存pool并把用mem_pool->list链表串起来。之后再记录内存池的开始和结束地址（53-54），再把这个结构加入全局管理。
　　再看一下申请后的内存是如何使用的呢？



1 void *
2 mem_get (struct mem_pool *mem_pool)
3 {
4         struct list_head *list = NULL;
5         void             *ptr = NULL;
6         int             *in_use = NULL;
7         struct mem_pool **pool_ptr = NULL;
8
9         if (!mem_pool) {
10                 gf_log_callingfn ("mem-pool", GF_LOG_ERROR, "invalid argument");
11                 return NULL;
12         }
13
14         LOCK (&mem_pool->lock);
15         {
16                 mem_pool->alloc_count++;
17                 if (mem_pool->cold_count) {
18                         list = mem_pool->list.next;
19                         list_del (list);
20
21                         mem_pool->hot_count++;
22                         mem_pool->cold_count--;
23
24                         if (mem_pool->max_alloc < mem_pool->hot_count)
25                                 mem_pool->max_alloc = mem_pool->hot_count;
26
27                         ptr = list;
28                         in_use = (ptr + GF_MEM_POOL_LIST_BOUNDARY +
29                                   GF_MEM_POOL_PTR);
30                         *in_use = 1;
31
32                         goto fwd_addr_out;
33                 }
34
35                 /* This is a problem area. If we've run out of
36                  * chunks in our slab above, we need to allocate
37                  * enough memory to service this request.
38                  * The problem is, these individual chunks will fail
39                  * the first address range check in __is_member. Now, since
40                  * we're not allocating a full second slab, we wont have
41                  * enough info perform the range check in __is_member.
42                  *
43                  * I am working around this by performing a regular allocation
44                  * , just the way the caller would've done when not using the
45                  * mem-pool. That also means, we're not padding the size with
46                  * the list_head structure because, this will not be added to
47                  * the list of chunks that belong to the mem-pool allocated
48                  * initially.
49                  *
50                  * This is the best we can do without adding functionality for
51                  * managing multiple slabs. That does not interest us at present
52                  * because it is too much work knowing that a better slab
53                  * allocator is coming RSN.
54                  */
55                 mem_pool->pool_misses++;
56                 mem_pool->curr_stdalloc++;
57                 if (mem_pool->max_stdalloc < mem_pool->curr_stdalloc)
58                         mem_pool->max_stdalloc = mem_pool->curr_stdalloc;
59                 ptr = GF_CALLOC (1, mem_pool->padded_sizeof_type,
60                                  gf_common_mt_mem_pool);
61                 gf_log_callingfn ("mem-pool", GF_LOG_DEBUG, "Mem pool is full. "
62                                   "Callocing mem");
63
64                 /* Memory coming from the heap need not be transformed from a
65                  * chunkhead to a usable pointer since it is not coming from
66                  * the pool.
67                  */
68         }
69 fwd_addr_out:
70         pool_ptr = mem_pool_from_ptr (ptr);
71         *pool_ptr = (struct mem_pool *)mem_pool; //保存分配者地址
72         ptr = mem_pool_chunkhead2ptr (ptr);
73         UNLOCK (&mem_pool->lock);
74
75         return ptr;
76 }
　　从17行到33行可以看出，当需要内存时，glusterfs从mem_pool->list中分配内存。关键是：当内存不足时，mem_pool如何处理呢？55-63行处理这个问题：当内存不足时，它向系统申请了内存，并处理了内存的管理信息后，直接将内存返回给调用者。
　　最后看看内存的释放过程：



1 void
2 mem_put (void *ptr)
3 {
4         struct list_head *list = NULL;
5         int    *in_use = NULL;
6         void   *head = NULL;
7         struct mem_pool **tmp = NULL;
8         struct mem_pool *pool = NULL;
9
10         if (!ptr) {
11                 gf_log_callingfn ("mem-pool", GF_LOG_ERROR, "invalid argument");
12                 return;
13         }
14
15         list = head = mem_pool_ptr2chunkhead (ptr);
16         tmp = mem_pool_from_ptr (head); //取出分配者地址
17         if (!tmp) {
18                 gf_log_callingfn ("mem-pool", GF_LOG_ERROR,
19                                   "ptr header is corrupted");
20                 return;
21         }
22
23         pool = *tmp;
24         if (!pool) {
25                 gf_log_callingfn ("mem-pool", GF_LOG_ERROR,
26                                   "mem-pool ptr is NULL");
27                 return;
28         }
29         LOCK (&pool->lock);
30         {
31
32                 switch (__is_member (pool, ptr))
33                 {
34                 case 1:
35                         in_use = (head + GF_MEM_POOL_LIST_BOUNDARY +
36                                   GF_MEM_POOL_PTR);
37                         if (!is_mem_chunk_in_use(in_use)) {
38                                 gf_log_callingfn ("mem-pool", GF_LOG_CRITICAL,
39                                                   "mem_put called on freed ptr %p of mem "
40                                                   "pool %p", ptr, pool);
41                                 break;
42                         }
43                         pool->hot_count--;
44                         pool->cold_count++;
45                         *in_use = 0;
46                         list_add (list, &pool->list);
47                         break;
48                 case -1:
49                         /* For some reason, the address given is within
50                          * the address range of the mem-pool but does not align
51                          * with the expected start of a chunk that includes
52                          * the list headers also. Sounds like a problem in
53                          * layers of clouds up above us. ;)
54                          */
55                         abort ();
56                         break;
57                 case 0:
58                         /* The address is outside the range of the mem-pool. We
59                          * assume here that this address was allocated at a
60                          * point when the mem-pool was out of chunks in mem_get
61                          * or the programmer has made a mistake by calling the
62                          * wrong de-allocation interface. We do
63                          * not have enough info to distinguish between the two
64                          * situations.
65                          */
66                         pool->curr_stdalloc--;
67                         GF_FREE (list);
68                         break;
69                 default:
70                         /* log error */
71                         break;
72                 }
73         }
74         UNLOCK (&pool->lock);
75 }
　　在switch语句中，在case 1中处理了内存池分配的过程。在case 0中处理内存不足的情况，从这里看出，glusterfs直接将内存释放了，正好与分配的过程完美的结合。