超越内存限制:深入探索内存池的工作原理与实现

举报
Lion Long 发表于 2023/09/25 22:24:58 2023/09/25
【摘要】 这篇文章将深入探索内存池的工作原理与实现,介绍如何超越传统的内存限制。首先,我们将了解什么是内存池以及它与传统内存分配方式的不同之处。接着,我们将探索内存池的工作原理,包括内存池的数据结构和算法。我们还将解释内存池如何提升性能,避免内存碎片化,并减少内存分配的开销。此外,我们将介绍一些常见的内存池实现技术,例如固定大小内存池和动态大小内存池,并对比它们的优劣之处。

一、引言

为什么需要内存池?
在系统应用层面,程序开发使用的都是虚拟内存。物理内存是底层的,只有底层程序(比如驱动、固件等)可以接触到。

程序通常能管理的内存主要是堆和共享内存(mmap)。应用层所谓的内存管理,主要是对堆上的内存池进行管理。

程序使用内存时,需要申请内存,通过调用malloc() / callol();使用完之后需要释放内存,调用free()。程序运行时会不断的申请内存、释放内存,会发现内存到后面可能出现不可控制的状态,比如还有总可用内存,但是无法分配下来了,这就是内存碎片,内存有很多的小窗口存在。
因此,需要内存管理,从而有内存池存在。通过内存管理避免内存碎片以及避免频繁的申请、释放内存。

new和malloc/callol关系:new是关键字,内部调用的是malloc/callol,delete和free一样,是对内存释放。

二、内存管理方式

分配内存的时候,分配的大小以及何时分配何时释放都是不确定的。因此,针对不同的常见有不同的内存管理方式。
(1)不管需要的内存大小,每次分配固定大小的内存。这可以有效的避免内存碎片,但是内存利用率低。
image.png
(2)以 2 n 2^n 累积内存池。可以提升内存的利用率,但是回收是一个很大的工程,没办法做到两块相邻的内存合在一起。
image.png
(3)大、小块。内存池中分大小块,申请内存大小大于某个值定为大块、否则是小块,内部使用链表串联。
image.png

三、posix_memalign()与malloc()

malloc / alloc函数原型:

#include <stdlib.h>

void *malloc(size_t size);
void free(void *ptr);
void *calloc(size_t nmemb, size_t size);
void *realloc(void *ptr, size_t size);

描述:
malloc函数的作用是分配大小字节并返回分配内存的指针。分配的内存未初始化。size=0,则malloc返回NULL或唯一的指针值,稍后可以成功传递给free()。

free函数释放ptr指向的内存空间,该空间必须是先前调用malloc()、calloc()或realloc()返回的。否则,或者如果之前已经调用了free(ptr),则会发生未定义的行为。如果ptr为空,则不执行任何操作。

calloc函数为每个size字节的nmemb元素数组分配内存,并返回分配内存的指针。内存被初始化为零。如果nmemb或size为0,则calloc()返回NULL或唯一的指针值,稍后可以成功传递给free()。

realloc函数将ptr指向的内存块大小更改为size字节。从区域开始到新旧尺寸的最小值,内容将保持不变。如果新大小大于旧大小,则不会初始化添加的内存。如果ptr为空,则对于size的所有值,调用等同于malloc(size);如果size等于零,且ptr不为空,则调用等同于free(ptr)。除非ptr为空,否则它必须是通过先前调用malloc()、calloc()或realloc()返回的。如果指向的区域被移动,则执行free(ptr)。

返回值:

malloc()和calloc()函数返回一个指向已分配内存的指针,该指针适合任何内置类型。出现错误时,这些函数返回NULL。如果成功调用大小为零的malloc(),或者成功调用nmemb或大小等于零的calloc(),也可能返回NULL。

free()函数不返回任何值。

realloc()返回一个指向新分配内存的指针,该指针适合任何内置类型,可能与ptr不同,如果请求失败,则为NULL。如果size=0,则返回NULL或适合传递给free()的指针。如果realloc()失败,则原始块保持不变;它不会被释放或移动。

错误:
calloc()、malloc()和realloc()可能会失败,并出现以下错误:
ENOMEM,内存不足。应用程序可能会达到getrlimit()中描述的RLIMIT_AS或RLIMIT-DATA限制。

malloc / alloc分配内存是有限制的,可能不能分配超过4k的内存的,为了内分配大内存,需要使用posix_memalign函数。

posix_memalign函数原型:

#include <stdlib.h>

int posix_memalign(void **memptr, size_t alignment, size_t size);
void *aligned_alloc(size_t alignment, size_t size);
void *valloc(size_t size);

#include <malloc.h>

void *memalign(size_t alignment, size_t size);
void *pvalloc(size_t size);

描述:
函数posix_memalign分配size字节,并将分配内存的地址放在memptr中。分配内存的地址将是alignment的倍数,必须是2的幂和sizeof(void)的倍数。如果大小为0,则放置在*memptr中的值要么为空,要么是唯一的指针值,稍后可以成功传递给free()。
返回:
posix_memalign()在成功时返回零,或在失败时错误值。在调用posix_memalign()之后,errno的值是不确定的。

错误值:

  • EINVAL:对齐参数不是2的幂,或者不是sizeof(void*)的倍数。
  • ENOMEM:内存不足,无法完成分配请求。

四、对齐计算

要分配一个以指定大小对齐的内存,可以使用如下公式:
假设要分配大小为n,对齐方式为x,那么 size=(n+(x-1)) & (~(x-1))。
举个例子:
n=17,x=4。即申请大小为17,对齐为4。则计算出对齐后的大小应该为
(17+4-1)&(~(4-1))=20;
用二进制来计算,
(0001 0001 + 0011)&(1111 1100)=0001 0100

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

五、内存池的具体实现

5.1、内存池的定义

typedef struct mp_large_s {
	struct mp_large_s *next;
	void *alloc;

}mp_large_t;

typedef struct mp_node_s {
	unsigned char *last; // last之前为已使用的内存
	unsigned char *end; // last到end之间为可分配内存
	struct mp_node_s *next;
	size_t failed;
}mp_node_t;

typedef struct mp_pool_s {
	size_t max;

	mp_node_t* current;
	mp_large_t* large;

	mp_node_t head[0];

}mp_pool_t;

5.2、内存池的创建

mp_pool_t *mp_create_pool(size_t size)
{
	mp_pool_t *p;
	// malloc无法分配超过4k的内存,size + sizeof(mp_pool_t) + sizeof(mp_node_s)保证有size大小可用
	int ret = posix_memalign((void*)&p, MP_ALIGNMENT, size + sizeof(mp_pool_t) + sizeof(mp_node_t));
	if (ret)
		return NULL;

	p->max = size;
	p->current = p->head;
	p->large = NULL;

	//(unsigned char*)(p + 1)
	// (unsigned char*)p + sizeof(mp_pool_t)
	p->head->last = (unsigned char*)p + sizeof(mp_pool_t)+sizeof(mp_node_t);
	p->head->end = p->head->last + size;
	p->head->failed = 0;

	return p;
}

5.3、内存池的销毁

void mp_destory_pool(mp_pool_t *pool) 
{
	mp_node_t *h, *n;
	mp_large_t *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);
}

5.4、内存池的重置

void mp_reset_pool(mp_pool_t *pool) 
{

	mp_node_t *h;
	mp_large_t *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(mp_node_t);
	}

}

5.5、内存池分配小块

void *mp_alloc_small(mp_pool_t *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;

	mp_node_t *p, *new_node, *current;

	new_node = (mp_node_t *)m;
	new_node->next = NULL;
	new_node->end = m + psize;
	new_node->failed = 0;
	m += sizeof(mp_node_t);
	m = mp_align_ptr(m, MP_ALIGNMENT);
	new_node->last += size;

	current = pool->current;
	for (p = current; p->next; p = p->next)
	{
		// 如存在多次分配失败,current不再指向此node
		if (p->failed++ > 4)
		{
			current = p->next;
		}
	}
	p->next = new_node;
	pool->current = current ? current : new_node;

	return m;
}

5.6、内存池分配大块

static void *mp_alloc_large(mp_pool_t *pool, size_t size) 
{
	void *p = NULL;
	int ret = posix_memalign((void*)&p, MP_ALIGNMENT, size);
	if (ret)
		return NULL;
	
	mp_large_t *large;
	
	// 查找是否有已经释放的large,在large list里面找到一个 null的节点
	size_t n = 0;
	for (large = pool->large; large; large = large->next)
	{
		if (large->alloc == NULL)
		{
			large->alloc = p;
			return p;
		}
		// 避免遍历链条太长
		if (n++ > 3)
			break;
	}

	// 大内存块的头作为小块保存在small中
	large = mp_alloc_small(pool, sizeof(mp_large_t));

	// 头插法
	large->alloc = p;
	large->next = pool->large;
	pool->large = large;
}

5.7、申请内存

void *mp_malloc(mp_pool_t *pool, size_t size)
{
	if (size > pool->max)
		return mp_alloc_large(pool, size);
	mp_node_t *p = pool->current;

	

	while (p)
	{
		
		if (p->end - p->last < size)
		{
			p = p->next;
			continue;
		}

		unsigned char *m = mp_align_ptr(p->last, MP_ALIGNMENT);
		p->last = m + size;
		return m;
	}
	
	return mp_alloc_small(pool, size);
}

void *mp_calloc(mp_pool_t *pool, size_t size) 
{

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

	return p;

}

5.8、释放内存

void mp_free(mp_pool_t *pool, void *p)
{
	mp_large_t *l;
	for (l = pool->large; l; l = l->next)
	{
		if (p == l->alloc)
		{
			free(l->alloc);
			l->alloc = NULL;
			return;
		}
	}
}

5.9、完整示例代码

为避免文章篇幅过长,完整代码已上传gitee:内存池完整示例代码
欢迎关注公众号《Lion 莱恩呀》学习技术,每日推送文章。

image.png

总结

设计一个内存池,可以有效的避免内存碎片和避免频繁的内存创建‘释放。程序通常能管理的内存主要是堆和共享内存(mmap)。应用层所谓的内存管理,主要是对堆上的内存池进行管理。
内存管理方式,使用比较多的是以 2 n 2^n 堆叠内存池以及大小块方式管理。nginx就是使用的大小块方式管理内存;为每个IO建立自己的内存池,IO生命周期结束再释放内存。

【版权声明】本文为华为云社区用户原创内容,未经允许不得转载,如需转载请自行联系原作者进行授权。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。