基于C语言的内存池实现

已于 2022-09-21 17:44:29 修改
阅读量1.1k 收藏 10
点赞数 2
文章标签： 内存池 内存管理 性能优化 tcmalloc 代码实现
于 2022-09-16 15:48:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/thunderLZM/article/details/126889844
版权

前言

1、池化技术 ：简单点来说，就是提前保存大量的资源，以备不时之需

        对于线程，内存，oracle的连接对象等等，这些都是资源，程序中当你创建一个线程或者在堆上申请一块内存时，都涉及到很多系统调用，也是非常消耗CPU的，如果你的程序需要很多类似的工作线程或者需要频繁的申请释放小块内存，如果没有在这方面进行优化，那很有可能这部分代码将会成为影响你整个程序性能的瓶颈。

池化技术主要有线程池，内存池，连接池，对象池等等。

一、内存池

1、内存池原理

        内存池(Memory pool)提供了一种比较可行的解决方案。首先是创建内存池。这个过程的主要任务是预先分配足够大的内存，形成一个初步的“内存池”。分配内存，也就是用户请求内存时，会返回内存池中一块空闲的内存，并将其标志置为已使用，当然具体细节和方法有很多。释放内存时，不是真正地调用free或是delete的过程，而是把内存放回内存池的过程。在把内存放入内存池的同时，要把标志位置为空闲。最后在应用程序结束时，要把内存池销毁。这里主要做的工作就是把内存池中的每一块内存释放。

2、使用内存池的好处

        设计内存池的目标是为了保证代码长时间高效的运行，通过对申请空间小而申请频繁的对象进行有效管理，减少内存碎片的产生，合理分配管理用户内存，从而减少系统中出现有效空间足够，而无法分配大块连续内存的情况。

  • 减少了内存碎片的产生。这个可以从创建内存池的过程中看出。我们在创建内存池时，分配的都是一块块比较整的内存块，这样可以减少内存碎片的产生；
  • 提高了内存的使用效率。这个可以从分配内存和释放内存的过程中看出。每次的分配与释放并不是去调用系统提供的函数或是操作符去操作实际的内存，而是在复用内存池中的内存。

3、缺点

就是很有可能会造成内存的浪费，原因也很明显，开始分配了一大块内存，不是全部都用得到的。

4、内存池的代码实现

内存池代码实现原理图

 4.1、内存池结构体

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

typedef struct mp_large_s {
	struct mp_large_s *next;    //下一块 内存大块
	void *alloc;                //内存大块的地址
}mp_large_t;

typedef struct mp_node_s {

	unsigned char *last;        //当前 内存小块已分配的地址
	unsigned char *end;         //内存小块 末尾地址
	
	struct mp_node_s *next;     //指向下一块 内存小块
	size_t failed;              //5次访问节点还是不可以分配空间就访问下一个节点
}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;

4.2 内存池函数封装

mp_pool_t *mp_create_pool(size_t size);            //内存池创建
void mp_destory_pool(mp_pool_t *pool);             //内存池删除
void *mp_alloc(mp_pool_t *pool, size_t size);      //内存池分配
void *mp_nalloc(mp_pool_t *pool, size_t size);     //内存池分配
void *mp_calloc(mp_pool_t *pool, size_t size);     //内存池分配
void mp_free(mp_pool_t *pool, void *p);            //内存池释放
void mp_reset_pool(mp_pool_t *pool) ;              //内存池重置

4.3 内存池测试代码

mp_pool_t *mp_create_pool(size_t size) {

	mp_pool_t *p;
	int ret = posix_memalign((void **)&p, MP_ALIGNMENT, size + sizeof(mp_pool_t) + sizeof(mp_node_t));
	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(mp_pool_t) + sizeof(mp_node_t);
	p->head->end = p->head->last + size;

	p->head->failed = 0;

	return p;

}

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

}

//内存池重置 释放large 将node节点last重置
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);
	}

}

//内存池小块分配
static void *mp_alloc_block(mp_pool_t *pool, size_t size) {

	unsigned char *m;
	mp_node_t *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->end = m + psize;
	new_node->next = NULL;
	new_node->failed = 0;

	m += sizeof(mp_node_t);
	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(mp_pool_t *pool, size_t size) {

	void *p = malloc(size);
	if (p == NULL) return NULL;

	size_t n = 0;
	mp_large_t *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(mp_large_t));
	if (large == NULL) {
		free(p);
		return NULL;
	}

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

	return p;
}

void *mp_memalign(mp_pool_t *pool, size_t size, size_t alignment) {

	void *p;
	
	int ret = posix_memalign(&p, alignment, size);
	if (ret) {
		return NULL;
	}

	mp_large_t *large = mp_alloc(pool, sizeof(mp_large_t));
	if (large == NULL) {
		free(p);
		return NULL;
	}

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

	return p;
}

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

	unsigned char *m;
	mp_node_t *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(mp_pool_t *pool, size_t size) {

	unsigned char *m;
	mp_node_t *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(mp_pool_t *pool, size_t size) {

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

	return p;
	
}

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


int main(int argc, char *argv[]) {

	int size = 1 << 12;
	int size1 = 1 << 3;
	int size2 = 1 << 6;
	int size3 = 1 << 9;
	mp_pool_t *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;

}

5、内存池库tcmalloc的使用

5.1 tcmalloc安装

        tcmalloc在gperftools之中，故想要使用tcmalloc，就得先安装gperftools。在linux下，其安装步骤如下：

去github官网下载： http://​ https://github.com/gperftools/gperftools.git ​ gperftools-master.zip

环境配置：

编译环境：Ubuntu 

编译器：arm-fsl-linux-gnueabi

指定安装路径：/home/thunder/Downloads/gperftools-master/build

cd gperftools-master

./autogen.sh 

默认安装

./configure --enable-frame-pointers

指定安装

./configure --prefix=/home/thunder/Downloads/gperftools-master/build --host=arm-fsl-linux-gnueabi --enable-frame-pointers

sudo make

sudo make install

执行上面命令后会生成下面4个文件

 5.2 tcmalloc的使用

只要在编译代码时添加 -ltcmalloc就可以了。

gcc -o main main.cc -L. -ltcmalloc

这样编译出来的可执行程序main使用的malloc和free将来自tcmalloc。

补充：类似的内存池的库还有Jemalloc

完！

如过文章对您有帮助，请点赞一下吧

4

444内存池池的实现内存池的实现

BUG键盘侠
关注
C语言使用libpq访问PostgresQL数据库
08-10
虽然代码中是.cpp文件但其实本质上是C，其实不是原创！只是自己整理下!希望对在学习的朋友提供点帮助 。
内存池 c语言实现
weixin_60208935的博客
09-28 3392
本文旨在纯c实现内存池。根据服务器一个客户端对应一个连接，一个连接对应一个内存池的业务场景实现内存池。
内存管控：内存池篇
最新发布
TravisBytes的博客
09-10 888
内存池（Memory Pool）是一种高效的内存管理策略，旨在优化内存分配效率、减少内存碎片，并提高应用程序性能。它特别适合需要频繁分配和释放小块内存的场景，如高性能计算、实时系统、长时间运行的服务器和嵌入式设备等。
C语言内存池使用模型
系统运维
09-27 195
在用C语言开发时，特别是在服务器端，内存的使用会成为系统性能的一个瓶颈，如频繁的分配和释放内存，会不断的增加系统的内存碎片，影响内核之后分配内存的效率，这个时候一个比较可行的做法是采用内存池，先分配好比较多的内存，然后在这个已经分配的内存里使用内存，这样就不需要内核过多的参与内存分配和释放的过程。 内存池根据应用不同有多种实现的策略，如有些分配很大的内存，然后将内存分配成大小相等的块，并将每个块...
c语言实现内存池
qq_39466755的博客
02-06 657
所谓内存池，顾名思义和线程池的设计原理是一样的，为了减少频繁申请释放内存而带来的资源消耗，减少释放内存后产生的内存碎片。
c语言实现简单的内存池
weixin_47342627的博客
08-24 331
项目需求，因为需要频繁的申请和释放内存，需要更高的内存分配和释放效率，所以需要写一个效率高的内存池，因为当前项目需要的内存的大小就只有两种长度，都是小于128字节，所以用数组来做内存块的管理。另外要考虑多线程的互斥。内存池数据结构维护了allocated和idle两个链表，用来表示一个分配出去的，一个是空闲的。每个内存块有一个前向和后向指针最后要和系统函数（malloc、free）进行效率比较。
MemoryPool_C语言实现的简单内存池
05-14
本项目是用C++实现的一个简单内存池，尽管标题中提到的是C语言，但考虑到C++的面向对象特性，使用C++来实现内存池更为常见。 内存池的核心思想是减少系统调用的次数，因为在操作系统中，每次malloc或calloc等函数...
基于C语言实现内存型数据库（kv存储）.zip
06-14
同时，考虑到内存碎片问题，可以使用内存池技术优化内存分配。 4. 并发控制：如果我们的数据库需要支持多线程访问，那么就需要处理并发控制问题。C语言提供互斥锁（mutexes）、条件变量等工具来实现线程安全。正确...
内存池的介绍与设计详解
08-10
- 内存单元大小的选择：应该基于应用程序的内存需求，确保大多数分配请求能够匹配到内存池中的内存单元，以减少内存碎片。 - 链表结构的实现：如何高效地插入和删除内存单元，以满足快速分配和回收的需求。 - 内存池...
基于C++实现内存池技术 memorypool.zip
06-03
C++是一种广泛使用的编程语言，它是由Bjarne Stroustrup于1979年在新泽西州美利山贝尔实验室开始设计开发的。...因此，无论是初学者还是经验丰富的程序员，都可以通过C++来设计和实现新系统或维护旧系统。3
基于C语言实现的一个简单http的高并发服务器源码
09-27
在IT领域，构建一个基于C语言的简单HTTP高并发服务器是一项基础且重要的实践。这个项目主要涉及以下几个核心知识点： 1. **C语言编程基础**：C语言是底层系统编程的首选，它允许直接操作内存和硬件，使得创建高效、...
C 语言内存池实现，包含内存池的创建、销毁、分配和释放等操作，使用了链表来管理内存块
MyLovelyJay的博客
04-15 234
C 语言内存池实现，包含内存池的创建、销毁、分配和释放等操作，使用了链表来管理内存块
c语言实现的内存池（适用于两个线程、不加锁、效率高）
weixin_47342627的博客
08-28 374
设计一个内存池，要求效率比系统调用的效率要高（测试1万次），同时支持一个线程申请，另外一个线程释放。
【池化技术】内存池技术原理和C语言实现
qq_41854911的博客
12-12 6833
文章目录一、基础概念1.一个可执行程序占用的内存分为哪几个区？一个进程的虚拟内存区域有哪些？2.静态内存分配和动态内存分配二、malloc实现原理malloc内存分配（下面算是正常一般的情况了）三、使用C语言实现一个内存池1.C语言实现一个内存池 一、基础概念 在讲内存池技术之前，咱们先对一些基础概念进行阐述，以便能更好的讨论问题。 1.一个可执行程序占用的内存分为哪几个区？一个进程的虚拟内存区域有哪些？ C语言在内存中一共分为如下几个区域，分别是： 内存栈区（stack）： 存放局部变量名； 内存
【池化技术】内存池技术原理和C语言实现_内存池c语言
2401_84264107的博客
04-12 1269
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语言
qq_26144489的博客
01-04 368
内存池
C语言中的内存池和内存管理技术是什么？
weixin_68551689的博客
11-07 244
内存池是一种内存管理技术，它是为了提高内存分配和释放的效率而设计的。在传统的内存管理中，每次分配和释放内存都需要与操作系统交互，这涉及到较大的开销。内存池的目标是通过一次性分配一块连续的内存，然后将其划分成小块，以供程序使用，从而减少这种开销。内存分配器（Allocator）：内存分配器负责从操作系统中分配一块连续的内存。这块内存通常是较大的，然后内存分配器将其划分成小块，以供程序使用。内存块（Memory Blocks）
C语言简易内存池实现
qq_42120843的博客
11-04 1057
C语言实现简易内存池
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值