004.多线程内存池

喜欢ヅ旅行 2023-06-29 10:32 6阅读 0赞

多线程安全内存池

内存分配通常是影响一个系统性能的关键所在。内存分配的主要性能瓶颈有：

1.由于Windows分配时需要进入操作系统内核态，而进入一个内核态至少需要2000个CPU时钟周期

2.频繁的小内存分配会导致内存出现大量碎片，另外容易引发内存页面错误

3.当有多个线程需要分配内存时，内存池必须加锁,加锁也需要进入内核态，更重要的是锁碰撞引起自旋等待将浪费大量cpu空转时间

实现思路：

1.用智能的内存池减少内存分配的时间和碎块(所谓智能是指智能侦测系统对内存的需求量)

2.每个线程调用各自独立的内存池，这样可以完全避免加锁(Lock-Free)，效率会有极大提高。

内存释放策略:

1.统计内存池内每个桶的内存需求频率(每秒需要多少块)，如果库存量大于平均需求量则释放多余的库存

2.小内存释放问题，小内存尽量不释放，如果存量远大于需求则强制释放，强制释放时可以将空闲内存排序，优先释放连续的内存块

3.小内存不要整块new，否则释放不了，连续new的内存块一般也是连续的，只要能解决内存碎块的问题即可

/*******************************************************************
    ** 文件名:    MemPool.h
    ** 描  述:
    ** 应  用:
    ********************************************************************/
    #pragma pack(1)
    #include "Singleton.h"
    enum
    {
    	MTMP_SHIFT = 4,								/// 对齐时的右移位数（决定了尺寸对齐的大小）， 可调
    	MTMP_MAX_SIZE =	8192,					    /// 内存池支持的最大分配单元,可调,最大8191*MTMP_ALIGN
    	MTMP_SMALL_SIZE = 0,						/// 小内存大小限制,可调,最大256*MTMP_ALIGN
    	MTMP_ALIGN = (1<<MTMP_SHIFT),				/// 内存对齐大小
    	MTMP_POOL_SIZE =(MTMP_MAX_SIZE>>MTMP_SHIFT),/// 内存池的桶数
    	MTMP_GROW = 16,						        /// 小内存在没有空闲节点时一次性分配的节点数,可调,<=64
    	MTMP_STATISTIC_INTERVAL = 2048,             /// 库存统计频率(2秒)
    	MTMP_SMALL_STORAGE = 4,                     /// 小内存库存 = 平均需求量的4倍
    	MTMP_LARGE_STORAGE = 1,                     /// 大内存库存 = 平均需求量
    };
    
    /// 强制断言
    #ifndef MY_ASSERT 
    #	define  MY_ASSERT(exp)				    if (!(exp)) { __asm { int 3 }; }
    #endif
    
    class   MemPool
    {
    public:
    	/
    	struct  SMALL_MEM_NODE
    	{
    		unsigned short     bAllotted : 1;        // 该内存块是否已分配
    		unsigned short     bIsLarge  : 1;        // 该内存块是否是大内存
    		unsigned short     nIndex    : 6;        // 该内存块是批量分配的小内存块中的第几块
    		unsigned short     nPoolID   : 8;        // 该内存块所在内存池ID,即内存大小/MTMP_ALIGN
    		unsigned short     nPadding  :16;
    	};
    
    	struct LARGE_MEM_NODE
    	{
    		unsigned short     bAllotted : 1;        // 该内存块是否已分配
    		unsigned short     bIsLarge  : 1;        // 该内存块是否是大内存
    		unsigned short     bSysMalloc: 1;        // 是否是系统分配的超大内存
    		unsigned short     nPoolID   :13;        // 该内存块所在内存池ID,即内存大小/MTMP_ALIGN
    		unsigned short     nPadding  :16;
    
    		inline void operator = (WORD node) 
    		{ 
    			*(WORD*)this = node; 
    		}
    
    		inline bool operator == (WORD node) 
    		{ 
    			return *(WORD*)this==node; 
    		}
    	};
    
    	struct SYSTEM_MEM_BLOCK
    	{
    		unsigned long      bPoolNode : 1;        // 是否是内存池分配的内存
    		unsigned long      block_len :31;        // 内存块长度
    	};
    
    	struct MEM_NODE                              // 内存块结构
    	{
    		union
    		{
    			SMALL_MEM_NODE   _node_s;
    			LARGE_MEM_NODE   _node_l;
    			SYSTEM_MEM_BLOCK _system_block;      // 大于MTMP_MAX_SIZE时使用系统分配内存机制
    		};
    
    		MEM_NODE *       pNext;                // 指向下一个节点
    	};
    
    public:
    	/
    	/// 分配内存
    	void * allocate(size_t size);
    
    	/// 重新分配内存
    	void * reallocate(void * p,size_t size);
    
    	/// 释放内存
    	void deallocate(void * p);
    
    	/// 构造函数
    	MemPool()
    	{
    		MY_ASSERT( MTMP_GROW <=64 );
    		MY_ASSERT( MTMP_SMALL_SIZE < 256*MTMP_ALIGN );
    		MY_ASSERT( MTMP_MAX_SIZE < 8191*MTMP_ALIGN );
    		memset(m_memPool,0,sizeof(m_memPool));
    	}
    
    	void MT_MemPool_() 
    	{
    		MY_ASSERT( MTMP_GROW <=64 );
    		MY_ASSERT( MTMP_SMALL_SIZE < 256*MTMP_ALIGN );
    		MY_ASSERT( MTMP_MAX_SIZE < 8191*MTMP_ALIGN );
    		memset(m_memPool,0,sizeof(m_memPool));
    	}
    
    protected:
    	/
    
    	/// 从内存池中取出空闲节点
    	inline MEM_NODE * pop( int pool );
    
    	/// 把一个新节点放进内存池
    	inline void push( int pool,MEM_NODE * node );
    
    	/// 创建新的节点
    	inline void buy_node( int pool );
    
    	/// 检查内存池存量,如果存量远大于需求则尝试释放
    	inline void check_mempool_store( int pool );
    
    	/// 释放大内存池
    	inline void free_large_mempool( int pool );
    
    	/// 释放小内存池
    	inline void free_small_mempool( int pool );
    
    protected:
    	struct MEM_POOL
    	{
    		MEM_NODE         *    pFreeHead;     // 内存池空闲头节点
    		unsigned long         nAlloted;      // 单位时间内已分配内存次数
    		unsigned long         nFreeNum;		 // 剩余内存块数
    		unsigned long         nAverNeed;	 // 单位时间内的平均需求量(MTMP_STATISTIC_INTERVAL指定)
    		unsigned long         nLastStatistic;// 最后统计时间
    	};
    
    	MEM_POOL               m_memPool[MTMP_POOL_SIZE];    // 内存池数组
    };
    
    /**
    @ name  : 多线程内存分配器
    @ brief : 根据线程ID,每个线程对应一个内存池
    */
    class  T20_EXPORT MT_Allocator : public Singleton<MT_Allocator>
    {
    public:
    	/// 分配内存
    	void * allocate(size_t size)
    	{
    		return TLS_MemPool()->allocate(size);
    	}
    
    	/// 重新分配内存
    	void * reallocate(void * p,size_t size)
    	{
    		return TLS_MemPool()->reallocate(p, size);
    	}
    
    	/// 释放内存
    	void deallocate(void * p)
    	{
    		TLS_MemPool()->deallocate(p);
    	}
    
    	/// 通过Thread Local Storage取得当前线程对应的内存池
    	MemPool * TLS_MemPool();
    
    	/// 构造
    	MT_Allocator()
    	{
    		m_dwTLSIndex = ::TlsAlloc();
    	}
    
    protected:
    	DWORD                m_dwTLSIndex;
    };

/*******************************************************************
    ** 文件名:    MemPool.cpp
    ** 描  述:
    ** 应  用:
    ********************************************************************/
    #include "stdafx.h"
    #include "MemPool.h"
    
    #define  round(s)						 ( ((s) + MTMP_ALIGN - 1) & ~(MTMP_ALIGN - 1) )
    #define  getMemPoolID(s)				 ( (round((s)) - 1) >> MTMP_SHIFT )
    #define  getPoolNodeSize(pool)           ( (pool << MTMP_SHIFT ) + MTMP_ALIGN )
    
    /
    void * MemPool::allocate(size_t size)
    {
    	// 不能分配0字节
    	if (size == 0)
    	{
    		size = 1;
    	}
    
    	// 超大内存
    	if (size >= MTMP_MAX_SIZE)
    	{
    		MEM_NODE * pNode = (MEM_NODE *)malloc(size + sizeof(MEM_NODE));
    		if (!pNode)
    			return 0;
    		pNode->_system_block.bPoolNode = 0;
    		pNode->_system_block.block_len = size;
    		return pNode + 1;
    	}
    	else
    	{
    		int pool = getMemPoolID(size);
    		MEM_NODE * pNode = pop(pool);
    
    		while (pNode == 0)
    		{
    			buy_node(pool);
    			pNode = pop(pool);
    		}
    
    		return pNode + 1;
    	}
    }
    
    /
    void * MemPool::reallocate(void * p, size_t size)
    {
    	// size=0等同于free
    	if ( size == 0 )
    	{
    		deallocate(p);
    		return 0;
    	}
    
    	// 传入null等同alloc
    	if  ( p == 0 )
    	{
    		return allocate(size);
    	}
    
    	MEM_NODE * pNode = (MEM_NODE *)p-1;
    	size_t block_len = 0;
    	if ( pNode->_system_block.bPoolNode == 0 )
    	{
    		block_len = pNode->_system_block.block_len;
    	}
    	else
    	{
    		int pool = 0;
    		if ( pNode->_node_l.bIsLarge )
    			pool = pNode->_node_l.nPoolID;
    		else
    			pool = pNode->_node_s.nPoolID;
    
    		block_len = getPoolNodeSize(pool);
    	}
    
    	// 长度不够则重新分配
    	void * new_ptr = allocate(size);
    	memcpy(new_ptr, p, block_len >= size ? size : block_len);
    	deallocate(p);
    	return new_ptr;
    }
    
    
    /
    void MemPool::deallocate(void * p)
    {
    	if ( p==0 ) { return; }
    
    	// 超大内存
    	MEM_NODE * pNode = (MEM_NODE *)p-1;
    
    	if ( pNode->_system_block.bPoolNode==0 )
    	{
    		free(pNode);
    		return;
    	}
    
    	if ( pNode->_node_l.bIsLarge==1 )
    	{
    		// 放回回收站
    		int pool = pNode->_node_l.nPoolID;
    		push( pool,pNode );
    
    		// 检查库存
    		check_mempool_store( pool );
    	}
    	else
    	{
    		// 放回回收站
    		int pool = pNode->_node_s.nPoolID;
    		push( pool,pNode );
    
    		// 检查库存
    		check_mempool_store( pool );
    	}
    }
    
    /
    MemPool::MEM_NODE * MemPool::pop(int pool)
    {
    	MEM_POOL & mem_pool = m_memPool[pool];
    	MEM_NODE * pNode = mem_pool.pFreeHead;
    	if ( pNode )
    	{
    		pNode->_node_s.bAllotted = 1;
    		mem_pool.pFreeHead = pNode->pNext;
    
    		mem_pool.nAlloted += 1;
    		mem_pool.nFreeNum -= 1;
    	}
    
    	return pNode;
    }
    
    /
    void MemPool::push( int pool, MEM_NODE * pNode )
    {
    	MEM_POOL & mem_pool = m_memPool[pool];
    	pNode->_node_s.bAllotted = 0;
    	pNode->pNext        = mem_pool.pFreeHead;
    	mem_pool.pFreeHead  = pNode;
    
    	mem_pool.nFreeNum  += 1;
    }
    
    /
    void MemPool::buy_node( int pool )
    {
    	size_t size = getPoolNodeSize( pool );
    
    	if ( size < MTMP_SMALL_SIZE )
    	{
    		// 小内存一次分配多个,减少内存碎块
    		size += sizeof( MEM_NODE );
    
    		MEM_NODE * pNode = (MEM_NODE *)malloc(size*MTMP_GROW);
    
    		for ( int i = 0; i < MTMP_GROW; ++i )
    		{
    			pNode->_node_s.bIsLarge = 0;
    			pNode->_node_s.nPoolID = pool;
    			pNode->_node_s.nIndex = i;
    
    			push( pool,pNode );
    			pNode = (MEM_NODE*)(((const char *)pNode) + size);
    		}
    	}
    	else
    	{
    		size += sizeof( MEM_NODE );
    		MEM_NODE * pNode = (MEM_NODE *)malloc(size);
    		pNode->_node_l.bIsLarge = 1;
    		pNode->_node_l.nPoolID = pool;
    
    		push( pool,pNode ); 
    	}
    }
    
    /
    void MemPool::check_mempool_store( int pool )
    {
    	MEM_POOL & mem_pool = m_memPool[pool];
    	unsigned long now   = GetTickCount();
    	unsigned long dt    = now - mem_pool.nLastStatistic;
    
    	if ( dt > MTMP_STATISTIC_INTERVAL )
    	{
    		// 统计平均需求量
    		unsigned long need = mem_pool.nAlloted;
    
    		if ( mem_pool.nLastStatistic != 0 && dt > (MTMP_STATISTIC_INTERVAL * 2) )
    		{
    			need = (mem_pool.nAlloted * MTMP_STATISTIC_INTERVAL) / dt;
    		}
    
    		mem_pool.nAverNeed = ( need + mem_pool.nAverNeed ) / 2;
    
    		// 库存是否超过
    		size_t size = getPoolNodeSize( pool );
    		if ( size < MTMP_SMALL_SIZE )
    		{
    			// 小内存释放原则: 超过平均需求量的4倍
    			if ( mem_pool.nFreeNum > mem_pool.nAverNeed * MTMP_SMALL_STORAGE )
    			{
    				free_small_mempool( pool );
    			}
    		}
    		else
    		{
    			// 大内存释放原则: 超过平均需求量即释放
    			if ( mem_pool.nFreeNum > mem_pool.nAverNeed * MTMP_LARGE_STORAGE )
    			{
    				free_large_mempool( pool );
    			}
    		}
    
    		// 重置统计数据
    		mem_pool.nAlloted  = 0;
    		mem_pool.nLastStatistic = now;
    	}
    }
    
    /
    void MemPool::free_large_mempool( int pool )
    {
    	MEM_POOL & mem_pool = m_memPool[pool];
    
    	// 释放大内存池至需求量以下
    	while( mem_pool.nFreeNum > mem_pool.nAverNeed )
    	{
    		MEM_NODE * pNode = pop( pool );
    		if ( pNode )
    		{
    			free( pNode );
    		}
    		else
    		{
    			break;
    		}
    	}
    }
    
    /
    void MemPool::free_small_mempool( int pool )
    {
    	MEM_POOL & mem_pool = m_memPool[pool];	
    
    	// 释放小内存池至需求量以下
    
    	std::set<MEM_NODE *> node_set;
    
    	MEM_NODE * pNode = 0;
    	while( pNode = pop( pool ) )
    	{
    		node_set.insert( pNode );
    	}
    
    	size_t size = getPoolNodeSize( pool );
    	size += sizeof( MEM_NODE );
    
    	// 优先释放连续的内存
    	MEM_NODE * head_node = 0;
    	int continued_num    = 0;
    	std::set<MEM_NODE *>::iterator it = node_set.begin();
    	for ( ;it != node_set.end(); )
    	{
    		MEM_NODE * node = *it;
    		++it;
    
    		int block_index = node->_node_s.nIndex;
    
    		if ( head_node )
    		{
    			// 是否和当前检查的节点是同一块内存
    			if ( continued_num + 1 == block_index && (unsigned long)node - (unsigned long)head_node == block_index*size )
    			{
    				++continued_num;
    
    				// 找到一块完整内存可以释放
    				if ( block_index == MTMP_GROW-1 )
    				{
    					char * free_ptr = (char*)head_node;
    					for ( int i=0;i<MTMP_GROW;++i )
    					{
    						node_set.erase( (MEM_NODE*)free_ptr );
    						free_ptr += size;
    					}
    
    					free( head_node );
    					head_node = 0;
    					continued_num = 0;
    
    					// 库存量已经低于需求量了
    					if ( node_set.size()<= mem_pool.nAverNeed )
    						break;
    				}
    
    				// 继续匹配
    				continue;
    			}
    		}
    
    		if ( block_index==0 )
    		{
    			head_node = node;
    			continued_num = 0;
    		}
    		else
    		{
    			head_node = 0;
    			continued_num = 0;
    		}
    	}
    
    	// 将不能释放的内存放回去
    	for ( it = node_set.begin();it!=node_set.end();++it )
    	{
    		push( pool,*it );
    	}
    }
    
    /
    /// 通过Thread Local Storage取得当前线程对应的内存池
    
    MemPool * MT_Allocator::TLS_MemPool()
    {
    	MemPool * pool = (MemPool*)::TlsGetValue(m_dwTLSIndex);
    	if ( pool==0 )
    	{
    		pool = (MemPool*)malloc(sizeof(MemPool));
    		pool->MT_MemPool_();
    
    		BOOL bSet = ::TlsSetValue(m_dwTLSIndex,pool);
    		MY_ASSERT(bSet);
    		return pool;
    	}
    
    	return pool;
    }
    
    void* mt_alloc(size_t s)
    {
    	return MT_Allocator::getInstance().allocate(s);
    }
    
    void* mt_realloc(void* p, size_t s)
    {
    	return MT_Allocator::getInstance().reallocate(p,s);
    }
    
    void  mt_free(void* p)
    {
    	MT_Allocator::getInstance().deallocate(p);
    }

使用：

char* p = (char*)MT_Allocator::getInstance().allocate(10); 
    	memset(p, 0, sizeof(0));
    	MT_Allocator::getInstance().deallocate(p);