Linux组件之内存池的实现

已于 2023-08-16 12:27:18 修改
阅读量597 收藏 6
点赞数 2
分类专栏： Linux基础组件 文章标签： linux 内存池 nginx 后端
于 2023-07-02 16:35:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ricardo2/article/details/131498896
版权

文章目录

一、为什么需要内存池

应用程序使用内存，需要先申请内存，使用完之后再释放内存。比如c语言中使用malloc/free来分配/释放内存，c++中使用new/delete来分配/释放内存。内存申请与释放都需要与操作系统进行交互，具体来说就是系统维护一个内存链表，当有一个内存申请过来时，根据分配算法在链表找一个合适的内存分配给它。分配的内存块可能会大于所申请的内存大小，这样需要进行切割，将剩余的内存插入到空闲链表中。释放的时候，系统要判断释放的内存块的前后是否有空闲，若有的话还要进行合并。可见，调用库中的内存分配函数，十分耗时。

另外，频繁的申请、释放内存，会使得一块大内存可能被分割成多块不连续的小内存。当需要再分配连续的大内存时候，尽管剩余内存的总和可能大于所要分配的内存大小，但系统就找不到连续的内存。这就是内存碎片的存在，从而导致分配错误。

综上所述，总结一下使用内存池的几个主要原因：

  • 1）提高内存分配效率：传统的内存分配方式会涉及到频繁的系统调用和内存管理开销，而内存池可以在初始化时一次性地分配一块连续的内存空间，然后根据需要从该池中快速分配内存，避免了频繁的系统调用，从而提高了内存分配的效率。
  • 2）降低内存碎片化：内存池会事先分配一定数量的连续内存块，当需要分配内存时，直接从这些预分配的内存块中获取，不涉及内存的分配和释放，减少了内存碎片的产生，提高了内存的利用率。
  • 3）减少动态内存分配次数：内存池可以在程序初始化的时候一次性分配好所需的内存，然后在运行时通过内存池进行内存分配，避免了频繁的动态内存分配，从而减少了内存管理的开销和潜在的内存泄漏风险。
  • 4）控制内存分配的策略：内存池可以自定义内存分配的策略，例如按照固定大小的内存块进行分配，或者按需动态调整内存池的大小等。这可以根据具体应用场景和需求来选择最合适的内存管理策略。

总之，内存池是一种有效管理内存的机制，通过提高内存分配和释放的效率，减少内存碎片化，降低动态内存分配的次数，能够帮助提高程序的性能和可靠性。

二、内存池的工作流程

1）开始时，申请一块大的内存（在该块内存不够用时在二次分配），
2）需要时，从这块内存中取出，并标记下这块内存被用了
3）释放时，标记此内存被释放了。注意此时并不真的把内存释放给操作系统，而是当一大块内存都空闲的时候，才释放给操作系统。
4）调用内存分配函数的时，小块内存每次都分配固定大小的内存块，这样就避免了内存碎片产生的可能。

参考 nginx 内存池的设计，以大、小块作为内存管理分配的方式。
具体来说，内存池中分大小块，申请内存大小大于某个值定为大块、否则是小块，内部使用链表串联。

在这里插入图片描述

三、内存池的实现

3.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;				// 当前的内存池分配失败的次数
};

内存池结构

struct mp_pool_s {

	size_t max;					// 内存池可分配的最大空间，超过的话用大块内存

	struct mp_node_s *current;	// 指向当前内存池
	struct mp_large_s *large;	// 指向大块内存链表

	struct mp_node_s head[0];	// 指向小块内存链表

};

在这里插入图片描述

3.2 接口设计

3.2.1 创建内存池

内存池创建的时候分三块，一块存储mp_pool_s结构体，一块存储mp_node_s结构体，一块为申请的内存块。返回指向整个内存池的指针p。
在这里插入图片描述

struct mp_pool_s *mp_create_pool(size_t size) {

	struct mp_pool_s *p;
	// posix_memalign 用于分配内存块，并保证所分配的内存块以指定的对齐方式进行对齐。
	// 参数:1)一个指向指针的指针，用于保存分配得到的内存块的地址。2)所需的内存对齐方式. 3)要分配的内存块的大小
	// 一开始并不知道大块内存具体大小，因此只需要分配：申请空间的大小 + 内存池结构体大小 + 小块内存结点
	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;

}

3.2.2 内存池销毁

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);

}

3.2.3 内存分配

通过mp_alloc向内存池申请内存，如果用户申请的内存大于pool->max，则认为是大块内存，直接向 OS 申请。否则就是小块内存，直接在内存池里面分配。

如果申请小块内存，遍历现有的小块内存链表，寻找是否有满足需求的内存块
1）如果有，返回待分配内存块的首地址
2）如果没有，创新新的小块内存

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

	unsigned char *m;
	struct mp_node_s *p;

	// 1、申请小块内存
	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);
	}

	// 2、申请大块内存
	return mp_alloc_large(pool, size);
	
}
1. 分配小块内存

调用mp_alloc_block创建新的小块内存，并插入到小块内存链表的末尾。

有一种情况，每个小块内存最后都剩下一小块，比如A内存块剩下5，B内存块剩下16。current指向的是A。此时需要申请大小20的内存，从current开始查，A不满足。再申请大小10的内存，从current开始查，A还是不满足。每次都从A开始，就很费时间，因此引入failed。
每次调用mp_alloc_block函数，代表内存池现有小块内存的空间分配失败，此时，所有可用的小块内存的 failed + 1，表示不满足用户的需求增加1次。若某个小块内存若连续 5 次不满足用户需求，则不再使用它，遍历时跳过。
在这里插入图片描述

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移动到可分配内存的开始位置
	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) {
		// 若某个小块内存连续5次都分配失败，则跳过这个小块内存，下次不再遍历它
		if (p->failed++ > 4) { //
			current = p->next;
		}
	}

	// 将新创建的内存块，尾插到小内存块链表
	p->next = new_node;

	// 更新pool->current指针，判断 current 是否为空？
	// 若非空，指向current指向的结点；若为空，代表之前所有的内存块都分配失败，则指向新的内存块
	pool->current = current ? current : new_node;

	return m;

}
2. 分配大块内存

调用mp_alloc_large()分配一个新的大块内存，插入到链表的开头，头插法。

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;

	// 遍历大块内存链表，找到可以挂载 p 的位置
	for (large = pool->large; large; large = large->next) {
		// 找到可以挂载的地方
		if (large->alloc == NULL) {
			large->alloc = p;
			return p;
		}
		// 若连续 4 次都没找到，就不再寻找了
		if (n ++ > 3) break;
	}

	// 创建一个新的大块内存结点，用来挂载p
	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;
}

3.2.4 内存池的释放

Nginx 内存池内部仅提供大块内存的释放接口

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 ;
		}
	}
	
}

3.2.5 内存池重置

nginx的小块内存是无法释放的，因为这个小块内存的分配都是通过last指针偏移的。
如果1和3分配出去了。但现在2不使用了，怎么归还到小块内存里？mp_node_s 结构通过指针last和end标识空闲内存，因此不能把2这块内存给拉进去空闲内存空间里面。
在这里插入图片描述
但是如果不释放小块内存，小块内存随着分配越来越大，系统的内存分配失败的概率越大。因此引入内存池重置。

当一个内存池被使用过一段时间后，可能会有一些内存块被分配出去，但是在后续的使用中，这些内存块可能已经不再需要了。此时，可以选择重置内存池，将所有已经分配的内存块释放回来，并重新初始化内存池的状态，使其恢复到最初的状态，以便重新利用这些内存空间。

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;

	// 通过指针复位重置小块内存（不调用free归还内存）
	for (h = pool->head; h; h = h->next) {
		h->last = (unsigned char *)h + sizeof(struct mp_node_s);
	}

}

3.3 完整代码




#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include <fcntl.h>



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

// 按指定的对齐方式 alignment 对齐。
#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;				// 当前的内存池分配失败的次数
};

// 内存池结构
struct mp_pool_s {

	size_t 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;
	// posix_memalign 用于分配内存块，并保证所分配的内存块以指定的对齐方式进行对齐。
	// 参数:1)一个指向指针的指针，用于保存分配得到的内存块的地址。2)所需的内存对齐方式. 3)要分配的内存块的大小
	// 一开始并不知道大块内存具体大小，因此只需要分配：申请空间的大小 + 内存池结构体大小 + 小块内存结点
	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;

	// 通过指针复位重置小块内存（不调用free归还内存）
	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移动到可分配内存的开始位置
	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) {
		// 若某个小块内存连续5次都分配失败，则跳过这个小块内存，下次不再遍历它
		if (p->failed++ > 4) { //
			current = p->next;
		}
	}

	// 将新创建的内存块，尾插到小内存块链表
	p->next = new_node;

	// 更新pool->current指针，判断 current 是否为空？
	// 若非空，指向current指向的结点；若为空，代表之前所有的内存块都分配失败，则指向新的内存块
	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;

	// 遍历大块内存链表，找到可以挂载 p 的位置
	for (large = pool->large; large; large = large->next) {
		// 找到可以挂载的地方
		if (large->alloc == NULL) {
			large->alloc = p;
			return p;
		}
		// 若连续 4 次都没找到，就不再寻找了
		if (n ++ > 3) break;
	}

	// 创建一个新的大块内存结点，用来挂载p
	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;

	// 1、申请小块内存
	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);
	}

	// 2、申请大块内存
	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);
	}

	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));

	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;

}

参考资料：
https://www.cnblogs.com/xiekeli/archive/2012/10/17/2727432.html
http://senlinzhan.github.io/2017/04/24/nginx-memory-pool/

闲谈社
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Linux多线程服务端编程：使用muduo C++网络库
08-17
《Linux多线程服务端编程：使用muduo C++网络库》主要讲述采用现代C++在x86-64 Linux上编写多线程TCP网络服务程序的主流常规技术，重点讲解一种适应性较强的多线程服务器的编程模型，即one loop per thread。...
内存池的介绍与经典实现
weixin_45144862的博客
05-21 1270
内存池介绍与经典内存池的实现
内存池技术
qq_43727529的博客
06-04 1841
为了学习池化技术以及后续自行实现一个仿tcmalloc的线程池，我们先浅浅的学习一下池化的概念，以及简单的实现一个定长的内存池。
内存池（memory pool）
weixin_48101150的博客
11-15 8786
前言 通常的进程发起申请内存的动作之后，会在系统的空闲内存区寻找合适大小的内存块（底层分配函数__alloc_node_mask），如果满足就直接分配，如果不满足就会向上查找。如果过大就会进行分裂，一部分分给申请进程，一部分放入空闲区。释放时需要找到这个块对应的伙伴，如果伙伴也为空闲，就进行合并，放入高阶空闲链表，如果不空闲就放入对应链表。同时对于多线程申请和释放内存，需要加锁。这样的默认的分配方式考虑到了系统中的大部分情况，具有通用性，但是无可避免的会产生内部碎片，而且加锁，解锁的开销也很大。 如果可以对
内存池解析
weixin_45266730的博客
07-11 569
内存池
内存池解释及线程池(Linux)实现
weixin_62859191的博客
03-26 1263
线程池的实现
C++内存池
sinat_31608641的博客
12-14 2694
内存池
基础库代码实现
06-05
基础库（配置文件读写、日志、多线程、多进程、锁、对象引用计数、内存池、免锁消息队列、免锁数据缓冲区、进程信号、共享内存、定时器等等基础功能组件）
HP-Socket:高性能TCPUDPHTTP通信组件
05-10
服务器基于IOCP / EPOLL通信模型，结合内存池，私有堆等技术，实现了高效的内存管理，以支持大规模和高并发通信场景。 代理代理组件本质上是一个多客户端组件，它使用与服务器组件相同的技术体系结构。 Agent组件...
ReiserRT_Core:Frank Reiser的C ++ 11核心组件，用于多线程实时嵌入式系统
04-12
这两个组件建立在各种子组件的基础之上，这些子组件被导出以进行潜在的重用。 这些子组件是Semaphore，RingBufferSimple和RingBufferGuarded。 为了获得最佳结果，您的流程应启用实时调度程序。 在Linux下，我的...
NewLife.Redis:高性能Redis客户端，支持.NETCore.NET4.0.NET4.5，为大数据与消息队列而特别优化，线上单应用日均100亿调用量
04-29
在Linux上多实例部署，实例个数等于处理器个数，各实例最大内存直接为本机物理内存，避免单个实例内存撑爆 把海量数据（10亿+）根据key哈希（Crc16/Crc32）存放在多个实例上，读写性能成倍增长 采用二进制序列化，而...
LwIP 之六 详解内存池（memp.c/h）动态内存管理策略
技术干货
08-01 8686
对于嵌入式开发来说，内存管理及使用是至关重要的，内存的使用多少、内存泄漏等时刻需要注意！合理的内存管理策略将从根本上决定内存分配和回收效率，最终决定系统的整体性能。LwIP 就提供了 动态内存堆管理（heap）和 动态内存池管理（pool）两种简单却又高效的动态内存管理机制。
Linux内核：内存管理——内存池
m0_74282605的博客
05-12 415
一般情况下，内存池建立在slab之上，也就是说池子里存放的是slab对象，当某个模块创建一个属于自己的内存池时，创建之前，需要设计好一个分配函数和一个释放函数，创建函数用于创建内存池时自动申请对应的slab对象，而释放函数则是用于将slab对象释放回到slab/slub中。最后我们看看mempool_free()函数，此函数用于将空闲内存对象释放到内存池中，当内存池中空闲对象不足时，优先将空闲内存对象放到elements数组中，否则直接返回到伙伴系统或slab缓冲区中。
C++内存管理（3）——内存池
qq_25218501的博客
09-07 644
池化技术是一种降低频繁操作导致开销过大的方法，如内存池、线程池、进程池和对象池等。内存池（Memory Pool）是一种内存分配方式。通常我们习惯直接使用new、malloc等API申请内存，这样做的缺点在于所申请内存块的大小不定，当频繁使用时会造成大量的内存碎片并进而降低性能。
内存池设计与实现
热门推荐
shawn的专栏
06-29 7万+
1. 内存池设计1.1 目的 在给定的内存buffer上建立内存管理机制，根据用户需求从该buffer上分配内存或者将已经分配的内存释放回buffer中。1.2 要求 尽量减少内存碎片，平均效率高于C语言的malloc和free。1.3 设计思路 将buffer分为四部分，第1部分是mem_pool结构体；第2部分是内存映射表；第3部分是内存chunk结构体缓冲区；第4部分
内存池原理与实现
congchp的博客
12-08 1472
什么是内存池 应用程序直接对使用的内存进行管理，避免频繁的从堆上申请释放内存，可以做到一次申请，多次分配。内存池主要是针对小块。 内存池管理的是堆内存。进程开始运行的时候，划分出一块内存 为什么需要内存池？ 对于服务器，如果不段有客户端连接，并且客户端不断发送消息，对于每个连接的每个消息，服务器都需要去malloc/free内存。如果服务器需要7*24运行，时间久了，就会产生很多内存碎片，没有整块，最后就有可能malloc比较大的内存的时候失败。最后进程就会coredump。 这种问题，出现了
tcmalloc（高并发内存池）简化版讲解-项目
2201_75352618的博客
10-10 291
高清发不上去，私我发高清，项目完整代码@我。
C++ 内存池介绍与经典内存池的实现
Dablelv 的博客专栏。
11-01 3万+
内存池（Memory Pool）是一种内存分配方式。通常我们习惯直接使用new、malloc等API申请内存，这样做的缺点在于所申请内存块的大小不定，当频繁使用时会造成大量的内存碎片并进而降低性能。
使用C++实现的高性能内存池
qq_52962878的博客
06-29 1072
并且使用一个管理自定义块的对象来保存它的地址，以便于在释放空间的时候我们能够找到他。
linux内存池代码
最新发布
10-11
这里是一个简单的 Linux 内存池代码示例： ```c #include #include #define POOL_SIZE 1024 typedef struct { int size; char data[POOL_SIZE]; } mem_block; mem_block* pool = NULL; int pool_index = 0; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

闲谈社

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值