【C++内存管理】loki::allocator 源码分析

loki 是书籍《Modern C++ Design》配套发行的一个 C++ 代码库，里面对模板的使用发挥到了极致，对设计模式进行了代码实现。这里是 loki 库的源码。

ps. 有空是不是应该把里面的设计模式的代码学习学习, hahahah

loki 库里面有两个文件，SmallObj.h 以及 SmallObj.cpp，就是一个内存管理的内，可以单独使用。下面就其源码进行分析。

1. 类层次结构

SmallObj 文件里面有三个类：Chunk，FixedAllocator 和 SmallObjAllocator。它们的类层次关系如下，其中SmallObjAllocator 是最上层的，直接供客户端使用的类。

2. Chunk

Chunk 就是直接管理单一内存块的类。它负责向操作系统索取内存块，并将内存块串成 “链表”。

2.1 初始化

先来看看其中的初始化函数 Init()：

void FixedAllocator::Chunk::Init(std::size_t blockSize, unsigned char blocks)
{    pData_ = new unsigned char[blockSize * blocks];Reset(blockSize, blocks);
}void FixedAllocator::Chunk::Reset(std::size_t blockSize, unsigned char blocks)
{firstAvailableBlock_ = 0;blocksAvailable_ = blocks;unsigned char i = 0;unsigned char* p = pData_;for (; i != blocks; p += blockSize) //指向下一个可用的 block 的 index{*p = ++i;}
}

传入参数为 block 的大小和数量
用 operator new 分配出一大块内存 chunk，并用指针 pData_ 指向 chunk。
Reset() 函数对这块内存进行分割。利用嵌入式指针的思想，每一块 block 的第一个 byte 存放的是下一个可用的 block 距离起始位置 pData_ 的偏移量（以 block 大小为单位），以这种形式将 block 串成 “链表”。
firstAvailableBlock_ 表示当前可用的 block 的偏移量；blocksAvailable_ 表示当前 chunk 中剩余的 block 数量。

初始状态的 chunk 如下图所示：

2.2 内存分配 allocate

void* FixedAllocator::Chunk::Allocate(std::size_t blockSize)
{if (!blocksAvailable_) return 0;unsigned char* pResult =pData_ + (firstAvailableBlock_ * blockSize);firstAvailableBlock_ = *pResult;--blocksAvailable_;return pResult;
}

这段代码也很好理解，可以结合下图理解：

2.3 内存回收 deallocate

void FixedAllocator::Chunk::Deallocate(void* p, std::size_t blockSize)
{unsigned char* toRelease = static_cast<unsigned char*>(p);//链接到链表上*toRelease = firstAvailableBlock_;//修改 “头指针”//回收的 block 指针距离头指针 pData_ 的距离（以 block 为单位）firstAvailableBlock_ = static_cast<unsigned char>((toRelease - pData_) / blockSize);++blocksAvailable_;
}

同之前的内存回收一样，回收的时候，都把 block 插到链表的头部。

3. FixedAllocate

FixedAllocate 则负责管理一个具有相同 block size 的 chunk 的集合。它负责根据客户需求，创建特定 block 大小的 chunk ，并放置在容器 vector 中进行管理。

3.1 内存分配 allocate

void* FixedAllocator::Allocate()
{if (allocChunk_ == 0 || allocChunk_->blocksAvailable_ == 0){   //目前没有标定的 chunk ，或者这个 chunk 已经用完了//从头找起Chunks::iterator i = chunks_.begin();for (;; ++i){//没找到，则创建一个新的 chunkif (i == chunks_.end()){// Initializechunks_.reserve(chunks_.size() + 1);Chunk newChunk;newChunk.Init(blockSize_, numBlocks_);chunks_.push_back(newChunk);allocChunk_ = &chunks_.back();//上面容器的大小会增长一个，可能会引起 vetor 的扩容操作，导致原来的元素被搬移到新的地方//所以这里的 deallocChunk 需要重新标定，直接标定为第一个。原来可能并不是指向第一个，//原来的那个经过搬移之后已经无法确定新的位置了deallocChunk_ = &chunks_.front();break;}if (i->blocksAvailable_ > 0){allocChunk_ = &*i;break;}}}return allocChunk_->Allocate(blockSize_);
}

allocChunk_ 指向当前正在使用中的 chunk。如果 allocChunk_ 指向的 chunk 中的 block 已经用完了，那么就在容器中去寻找其他可用的 chunk 。如果没有找到，就新建一个 chunk ，放进容器中，并标定为当前的 allocChunk_。
本来这里的 allocate 动作跟 deallocChunk_ 成员没有关系的。但是，创建新的 chunk 并添加进 vector 中后，可能会引起 vector 的内存重分配动作，导致原来的 deallocChunk_ 指向的内存并不存在了，所以要对 deallocChunk_ 重新标定。它这里直接重新标定为第一个 chunk，因为原来的那个已经无法确定位置了。 ps. 大神就是大神，这都能想到~

其实我这里有一个疑问。用 allocChunk_ 变量对当前使用的 chunk 进行标定，如果当前使用的 chunk 没有用完，会一直使用这一块 chunk，直到这一块 chunk 用完。那么，当这一块 chunk 用完的时候，其他的 chunk 难道不是能够确定一定用完了吗？那么还有必要去对 vector 进行遍历，去寻找可用的 chunk 吗？为什么不直接就去创建一个新的 chunk ？

3.2 内存回收 deallocate

我们需要根据归还内存的位置，把这块内存回收到相对应的 chunk 中。

void FixedAllocator::Deallocate(void* p)
{    deallocChunk_  = VicinityFind(p);DoDeallocate(p);
}

我们知道每一块 chunk 的头指针，以及这一块 chunk 的大小，这样的话，我们就可以计算出每一块 chunk 的地址范围。我们只要找到归还的内存的地址是落在哪一个 chunk 地址范围内，就可以确定 chunk。这一功能由函数 VicinityFind() 实现。
VicinityFind() 函数采用一种分头查找的算法，从上一次 deallocChunk_ 的位置出发，在容器中分两头查找。这也应该是设计这个 deallocChunk_ 指针的原因把。内存分配通常是给容器服务的。而容器内元素连续创建时，通常就从同一个 chunk 获得连续的地址空间。归还的时候当然也需要归还到同一块 chunk 。通过对上一次归还 chunk 的记录，能提高搜索的效率。下面是 VicinityFind() 的实现代码：

FixedAllocator::Chunk* FixedAllocator::VicinityFind(void* p)
{const std::size_t chunkLength = numBlocks_ * blockSize_;Chunk* lo = deallocChunk_;Chunk* hi = deallocChunk_ + 1;Chunk* loBound = &chunks_.front();Chunk* hiBound = &chunks_.back() + 1;// Special case: deallocChunk_ is the last in the arrayif (hi == hiBound) hi = 0;for (;;){if (lo){if (p >= lo->pData_ && p < lo->pData_ + chunkLength){return lo;}if (lo == loBound) lo = 0;else --lo;}if (hi){if (p >= hi->pData_ && p < hi->pData_ + chunkLength){return hi;}if (++hi == hiBound) hi = 0;}}
}

最后内存回收的动作由函数 DoDeallocate() 完成。如果当前回收的 chunk 已经将所有的 block 全部回收完了，即 deallocChunk_->blocksAvailable_ == numBlocks_ ，本来这块内存就可以归还给 OS 了的。但是这里采取了一个延迟归还的动作。把这个空的 chunk 通过 swap 函数放在 vector 的末尾，并且将 allocChunk_ 指向它，供下一次再使用。只有当有两个空 chunk 出现时，才会把上一个空的 chunk 归还给 OS。下面是源码：

void FixedAllocator::DoDeallocate(void* p)
{// call into the chunk, will adjust the inner list but won't release memorydeallocChunk_->Deallocate(p, blockSize_);//如果已经全回收了if (deallocChunk_->blocksAvailable_ == numBlocks_){// deallocChunk_ is completely free, should we release it? Chunk& lastChunk = chunks_.back();//最后一个就是当前的 deallocChunkif (&lastChunk == deallocChunk_){// check if we have two last chunks emptyif (chunks_.size() > 1 && deallocChunk_[-1].blocksAvailable_ == numBlocks_){// Two free chunks, discard the last onelastChunk.Release();chunks_.pop_back();allocChunk_ = deallocChunk_ = &chunks_.front();}return;}if (lastChunk.blocksAvailable_ == numBlocks_){// Two free blocks, discard onelastChunk.Release();chunks_.pop_back();allocChunk_ = deallocChunk_;}else{// move the empty chunk to the endstd::swap(*deallocChunk_, lastChunk);allocChunk_ = &chunks_.back();}}
}

这里我突然明白上面说到的，为什么要遍历容器寻找下一个可用的 chunk 的问题了。因为在这里，allocChunk_ 会转而指向这个回收完成了的空的 chunk，它原来指向的 chunk 可能并没有使用完。
不过这里我又有一个新的疑惑。如果当前空的 chunk 就是容器中最后一个时，为什么要往前看一个 chunk，看它是不是空？前面一个有可能是空吗？？

4. SmallObjAllocator

SmallObjAllocator 则负责管理具有不同 block size 的 FixedAllocate 的 vector 集合。

4.1 内存分配 allocate

void* SmallObjAllocator::Allocate(std::size_t numBytes)
{if (numBytes > maxObjectSize_) return operator new(numBytes);if (pLastAlloc_ && pLastAlloc_->BlockSize() == numBytes){return pLastAlloc_->Allocate();}//找到第一个 >= numBytes 的位置Pool::iterator i = std::lower_bound(pool_.begin(), pool_.end(), numBytes);//没找到相同的，就重新创建一个 FixedAllocatorif (i == pool_.end() || i->BlockSize() != numBytes){i = pool_.insert(i, FixedAllocator(numBytes));pLastDealloc_ = &*pool_.begin();}pLastAlloc_ = &*i;return pLastAlloc_->Allocate();
}

SmallObjAllocator 不可能无穷无尽的满足客户不同的 block size 的需求。它设有一个最大的 block size 变量 maxObjectSize_ 。如果客户端需求的 block size 大于这个 threshold，就直接交由 operator new 去进行处理。
pLastAlloc_ 记录上一次分配 block 的 FixedAllocator object 。如果这一次需求的 block size 等于上一次分配的 block size，就直接使用同一个 FixedAllocator object 去分配内存。我认为这个变量的设计和 FixedAllocator 中 deallocChunk_ 的设计道理是一样的。 SmallObjAllocator 是给容器服务，而容器通常连续多次为其中的 element 索取多个相同 size 的 block，所以对上一次分配的 FixedAllocator object 进行记录能够减少不必要的查找动作。
如果这一次需求的 block size 不等于上一次分配的 block size，就遍历容器寻找不小于需求的 block size 而且最接近的位置，也就是 std::lower_bound() 函数的功能。如果找到 block size 相等的，就直接分配；如果没找到相等的，就在该位置上插入一个新的 FixedAllocator object。同样，为了防止 vector 扩容操作引起重新分配内存，需要对 pLastDealloc_ 进行重定位。

4.2 内存回收 deallocate

void SmallObjAllocator::Deallocate(void* p, std::size_t numBytes)
{if (numBytes > maxObjectSize_) return operator delete(p);if (pLastDealloc_ && pLastDealloc_->BlockSize() == numBytes){pLastDealloc_->Deallocate(p);return;}Pool::iterator i = std::lower_bound(pool_.begin(), pool_.end(), numBytes);assert(i != pool_.end());assert(i->BlockSize() == numBytes);pLastDealloc_ = &*i;pLastDealloc_->Deallocate(p);
}

设计上没啥新颖的，不多说了。

5. 总结

相比于之前分析的 std::alloc 的内存管理：

std::alloc 一旦向 OS 索取了新的 chunk，就不会还给 OS 了，一直在自己的掌控之中。因为它里面的指针拉扯比较复杂，几乎不可能去判断一块 chunk 中给出去的 block 是否全部归还了。但是 loki::allocator 通过利用一个 blocksAvailable_ 变量，就很容易的判断出某一块 chunk 中的 block 是否已经全部归还了，这样就可以归还给 OS。
std::alloc 只负责一些特定 block size 的内存管理。如果客户端需要的 block size 它并不支持，那个客户端的 block size 会被取整到最接近的大小 (当然前提是小于它所能够分配的最大的 block size）；但是 loki::allocator 能够为不大于最大 block size 的所有 block size 服务。