小对象的分配技术（2/4）

2.大小一致得分配器

Chunk可以分配固定大小的有限数量内存块，为了达到分配任意多个内存块的目的，我们需要另外一个策略满足这个需求，也就是对Chunk的进一步包装。

小对象的分配技术将固定大小内存分配做成两个层次，当然，更多时候这种划分里考虑效率问题，但是你可以用心体会这里的隔离思想。

FixedAllocator的思想异常简单，为了应对可能的数量不固定的内存块分配，它使用vector存放Chunks，这已经可以解决问题，唯一需要注意的是如何提高效率。

我们记录可用Chunk位置，当有分配请求的时候直接获取，如果可用Chunk用完，则引发一次线性查找，如果还是未找到，那引发一次分配。为了提高哪怕是一点点的归还效率，我们记录最后分配内存的Chunk的位置，在归还的时候优先查询，如果未找到（也就是该块待归还内存不在当前Chunk里），会引发一次线性查找。

是的，FixedAllocator中，查找开始变的多了起来，但是似乎不太容易找到更好的方案了。

为了进一步提高效率，可以使用高速缓冲的策略，归还的内存留待下次使用，而不是直接归还，这是个不错的想法，但是暂时我不优化这个，我更想说的是Loki的小对象分配策略，确切的说是它使用的结构和有限的技术细节。

有必要提一下FixedAllocator的结构和分配方法：

class  FixedAllocator
... {
private:
    std::size_t        blockSize_;
    unsigned char    numBlocks_;
    typedef    std::vector<Chunk>    Chunks;
    Chunks            chunks_;
    Chunks*            allocChunk_;
    Chunks*            deallocChunk_;
} ;

void *     FixedAllocator::Allocate()
... {
    if(allocChunk_ == 0 || allocChunk_->blockAvailable_ == 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_);
}