小型对象分配技术



内存薄记机构
struct MemControlBlock{
 std::size_t size_;
 bool available_;
}
内存池起始处只有一个MemControlBlock，并将所有内存视为一块，这是所谓root控制块
策略：
最先匹配法则，最佳匹配法则，最差匹配法则，随机匹配法则
struct Chunk
{
 void Init(std::size_t blockSize,unsigned char blocks);
 void Release();
 void * Allocate(std::size_t blockSize); //申请  
 void Deallocate(void * p ,std::size_t blockSize);//释放
 unsigned char * pData_;
 unsigned char firstAvailableBlock_,   //第一个可用区块索引号
 blocksAvailable_;    //chunk内的可用区块总数
} 

void Chunk::Init(std::size_t blockSize,unsigned char blocks)
{
 pData_=new unsigned cha[blockSize * blocks];
 firstAvailableBlock_ =blocks;
 unsigned char i =0;
 unsigned char *p = pData_;
 for (;i!=blocks;p += blockSize)
 {
  * p = ++i;
 }
}
void * Chunk::Allocate(std::size_t blockSize)
{
 if(!blocksAvailable_) return 0;    一个
 unsigned char * pResult =pData_+(firstAvailableBlock_*blockSize);
 firstAvailableBlock_=*pResult;
 --blocksAvailable_;
 return pResult;
}
void Chunk::Deallocate(void *p,std::size_t blockSize)
{
 assert(p>pData_);
 unsigned char * toRelease = static_cast<unsigned char *>(p);
 assert((toRelease-pData_)%blockSize == 0);
 *toRelease = firstAvailableBlock_;
 firstAvailableBlock_=static_cast<unsigned char>(
 (toRelease-pData_)/blockSize);
 assert(firstAvailableBlock_==(toRelease-pData_)/blockSize);
 ++blocksAvailable_;
}
class FixedAllocator{
 ...
 private:
 std::size_t  blockSize_;
 unsigned char  numBlocks_;
 typedef std::vector<Chunk> Chunks;
 Chunks chunks_;
 Chunks * allocChunk_;
 Chunks * dealloChunk_;
}
void * FixedAllocator::Allocate()
{
 if(allocChunk_==0 || allocChunk_->blocksAvailable_==0)
 {
  Chunks::iterator i =chunks_.begin();
  for(::++i)
  {
   if(i==chunks_.end())
   {
    chunks_.push_back(Chunk());
    Chunk& newChunk = chunks_back();
    newChunk.Init(blockSize_,numBlocks_);
    allocChunk_=&newChunk;
    deallocChunk_=&chunks_.front();
    break;
   }
   if(i->blocksAvailable_>0)
   {
    allocChunk_=&*i;
    break;
   }
  }
 }
 assert(allocChunk_ !=0);
 assert(allocChunk_ ->blocksAvailable_>0);
 return allocChunk_ ->Allocate(blockSize_);
}

class SmallObjAllocator
{
 public:
 SmallObjAllocator(
  std::size_t chunkSize,
  std::size_t maxObjectSize);
 void * Allocate(std::size_t numBytes);
 void Deallocate(void* p,std::size_t size);

 private:
 std::vector<FixedAllocator> pool_;
 )
}

class SmallObjAllocator{
 ...
 private:
 std::vector<FixedAllocator> pool_;
 FixedAllocator * pLastAlloc_;
 FixedAllocator * PLastDealloc_;
};

class SmallObject
{
 public :
 static  void * operator new (std::size_t size);
 static  void operator delete(void *p,std::size_t size);
 virtual ~SmallObject(){}
};
typedef SingletonHolder<SmallObjAllocator> MyAlloc;
void * SmallObject::oPerator new(std::size_t size)
{
 return MyAlloc::Instance().Allocate(size);
}
void SmallObject::operator delete(void *p,std::size_t size){
 MyAlloc::Instance().Deallocate(p,size);
}

template<tempalte<class T> class ThreadingModel>
class SmallObject:public ThreadingModel<SmallObjcet>
{
 ....如同以往....
}
template<template<class T> class ThreadingModel>
void * SmallObject<tm>::operator new(std::size_t size)
{
 Lock lock;
 return MyAlloc::Instance().Allocate(size);
}
template<template<class T>class ThreadingModel>