utlis 内存池 对象池

已于 2022-07-31 23:58:53 修改
阅读量145 收藏
点赞数
分类专栏： utlis 手写 文章标签： c++
于 2022-06-04 14:31:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41565920/article/details/125121523
版权

utils 内存池

内存池负责管理多个对象池，对象池负责管理多个对象

空间非连续，用时分配

对象池

对象池类的变量 map<mid_t, T*>负责记录正在使用的内存映射，POD类型的对象池，size时确定的
UNIT_POOL_BASE
+u64 _type
+int _num_limit
+int _unit_size
+int _max_used
+string _type_name
+alloc_unit() : virtual
+get_unit() : virtual
+free_unit() : virtual
+get_cur_use_num() : virtual
UNIT_POOL
+std::map _map_use 
class UNIT_POOL_BASE
{
public:
    virtual mid_t alloc_unit() = 0;
    virtual void free_unit(mid_t mid) = 0;
    virtual void* get_unit(mid_t mid) = 0;
    virtual int get_cur_use_num() = 0;

public:
    u16 _type;                       // pool type
    int _num_limit;                  // 数量限制
    int _unit_size;                  // 单个unit大小
    int _max_used;                   // 最大用了多少个
    std::string _type_name;          // type name
};

template<typename T>
class UNIT_POOL : UNIT_POOL_BASE
{
public:
    typedef typename std::map<mid_t, T*>::iterator IT;
    UNIT_POOL()
    {
        _map_use.clear();
        _num_limit = 0;
        _max_used = 0;
        _type_name = "";
    }

    ~UNIT_POOL()
    {
        for (auto& itr : _map_use)
        {
            if (itr->second)
            {
                delete (itr->second); //delete 指针时会调用指针所指对象的析构函数
            }
        }
        _map_use.clear();
    }

    virtual mid_t alloc_unit();
    virtual void free_unit(mid_t mid);
    virtual void* get_unit(mid_t mid);
    virtual int get_cur_use_num();

private:
    std::map<mid_t, T*> _map_use;  //  正在使用的内存映射
};

小技巧，使用位域在按type分配时，加入序列号信息。对象记录了自己的type可以反查到对应对象池的信息

typedef struct unitmid_t
{
    u64      type : 16;
    u64      serial : 48;
} unitmid_t;

inline mid_t alloc_mid(u16 type)
{
    static u64 base_id = 10000;
    ++base_id;

    unitmid_t unit_mid;
#pragma GCC diagnostic ignored "-Wconversion"
    unit_mid.type = type;
    unit_mid.serial = base_id;
#pragma GCC diagnostic pop
    return *(mid_t *)&unit_mid;
}

相应函数实现 分配对象 获取对象 释放对象

template<typename T>
mid_t UNIT_POOL<T>::alloc_unit()
{
    if (_num_limit <= (int)_map_use.size())
    {
        fatal_log("type:%d type_name:%s alloc fail, cur use:%d upper limit exceeded"
                    , _type, _type_name.c_str(), (int)_map_use.size());
        return INVALID_MID;
    }

    void* data = malloc(_unit_size);
    assert_retval(data, INVALID_MID);

    // placement new
    memset((char*)data, 0x00, _unit_size);
    T* ptr = new(data) T;
    assert_retval(ptr != nullptr, INVALID_MID);

    mid_t mid = alloc_mid(_type);
    _map_use[mid] = ptr;

    if (_max_used < (int)_map_use.size())
    {
        _max_used = (int)_map_use.size();
    }

    return mid;
}

#pragma GCC diagnostic ignored "-Wdelete-non-virtual-dtor"
template<typename T>
void UNIT_POOL<T>::free_unit(mid_t mid)
{
    IT itr = _map_use.find(mid);
    if (itr == _map_use.end())
    {
        return;
    }

    T* ptr = itr->second; // 在已分配存储中构造（“布置”）
    _map_use.erase(itr);

    assert_retnone(ptr);
    ptr->~T(); // free并不会调用对象的析构，要手动调用

    // free
    free((void*)ptr);

}
#pragma GCC diagnostic warning "-Wdelete-non-virtual-dtor"

template<typename T>
void* UNIT_POOL<T>::get_unit(mid_t mid)
{
    IT itr = _map_use.find(mid);
    if (itr == _map_use.end())
    {
        return nullptr;
    }

    return itr->second;
}

template<typename T>
int UNIT_POOL<T>::get_cur_use_num()
{
    return (int)_map_use.size();
}

内存池

对象池根据编号管理对应的对象池

 std::map<int, UNIT_POOL_BASE*>  g_map_pool; //全局的内存池 装有对象池的地址

相应函数封装 分配对象 获取对象 释放对象

/**
@brief 内存池初始化和回收，进程启动和退出时调用
*/
int mempool_init();
void mempool_fini();

/**
@brief 对象类型注册
@param[in] type -- 内存对象类型
@param[string] type_name -- 内存type名字
@param[in] num_limit -- 内存数量限制
@param[UNIT_POOL_BASE] pool_fn -- 内存对象管理指针
@retval 0 -- 成功
@retval <0 -- 失败
*/
int unitpool_init(u16 type, const char* type_name, int num_limit, int unit_size, UNIT_POOL_BASE* unit_pool);

/**
@brief 申请对象 // 申请对象，调用内存池中固定类型对象池的分配对象
@param[in] type -- 内存对象类型
@retval =INVALID_MID -- 失败
@retval 其他值-- 成功，对象的mid标志
*/
mid_t memunit_alloc(u16 type);

/**
@brief 对象释放
@param[in] type -- 内存对象类型
*/
void memunit_free(mid_t mid);

/**
@brief 获得对象内存地址
@param[in] type -- 内存对象类型
@retval =nullptr -- 失败，找不到该对象
@retval !=nullptr-- 成功，对象的内存地址
*/
void* memunit_get(mid_t mid);

具体实现

int mempool_init()
{
    g_map_pool.clear();
    return 0;
}

void mempool_fini()
{
    g_map_pool.clear();
}

int unitpool_init(u16 type, const char* type_name, int num_limit, int unit_size, UNIT_POOL_BASE* unit_pool)
{
    assert_retval(unit_pool && type_name, BGERR_INVALID_ARG);
    assert_retval(type >= 0 && type < MAX_POOL_TYPE_NUM, BGERR_INVALID_ARG);
    assert_retval(num_limit > 0, BGERR_INVALID_ARG);

    auto itr = g_map_pool.find(type);
    if (itr != g_map_pool.end())
    {
        assert_retval(0, BGERR_INVALID_ARG);
    }

    unit_pool->_type = type;
    unit_pool->_num_limit = num_limit;
    unit_pool->_type_name = type_name;
    unit_pool->_unit_size = unit_size;

    g_map_pool[type] = unit_pool;

    infor_log("unitpool init, type:%d name:%s num_limit:%d", type, type_name, num_limit);

    return 0;
}

mid_t memunit_alloc(u16 type) 
{
    auto itr = g_map_pool.find(type);
    if (itr == g_map_pool.end() || !itr->second)
    {
        assert_retval(0, INVALID_MID);
    }

    return itr->second->alloc_unit();
}

void memunit_free(mid_t mid)
{
    unitmid_t *unitmid = (unitmid_t *)&mid;
    int type = unitmid->type;

    auto itr = g_map_pool.find(type);
    if (itr == g_map_pool.end() || !itr->second)
    {
        //assert_retnone(0);
        return;
    }

    itr->second->free_unit(mid);
}


void* memunit_get(mid_t mid)
{
    unitmid_t *unitmid = (unitmid_t *)&mid;
    int type = unitmid->type;

    auto itr = g_map_pool.find(type);
    if (itr == g_map_pool.end() || !itr->second)
    {
        //assert_retval(0, nullptr);
        return nullptr;
    }

    return itr->second->get_unit(mid);
}

#define POOL_REGISTER(MEM_TYPE_ID, MEM_TYPE_NAME, MEM_STRUCT_TYPE, MEM_UNIT_NUM) \
    do {\
        UNIT_POOL<MEM_STRUCT_TYPE>* unit_pool = new UNIT_POOL<MEM_STRUCT_TYPE>;\
        if (nullptr == unit_pool)\
        {\
            error_log("mem type: %s create register deal fn failed", #MEM_TYPE_ID); \
            return BGERR_UNKNOWN; \
        }\
        int ret = bg_unitpool_init(MEM_TYPE_ID, MEM_TYPE_NAME, MEM_UNIT_NUM, sizeof(MEM_STRUCT_TYPE), (UNIT_POOL_BASE*)unit_pool);\
        if (0 != ret)\
        {\
            error_log("mem type: %s register deal fn failed, retval: %d", \
                #MEM_TYPE_ID, BGERR_UNKNOWN); \
            return ret; \
        }\
    }while(0)

思考

  • 对象池用时分配，并未在连续空间上分配，如果连续空间要初始化时分配所有空间，对对象的管理可以使用map或者free_list记录，或者数组记录第几块被使用

  • 连续空间如何防止边缘部分被写坏，非连续空间段错误，连续空间加入保护部分，转型使用dynamic_cast

补充

内存池的分配算法：
伙伴算法和slab

  • 伙伴算法(将整块分配成对应的小块，回收时看看相邻的能不能合并)
  • slab(类似stl的16条free_list)
  • 特定情况只分配按池回收的(注意好内存对齐即可)

只分配按池回收的

#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的倍数
// mp_align(31, 32) = 32, mp_align(32, 32) = 32, mp_align(33, 32) = 64
#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;
	// 这里的循环用来找最后一个链表节点，这里failed用来控制循环的长度，如果分配失败次数达到5次，
	// 就忽略，不需要每次都从头找起
	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;
		}
		// 为了提高效率， 如果在三次内没有找到空的large结构体，则创建一个
		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);
	}

	/*
	* 比如来了个8K，找到空闲给他分配，如果不够再分配，
	* 回收的时候不做释放，后面再次使用的时候直接拿出来使用。
	**/
	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) {
		/*
		* 遍历large链表，释放large内存块，
		* 注意此处并没有释放管理large内存块的内存(即large链表节点)，
		* 而仅是将其alloc指针设为NULL
		**/
			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;

}
Zip-List
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
有感于STL的内存管理 [存档]
Get my world，break free!
01-12 210
有感于STL的内存管理 转自 http://blog.163.com/dengminwen@126/blog/static/870226720097189486788/ web技术 2009-08-18 09:48 阅读244 评论4 字号： 大 中 小 警告：本文是技术类文章，只适合码工们围观，非码工请跳过此坑 1. 背景 前些天在一个技术分享会上，某...
Netty源码剖析之内存池和对象池设计流程
白鸽
09-28 931
根据谁最后使用谁负责释放的原则，每个Handler对消息可能有三种处理方式对原消息不做处理，调用ctx.fireChannelRead(msg)把原消息往下传，那不用做什么释放。将原消息转化为新的消息并调用 ctx.fireChannelRead(newMsg)往下传，
C++的对象池实践
sinat_31608641的博客
02-17 804
对象池
STL中的list/set/map等容器clear之后的内存占用
热门推荐
hekailing的专栏
11-09 1万+
最近在知乎上看到一个问题
Android时间相关的工具类
11-28
millis2String : 将时间戳转为时间字符串 string2Millis : 将时间字符串转为时间戳 string2Date : 将时间字符串转为Date类型 date2String : 将Date类型转为时间字符串 date2Millis : 将Date类型转为时间戳 ...
react-dev-utils:Webpack 4兼容的react-dev-utlis，https的独立fork
05-16
react-dev-utils 该软件包包括使用的一些实用。 请参考其文档： –如何创建新应用。 –如何开发使用Create React App引导的应用程序。 在创建React App项目中的用法 这些实用程序默认包含在，默认情况下包括它。...
RetrofitUtil网络框架封装，让你事半功倍
11-14
进行retrofit框架的封装，让调用更加的简单，高效。适用于不同需求的开发者，详细介绍请看博客 https://blog.csdn.net/lou_liang/article/details/84071044
vue使用xe-utils函数库的具体方法
08-27
主要介绍了vue使用xe-utils函数库的具体方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
硕士论文：此存储库是有关主题-领域适应的硕士论文实施
02-28
帕绍大学硕士论文 主题：域自适应 本文讨论了一种通用的领域自适应模型技术的发展，这将有助于解决各种计算机视觉任务。 该模型在流行的视觉域数据集上进行图像分类任务训练，... utlis.py定义了各种绘图，辅助方法和
内存池和对象池C++实现(v20150527)
05-27
这个代码是对之前上传的http://download.csdn.net/detail/muyelian/4020122资源的一个修正，因为少上传了部分文件，有不能修改，所以再次上传了一下 另，此代码在linux上无法编译通过。 --------------------- 这是参考了BOOST的内存池和对象池的实现的，基本上和BOOST的代码一样，不同的是： （1）风格不一样； （2）把实现的代码尽量简化了 （3）大多代码都加了详尽的注释（注释是中文的） 个人认为这份代码的意义在于如果你想深入了解并实现内存池和对象池，这份代码代码将是不错的选择 （如有错误请发邮件指正共同学习，E-mail:562236616@qq.com）
内存池:简单的内存池的实现
mmdev
07-31 196
转载自：http://blog.sina.com.cn/s/blog_46ed82810100ch8h.html 当频繁地用malloc申请内存，然后再用free释放内存时，会存在两个主要问题。第一个问题是频繁的分配释放内存可能导致系统内存碎片过多；第二个问题是分配释放内存花费的时间可能比较多（这个问题不太明显）。这个时候我们就可以考虑使用内存池了。 最朴素的内存池思想就是，首先你向系...
boost 内存池使用map
fallentopaz的专栏
02-09 754
大路货在这里， http://cplusplus.wikidot.com/cn:mempool-example-boost-pool 我想说的是，第四种池子，使用map进行存储。 绝大部分给的都是下面这个例子 std::vectorint,boost::pool_allocatorint> >v;话不多说，直接上例子。看到就知道该如何使用了。typedef struct MyStruc
C++ std::map报错的解决办法：_Rb_tree_increment(std::_Rb_tree_node_base const
柳鲲鹏
01-10 6814
参考：＜std::map的KEY如果是char*，必须是malloc的 ＞
简易的实现对象内存池
qq_43575653的博客
11-04 140
简易的实现对象内存池
简易内存池（对象池）的实现
进阶之路
12-02 465
#pragma once #include <vector> #include <time.h> #include <string> // 对象池的实现 针对于一个知道类型的对象 //我们通过对象池 来比较普通向内存中申请空间 //和我们直接向我们的内存池中申请空间的性能对比 template <class T, size_t initNum = 10...
对象内存池技术
blade2001的专栏
09-29 1345
 在这里,还是先介绍下我们这边对象内存池技术的基本概念和设计过程： 所谓的对象内存池技术设计过程如下：首先为某种对象预先生成若干个空闲对象,并且使用对象管理类进行管理。应用程序在需要使用此对象时,即向管理对象申请空闲对象.管理对象即检视对象内存池，如果发现存在未使用空闲对象，即分配给申请者。如果发现已无空闲对象，可自行扩充对象内存池，并且满足申请对象的需求，也可以直接返回NULL，
python utlis
最新发布
07-27
引用\[1\]和\[3\]提供了一段Python代码，其中定义了一个Excel类用于读取和写入Excel文件。该类的初始化方法根据传入的参数类型来选择是读取还是写入Excel文件。如果类型为'r'，则打开文件并获取所有的sheet名称和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值