GitHub: https://github.com/storagezhang

Emai: debugzhang@163.com

LevelDB: https://github.com/google/leveldb

内存池

内存池的存在主要就是减少调用 malloc 或者 new 的次数，减少内存分配所带来的系统开销，提升性能。

LevelDB 中的内存池是由类 Arena 实现的。Arena 先向系统申请一块大的内存，当其他组件需要申请内存时，Arena 先将已有的内存块分配给组件，如果不够用则再申请一块大的内存。当内存池对象析构时，分配的内存均被释放，这保证了内存不会泄漏。

申请内存和分配内存的区别：

• 申请内存：向操作系统申请一块连续的内存空间。
• 分配内存；将已经申请的内存分配给其他组件使用。

成员变量

// 指向当前内存块未分配内存的起始地址的指针
char* alloc_ptr_;
// 记录当前内存块未分配内存的大小
size_t alloc_bytes_remaining_;

// 每个内存块的地址都存储在 vector 中
std::vector<char*> blocks_;

// 原子变量：记录当前对象的内存总量
std::atomic<size_t> memory_usage_;

如图所示，Arena 的成员变量 blocks_ 存储若干个指针，每个指针指向一块内存。alloc_ptr_ 指向当前内存块未分配内存的起始地址，alloc_bytes_remaining_ 为当前内存块未分配内存的大小。

static const int kBlockSize = 4096;

Arena 以内存块为单位来管理内存，每个内存块的大小 kBlockSize 为 4096 KB。

构造函数与析构函数

Arena::Arena()
    : alloc_ptr_(nullptr), alloc_bytes_remaining_(0), memory_usage_(0) {}

Arena::~Arena() {
  for (size_t i = 0; i < blocks_.size(); i++) {
    delete[] blocks_[i];
  }
}

构造函数初始化所有的成员变量，保证不会使用未初始化的变量。

析构函数释放 blocks_ 中每个指针指向的内存块。

内存分配接口

Arena 提供了 3 个 public 函数来简化内存分配。

Arena 的内存分配策略有三种，当申请 bytes 大小的内存时：

• 如果 bytes 小于等于当前内存块剩余内存，直接在当前内存块上分配内存；
• 如果 bytes 大于当前内存块剩余内存，调用 AllocateFallback 函数按照另外两种分配策略分配内存。

Allocate

inline char* Arena::Allocate(size_t bytes) {
  // 不需要分配 0 字节的内存
  assert(bytes > 0);
  
  // 申请的内存小于当前内存块剩余的内存，直接在当前内存块上分配内存
  if (bytes <= alloc_bytes_remaining_) {
    char* result = alloc_ptr_;
    
    // 从当前内存块中分配内存
    alloc_ptr_ += bytes;
    
    // 计算当前内存块的剩余内存大小
    alloc_bytes_remaining_ -= bytes;
    return result;
  }
  
  // 申请的内存大于当前内存块剩余的内存，使用 AllocateFallback 函数重新申请内存
  return AllocateFallback(bytes);
}

Allocate 函数分配 bytes 大小的内存空间，返回指向所分配内存的指针。

AllocateAligned

char* Arena::AllocateAligned(size_t bytes) {
  // 计算当前机器要对齐的字节数，最多 8 字节对齐，否则就按照当前机器的 void* 的大小来对齐
  const int align = (sizeof(void*) > 8) ? sizeof(void*) : 8;
  
  // 字节对齐必须是 2 的次幂
  // x & (x - 1) = 0 表示 x 是 2 的次幂
  static_assert((align & (align - 1)) == 0,
                "Pointer size should be a power of 2");
  
  // A & (B - 1) = A % B
  // reinterpret_cast<uintptr_t> 类型对应机器指针大小
  size_t current_mod = reinterpret_cast<uintptr_t>(alloc_ptr_) & (align - 1);
  
  // 如果 current_mod = 0 表示 alloc_ptr_ 已经是字节对齐的
  // 否则计算 align - current_mod，表示当前指针地址距离字节对齐的偏差
  size_t slop = (current_mod == 0 ? 0 : align - current_mod);
  
  // 当前需要分配的字节大小加上对齐偏差就是最终需要分配的总大小
  size_t needed = bytes + slop;
  char* result;
  
  // 所需的内存小于当前内存块剩余的内存，直接在当前内存块上分配内存
  if (needed <= alloc_bytes_remaining_) {
    result = alloc_ptr_ + slop;
    alloc_ptr_ += needed;
    alloc_bytes_remaining_ -= needed;
  } else {
    // 所需的内存大于当前内存块剩余的内存，使用 AllocateFallback 函数重新申请内存
    result = AllocateFallback(bytes);
  }
  
  // 保证分配的内存起始地址是字节对齐的
  assert((reinterpret_cast<uintptr_t>(result) & (align - 1)) == 0);
  return result;
}

AllocateAligned 函数分配 bytes 大小的内存空间，且起始地址字节对齐，返回指向所分配内存的指针。

MemoryUsage

size_t MemoryUsage() const {
  return memory_usage_.load(std::memory_order_relaxed);
}

MemoryUsage 函数返回当前分配给 Arena 对象的所有内存空间大小和所有指向内存块的指针大小之和。

内存分配内部实现

接上节中的 Arena 的内存分配策略，当申请 bytes 大小的内存时：

• 如果 bytes 小于等于当前内存块剩余内存，直接在当前内存块上分配内存；
• 如果 bytes 大于当前内存块剩余内存：
  • 如果 bytes 小于等于默认内存块大小的四分之一，新申请一个内存块，大小为默认内存块大小，在该内存块上分配内存；
  • 如果 bytes 大于默认内存块大小的四分之一，新申请一个内存块，大小为 bytes，分配内存。

AllocateFallback

char* Arena::AllocateFallback(size_t bytes) {
  // 调用 AllocateNewBlock 申请一块大小为 bytes 的新内存块
  if (bytes > kBlockSize / 4) {
    // 在新申请的内存块中分配全部内存
    char* result = AllocateNewBlock(bytes);
    return result;
  }

  // 调用 AllocateNewBlock 申请一块大小为 kBlockSize 的新内存块
  alloc_ptr_ = AllocateNewBlock(kBlockSize);
  alloc_bytes_remaining_ = kBlockSize;

  // 在新申请的内存块中分配 bytes 大小的内存
  char* result = alloc_ptr_;
  alloc_ptr_ += bytes;
  alloc_bytes_remaining_ -= bytes;
  return result;
}

当申请的内存大于当前内存块剩余内存时，AllocateFallback 函数会被调用，用来按照后两种分配策略分配内存。

这两种分配策略可以进一步减少内存分配的次数，但同时每块最后 $\frac{1}{4}$ 的空间有可能会被浪费。

AllocateNewBlock

char* Arena::AllocateNewBlock(size_t block_bytes) {
  // 申请一个大小为 block_bytes 的内存块
  char* result = new char[block_bytes];
  
  // 将该内存块的地址添加到 blocks 中
  blocks_.push_back(result);
  
  // 记录当前对象内存分配总量
  memory_usage_.fetch_add(block_bytes + sizeof(char*),
                          std::memory_order_relaxed);
  return result;
}

AllocateNewBlock 函数申请一个大小为 block_bytes 的内存块。

总结

当向 Arena 申请 bytes 大小的内存时：

• 如果 bytes 小于等于当前内存块剩余内存，直接在当前内存块上分配内存；
• 如果 bytes 大于当前内存块剩余内存：
  • 如果 bytes 小于等于默认内存块大小的四分之一，新申请一个内存块，大小为默认内存块大小，在该内存块上分配内存；
  • 如果 bytes 大于默认内存块大小的四分之一，新申请一个内存块，大小为 bytes，分配内存。