固定长度的内存池

最新推荐文章于 2024-04-24 06:14:50 发布
最新推荐文章于 2024-04-24 06:14:50 发布
阅读量537 收藏
点赞数
分类专栏： C++ 文章标签： C++ 内存池 内存管理 内存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xnayufenglin/article/details/40826987
版权

    

    有了前面的内存块和线程锁，现在就可以写内存池了，关于内存池的原理、好处什么的，这里都一概不说了，主要就是把自己封装的东西来贴出来分享，有些模块我经常用，感觉还是比较干净利索，假若您发现了其中的bug或者不合理的地方，请发个评论，一块讨论下，就怕自己成了井底之蛙，这些可能都有一些成熟的第三方库了，但自己总喜欢造自己的轮子，就是一兴趣吧！

    这里的内存池和内存块不同的地方就是内存池将内存块组成一个链表来管理，动态的来控制这个链表的个数，如果不停的调用Malloc来申请Node，链表的长度就会很长。其中有个链表指针(mem_block_header_free)指向最前面可以申请Node的的内存块，每次Free一个Node时就检查这个Node所在的内存块是否在mem_block_header_free的前面，若在前面就赋值给它，另外还有一个变量free_sustained，它负责记录连续Free的次数，若连续Free的次数等于一个内存块的Node数量就检查下是否有可以释放的内存块，以此来减少内存块链表的长度，此外通过模板参数来支持线程安全。

    在使用时，模板参数要根据自己的情况来定义，当然要熟悉使用还是要理解下内部的原理，内部总共就四个有效变量，不涉及什么算法，理解起来不算困难，另外我还写了一个基于对象的内存池，对象大小本身就是固定大小的，所以很好实现，能调用对象的构造和析构函数，以后再发吧，下面就把本次的代码贴出来：

注：
    CSDN编辑博客的工具真难用，表示强烈的鄙视下 


/* 
============================================================================================
	内存池模块 固定长度的内存池
	通过模板参数来做线程安全

	add 2013.11.22 by yuwf

	Copyright (c), ...	

=============================================================================================
*/

#ifndef _PALANTIR_MEM_POOL_H
#define _PALANTIR_MEM_POOL_H

#include "PLTLocker.h"
#include "PLTMemBlock.h"
#include "PLTMemBlock2.h"

namespace Palantir
{

	template < unsigned int _NODE_SIZE_, unsigned int _BLOCK_NODE_COUNT_ = 8, class _LOCK_TYPE_ = EmptyLocker, class _BLOCK_TYPE_ = MemBlock2<_NODE_SIZE_,_BLOCK_NODE_COUNT_> >
	class MemPool
	{
	public:
		// 内存块 组织成链表
		class MemBlock : public _BLOCK_TYPE_
		{
		public:
			MemBlock() : pnext(nullptr) {}
			MemBlock* pnext;
		};

		typedef _LOCK_TYPE_					Locker;		// 锁类型
		typedef LockerGuard<_LOCK_TYPE_>	AutoLocker;	// 辅助使用


	public:
		// 构造和析构函数
		MemPool();

		virtual ~MemPool();

		// 分配一块内存
		inline void* Malloc();

		// p 必须是从malloc获取的
		// 返回值表示是否删除成功
		inline bool Free(const void* p);

		// 将所有分配的内存回收到内存池中
		// 没有使用的内存块回收给系统
		inline void Free();

		// 将所有分配的内存回收到系统
		inline void Destroy();

		// 内存池交换
		inline void Swap( MemPool& pool );

		// 获取当前的block的数量
		inline unsigned int Block_Count();
		
		// 获取这个内存池占用内存的大小
		inline unsigned int Mem_Size();

	protected:

		// 释放掉没有使用的block 将内存回收到系统中
		void _Destroy_NotUse_Block();

		MemBlock*		mem_block_header;		// 记录第一个block的位置
		MemBlock*		mem_block_header_free;	// 记录最前面有空的block 如果这个block也没空就要重新申请一个block
		unsigned int	free_sustained;			// 连续回收的次数 有分配就回归0
		Locker			locker;					// 线程池的锁
	};


	// 功能实现部分 ========================

	template <unsigned int _NODE_SIZE_, unsigned int _BLOCK_NODE_COUNT_, class _LOCK_TYPE_, class _BLOCK_TYPE_>
	MemPool<_NODE_SIZE_,_BLOCK_NODE_COUNT_,_LOCK_TYPE_,_BLOCK_TYPE_>::MemPool() : mem_block_header(nullptr), mem_block_header_free(nullptr), free_sustained(0)
	{
	}

	template <unsigned int _NODE_SIZE_, unsigned int _BLOCK_NODE_COUNT_, class _LOCK_TYPE_, class _BLOCK_TYPE_>
	MemPool<_NODE_SIZE_,_BLOCK_NODE_COUNT_,_LOCK_TYPE_,_BLOCK_TYPE_>::~MemPool()
	{
		// 将内存回收给系统
		Destroy();
	}

	template <unsigned int _NODE_SIZE_, unsigned int _BLOCK_NODE_COUNT_, class _LOCK_TYPE_, class _BLOCK_TYPE_>
	inline void* MemPool<_NODE_SIZE_,_BLOCK_NODE_COUNT_,_LOCK_TYPE_,_BLOCK_TYPE_>::Malloc()
	{
		AutoLocker lock( locker );
		free_sustained = 0;
		if ( mem_block_header == nullptr )
		{
			mem_block_header = new MemBlock;
			mem_block_header_free = mem_block_header;
		}

		MemBlock* free_block = mem_block_header_free;
		while( free_block->Is_Full() )
		{
			if ( free_block->pnext == nullptr )
			{
				free_block->pnext = new MemBlock;
				mem_block_header_free = free_block->pnext;
				break;
			}
			free_block = free_block->pnext;
		}
		return free_block->Malloc();
	}

	template <unsigned int _NODE_SIZE_, unsigned int _BLOCK_NODE_COUNT_, class _LOCK_TYPE_, class _BLOCK_TYPE_>
	inline bool MemPool<_NODE_SIZE_,_BLOCK_NODE_COUNT_,_LOCK_TYPE_,_BLOCK_TYPE_>::Free(const void* p)
	{
		if ( p )
		{
			AutoLocker lock( locker );
			MemBlock* at_block = mem_block_header;
			bool free_at_back = true;					// 判断p所在的block是否在mem_block_header_free的后面
			// 遍历block 找到p所在的block
			while( at_block )
			{
				if ( at_block == mem_block_header_free )
				{
					free_at_back = false;
				}
				if ( at_block->Is_From(p) )
				{
					break;
				}
				at_block = at_block->pnext;
			}
			if ( !at_block )
			{
				return false;
			}
			// 如果p所在的block是在mem_block_header_free的前面
			// 将这个block赋值给mem_block_header_free 因为他记录最靠前可能有空的block
			if ( free_at_back )
			{
				mem_block_header_free = at_block;
			}
			++free_sustained;
			at_block->Free(p);
			if ( free_sustained % MemBlock::NODE_COUNT == 0 )
			{
				_Destroy_NotUse_Block();
			}
			return true;
		}
		return false;
	}

	template <unsigned int _NODE_SIZE_, unsigned int _BLOCK_NODE_COUNT_, class _LOCK_TYPE_, class _BLOCK_TYPE_>
	inline void MemPool<_NODE_SIZE_,_BLOCK_NODE_COUNT_,_LOCK_TYPE_,_BLOCK_TYPE_>::Free()
	{
		AutoLocker lock( locker );
		MemBlock* cur_block = mem_block_header;
		MemBlock* last_block = nullptr;
		while( cur_block )
		{
			// 发现这个block没有使用 归还给系统
			if ( cur_block->Is_Not_Use() )
			{
				if ( last_block )
				{
					last_block->pnext = cur_block->pnext;
				}
				if ( cur_block == mem_block_header )
				{
					mem_block_header = cur_block->pnext;
				}
				MemBlock* mem = cur_block;
				cur_block = cur_block->pnext;
				delete mem;
			}
			else
			{
				cur_block->Free();
				last_block = cur_block;
				cur_block = cur_block->pnext;
			}
		}
		mem_block_header_free = mem_block_header;
		free_sustained = 0;
	}

	template <unsigned int _NODE_SIZE_, unsigned int _BLOCK_NODE_COUNT_, class _LOCK_TYPE_, class _BLOCK_TYPE_>
	inline void MemPool<_NODE_SIZE_,_BLOCK_NODE_COUNT_,_LOCK_TYPE_,_BLOCK_TYPE_>::Destroy()
	{
		AutoLocker lock( locker );
		MemBlock* cur_block = mem_block_header;
		while( cur_block )
		{
			MemBlock* mem = cur_block;
			mem->Free();
			cur_block = cur_block->pnext;
			delete mem;
		}
		mem_block_header = nullptr;
		mem_block_header_free = nullptr;
		free_sustained = 0;
	}

	template <unsigned int _NODE_SIZE_, unsigned int _BLOCK_NODE_COUNT_, class _LOCK_TYPE_, class _BLOCK_TYPE_>
	inline void MemPool<_NODE_SIZE_,_BLOCK_NODE_COUNT_,_LOCK_TYPE_,_BLOCK_TYPE_>::Swap( MemPool& pool )
	{
		AutoLocker lock( locker );
		AutoLocker lock2( pool.locker );
		MemBlock* ptemp = mem_block_header;
		mem_block_header = pool.mem_block_header;
		pool.mem_block_header = ptemp;

		ptemp = mem_block_header_free;
		mem_block_header_free = pool.mem_block_header_free;
		pool.mem_block_header_free = ptemp;

		unsigned int itemp = free_sustained;
		free_sustained = pool.free_sustained;
		pool.free_sustained = itemp;
	}

	template <unsigned int _NODE_SIZE_, unsigned int _BLOCK_NODE_COUNT_, class _LOCK_TYPE_, class _BLOCK_TYPE_>
	inline unsigned int MemPool<_NODE_SIZE_,_BLOCK_NODE_COUNT_,_LOCK_TYPE_,_BLOCK_TYPE_>::Block_Count()
	{
		AutoLocker lock( locker );
		unsigned int count = 0;
		MemBlock* cur_block = mem_block_header;
		while( cur_block )
		{
			MemBlock* mem = cur_block;
			cur_block = cur_block->pnext;
			++count;
		}
		return count;
	}

	template <unsigned int _NODE_SIZE_, unsigned int _BLOCK_NODE_COUNT_, class _LOCK_TYPE_, class _BLOCK_TYPE_>
	inline unsigned int MemPool<_NODE_SIZE_,_BLOCK_NODE_COUNT_,_LOCK_TYPE_,_BLOCK_TYPE_>::Mem_Size()
	{
		return Block_Count() * sizeof(MemBlock) + sizeof(*this);
	}

	template <unsigned int _NODE_SIZE_, unsigned int _BLOCK_NODE_COUNT_, class _LOCK_TYPE_, class _BLOCK_TYPE_>
	inline void MemPool<_NODE_SIZE_,_BLOCK_NODE_COUNT_,_LOCK_TYPE_,_BLOCK_TYPE_>::_Destroy_NotUse_Block()
	{
		MemBlock* cur_block = mem_block_header;
		MemBlock* last_block = nullptr;
		while( cur_block )
		{
			// 发现这个block没有使用 归还给系统
			if ( cur_block->Is_Not_Use() )
			{
				if ( last_block )
				{
					last_block->pnext = cur_block->pnext;
				}
				if ( cur_block == mem_block_header )
				{
					mem_block_header = cur_block->pnext;
				}
				if ( mem_block_header_free == cur_block )
				{
					mem_block_header_free = cur_block->pnext;
				}
				MemBlock* mem = cur_block;
				cur_block = cur_block->pnext;
				delete mem;
			}
			else
			{
				last_block = cur_block;
				cur_block = cur_block->pnext;
			}
		}
	}

}

#endif


xnayufenglin
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于一个简单定长内存池的实现方法详解
09-05
本篇文章对一个简单定长内存池的实现方法进行了详细的分析介绍。需要的朋友参考下
从零实现一个定长高并发内存池
weixin_68644350的博客
04-13 128
从堆上一次性开辟一大片空间，由我们自己管理，这里的一大片的空间我们就将它称为池，当我们需要拿空间的时候去这个池中拿取。
定长内存池
wjmhlh的博客
02-05 628
设计出一个定长内存池，为后续实现高并发内存池做准备。
C++项目——高并发内存池（1）--介绍及定长内存池
qq_68741368的博客
02-20 497
高并发内存池项目——内存池的介绍，定长内存池的实现
高效内存池；动态内存池|单元内存池-易语言
06-12
动态内存池支持不固定长度的内存分配，相同，动态内存池也效率极高，并且此动态内存池在归还内存块时会空闲内存合并，以左右探查方式合并空闲内存，此方式极大的加速了分配内存效率，并且极大的减少了内存碎片的产生...
mem.rar_vxworks mem_体系结构_内存碎片_内存管理_操作系统 内存管理
09-14
静态预分配内存池支持一种以上固定长度内存池，如16 字节内存池和256 字节内存池。固定长度内存池的单块长度应考虑体系结构开销，并尽量减少内部碎片；固定长度内存池数量应可配置； 静态预分配内存池与系统内存池的...
易语言基础数据结构应用模块(包含一个高效动态内存池)
05-27
3.动态内存池bx 一个高效的可动态分配内存长度，而不是固定单元长度的内存池。并支持自动处理合并可合并的内存区块(以高效的左右探查方式寻找可合并的内存块)。自动寻找更加合适的大小的内存块作为分配使用以减少...
易语言-易语言基础数据结构应用模块(包含一个高效动态内存池)
06-29
3.动态内存池bx 一个高效的可动态分配内存长度，而不是固定单元长度的内存池。 并支持自动处理合并可合并的内存区块(以高效的左右探查方式寻找可合并的内存块)。 自动寻找更加合适的大小的内存块作为分配使用以减少...
内存池NedAllocator
12-06
NedAllocator是一个跨平台的高性能多线程安全的内存池，使用c语言开发，提供了C++借口。
多线程安全的内存池支持类
11-17
提供两个多线程安全的内存池支持类，详细的内容请看类说明
【C++项目】手动实现一个定长内存池（了解内存分配机制、定长内存提高效率 附源码）
广西彭于晏的博客
10-11 276
这是一个 C++ 中的对象池（Object Pool）的简单实现，用于更有效地管理对象的内存分配和回收。对象池是一种内存管理技术，旨在减少频繁分配和释放对象的开销，从而提高程序的性能。以下是该对象池的一些关键部分和功能：New() 函数：用于获取一个新的对象。它首先检查是否有已归还的内存块，如果有，则使用归还的内存，否则从内存池中分配一个新的对象。它使用 malloc 来分配内存，然后使用定位 new 来调用对象的构造函数，初始化对象。Delete() 函数：用于回收一个对象。
简单实现定长内存池
weixin_57023347的博客
11-10 1313
目录 前言 一.定长内存池 1.1 概念 1.2 实现 1.2.1 成员变量介绍 1.2.2 成员函数介绍 1.2.3细节 1.3 代码 前言 我们知道用户申请内存必须通过操作系统，操作系统再从堆上开辟一段空间给用户。但是如果频繁的向操作系统申请空间，导致操作系统需要频繁的为用户开辟空间。但是操作系统需要管理很多东西，这样会导致操作系统的效率变得很低。 ...
定长内存池详解
m0_57330725的博客
07-22 206
定长内存池的详解
一个简单的固定长度内存池的实现
心之所向，身之所往
06-01 3140
一个简单的内存池的实现 j   当频繁地用malloc申请内存，然后再用free释放内存时，会存在两个主要问题。第一个问题是频繁的分配释放内存可能导致系统内存碎片过多；第二个问题是分配释放内存花费的时间可能比较多（这个问题不太明显）。这个时候我们就可以考虑使用内存池了。 TAG: 内存池   当频繁地用malloc申请内
2024最新版JavaScript逆向爬虫教程-------基础篇之深入JavaScript运行原理以及内存管理
最新发布
Amo Xiang的博客
04-24 694
深入学习JavaScript运行原理以及JS内存管理，为后续函数，闭包，作用域的学习打下坚实基础。函数，闭包，作用域，this指向等问题在后续JS逆向的学习中非常重要，如果想要学好这些知识点，就必须先了解JavaScript的运行原理。
论文解读-Contiguitas: The Pursuit of Physical Memory Contiguity in Datacenters
qq_38473009的博客
04-20 353
Contiguitas-HW将正在被迁移的页分为源页和目标页，并将对页的访问正确重定向到对应的页中。如果页的属性从可移动变化为不可移动，则Contiguitas将其迁移到不可移动区，避免对可移动区的污染。采用算法动态调整不可移动区和可移动区的边界，确定不可移动区的大小。为了解决不可移动页带来的内存碎片问题，Contiguitas进行了三个方面的设计，如图6所示：① 让不可移动页只在不可移动区域被分配；其中③也可以用于可移动页的迁移，不需要执行费时的TLB shootdown，提高页迁移操作的可扩展性。
transformer固定长度
05-29
在Transformer模型中，输入序列的长度通常是固定的。这是因为Transformer中的自注意力（self-attention）机制需要对整个输入序列进行计算，因此输入序列的长度必须是确定的，以便在计算自注意力时使用固定大小的矩阵。 通常，在训练模型时，我们会将所有的输入序列padding到相同的长度。其中，padding指的是在序列的末尾添加一些特殊的“padding”标记，使得所有的序列长度相同。这样，我们就可以将所有的序列打包成一个 batch 进行训练，提高训练效率。 在实际应用中，为了避免过多的padding对模型效果的影响，我们可以根据数据集中序列的长度分布，选择一个合适的序列长度作为模型的固定长度。通常情况下，我们会选择能够覆盖大部分序列长度的固定长度，以便让模型能够在不过多丢失信息的情况下对序列进行处理。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值