内存池的实现场景分析

已于 2024-01-09 20:56:24 修改
阅读量406 收藏 7
点赞数 8
分类专栏： C/C++ 文章标签： 后端 c语言
于 2024-01-09 20:54:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/axyw_/article/details/134837462
版权

我们所说的就是虚拟内存，物理内存实际由OS来控制

1. 为什么要有内存池？

内存池是一种高效的内存管理机制，它可以提高性能和可靠性，减少内存分配和释放操作。

在传统的内存管理方式中，每次分配内存时都需要调用系统的内存分配函数（如malloc），这会涉及到内核态和用户态之间的频繁切换，造成较大的开销。而内存池则可以预先分配一定数量的内存，将其组织为一组内存块，并在需要时从内存池中分配内存。这样可以避免频繁地调用系统的内存分配函数，减少内核态和用户态之间的切换次数，从而提高程序的性能。

此外，内存池还可以减少内存碎片的产生。在传统的内存管理方式中，频繁地分配和释放内存会导致内存碎片的产生，从而降低内存的利用率。而内存池可以预先分配一定数量的内存，并将其组织为一组内存块，这样可以避免频繁地分配和释放内存，从而减少内存碎片的产生，提高内存的利用率。

总之，内存池可以提高程序的性能和可靠性，减少内存分配和释放操作，避免频繁地调用系统的内存分配函数，减少内核态和用户态之间的切换次数，同时还可以减少内存碎片的产生，提高内存的利用率。

2. 内存池实现思路

内存池的实现方法有许多，本文只介绍一种实现方法。

在这里插入图片描述
代码中定义了三个结构体：mp_pool_s、mp_node_s 和 mp_large_s。其中，mp_pool_s 结构体表示内存池，用于管理动态分配的内存；mp_node_s 结构体表示内存池中的一个节点，用于管理小块内存；mp_large_s 结构体表示内存池中的一个大块内存。

下面介绍整个代码的逻辑
在这里插入图片描述

3.总结

本文中所介绍的内存池主要是参考了Nginx内部的内存池的实现，主要思路：先判断需要的内存是多大，然后，大于指定的最大值的话，那么需要重新给分配一大块，存储这一大块的结构体所占用的内存是从内存池中分配的，就是便利遍历的池子看是否有满足要求的；然后如果需要的内存小于指定值，那么就是去内存池中，遍历链表，然后找到满足需要内存要求的块，分配内存给他即可。总的来说，个人觉得这个内存池的实现就是使得每次申请者需要的内存不多时，直接去内存池拿，不需要再去进行系统调用。

如果实际开发需要的话，也可以去使用一些开源的内存池组件tcmalloc/jemalloc等。

4.完整源代码

// 下面时完整的代码


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

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

}
毛毛不怕困难
关注
专栏目录
内存池之一：基本概念
云彩挂上的二叉树
02-28 1413
Wrote by mutouyun. (http://darkc.at/memory-pool-basic-concepts/)   1. 内存池是什么 内存池（Memory Pool），是内存分配器（Memory Allocation）的一种表现形式。它以预存储的方式预先分配一大块内存（相对于每次请求的内存大小来说），使得绝大部分的内存请求只需要在已分配的大块内存上划分出一小块
内存池的实现与场景分析
EquinoxM的博客
03-22 805
内存池是对malloc在堆上申请出来的空间进行的管理！ 内存池作用：(内存池要用但不要自己造，要懂他的原理） 避免频繁分配内存（recv之前malloc一块空间，让recv函数来用，这种方式内存会被频繁分配释放和使用，会造成内存碎片化，这样当我们再次申请一块大内存的时候会遇到分配失败的情况。） 内存池：jemalloc，tcmalloc 避免频繁分配与释放方法： 1. 使用链表，每次malloc把块加入到链表中，不释放，调用free的时候直接在结构体里设置一个fla...
为什么使用内存池
最新发布
weixin_43225194的博客
07-25 921
操作系统分用户态和内核态，我们只能在用户态进行操作。我们所使用的内存有栈和堆的，栈的内存自动分配和回收。对于程序员来说，主动申请和释放的内存是堆的内存。比如malloc()free()。我们调用malloc()向堆申请内存，系统也分配给了我们。但是我们申请的这部分内存容易造成内部碎片，这会导致残缺的内存块不能被我们所利用。比如申请 4k 的内存块，系统剩余的内存空间也够。但是这些是不连续的，连续的块可能只有 2k 大小，那么就会发生内存分配失败的情况。如果是公司级别的程序，不像个人写的 demo。
内存池的意义与原理
ajffaj的博客
08-13 1024
内存池的原理
内存池总结
逍遥子曰：
05-23 2228
原文放在另一个博客地址： http://houjixin.blog.163.com/ 为什么要内存池？ （1）       在调试阶段检查内存泄露。C++的指针给大家带来了很大的方便，但是它对内存的自由操作也带来了内存泄露等一系列问题，在一些嵌入式软件开发过程中 （2）       减少内存碎片。频繁的从堆中new一些小内存容易造成内存碎片增加。
C语言实现内存池
09-25
这两个文件很可能是内存池实现的核心代码。`LMemoryPool.h`是头文件，通常会包含内存池的结构定义、接口声明等。`LMemoryPool.cpp`则是实现文件，包含了内存池的具体实现，如内存块的分配、释放、初始化等函数的...
c版本内存池实现完整源码
06-05
本文将深入探讨C版本的内存池实现，并通过提供的源码进行解析，帮助你理解其工作原理。 内存池的基本思想是预先一次性分配一大块内存，然后根据需要从中划分出小块内存供程序使用，而不是每次需要内存时都向操作...
一个C++内存池实现
12-13
为了优化这个内存池实现，可以考虑以下策略： - **内存块大小的调整**: 分析程序中不同大小的内存请求，优化内存块的大小，以减少浪费并提高空间利用率。 - **动态扩展**: 当一级内存池或二级内存池中的内存耗尽时...
为什么要使用内存池技术？
HelloKandy's Blog
04-26 2963
首先，要弄清楚一个事实： C/C++的内存分配（通过malloc或new）可能需要花费很多时。更糟糕的是，随着时间的流逝，内存将形成碎片，所以一个应用程序的运行会越来越慢。当它运行了很长时间或执行了很多的内存分配（释放）操作的时候。特别是，你经常申请很小的一块内存，堆（heap）会变成碎片的。 如何解决？ 一个（行之有效的）解决方法是内存池（Memory Pool）。 在启动的
C++中我们为什么提倡使用内存池技术？
weixin_30682415的博客
12-27 411
1.什么是内存池技术及为什么要设计自己的内存池？ 通常我们习惯直接使用new、malloc等API申请分配内存，这样做的缺点在于：由于所申请内存块的大小不定， 当频繁使用时会造成大量的内存碎片并进而降低性能。C/C++的内存分配(通过malloc或new)可能需要花费很多时。更糟糕的是，随着时间的流逝，内存(memory)将形成碎片，所以一个应用程序的运行会越来越慢当它...
高性能后台服务为什么需要内存池
资料qun832218493
07-06 727
C/C++程序为什么比起其它语言开发的程序效率要高，一个很重要的原因就是可以直接操作内存，今天就来讲讲为什么需要内存池的技术。从一个示例开始 先看下面两段代码...
内存池详解
SeasonJoe的博客
03-08 1105
文章目录简介内存池和allocator的关系内存池的具体实现内存池数组内存池中的类型allocate和deallocate测试结果 最近一直在搞内存池，这一块之前一直没有注意过，最近看书看到这一块，发现挺重要的，琢磨了挺长时间，也在github上找了很多代码，感觉都不太好，最后是看《深入实践C++模板编程》书中的实现，感觉还不错，就自己敲了一下并分析理解了原理，感觉受益匪浅。 源码 简介 什么是内...
c++内存池作用和优势
caoyan_12727的博客
08-20 7668
C/C++下内存管理是让几乎每一个程序员头疼的问题，分配足够的内存、追踪内存的分配、在不需要的时候释放内存——这个任务相当复杂。而直接使用系统调用malloc/free、new/delete进行内存分配和释放，有以下弊端：     1.调用malloc/new,系统需要根据“最先匹配”、“最优匹配”或其他算法在内存空闲块表中查找一块空闲内存，调用free/delete,系统可能需要合并空闲内存块
c语言内存池介绍与应用
xie_calm的专栏
07-30 943
为什么要使用内存池（why）? 我们知道，在使用c语言开发程序时，进程会对内存进行动态的分配和释放，那么，如果在一个程序里频繁的分配和释放内存会带来两点不好的结果： （1）频繁分配和释放内存会进行多次系统调用，增加系统开销，影响程序效率；  （2）频繁分配和释放内存会产生许多内存碎片，降低内存的使用率，降低内存分配的效率； 因此，为了解决上述两点弊端，我们在开发程序时，如果需要频繁地分配使
内存池的作用--减少内存碎片
u012590688的专栏
09-28 4457
1 内存池出现的必要性和原因 C/C++下内存管理是让几乎每一个程序员头疼的问题，分配足够的内存、追踪内存的分配、在不需要的时候释放内存——这个任务相当复杂。而直接使用系统调用malloc/free、new/delete进行内存分配和释放，有以下弊端： 调用malloc/new,系统需要根据“最先匹配”、“最优匹配”或其他算法在内存空闲块表中查找一块空闲内存，调用free/delete
浅谈为什么要使用池化技术(线程池,内存池等)
热门推荐
Alex_Cxl的博客
07-28 1万+
池化技术常见应用 在系统开发过程中，我们经常会用到池化技术来减少系统消耗，提升系统性能。对象池通过复用对象来减少创建对象、垃圾回收的开销；连接池（数据库连接池、Redis连接池和HTTP连接池等）通过复用TCP连接来减少创建和释放连接的时间。线程池通过复用线程提升性能。简单来说，池化技术就是通过复用来提升性能。 线程、内存、数据库的连接对象都是资源，在程序中，当你创建一个线程或者在堆上申请一块内存的时候都涉及到很多的系统调用，也是非常消耗CPU的。如果你的程序需要很多类似的工作线程或者需要频繁地申请释放
使用内存池的原因，内存池的应用
滴水穿石
09-14 2479
网络游戏服务器开发技术  -------如何正确高效的使用内存和对象内存池？    大家都知道，游戏服务器在网络游戏开发中所占的比重。而评论游戏服务器的好坏标准，除了实现游戏的逻辑功能外，最重要的也就是稳定和高效。一个不稳定的服务器对于一款网络游戏的打击是沉重，一个不高效的服务器对于玩家的感觉也是非常明显的。 在这一章节中，我将要向大家介绍游戏服务器高效开发的一个方面，如何正确高效的使用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值