内存池管理 库 分享

最新推荐文章于 2025-08-06 17:01:48 发布
最新推荐文章于 2025-08-06 17:01:48 发布
阅读量219 收藏 4
点赞数 6
CC 4.0 BY-SA版权
文章标签： 算法
g
本文链接：https://blog.csdn.net/qq_51082383/article/details/149450464

文章目录

简洁

内存池是一种 预先分配一大块内存，然后再按需 “划小块” 提供内存的机制

撰写原由

文档

模块：hali_memory_pool
功能：线程池 
实现：未采用常见的分块化结构，更是根据所需空间大小，动态组建——块链表
	优点：1.小数量大需求情况下，对于头的占用减少 2.避免了分块导致的分配大小>需求大小的问题
	缺点：


结构体：
struct Hali_SubModule_Pool {
	struct Hali_SubModule_Pool *next; /* 指向下一个可用内存块的位置，为NULL就是没有下一个 */

	unsigned short module_size; /* 该内存区域块的大小 ，柔性数组指向空间的大小 */
	unsigned char used; /* 该内存区域是否有使用 */
	unsigned char reserved;

	unsigned char *data[]; /* 柔性数组，指向真实可分配使用空间 */
};

#define SUB_MODULE_HEAD_SIZE sizeof(struct Hali_SubModule_Pool)

typedef struct Hali_Memory_Pool {
	unsigned char *pool_start_address; /* 内存池起始地址 */

	unsigned char *pool_rightmost_address;

	struct Hali_SubModule_Pool *list;
}Hali_Memory_Pool;
Hali_Memory_Pool hali_p;

一个块的架构
头 + data

头的构成：
4Bytes	——	*next
2Bytes	——	module_size
1Bytes	——	used
1Bytes	——	reserved

我们暂且将一个“ 头 + data ”的结构称为块
当 块 与 块相邻时，会判断是否可以融合，即将两个块融合为一个块，从而节省对 头 的开支

请求空间，分配大小时，也会尽量分配给合适的块供给，以免导致内存池碎片化

.c

#include "hali_memory_pool.h"
#include <string.h>
#include <stdlib.h>

/**
 * 内存池 优点：更高的速度，更低的碎片，更低的系统开销
 * 缺点： 对于空间管理上的冗余字段的浪费现象
 *
 * 力求 设计一种较好的内存池管理
 */

#define TAG "hali_memory_pool"
#define HALI_MEMORY_DEBUG_SWITCH_FLAG	(1)
#ifdef HALI_MEMORY_DEBUG_SWITCH_FLAG
 #define HALI_MD_LOGE	printf // error
 #define HALI_MD_LOGW	printf // warning
 #define HALI_MD_LOGI	printf // info
 #define HALI_MD_LOGD	printf // debug
 #define HALI_MD_LOGV	printf // verbose
#else
 #define HALI_MD_LOGE	
 #define HALI_MD_LOGW	
 #define HALI_MD_LOGI	
 #define HALI_MD_LOGD	
 #define HALI_MD_LOGV	
#endif

#define DIFF_MAX_VALUE (unsigned int)(-1)

enum HALI_RETURN_TYPE {
	HALI_RETURN_ERROR = -1,
	HALI_RETURN_OK = 0,
};

struct Hali_SubModule_Pool {
	struct Hali_SubModule_Pool *next; /* 指向下一个可用内存块的位置，为NULL就是没有下一个 */

	unsigned short module_size; /* 该内存区域块的大小 ，柔性数组指向空间的大小 */
	unsigned char used; /* 该内存区域是否有使用 */
	unsigned char reserved;

	unsigned char *data[]; /* 柔性数组，指向真实可分配使用空间 */
};

#define SUB_MODULE_HEAD_SIZE sizeof(struct Hali_SubModule_Pool)

typedef struct Hali_Memory_Pool {
	unsigned char *pool_start_address; /* 内存池起始地址 */

	unsigned char *pool_rightmost_address;

	struct Hali_SubModule_Pool *list;
}Hali_Memory_Pool;
Hali_Memory_Pool hali_p;

static unsigned char hali_memory_pool_inited = 0;


static void* hali_malloc(int size)
{
#if HALI_POOL_MEMORY_USE_PSRAM
	psram_malloc(size);
#else
	malloc(size);
#endif
}

static void hali_free(void *data) 
{
#if HALI_POOL_MEMORY_USE_PSRAM
	psram_free(data);
#else
	free(data);
#endif	
}

static void ensure_rightmost_address(void)
{
	struct Hali_SubModule_Pool *pos = (struct Hali_SubModule_Pool *)hali_p.pool_start_address;
	struct Hali_SubModule_Pool *pos_last = NULL;

	do {
		pos_last = pos;
		hali_p.pool_rightmost_address = (unsigned char*)pos_last;
		pos = (struct Hali_SubModule_Pool *)((unsigned char*)pos + SUB_MODULE_HEAD_SIZE + pos->module_size);
		if (pos && pos->next != pos_last) { // 说明这就是最右边的 block 了
			break;
		} else if (!pos) {
			break;
		}
	} while(1);
}

static struct Hali_SubModule_Pool *get_last_node(struct Hali_SubModule_Pool *node)
{
	ensure_rightmost_address();

	struct Hali_SubModule_Pool *pos = (struct Hali_SubModule_Pool *)hali_p.pool_rightmost_address;

	for (; pos; pos = pos->next) {
		if (pos->next == node) {
			return pos;
		}
	}

	return NULL; // 说明并没有前一个
}

void *hali_memory_pool_alloc(int size)
{
	if (size < 0) {
		HALI_MD_LOGE("%s -> args is invalid\r\n", TAG);
		return NULL;
	}
	ensure_rightmost_address();
	
	// NOTE 寻找最适合的 块，分配空间
	struct Hali_SubModule_Pool *pos = (struct Hali_SubModule_Pool *)hali_p.pool_rightmost_address;
	struct Hali_SubModule_Pool *new = NULL;
	struct Hali_SubModule_Pool *pos_last = NULL;
	struct Hali_SubModule_Pool *match_pos = NULL;
	unsigned int diff_min_size = DIFF_MAX_VALUE;

	// REVIEW 或许后面这个算法还可以优化???
	for (; pos; pos = pos->next) { // 轮询一周，找到大小与size最接近的 block
		if (pos->used == 0 && pos->module_size >= size) {
			if ((pos->module_size - size) < diff_min_size) {
				diff_min_size = pos->module_size - size;
				match_pos = pos;
			}
		} else { 
			continue;
		}
	}

	// NOTE 融合操作只在free的时候才有，也就是代表申请空间时，不存在融合操作，只有分块操作
	if (diff_min_size != DIFF_MAX_VALUE) { // NOTE 这原本就是一个块，是已经分为了块的
		new = match_pos;
		// new->data = match_pos->data; // 柔性数组 本身就是指向这个位置 显示表达就是如此
		new->next = match_pos->next;
		new->module_size = size;
		new->used = 1;

		if (diff_min_size >= SUB_MODULE_HEAD_SIZE) { // 说明剩余大小还可以成块
			match_pos = (struct Hali_SubModule_Pool *)((unsigned char*)match_pos + SUB_MODULE_HEAD_SIZE + size);
			match_pos->module_size = diff_min_size - SUB_MODULE_HEAD_SIZE; // 此值可以为0
			match_pos->used = 0;
			// match_pos->data = (unsigned char*)match_pos + SUB_MODULE_HEAD_SIZE; // 同上柔性数组解释
			match_pos->next = new;
			pos_last = get_last_node(match_pos);
			if (pos_last) {
				pos_last->next = match_pos;
			}
		} else { // 剩余空间大小不足以成块，直接冗余分配出去 (因为无法形成头即无法执行融合块操作)
			new->module_size += diff_min_size;
		}

		return (void *)new->data;
	}

	return NULL; // 分配不了
}

int hali_memory_pool_free(void *data) // 释放空间需要注意 （ 标记为不合法时，需要再自动归碎为整数 ）
{
	if (data == NULL) {
		HALI_MD_LOGE("%s -> args is invalid\r\n", TAG);
		return HALI_RETURN_ERROR;
	}
	ensure_rightmost_address();

	struct Hali_SubModule_Pool *pos = (struct Hali_SubModule_Pool *)hali_p.pool_rightmost_address;
	struct Hali_SubModule_Pool *pos_last = NULL;
	struct Hali_SubModule_Pool *pos_last_last = NULL;
	struct Hali_SubModule_Pool *pos_next = NULL;

	for (; pos; pos = pos->next) {
		if (pos->data == data) { // 找到了
			pos_last = get_last_node(pos);
			if (pos->next) { // 存在两边都有的情况
				pos_next = pos->next;
				if (pos_next->used == 0) { // 左边可融合
					if (pos_last && pos_last->used == 0) { // 左边右边都可以融合 就融合成一个大的
						pos_next->module_size = pos_next->module_size + SUB_MODULE_HEAD_SIZE + pos->module_size + SUB_MODULE_HEAD_SIZE + pos_last->module_size;
						memset(pos_next->data, 0, pos_next->module_size);
						return HALI_RETURN_OK;
					} else { // 只能和左边融合
						pos_next->module_size = pos_next->module_size + SUB_MODULE_HEAD_SIZE + pos->module_size;
						memset(pos_next->data, 0, pos_next->module_size);
						return HALI_RETURN_OK;
					}
				} else { // 只需要考虑右边可不可以融合
					goto JUST_RIGHT;
				}	
			} else { // 只有右边节点指向过来
JUST_RIGHT:
				if (pos_last && pos_last->used == 0) { // 前面一个节点是未使用的 合并
					pos_last_last = get_last_node(pos_last);
					if (pos_last_last) {
						pos_last_last->next = pos;
					}
					pos->module_size = pos->module_size + SUB_MODULE_HEAD_SIZE + pos_last->module_size;
					pos->used = 0;
					memset(pos->data, 0, pos->module_size);
					return HALI_RETURN_OK;
				} else { // 前面一个节点是使用了的，无法合并，直接表示未再使用即可
					pos->used = 0;
					memset(pos->data, 0, pos->module_size);
					return HALI_RETURN_OK;
				}
			}

		} else {
			continue;
		}
	}

	// 这里返回 说明根本就找不到这个block
	return HALI_RETURN_ERROR;
}

/**
 * 为线程池总初始化，并分配成一个 “块”
 * @return  HALI_RETURN_OK:成功 HALI_RETURN_ERROR：失败
 */
static int hali_memory_pool_malloc(void)
{
	hali_p.pool_start_address = hali_malloc(HALI_POOL_MEMORY_SIZE);
	if (hali_p.pool_start_address == NULL) {
		HALI_MD_LOGE("%s -> malloc failed,please ensure\r\n", TAG);
		return HALI_RETURN_ERROR;
	}
	hali_p.pool_rightmost_address = hali_p.pool_start_address;

	hali_p.list = (struct Hali_SubModule_Pool *)hali_p.pool_start_address;
	hali_p.list->next = NULL;
	hali_p.list->module_size = HALI_POOL_MEMORY_SIZE - SUB_MODULE_HEAD_SIZE;
	hali_p.list->used = 0;
	// hali_p.list->data = hali_p.pool_start_address + SUB_MODULE_HEAD_SIZE; // 同上柔性数组解释

	return HALI_RETURN_OK;
}

/**
 * 释放整个线程池
 * @return  HALI_RETURN_OK:成功 HALI_RETURN_ERROR：失败
 */
static int hali_memory_pool_free_all(void)
{
	if (hali_p.pool_start_address) {
		hali_free(hali_p.pool_start_address);
	} else {
		return HALI_RETURN_ERROR;
	}

	return HALI_RETURN_OK;
}

int hali_memory_pool_init(void)
{
	if (hali_memory_pool_inited == 1) {
		HALI_MD_LOGW("%s -> pool init already init\r\n", TAG);
		return HALI_RETURN_ERROR;
	}
	int ret = -1;

	ret = hali_memory_pool_malloc();
	if (ret != HALI_RETURN_OK) {
		HALI_MD_LOGD("%s -> malloc module failed,memory pool init failed\r\n\r\n", TAG);
		return HALI_RETURN_ERROR;
	}

	return HALI_RETURN_OK;
}


int hali_memory_pool_deinit(void)
{
	if (hali_memory_pool_inited == 1) {
		HALI_MD_LOGW("%s -> pool deinit not init yet\r\n", TAG);
		return HALI_RETURN_ERROR;
	}

	int ret = -1;

	ret = hali_memory_pool_free_all();
	if (ret != HALI_RETURN_OK) {
		HALI_MD_LOGD("%s -> free module failed,memory pool deinit failed\r\n\r\n", TAG);
		return HALI_RETURN_ERROR;
	}

	return HALI_RETURN_OK;
}

// test code under

static void print_pool_free_size(void)
{
	unsigned int free_sum_size = 0;
	unsigned short block_num = 0;
	struct Hali_SubModule_Pool *pos = NULL;

	ensure_rightmost_address();
	pos = (struct Hali_SubModule_Pool *)hali_p.pool_rightmost_address;

	for (; pos; pos = pos->next) {
		if (pos->used == 0) {
			free_sum_size += (pos->module_size + SUB_MODULE_HEAD_SIZE);
		}
		block_num++;
	}

	HALI_MD_LOGD("%s -> free sum size is %d\r\n", TAG, free_sum_size);
	HALI_MD_LOGD("%s -> block num is %d\r\n", TAG, block_num);
}

int main(void)
{
	HALI_MD_LOGD("%s -> test begin\r\n", TAG);

	hali_memory_pool_init();
	print_pool_free_size();

	void *data_0 = hali_memory_pool_alloc(200); 
	if (data_0 != NULL) {
		HALI_MD_LOGD("%s -> alloc data_0 ok\r\n", TAG);
	}
	print_pool_free_size();
	if (hali_memory_pool_free(data_0) == HALI_RETURN_OK) {
		HALI_MD_LOGD("%s -> free data_0 ok\r\n", TAG);
	}
	print_pool_free_size();

	void *data_1 = hali_memory_pool_alloc(100); 
	if (data_1 != NULL) {
		HALI_MD_LOGD("%s -> alloc data_1 ok\r\n", TAG);
	}
	print_pool_free_size();
	void *data_2 = hali_memory_pool_alloc(100); 
	if (data_2 != NULL) {
		HALI_MD_LOGD("%s -> alloc data_2 ok\r\n", TAG);
	}
	print_pool_free_size();
	if (hali_memory_pool_free(data_1) == HALI_RETURN_OK) {
		HALI_MD_LOGD("%s -> free data_1 ok\r\n", TAG);
	}
	print_pool_free_size();
	if (hali_memory_pool_free(data_2) == HALI_RETURN_OK) {
		HALI_MD_LOGD("%s -> free data_2 ok\r\n", TAG);
	}
	print_pool_free_size();

	return 0;
}

.h

#ifndef __HALI_MEMORY_POOL_H__
#define __HALI_MEMORY_POOL_H__

#ifdef _cplusplus
extern "C" {
#endif

/**
 * 内存池
 */

#include "stdio.h"

#define HALI_POOL_MEMORY_USE_PSRAM	(0)

#define HALI_POOL_MEMORY_SIZE	8192 // memory pool size


void *hali_memory_pool_alloc(int size); 
int hali_memory_pool_free(void *data);

int hali_memory_pool_init(void); // 申请一大段区域用于使用
int hali_memory_pool_deinit(void); // 



#ifdef _cplusplus
}
#endif
#endif // end __HALI_MEMORY_POOL_H__

结尾

欢迎交流指正~

堆外内存 OOM：现象分析与优化方案
张彦峰的博客
03-30 4万+
本文分析了 Java 中堆外内存泄漏及其引发的 OOM 问题，重点讨论了主动申请未释放和 JNI 调用未释放的两大原因。提供了排查策略，如启用 Native Memory Tracking（NMT）和监控堆外内存使用。并提出了优化方案，包括合理管理堆外内存、设置内存限制及定期监控，帮助避免内存泄漏对系统性能的影响。
内存池对象池设计
12-28
内存池和对象池是计算机程序设计中的两种优化技术，它们主要应用于C++编程语言...希望这个介绍能为你提供关于内存池和对象池设计的深入理解，也欢迎你分享自己的观点和改进建议，共同探讨这些高效内存管理策略的实现。
boost库 内存池
weixin_50873490的博客
07-29 1553
简单轻量:它是一个基础的内存管理工具,实现简单,开销较小。高效:通过维护内存块列表,可以快速分配和回收内存。可定制:提供了许多可配置的选项,如内存块大小、对齐方式等。可重用:可以被上层的内存池实现 (如) 重复利用。内存池管理Boost.Pool 提供了两种主要的内存池实现:和。它们都利用来管理内存块,提高内存利用率和缓存命中率。固定大小对象管理Boost.Pool 专注于管理固定大小的对象,这种设计能够提高内存管理的效率。它使用连续的内存块来存储这些对象,避免了频繁的new和。
C++11实现高效内存池
nepu_bin的博客
05-03 4089
【源码剖析】MemoryPool —— 简单高效的内存池 allocator 实现 什么是内存池？什么是 C++ 的 allocator？ 内存池简单说，是为了减少频繁使用 malloc/free new/delete 等系统调用而造成的性能损耗而设计的。当我们的程序需要频繁地申请和释放内存时，频繁地使用内存管理的系统调用可能会造成性能的瓶颈，嗯，是可能，毕竟操作系统的设计也不是盖的（麻麻说把话说太满会被打脸的(⊙v⊙)）。内存池的思想是申请较大的一块内存（不够时继续申请），之后把内存管理放在应用层执行，减
池式结构---内存池
Z2460986913的博客
04-12 1244
内存池是在程序运行初期，预先从系统申请一块较大连续内存空间的池式结构。负责管理内存空间的分配与回收工作，当程序需要小块内存时，直接从内存池中取出合适的部分交付，而不是频繁向系统请求；当程序释放内存时，内存池将其回收，等待下次再分配，而非立刻归还给系统。减少因频繁系统调用带来的开销，提高内存分配的效率。同时降低内存碎片的产生，因为系统调用分配内存相对耗时，且零散的内存分配易产生碎片，内存池通过集中管理内存，有效解决了这些问题。
FastMM4内存管理库深度解析与应用
weixin_35749440的博客
05-27 965
FastMM4是一款高效的开源内存管理库，它专门为Delphi和Free Pascal应用程序设计，提供了一系列内存管理的优化工具。通过对传统内存管理的改良，FastMM4能够有效地减少内存碎片，提高内存分配效率，同时通过集成内存泄漏检测功能，帮助开发者快速定位并修复潜在问题。本章将概述FastMM4的主要特点、功能以及它如何在内存管理方面优于标准的内存管理器，为后续章节中关于内存优化、泄漏检测、多线程管理等深入讨论打下基础。
Qt平台下C++内存管理
23时01分
04-11 1239
C++编程中，内存一直就是显著的问题。在Qt平台中，我推荐使用Qt智能指针、对象树、大内存技术来进行内存管理。
【带你吃透C++】C++动态内存管理
平淡中造就不平凡
01-21 6943
作为一名编程初学者，通常学习中，发生内存错误是件非常麻烦的事情。编译器不能自动发现这些错误，通常是在程序运行时才能捕捉到。而这些错误大多没有明显的症状，时隐时现，增加了改错的难度。 了解内存分配并掌握运用它是必不可少的。本文主要针对C++动态内存管理内容进行分享，如果想了解C语言动态内存管理可以参考：【C语言进阶】动态内存管理（详细介绍）
自用学习资料，Linux内核之【内存管理】的一些分享
a410974689的博客
12-23 1172
本文涉及的资料全部打包放到我Github仓： GitHub - 0voice/kernel_memory_management: 总结整理linux内核的内存管理的资料，包含论文，文章，视频，以及应用程序的内存泄露，内存池相关 有需要的可以前去下载，或者觉得还不错，请给我Star，感谢支持！ ???? 100篇文章 内存管理（一）：硬件原理 和 分页管理 内存管理（二）：内存的动态申请和释放 内存管理（三）：进程的内存消耗和泄漏 内存管理（四）：内存与IO的交换 内存管理（五）：其他工程问题以及调优 -
C++之内存管理：申请与释放
weixin_53472920的博客
08-17 7647
其实关于内存管理，我觉得重点就在于合理申请，及时释放，将有限的内存空间发挥出最大的价值。
C++ 游戏开发中内存管理进阶
好看资源网的博客
10-08 1865
内存管理是游戏开发中不可或缺的一部分，特别是在 C++ 这类低级语言中，开发者需自行处理内存的分配和释放。有效的内存管理不仅能提高游戏性能，还能提升代码的稳定性和安全性。内存池是一种高效的内存管理技术，能够降低内存分配和释放的开销，尤其适合高频率分配和释放的场景。自定义内存分配器可以根据游戏的特定需求优化内存管理，降低分配和释放的开销。例如，可以实现一个基于内存池的分配器。内存管理在游戏开发中是一个复杂而重要的话题。随着技术的发展，内存管理也在不断演进，开发者需要不断学习和实践，掌握最新的内存管理技巧。
基于TCMalloc原理的C++高并发内存池设计源码
09-29
在该项目中，涉及了内存管理的核心机制，如内存分配策略、内存池的大小、内存碎片的处理以及如何高效地回收内存等。 项目包含的文件类型多样，其中头文件主要包含了内存池设计的接口声明和数据结构定义；C++源文件...
C++内存池自实现方法及代码文档分享
- 兼容性：内存池的实现需要与C++标准库中的容器和算法兼容，提供与std::vector、std::list等容器类似的行为。 文档部分可能详细描述了该内存池的使用方法、设计理念、性能测试结果等信息，而代码部分则是实现内存...
贝叶斯分类算法详解：从数学原理到实践应用
weixin_73958875的博客
08-05 613
本文系统介绍了贝叶斯分类算法及其应用。首先阐述了贝叶斯定理的数学原理，包括朴素贝叶斯的特征独立性假设及其三种主要实现形式（高斯、多项式和伯努利贝叶斯）。然后详细解析了Scikit-learn中贝叶斯分类器的API参数和使用方法，包括关键参数调优建议。最后通过垃圾邮件分类案例展示了实际应用流程，并分析了贝叶斯算法在计算效率、内存消耗等方面的优势，以及特征独立性假设带来的局限性。全文为读者提供了从理论到实践的完整贝叶斯分类器应用指南。
Transformer实战——Transformer分词算法详解
盼小辉丶的博客
08-05 714
本文系统性地介绍了 Transformer 模型中的分词算法。我们首先分析了传统分词方法的局限性，进而深入探讨了 BPE、WordPiece 和 SentencePiece 这三种子词分词算法的工作原理和适用场景。通过 Hugging Face tokenizers 库的实践，完整展示了分词器从数据预处理到模型训练的全流程。
USACO 2025 JAN Table Recovery S 题解
2401_84512298的博客
08-06 886
举例+思路+实现，保姆级详细题解
非机动车识别mAP↑28%！陌讯多模态融合算法在智慧交通的实战解析
最新发布
2501_92472966的博客
08-06 416
陌讯多模态融合算法显著提升非机动车识别性能，在边缘计算设备上实现[email protected]达89.1%，较基线提升28%。该方案通过偏振特征增强、HDR补偿等技术有效解决强光/逆光等复杂场景识别难题，使小目标识别率提升46.1%，早晚高峰漏检率降低85.3%。同时提供INT8量化等边缘部署优化方案，内存占用减少60%且保持精度损失<0.5%。实测数据表明，该技术可显著提升智慧交通场景下的非机动车识别准确率。
力扣热题100——子串
weixin_45789915的博客
08-05 240
我的暴力双指针解法超时，并且此方法仅适用于全非负数组！
无人机开发分享——基于行为树的无人机集群机载自主决策算法框架搭建及开发
Vesan的博客
08-06 254
* 在之前的开发分享中，我们分享了机载端开发任务管理、协同控制、无人机平台接口等一系列模块软件，但是要想实现真正的无人机高度智能化，机载的自主决策模块功能必不可少。机载自主决策模块主要实现无人机集群任务过程中地面任务获取分析、战场实时态势分析与自主决策，可在断连或自主模式时对作业中的无人机集群进行决策与控制，减少地面交互，提升任务效率。下面我们对机载自主决策模块的开发进行介绍。**
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值