glusterfs中的内存管理方式：
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直接将内存释放了，正好与分配的过程完美的结合。
glusterfs 内存管理方式,布布扣,bubuko.com
时间： 2024-12-20 10:47:06