手写内存池以及代码分析【C语言】

最新推荐文章于 2024-05-15 15:28:22 发布
最新推荐文章于 2024-05-15 15:28:22 发布
阅读量492 收藏 4
点赞数
文章标签： c语言 nginx 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuqiushiya/article/details/122658868
版权

内存池是对堆进行管理

当进程执行时，操作系统会分出0~4G的虚拟内存空间给进程，程序员可以自行管理（分配、释放）的部分就是mmap映射区、heap堆区，而内存池管理的部分就是用户进程的堆区。

为什么要用内存池？

内存池就是用来避免堆区出现碎片化

  • 避免频繁地分配和释放内存（防止堆区出现碎片化）

当客户端连接上服务端的时候，服务端会准备一部分的堆区用来做消息保留。当一个连接成功之后，服务器会在堆区为其分配一段属于这个连接的内存，当连接关闭之后，所分配的内存也随之释放。但是当连接量较大且过于频繁时，不可避免地对内存进行频繁的分配和释放。这会导致堆区出现小窗口，也就是堆区碎片化。

堆区出现碎片化会怎么样？

  • 长时间工作会出现不可查的BUG
  • 无法分配较大且整块的内存，malloc会返回NULL

内存池设计

场景：在一段很干净的堆区上，如何实现能避免内存碎片化的内存池？

第一：使用链表管理内存

使用链表将分配出来的一块一块内存在堆区连接起来，设置flag(是否被使用)，让链表节点上的各段内存慢慢各自扩张。

单独使用链表会出现什么问题？

  • 内存块会被划分得越来越小，链表会变得越来越长，知道不能划分出更大得内存。

所以加入了固定内存的想法的设计

对于分配小段内存时，将小段内存进行固定划分，如下

  1. 16bytes
  2. 32bytes
  3. 64bytes
  4. 128bytes
  5. 256byts
  6. 512bytes

但是不同的固定小内存的分配的话就会出现以下问题:

  1. 查找慢
    • 分配时查找
    • 释放时候查找
  2. 块与块之间也会出现间隙
    • 无法将块合并
    • 小块回收麻烦

所以最后得出自定义固定小块和随机大块的内存池模型

内存池

在这里插入图片描述

内存池工作流程

在这里插入图片描述

内存池结构体

//内存池
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_node_s{

	unsigned char *last;    //当前的
	unsigned char *end;   //最后

	struct mp_node_s *next; //下一个4k
	size_t failed;
	
};

大块内存也是用单向链表串起来

//大块内存
struct mp_large_s{

	struct mp_large_s *next;
	void *alloc;
	
};

API

创建内存池

  1. 确定以size大小作为小块内存的固定大小
  2. 一来是last指向所在节点的第一个字节
  3. end指向最后
//创建内存池
struct mp_pool_s *mp_create_pool(int size){
	
	struct mp_pool_s *pool;
	
	int ret = posix_memalign((void**)&pool, ALIGNMENT, size + sizeof(struct mp_pool_s) + sizeof(struct mp_node_s));
	if(ret)return NULL;

	pool->max = (size<MP_MAX_ALLOC_FORM_POOL) ? size : MP_MAX_ALLOC_FORM_POOL;
	
	pool->current = pool->head;
	
	pool->head->last = (unsigned char*)pool + sizeof(struct mp_pool_s) + sizeof(struct mp_node_s);
	pool->head->end = pool->head->last + size;
	pool->head->failed = 0;
	
	pool->large = NULL;

	return pool;
}

销毁内存池

  1. 先释放大块内存，遍历链表
  2. 再释放小块，遍历链表
//销毁内存池
void mp_destroy_pool(struct mp_pool_s *pool){
	
	struct mp_large_s *large;
	
	for(large = pool->large; large!=NULL; large = large->next){ //释放大块
		if(large->alloc)free(large->alloc);
	}
	
	struct mp_node_s *h = pool->head->next;
	
	while(h){	//释放小块
		struct mp_pool_s *next = h->next;
		free(h);
		h = h->next;
	}

	free(pool);
}

重置内存池

  1. 先释放大块内存
  2. 再将小块内存的last指向内存的第一个位置

//重置内存池
void mp_reset_pool(struct mp_pool_s *pool){

	struct mp_node_s *head;
	struct mp_large_s *large;

	for(large = pool->large; large; large=large->next){ //将释放大块
		if(large->alloc)free(large->alloc);
	}

	pool->large = NULL;

	for(head = pool->head; head; head = head->next){	//将各个节点的头位置指向刚创建的位置
		head->last = (unsigned char*)head + sizeof(struct mp_node_s);
	}
}

给内存池分配一个小块内存

  1. 首先分配出一整块（大小为psize）小块内存，并创建节点指向这块内存
  2. 内存对齐，利用尾插法插入链表最后的位置
  3. 重新调整内存池的current的指向
/*分配psize大小的小块内存，开始指向的位置head->last = memblk + size，链表尾插法*/
static void *mp_alloc_block(struct mp_pool_s *pool, size_t size){

	unsigned char *memblk;
	struct mp_node_s *head = pool->head;
	size_t psize = (size_t)(head->end - (unsigned char*)head);  //psize == 创建内存池时输入的参数
	
	int ret = posix_memalign((void*)&memblk, ALIGNMENT, psize);  //分配内存     24字节对齐
	if(ret)return NULL;

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

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

	memblk += sizeof(struct mp_node_s); 				//跳过节点结构体做内存对齐
	memblk = mp_align_ptr(memblk, ALIGNMENT);			//内存对齐
	new_node->last = memblk + 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 memblk;
}

在小块内存中取出一块size大小的内存（不做字节对齐）

  1. 首先获取当前内存池所指向的小块内存
  2. 跟着一个节点一个节点往下面查找小块内存中是否有足够size大小的内存分配
  3. 如果有就将内存做字节对齐并返回
  4. 如果没有合适的小块内存则分配多一整块小块内存
  5. 如果小块内存分配失败，则以创建大块内存的方式对size分配
//在小块内存区上取一块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){ //如果当前节点剩余内存比size大的话就在该节点分配
				p->last = m + size;
				return m;
			}
			p = p->last;
			//如果没有一个节的剩余大小大于size就重新分配一个block
		}while(p);

		return mp_alloc_block(pool, size);
	}
	//如果这个size超过了小块内存的限制，就以大块内容分配方式来分配
	return mp_alloc_large(pool, size);
}

在小块内存中取出一块size大小的内存（做字节对齐）

//在小块内存区上取一块size大小的内存  字节对齐
void *mp_alloc(struct mp_pool_s *pool, size_t size){

	unsigned char *memblk;
	struct mp_pool_s *p;

	if(size<=pool->max){
		p = pool->current; 		//当前小块指向

		do{
			memblk = mp_align_ptr(p->last, ALIGNMENT);//做字节对齐
			if((size_t)(p->end-memblk) >= size){  //如果当前节点剩余内存比size大的话就在该节点分配
				p->last = memblk + size;
				return memblk;
			}
			p = p->next;			
		}while(p);
		//如果没有一个节的剩余大小大于size就重新分配一个block
		return mp_alloc_block(pool, size);
	}
	//如果这个size超过了小块内存的限制，就以大块内容分配方式来分配
	return mp_alloc_large(pool, size);
}

在小块内存中取出一段size大小的内存并初始化为0

//分配内存且初始化为0
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;
}

分配size大小的大块内存（大块内存的节点放在小块内存里）

  1. 首先malloc得到内存首地址，然后将大内存挂到内存池上，如果大块内存的结构体没有创建就在小块内存中创建
  2. 创建好之后挂接好并返回大块内存首地址

//创建大块内存
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(large);
		return NULL;
	}

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

	return p;
}

释放指定大块内存p

  • 先查找再释放
//释放内存p
void mp_free(struct mp_pool_s *pool, void *p){

	struct mp_large_s * large;
	for(large = pool->large; large; large = large->next){

		if(p==large->alloc){
			free(large->alloc);
			large->alloc = NULL;	
			return;
		}
	}

重载posix_memalign

//重构mem_memalign
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(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;
}

内存对齐公式

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

至此，内存池全部内容都在这

推荐看看nginx的内存池，这个内存池的demo和nginx的很类似

fallsom
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
手写c语言实时操作系统代码.rar
07-09
在本项目中，"手写c语言实时操作系统代码"是一个使用C语言编写的简易版RTOS，它基于双链表的数据结构进行实现，旨在帮助开发者更好地理解和实践操作系统的基本概念。 C语言是一种通用的、面向过程的编程语言，特别...
基于C语言的内存池实现
thunderLZM的博客
09-16 1006
设计内存池的目标是为了保证代码高效的运行，通过对申请空间小而申请频繁的对象进行有效管理，减少内存碎片的产生，合理分配管理用户内存，从而减少系统中出现有效空间足够，而无法分配大块连续内存的情况。对于线程，内存，oracle的连接对象等等，这些都是资源，程序中当你创建一个线程或者在堆上申请一块内存时，都涉及到很多系统调用，也是非常消耗CPU的，在把内存放入内存池的同时，要把标志位置为空闲。就是很有可能会造成内存的浪费，原因也很明显，开始分配了一大块内存，不是全部都用得到的。4、内存池的代码实现。
【项目】实现一个mini的tcmalloc（高并发内存池）
m0_53005929的博客
09-04 1273
简易的高并发内存池，学习tcmalloc的基本思想以及实现一个简易的tcmalloc
2024年最全【池化技术】内存池技术原理和C语言实现_内存池c语言，Kotlin可能带来的一个深坑
最新发布
2401_84976434的博客
05-15 434
鉴于此，malloc采用的是的实现方式，malloc内存池实现方式更类似于STL分配器和memcached的内存池，。由于文首的链接里没图，所以从这个链接里盗来几张图，而且这个链接讲的内存池也很不错。先看内存池的整体结构：（感觉下面的都很核心！（第一眼看上去有没有很像哈希表？哈哈。malloc将内存分成了大小不同的chunk，然后通过来组织起来。malloc将，这样一个。malloc一共维护了，并使用一个数组来存储这些bin。数组中第一个为unsorted bin,数组从2开始编号，前。
内存池的简单实现 c语言
qq_26144489的博客
01-04 337
内存池
C 语言内存池实现，包含内存池的创建、销毁、分配和释放等操作，使用了链表来管理内存块
MyLovelyJay的博客
04-15 209
C 语言内存池实现，包含内存池的创建、销毁、分配和释放等操作，使用了链表来管理内存块
内存池 c语言实现
weixin_60208935的博客
09-28 3204
本文旨在纯c实现内存池。根据服务器一个客户端对应一个连接，一个连接对应一个内存池的业务场景实现内存池。
C语言-手写天天酷跑exe应用程序
07-06
【标题】"C语言-手写天天酷跑exe应用程序"涉及的是使用C语言进行游戏开发的知识，特别是如何创建一个可执行的exe程序。C语言是一种底层、高效的编程语言，广泛用于系统开发、游戏编程等领域。在本项目中，开发者不仅...
手写代码-手写代码大佬 戴方勤 著
06-25
《手写代码-手写代码大佬 戴方勤 著》这个资源是针对程序员面试的一个重要学习资料，尤其对于想要在C++和C语言领域深入发展的求职者来说更是不可多得的宝典。这份资源源于戴方勤，一位在编程领域具有深厚造诣的大佬...
C语言实现神经网络手写数字识别_LeNet-5
07-02
- **内存管理**：C语言需要手动管理内存，对于大规模的矩阵运算，需要谨慎处理内存分配和释放，避免内存泄漏。 - **并行计算**：虽然C语言可以利用多线程（如POSIX线程库）进行并行计算，但实现起来相对复杂，尤其是...
安徽专升本计算机C语言程序设计各院校真题手写速记
04-15
考生需理解数组的声明、初始化、索引访问以及数组在内存中的存储方式。 在处理输入输出时，考生应熟悉`printf`和`scanf`函数的使用，同时还要注意格式化字符串的编写，以确保数据正确地输出和输入。对于更复杂的...
C++手写内存池
lingshengxiyou的博客
04-08 134
/内存池的字节大小 = 每个实例的大小（字节数）* 内存池中能容纳的最大实例数 freeMemHeader = reinterpret_cast(new char[pool_mem_bytes]);若内存池中无内存，则再申请分配大块内存。细心的读者可能会发现，前面的那两种方案都有共同的小缺陷，即当程序一直实例化而不析构时，内存池会向操作系统申请多次大块内存，而当这些对象一起回收时，内存池中的剩余桶数会远大于设定的POOL_SIZE的大小，这个峰值多大取决于类实例化和回收的时机。
c语言实现内存池
qq_39466755的博客
02-06 548
所谓内存池，顾名思义和线程池的设计原理是一样的，为了减少频繁申请释放内存而带来的资源消耗，减少释放内存后产生的内存碎片。
【池化技术】内存池技术原理和C语言实现_内存池c语言
2401_84264107的博客
04-12 1175
NULL) //节点开辟不成功\n”);n += 1;//节点总数增加1个if(n == 1) //如果节点总数是1，则head指向刚创建的节点p1//此时的p2就是p1,也就是p1->next指向NULL。else//指向上次下面刚刚开辟的新节点p2 = p1;//把p1的地址给p2保留，然后p1产生新的节点//开辟出新节点\n”,n+1);//开辟出新内存块//链表的最后一个节点指向NULL。
图文结合纯c手写内存池
清风
07-27 3426
本文从零到一，手把手实现一个内存池。
性能优化-高效内存池的设计与实现
高性能架构探索
12-07 2509
原文地址： 高效内存池的设计与实现 关注公众号【高性能架构探索】，也可以后台回复【pdf】，获取计算机必备经典书籍 大家好，我是雨乐！ 在之前的文章中，我们分析了glibc内存管理相关的内容，里面的是不是逻辑复杂????，毕竟咱们用几十行代码完成的功能，glibc要用上百乃至上千行代码来实现，毕竟它的受众太多了，需要考虑跨平台，各种边界条件等。 其实，glibc的内存分配库ptmalloc也可以看做是一个内存池，出于性能考虑，每次内存申请都是先从ptmalloc中进行分配，如果没有合适的则通过系统分配函
基于C语言的内存池的设计与实现
ugg的专栏
03-27 1万+
介绍：       设计内存池的目标是为了保证服务器长时间高效的运行，通过对申请空间小而申请频繁的对象进行有效管理，减少内存碎片的产生，合理分配管理用户内存，从而减少系统中出现有效空间足够，而无法分配大块连续内存的情况。目标：    此次设计内存池的基本目标，需要满足线程安全性（多线程），适量的内存泄露越界检查，运行效率不太低于malloc/free方式，实现对4-128字节范围内
各种池---内存池的高效实现（C语言）
热门推荐
forever5312的专栏
09-19 2万+
序言 在编程过程中，尤其是对于C语言开发者，其实编程就是在使用内存，不停地变化内存中的数据。当我们想开辟一片新的内存使用时，就会使用malloc实现。但是通过查阅很多资料，发现频繁的使用malloc并不是很好的选择。原因就是如果频繁的申请内存、释放内存，操作系统由于内存管理算法原因，导致会出现内存碎片。其实产生碎片是一件很平常的事情，为何会这样，我想主要是内存利用率与性能的一个平衡。如果操作系统
C语言的内存池的设计与实现6,C++内存池实现
weixin_29501693的博客
05-20 267
C++内存池设计在项目中进程要对变量和对象分配空间，由于频繁的使用new和delete很消耗程序的运行时间，而且容易产生各种内存泄露，内存释放错误等问题。为此，需要设计一个通用的内存池来完成相关的分配和释放的工作。建立内存池：首先向系统申请一块内存，这块内存的大小由使用者根据需要设置初始内存大小。定义一个如下面代码所示的双向链表，将从系统分配的内存分为若干块。使用双向链表方便指针向前和向后遍历查找...
c语言手写memset函数
08-21
当然，我可以帮你手写一个简单的memset函数。memset函数用于将一块内存区域设置为指定的值。 下面是一个使用C语言编写的示例： ```c #include <stdio.h> void *my_memset(void *ptr, int value, size_t num) { unsigned char *p = ptr; while (num-- > 0) { *p++ = (unsigned char)value; } return ptr; } int main() { char str = "Hello, World!"; printf("Before memset: %s\n", str); my_memset(str, '-', 5); printf("After memset: %s\n", str); return 0; } ``` 上述代码中，我们定义了一个名为`my_memset`的函数。该函数接受三个参数：要设置的内存指针`ptr`，要设置的值`value`，以及要设置的字节数`num`。函数通过将指针逐个指向的内存位置赋值为指定值来实现。 在主函数中，我们声明了一个字符数组`str`并初始化为"Hello, World!"。我们调用了`my_memset`函数将数组中的前5个字符设置为'-'，然后打印结果。 运行上述代码将输出： ``` Before memset: Hello, World! After memset: ----- World! ``` 这样，我们就手写了一个简单的memset函数。请注意，这只是一个基本的示例，并未进行任何错误检查或优化。实际使用时，你可能需要添加更多的功能来满足你的需求。希望对你有所帮助！如果你还有其他问题，请随时提问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

fallsom

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

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

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

打赏作者

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

抵扣说明：

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

余额充值