cache_alloc库实现

版权声明： https://blog.csdn.net/qq_28710983/article/details/83064383

注意：主要使用c链表功能实现，链表主要是通过一个指针保存实际数据存放的位置，指针里面有指向下一个地址的一个指针，循环嵌套指向下一个地址，链表node其实和内存缓存区是两个部分。用node来把内存缓冲区做一个表链接起来使用而已

1、cache_alloc是c库，c++调用需要extern “C”

#ifdef __cplusplus
extern "C" {
#endif
	struct cache_allocer* create_cache_allocer(int capacity, int elem_size);
	void destroy_cache_allocer(struct cache_allocer* allocer);

	void* cache_alloc(struct cache_allocer* allocer, int elem_size);
	void cache_free(struct cache_allocer* allocer, void* mem);

#ifdef __cplusplus
}
#endif

create_cache_allocer函数：用户创建一个内存缓存区

destroy_cache_allocer函数：用于销毁整个内存缓存区

cache_alloc函数：用户分配内存空闲缓冲区

cache_free函数：回收内存缓冲区

struct node {
	struct node* next;
};

struct cache_allocer {
	unsigned char* cache_mem;   
	int capacity;
	struct node* free_list;  
	int elem_size;
};

struct cache_allocer* create_cache_allocer(int capacity, int elem_size) {
	struct cache_allocer* allocer = malloc(sizeof(struct cache_allocer));
	memset(allocer, 0, sizeof(struct cache_allocer));

	elem_size = (elem_size < sizeof(struct node)) ? sizeof(struct node) : elem_size;
	allocer->capacity = capacity;
	allocer->elem_size = elem_size;
	allocer->cache_mem = malloc(capacity * elem_size);
	memset(allocer->cache_mem, 0, capacity * elem_size);
	allocer->free_list = NULL;
	for (int i = 0; i < capacity; i++) {
		struct node*walk = (struct node*)(allocer->cache_mem + i * elem_size);
		walk->next = allocer->free_list;
		allocer->free_list = walk;
	}

	return allocer;
}

struct cache_allocer* allocer = malloc(sizeof(struct cache_allocer));创建并返回一个cache_allocer结构体指针

allocer->cache_mem = malloc(capacity * elem_size);分配内存区域

for循环通过结构体里面struct node* free_list把所有的allocer->cache_mem分段链接起来，把当前这块的next指向free_list，然后当前free_list指向这块内存，就把整个内存区都链起来了

destroy_cache_allocer函数用于把这个内存缓存区销毁掉

void destroy_cache_allocer(struct cache_allocer* allocer) {
	if (allocer->cache_mem != NULL) {
		free(allocer->cache_mem);
	}

	free(allocer);
}

当有需要使用缓存区的时候，从缓存区里面把allocer->free_list分配给用户使用，然后把free_list指向free_list->next，

void* cache_alloc(struct cache_allocer* allocer, int elem_size) {
	if (allocer->elem_size < elem_size) {
		return malloc(elem_size);
	}

	if (allocer->free_list != NULL) {
		void* now = allocer->free_list;
		allocer->free_list = allocer->free_list->next;
		return now;
	}

	return malloc(elem_size);
}

当用户不使用这一块内存的时候，需要释放掉把这块内存加入到空闲缓存区中，If是判断这一块内存是在缓存区中，还是因为申请内存的时候另外分配的内存，如果在缓存区中就把当前这块内存的next指向free_list，然后把free_list指向当前释放的内存，就把这块内存加到了缓存区中

void cache_free(struct cache_allocer* allocer, void* mem) {
	if (((unsigned char*)mem) >= allocer->cache_mem && ((unsigned char*)mem) < allocer->cache_mem + allocer->capacity * allocer->elem_size) {
		struct node* node = mem;
		node->next = allocer->free_list;
		allocer->free_list = node;
		return;
	}
	free(mem);
}