内存池的原理剖析与代码实现

一、内存池的作用

降低内存碎片化、提高内存使用率

我们在写c/c++程序时，会经常使用malloc/new来申请使用堆上的空间，当我们一个程序，因为需要频繁的去申请使用小块内存，在程序运行过程中可能会产生很多不连续的小块内存；
当程序运行一定时间后，这种情况将会加剧，如果此时程序需要一大块内存空间，就有可能没有一整块连续的大内存块供其使用，从而导致难以定位的问题。

二、其思想及工作原理

当内存池这个组件启动时，它会预先分配一块合适的内存备用，当程序使用内存池申请内存时，内存池会从预先申请好的内存块中给其分配，当程序释放这个内存后，内存池将其回收，后续复用或者整体释放，使得内存使用效率得到提升，避免大量内存碎片的产出生。

三、主要结构体设计

1、整体思路设计：
预先申请固定大小的内存块，当这个内存块被分配完了之后，新增同样（大块就随机了）的一块内存，用链表的方式将它们组织起来，继续供程序使用；当链表中某一整块内存所分配出去的空间全部释放后，则内存池就可以将这一整块内存整体释放（至少是2k，避免出现内存碎片）。
主要分为两部分，申请大块内存的处理和小块内存的处理；
本内存池将以2k为分界线，大于2k视为大内存块，小于2k视为小内存块；
整体的内存池结构图如下：

2、主要结构体设计：

结构体之间的关系如下图所示

struct mp_large_s 	//大块内存的节点信息
{
	struct mp_large_s *next;	//指向后续大块内存
	void *alloc;				//新申请的大块内存地址
};

struct mp_node_s 	//小内存块的节点信息
{
	unsigned char *last;		//整块内存中，已经使用的最后位置
	unsigned char *end;			//整块内存的最后位置
	
	struct mp_node_s *next;		//指向后续申请整块内存（供小快内存申请使用）
	size_t failed;				//标志位
};

struct mp_pool_s 	//内存池结构
{
	size_t max;					//内存池的界限，最大能分配max大

	struct mp_node_s *current;	//小内存块指针
	struct mp_large_s *large;	//大块内存指针

	struct mp_node_s head[0];	//内存池的头节点

};

3、内存池的工作流程：

四、代码实现

#include 
#include 
#include 
#include 

#include 



#define MP_ALIGNMENT       		32
#define MP_PAGE_SIZE			4096
#define MP_MAX_ALLOC_FROM_POOL	(MP_PAGE_SIZE-1)

#define mp_align(n, alignment) (((n)+(alignment-1)) & ~(alignment-1))
#define mp_align_ptr(p, alignment) (void *)((((size_t)p)+(alignment-1)) & ~(alignment-1))





struct mp_large_s 	//大块内存的节点信息
{
	struct mp_large_s *next;	//指向后续大块内存
	void *alloc;				//新申请的大块内存地址
};

struct mp_node_s 	//小内存块的节点信息
{
	unsigned char *last;		//整块内存中，已经使用的最后位置
	unsigned char *end;			//整块内存的最后位置
	
	struct mp_node_s *next;		//指向后续申请整块内存（供小快内存申请使用）
	size_t failed;				//标志位，1说明
};

struct mp_pool_s 	//内存池结构
{
	size_t max;					//内存池的界限，最大能分配max大

	struct mp_node_s *current;	//小内存块指针
	struct mp_large_s *large;	//大块内存指针

	struct mp_node_s head[0];	//内存池的头节点

};

struct mp_pool_s *mp_create_pool(size_t size);
void mp_destory_pool(struct mp_pool_s *pool);
void *mp_alloc(struct mp_pool_s *pool, size_t size);
void *mp_nalloc(struct mp_pool_s *pool, size_t size);
void *mp_calloc(struct mp_pool_s *pool, size_t size);
void mp_free(struct mp_pool_s *pool, void *p);


struct mp_pool_s *mp_create_pool(size_t size) {

	struct mp_pool_s *p;
	int ret = posix_memalign((void **)&p, MP_ALIGNMENT, size + sizeof(struct mp_pool_s) + sizeof(struct mp_node_s));
	if (ret) {
		return NULL;
	}
	
	p->max = (size < MP_MAX_ALLOC_FROM_POOL) ? size : MP_MAX_ALLOC_FROM_POOL;
	p->current = p->head;
	p->large = NULL;

	p->head->last = (unsigned char *)p + sizeof(struct mp_pool_s) + sizeof(struct mp_node_s);
	p->head->end = p->head->last + size;

	p->head->failed = 0;

	return p;

}

void mp_destory_pool(struct mp_pool_s *pool) {

	struct mp_node_s *h, *n;
	struct mp_large_s *l;

	for (l = pool->large; l; l = l->next) {
		if (l->alloc) {
			free(l->alloc);
		}
	}

	h = pool->head->next;

	while (h) {
		n = h->next;
		free(h);
		h = n;
	}

	free(pool);

}

void mp_reset_pool(struct mp_pool_s *pool) {

	struct mp_node_s *h;
	struct mp_large_s *l;

	for (l = pool->large; l; l = l->next) {
		if (l->alloc) {
			free(l->alloc);
		}
	}

	pool->large = NULL;

	for (h = pool->head; h; h = h->next) {
		h->last = (unsigned char *)h + sizeof(struct mp_node_s);
	}

}

static void *mp_alloc_block(struct mp_pool_s *pool, size_t size) {

	unsigned char *m;
	struct mp_node_s *h = pool->head;
	size_t psize = (size_t)(h->end - (unsigned char *)h);
	
	int ret = posix_memalign((void **)&m, MP_ALIGNMENT, psize);
	if (ret) return NULL;

	struct mp_node_s *p, *new_node, *current;
	new_node = (struct mp_node_s*)m;

	new_node->end = m + psize;
	new_node->next = NULL;
	new_node->failed = 0;

	m += sizeof(struct mp_node_s);
	m = mp_align_ptr(m, MP_ALIGNMENT);
	new_node->last = m + size;

	current = pool->current;

	for (p = current; p->next; p = p->next) {
		if (p->failed++ > 4) {
			current = p->next;
		}
	}
	p->next = new_node;

	pool->current = current ? current : new_node;

	return m;

}

static void *mp_alloc_large(struct mp_pool_s *pool, size_t size) {

	void *p = malloc(size);
	if (p == NULL) return NULL;

	size_t n = 0;
	struct mp_large_s *large;
	for (large = pool->large; large; large = large->next) {
		if (large->alloc == NULL) {
			large->alloc = p;
			return p;
		}
		if (n ++ > 3) break;
	}

	large = mp_alloc(pool, sizeof(struct mp_large_s));
	if (large == NULL) {
		free(p);
		return NULL;
	}

	large->alloc = p;
	large->next = pool->large;
	pool->large = large;

	return p;
}

void *mp_memalign(struct mp_pool_s *pool, size_t size, size_t alignment) {

	void *p;
	
	int ret = posix_memalign(&p, alignment, size);
	if (ret) {
		return NULL;
	}

	struct mp_large_s *large = mp_alloc(pool, sizeof(struct mp_large_s));
	if (large == NULL) {
		free(p);
		return NULL;
	}

	large->alloc = p;
	large->next = pool->large;
	pool->large = large;

	return p;
}




void *mp_alloc(struct mp_pool_s *pool, size_t size) {

	unsigned char *m;
	struct mp_node_s *p;

	if (size <= pool->max) {

		p = pool->current;

		do {
			
			m = mp_align_ptr(p->last, MP_ALIGNMENT);
			if ((size_t)(p->end - m) >= size) {
				p->last = m + size;
				return m;
			}
			p = p->next;
		} while (p);

		return mp_alloc_block(pool, size);
	}

	return mp_alloc_large(pool, size);
	
}


void *mp_nalloc(struct mp_pool_s *pool, size_t size) {

	unsigned char *m;
	struct mp_node_s *p;

	if (size <= pool->max) {
		p = pool->current;

		do {
			m = p->last;
			if ((size_t)(p->end - m) >= size) {
				p->last = m+size;
				return m;
			}
			p = p->next;
		} while (p);

		return mp_alloc_block(pool, size);
	}

	return mp_alloc_large(pool, size);
	
}

void *mp_calloc(struct mp_pool_s *pool, size_t size) {

	void *p = mp_alloc(pool, size);
	if (p) {
		memset(p, 0, size);
	}

	return p;
	
}

void mp_free(struct mp_pool_s *pool, void *p) {

	struct mp_large_s *l;
	for (l = pool->large; l; l = l->next) {
		if (p == l->alloc) {
			free(l->alloc);
			l->alloc = NULL;

			return ;
		}
	}
	
}


int main(int argc, char *argv[]) {

	int size = 1 << 12;

	struct mp_pool_s *p = mp_create_pool(size);

	int i = 0;
	for (i = 0;i < 10;i ++) {

		void *mp = mp_alloc(p, 512);
//		mp_free(mp);
	}

	//printf("mp_create_pool: %ld\n", p->max);
	printf("mp_align(123, 32): %d, mp_align(17, 32): %d\n", mp_align(24, 32), mp_align(17, 32));
	//printf("mp_align_ptr(p->current, 32): %lx, p->current: %lx, mp_align(p->large, 32): %lx, p->large: %lx\n", mp_align_ptr(p->current, 32), p->current, mp_align_ptr(p->large, 32), p->large);

	int j = 0;
	for (i = 0;i < 5;i ++) {

		char *pp = mp_calloc(p, 32);
		for (j = 0;j < 32;j ++) {
			if (pp[j]) {
				printf("calloc wrong\n");
			}
			printf("calloc success\n");
		}
	}

	//printf("mp_reset_pool\n");

	for (i = 0;i < 5;i ++) {
		void *l = mp_alloc(p, 8192);
		mp_free(p, l);
	}

	mp_reset_pool(p);

	//printf("mp_destory_pool\n");
	for (i = 0;i < 58;i ++) {
		mp_alloc(p, 256);
	}

	mp_destory_pool(p);

	return 0;

}

代码来源：零声教育-king老师