c++内存分配器

#pragma once
/*
说明，此源文件内容由LJ类库轴抽取而来，
如有问题请QQ联系作者，QQ：511266323（W意波）（这是原作者的QQ）
加好友时请注明“BlockMemory"或者”LJ类库“字样
*/
#ifdef WIN32
#include <windows.h>
#else
#include <pthread.h>
#endif
namespace LJ
{

//同步操作相关，单次互斥对象
class MutexOnce
{
#ifdef WIN32
long mlock;
#else
pthread_mutex_t mutex;
#endif
MutexOnce(const MutexOnce&) {}
MutexOnce& operator=(const MutexOnce&) { return *(MutexOnce*)0; }
public:
MutexOnce();
~MutexOnce();
void Lock();
bool Try();
void UnLock();
void Reset();
};
#ifdef WIN32
inline MutexOnce::MutexOnce() :mlock(0) {}
inline void MutexOnce::Lock() {
for (;;) {
#ifdef InterlockedCompareExchangePointer
if (!InterlockedCompareExchange(&mlock, 1, 0))
return;
#else
if (!InterlockedCompareExchange((void**)&mlock, (void*)1, (void*)0))
return;
#endif
Sleep(0);
}
}
inline bool MutexOnce::Try()
{
#ifdef InterlockedCompareExchangePointer
return !InterlockedCompareExchange(&mlock, 1, 0);
#else
return !InterlockedCompareExchange((void**)&mlock, (void*)1, (void*)0);
#endif
}
inline void MutexOnce::UnLock()
{
InterlockedExchange(&mlock, 0);
}
inline MutexOnce::~MutexOnce() {}
inline void MutexOnce::Reset() { mlock = 0; }
#else
inline MutexOnce::MutexOnce() { pthread_mutex_init(&this->mutex, NULL); }
inline MutexOnce::~MutexOnce() { pthread_mutex_destroy(&this->mutex); }
inline void MutexOnce::Lock() { pthread_mutex_lock(&this->mutex); }
inline bool MutexOnce::Try() { return pthread_mutex_trylock(&this->mutex) == 0; }
inline void MutexOnce::UnLock() { pthread_mutex_unlock(&this->mutex); }
inline void MutexOnce::Reset() { pthread_mutex_destroy(&this->mutex); pthread_mutex_init(&this->mutex, NULL); }
#endif
//位操作相关内容
struct Bits
{
//获取i前导0的比特数（32位）
static int LeftZeroCount32(unsigned long i);
//获取i前导0的比特数（64位）
static int LeftZeroCount64(unsigned long long i);
//获取i前导0的比特数（自动匹配位数）
static int LeftZeroCount(unsigned long long i) { return LeftZeroCount64(i); }
//获取i前导0的比特数（自动匹配位数）
static int LeftZeroCount(unsigned long i) { return LeftZeroCount32(i); }
//获取i前导0的比特数（自动匹配位数）
static int LeftZeroCount(unsigned int i) { return LeftZeroCount32(i); }
};
inline int Bits::LeftZeroCount32(unsigned long z)
{
if (z > 0x0000ffff)
{
if (z > 0x00ffffff)
{
if (z > 0x0fffffff)
{
if (z > 0x3fffffff)
{
if (z > 0x7fffffff)return 0; return 1;
}   if (z > 0x1fffffff)return 2; return 3;
}   if (z > 0x03ffffff)
{
if (z > 0x07ffffff)return 4; return 5;
}   if (z > 0x01ffffff)return 6; return 7;
}   if (z > 0x000fffff)
{
if (z > 0x003fffff)
{
if (z > 0x007fffff)return 8; return 9;
}   if (z > 0x001fffff)return 10; return 11;
}   if (z > 0x0003ffff)
{
if (z > 0x0007ffff)return 12; return 13;
}   if (z > 0x0001ffff)return 14; retur
167c3
n 15;
}   if (z > 0x000000ff)
{
if (z > 0x00000fff)
{
if (z > 0x00003fff)
{
if (z > 0x00007fff)return 16; return 17;
}   if (z > 0x00001fff)return 18; return 19;
}   if (z > 0x000003ff)
{
if (z > 0x000007ff)return 20; return 21;
}   if (z > 0x000001ff)return 22; return 23;
}   if (z > 0x0000000f)
{
if (z > 0x0000003f)
{
if (z > 0x0000007f)return 24; return 25;
}   if (z > 0x0000001f)return 26; return 27;
}   if (z > 0x00000003)
{
if (z > 0x00000007)return 28; return 29;
}   if (z > 0x00000001)return 30; return z != 0 ? 31 : 32;
}
inline int Bits::LeftZeroCount64(unsigned long long i)
{
if (i < 0x0000000100000000)//很有意思的感觉，呵呵
{
if (i < 0x0000000000010000)
{
if (i < 0x0000000000000100)
{
if (i < 0x0000000000000010)
{
if (i < 0x0000000000000004)
{
if (i < 0x0000000000000002)return 64 - (int)i; return 62;
}   if (i < 0x0000000000000008)return 61; return 60;
}   if (i < 0x0000000000000040)
{
if (i < 0x0000000000000020)return 59; return 58;
}   if (i < 0x0000000000000080)return 57; return 56;
}   if (i < 0x0000000000001000)
{
if (i < 0x0000000000000400)
{
if (i < 0x0000000000000200)return 55; return 54;
}   if (i < 0x0000000000000800)return 53; return 52;
}   if (i < 0x0000000000004000)
{
if (i < 0x0000000000002000)return 51; return 50;
}   if (i < 0x0000000000008000)return 49; return 48;
}   if (i < 0x0000000001000000)
{
if (i < 0x0000000000100000)
{
if (i < 0x0000000000040000)
{
if (i < 0x0000000000020000)return 47; return 46;
}   if (i < 0x0000000000080000)return 45; return 44;
}   if (i < 0x0000000000400000)
{
if (i < 0x0000000000200000)return 43; return 42;
}   if (i < 0x0000000000800000)return 41; return 40;
}   if (i < 0x0000000010000000)
{
if (i < 0x0000000004000000)
{
if (i < 0x0000000002000000)return 39; return 38;
}   if (i < 0x0000000008000000)return 37; return 36;
}   if (i < 0x0000000040000000)
{
if (i < 0x0000000020000000)return 35; return 34;
}   if (i < 0x0000000080000000)return 33; return 32;
}   if (i < 0x0001000000000000)
{
if (i < 0x0000010000000000)
{
if (i < 0x0000001000000000)
{
if (i < 0x0000000400000000)
{
if (i < 0x0000000200000000)return 31; return 30;
}   if (i < 0x0000000800000000)return 29; return 28;
}   if (i < 0x0000004000000000)
{
if (i < 0x0000002000000000)return 27; return 26;
}   if (i < 0x0000008000000000)return 25; return 24;
}   if (i < 0x0000100000000000)
{
if (i < 0x0000040000000000)
{
if (i < 0x0000020000000000)return 23; return 22;
}   if (i < 0x0000080000000000)return 21; return 20;
}   if (i < 0x0000400000000000)
{
if (i < 0x0000200000000000)return 19; return 18;
}   if (i < 0x0000800000000000)return 17; return 16;
}   if (i < 0x0100000000000000)
{
if (i < 0x0010000000000000)
{
if (i < 0x0004000000000000)
{
if (i < 0x0002000000000000)return 15; return 14;
}   if (i < 0x0008000000000000)return 13; return 12;
}   if (i < 0x0040000000000000)
{
if (i < 0x0020000000000000)return 11; return 10;
}   if (i < 0x0080000000000000)return 9; return 8;
}   if (i < 0x1000000000000000)
{
if (i < 0x0400000000000000)
{
if (i < 0x0200000000000000)return 7; return 6;
}   if (i < 0x0800000000000000)return 5; return 4;
}   if (i < 0x4000000000000000)
{
if (i < 0x2000000000000000)return 3; return 2;
}   if (i < 0x8000000000000000)return 1; return 0;
}

//为了加速分配过程，节点将以size_t []动态数组的形式出现，BlockMemoryNode类提供操作size_t []数组节点的方法
//size_t p[]数组中内容安排：
//p[0]：已使用元素数
//p[1]：可用元素对应的位置数组记录索引
//p[2]：位置记录数组起始索引，数组元素数为iSize
//p[iSize+2]：内容数组起始索引，内容元素数为bSize
struct BlockMemoryNode
{
//将位置记录数组的index位置设置为相反的状态
static void set(size_t*p, size_t index)
{
p[index / (sizeof(size_t) * 8) + 2] ^= ((size_t)(1ull << (sizeof(size_t) * 8 - 1))) >> (index&(sizeof(size_t) * 8 - 1));
}
//获取一个可用的位置的指针并将该位置设置为不可用
static void*get(size_t*p, size_t iLen, size_t size)
{
size_t t = p[1];
size_t i = t;
iLen += 2;//iLen转换为终止位置索引
while (p[i] == 0)//i从2开始
{
if (++i == iLen)i = 2;
if (i == t)return (void*)NULL;
}
p[1] = i;
size_t tmp = (i - 2)*(sizeof(size_t) * 8) + Bits::LeftZeroCount(p[i]);
set(p, tmp);
++p[0];
return (unsigned char*)(p + iLen) + tmp*size;
}
//释放一个内存，成功返回true，size表示分配的块大小
template<size_t size>static bool free(void* pf, size_t*p, size_t iLen, size_t bLen)
{
size_t index = ((unsigned char*)pf - (unsigned char*)(p + 2 + iLen)) / size;
if (index >= bLen)
return false;
#ifdef _DEBUG
if (((p + 2)[index / (sizeof(size_t) * 8)]
& (((size_t)(1ull << (sizeof(size_t) * 8 - 1))) >> (index&(sizeof(size_t) * 8 - 1)))) != 0)
{
throw - 2;//抛出异常
}
#endif
size_t tmp = index;
set(p, tmp);
--p[0];
p[1] = tmp / (sizeof(size_t) * 8);
return true;
}
//获取一个内存，失败返回NULL
inline static void* alloc(size_t*p, size_t iLen, size_t size)
{
return get(p, iLen, size);
}
//初始化
static void Initial(size_t*p, size_t iLen, size_t bLen)
{
p[0] = p[1] = 0;
for (size_t i = 2; i < iLen + 2; ++i)p[i] = (size_t)-1;
size_t mov = (iLen * sizeof(size_t) * 8 - bLen);
p[iLen + 1] <<= mov;
}
static size_t GetIndexLen(size_t bLen)
{
return (bLen + sizeof(size_t) * 8 - 1) / (sizeof(size_t) * 8);
}
static size_t GetBlockLen(size_t bufferLength, size_t size)
{
size_t result = ((bufferLength - 2) * sizeof(size_t) * 8) / (size * 8 + 2);
while (((result + 1) * sizeof(size_t) * 8 - 1) / (sizeof(size_t) * 8) + (size*result + sizeof(size_t) - 1) / (sizeof(size_t) * 8) > bufferLength - 2)--result;
return result;
}
};
//块内存对象，用以分配块大小为size字节大小的内存
template<size_t size>class BlockMemory
{
//节点数组，检索以分配内存（升序排列）
size_t** pArr;
//数组大小
size_t arrSize;
//互斥对象
MutexOnce mtStatic;
//节点总数
size_t NodeCount;
//已用节点数
size_t UsedCount;
//上次有内容节点号
size_t TmpIndex;
//索引数组长度
size_t IndexLength;
//元素数组长度
size_t BlockLength;
//节点大小
size_t BufferLength;
//增加新节点
void AddNode(size_t*);
//禁止复制和赋值
BlockMemory(BlockMemory const&) {}
BlockMemory&operator=(BlockMemory const&) {}
public:
//构造函数，参数enableMutex用以指定是否进行多线程同步，参数bufferLength用以指定节点大小（以size_t为单位）
//注意：块大小在对象生成后需要释放所有内存才能修改
BlockMemory(bool enableMutex = true, size_t bufferLength = 65536 / sizeof(size_t) - 8);
//析构函数
~BlockMemory() { RemoveAll(); }
//是否启用多线程同步（默认使用）
bool EnableMutex;
//返回一个指针指向一个StructOfSize<size>对象（size字节大小）
void* Alloc();
//释放Alloc所分配的内存
void Free(void*p);
//移除未使用的节点
void RemoveEmpty();
//移除所有节点（如果有内存未释放将抛出异常）
void RemoveAll();
//修改块大小，（以size_t为元素的数组元素数）
void ChangeBufferSize(size_t bufferLength);
//获取当前块大小
size_t GetBufferSize() { return BufferLength; }
};
template<size_t size>void BlockMemory<size>::AddNode(size_t*p)
{
if (pArr == NULL)
{
pArr = (size_t**)malloc(4 * sizeof(size_t*));
arrSize = 4;
*pArr = p;
TmpIndex = 0;
}
else
{
if (NodeCount == arrSize)
{
++arrSize;
void* pp = realloc(pArr, arrSize * sizeof(size_t*));
if (pp == 0)throw - 3;//申请内存失败
pArr = (size_t**)pp;
}
if (p > pArr[NodeCount - 1])
{
pArr[TmpIndex = NodeCount] = p;
}
else if (p < pArr[0])
{
for (size_t i = NodeCount; i > 0; --i)
{
pArr[i] = pArr[i - 1];
}
pArr[0] = p;
TmpIndex = 0;
}
else
{
size_t high = NodeCount - 1;
size_t low = 1;
size_t current = NodeCount / 2;
for (;;)
{
if (pArr[current]>p)
{
high = current;
if (pArr[current - 1] < p)break;
size_t tmp = (low + current) / 2;
if (current == tmp)
{
--current;
}
else current = tmp;
}
else if (pArr[current] < p)
{
low = current;
size_t tmp = (current + high) / 2;
if (current == tmp)
{
++current;
}
else current = tmp;
}
else break;
}
for (size_t i = NodeCount; i>current; --i)
{
pArr[i] = pArr[i - 1];
}
pArr[current] = p;
TmpIndex = current;
}
}
++NodeCount;
}
template<size_t size>BlockMemory<size>::BlockMemory(bool enableMutex, size_t bufferLength)
:BufferLength(bufferLength), pArr(NULL), UsedCount(0), TmpIndex(0), arrSize(0), NodeCount(0), EnableMutex(enableMutex)
{
BlockLength = BlockMemoryNode::GetBlockLen(bufferLength, size);
IndexLength = BlockMemoryNode::GetIndexLen(BlockLength);
}
template<size_t size>void* BlockMemory<size>::Alloc()
{
void*p;
if (EnableMutex)mtStatic.Lock();
size_t i = NodeCount - 1;
if (UsedCount == NodeCount)
{
size_t* t = (size_t*)malloc(BufferLength * sizeof(size_t));
BlockMemoryNode::Initial(t, IndexLength, BlockLength);
p = BlockMemoryNode::alloc(t, IndexLength, size);
AddNode(t);
}
else
{
size_t t = TmpIndex;
if (pArr[t][0] == BlockLength)
{
for (;;)
{
if (++t == NodeCount)t = 0;
if (pArr[t][0] != BlockLength)break;
}
TmpIndex = t;
}
p = BlockMemoryNode::alloc(pArr[t], IndexLength, size);
if (pArr[t][0] == BlockLength)
UsedCount++;
}
if (EnableMutex)mtStatic.UnLock();
return p;
}
template<size_t size>void BlockMemory<size>::Free(void*p)
{
if (!p)return;
if (EnableMutex)mtStatic.Lock();
if (pArr)
{
if (NodeCount == 1 || pArr[1] > p)
{
TmpIndex = 0;
if (BlockMemoryNode::free<size>(p, pArr[0], IndexLength, BlockLength) && pArr[0][0] == BlockLength - 1)UsedCount--;
}
else if (pArr[NodeCount - 1] < p)
{
TmpIndex = NodeCount - 1;
if (BlockMemoryNode::free<size>(p, pArr[NodeCount - 1], IndexLength, BlockLength) && pArr[NodeCount - 1][0] == BlockLength - 1)UsedCount--;
}
else//二分法查找
{
size_t high = NodeCount - 1;
size_t low = 0;
size_t current = high / 2;
for (;;)
{
if (pArr[current]>p)
{
high = current;
size_t tmp = (low + current) / 2;
if (current == tmp)
--current;
else current = tmp;
}
else if (pArr[current + 1] < p)
{
low = current;
size_t tmp = (current + high) / 2;
if (current == tmp)
{
if (pArr[current + 1]>p)break;
++current;
}
else current = tmp;
}
else break;
}
if (BlockMemoryNode::free<size>(p, pArr[current], IndexLength, BlockLength) && pArr[current][0] == BlockLength - 1)UsedCount--;
TmpIndex = current;
}
}
if (EnableMutex)mtStatic.UnLock();
}
template<size_t size>void BlockMemory<size>::RemoveEmpty()
{
if (EnableMutex)mtStatic.Lock();
for (size_t t = 0, lt = 0; lt < NodeCount; ++lt)
{
pArr[t] = pArr[lt];
if (pArr[t][0] == 0)
{
free(pArr[t]);
if (TmpIndex == t)TmpIndex = 0;
else if (TmpIndex>t)--TmpIndex;
--NodeCount;
}
else ++t;
}
if (EnableMutex)mtStatic.UnLock();
}
template<size_t size>void BlockMemory<size>::RemoveAll()
{
if (EnableMutex)mtStatic.Lock();
if (UsedCount != 0)
{
if (EnableMutex)mtStatic.UnLock();
throw - 1;//有部分内容未释放
}
for (size_t t = 0; t < NodeCount; ++t)
{
free(pArr[t]);
}
free(pArr);
pArr = NULL;
NodeCount = 0;
arrSize = 0;
if (EnableMutex)mtStatic.UnLock();
}
template<size_t size>void BlockMemory<size>::ChangeBufferSize(size_t bufferLength)
{
RemoveAll();
BlockLength = BlockMemoryNode::GetBlockLen(bufferLength, size);
IndexLength = BlockMemoryNode::GetIndexLen(BlockLength);
}
}

// myMalloc.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include "myMalloc.h"
using namespace LJ;
void* p[10000000];
int main()
{
//简单测试程序（块大小为123字节）
BlockMemory<128> mc;
//申请内存
for (size_t i = 0; i < 10000000; ++i)
{
p[i] = mc.Alloc();
}
//释放内存
for (size_t i = 0; i < 10000000; ++i)
{
mc.Free(p[i]);
}
//移除所有占用内存
mc.RemoveAll();
}