levelDB源码阅读-内存池arena

levelDB源码阅读-内存池arena

前言

直接使用系统调用分配内存是非常不明智的

• 频繁调用malloc/new是非常耗时的，且系统需要根据一些算法在内存空闲块表中查找
• 可能会产生大量的内存碎片
• 如果使用不细心也很容易造成内存泄漏

采用内存池，预先申请一块比较大的空间供申请，可以根据程序的实际需要指定申请的规则，并且对这些内存资源统一管理。

使用内存池的好处

• 申请内存的时间会更快，直接在内存池中获取
• 不会或很少产生堆碎片
• 由于统一管理，可以避免内存泄漏

levelDB实现的内存池为arena：

arena内存池中，向系统申请的所有内存都是存放在一个vector数组----block_中的，指针alloc_ptr和剩余容量alloc_bytes_remaining_管理着内存池中的内存分配。

当用户申请byetes大小的空间时，若内存够用则直接分配给用户，若不够用则向系统申请新的内存并 push_back 到 block_中去：

当byetes小于kBlockSize的四分之一时，向系统申请的容量大小为kBlockSize大小，并改变指针指向和剩余容量，这意味着需要摒弃alloc_ptr管理的上一块内存的剩余容量；当byetes大于kBlockSize的四分之一时则直接申请用户请求的大小并且返回给用户。
接下来我们来分析其源码。

代码位置：
leveldb-master/leveldb-master/util/arena.h
leveldb-master/leveldb-master/util/arena.cc

深入源码

arena的结构

class Arena {
  //...
  // Allocation state
  //未分配的内存的起始位置
  char* alloc_ptr_;
  //剩余可分配的内存总量
  size_t alloc_bytes_remaining_;

  // Array of new[] allocated memory blocks
  //存放arena申请到的内存
  std::vector<char*> blocks_;

  // Total memory usage of the arena.
  //arena的内存总量
  port::AtomicPointer memory_usage_;

  //...
};

构造/析构函数

//静态全局常量
static const int kBlockSize = 4096;

Arena::Arena() : memory_usage_(0) {
  //内存池初始化时不申请内存
  alloc_ptr_ = nullptr;  // First allocation will allocate a block
  alloc_bytes_remaining_ = 0;
}

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

AllocateNewBlock

向系统申请新的空间添加到内存池中。

char* Arena::AllocateNewBlock(size_t block_bytes) {
  //新申请block_bytes大小的内存
  char* result = new char[block_bytes];
  //将它添加到内存池尾部供使用
  blocks_.push_back(result);
  memory_usage_.NoBarrier_Store(
      reinterpret_cast<void*>(MemoryUsage() + block_bytes + sizeof(char*)));
  return result;
}

}

关于Allocate的一些函数

Allocate

提供给外部使用的接口，用于申请内存，这种方式是没有对齐操作的。

inline char* Arena::Allocate(size_t bytes) {
  // The semantics of what to return are a bit messy if we allow
  // 0-byte allocations, so we disallow them here (we don't need
  // them for our internal use).
  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);
}

}

AllocateAligned

以内存对齐的方式进行分配，其逻辑和Allocate没有什么区别。

char* Arena::AllocateAligned(size_t bytes) {
  //设置对齐方式
  const int align = (sizeof(void*) > 8) ? sizeof(void*) : 8;
  assert((align & (align-1)) == 0);   // Pointer size should be a power of 2
  //进行模运算
  size_t current_mod = reinterpret_cast<uintptr_t>(alloc_ptr_) & (align-1);
  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 always returned aligned memory
    result = AllocateFallback(bytes);
  }
  assert((reinterpret_cast<uintptr_t>(result) & (align-1)) == 0);
  return result;
}

AllocateFallback

该函数供Allocate和AllocateAligned调用，用来处理当内存池中剩余量不够的情况。
这里区分了两种情况：

• 申请内存大于kBlockSize的四分之一时
  调用AllocateNewBlock申请bytes大小的空间，直接返回给用户使用
• 申请内存小于kBlockSize的四分之一时
  调用AllocateNewBlock申请kBlockSize大小的空间，并改变alloc_ptr指针指向以及剩余容量alloc_bytes_remaining_。

char* Arena::AllocateFallback(size_t bytes) {
  //如果所申请的大小大于kBlockSize的四分之一
  //为了避免浪费太多剩余的内存，则向系统新申请bytes大小的空间，直接分配给用户
  if (bytes > kBlockSize / 4) {
    // Object is more than a quarter of our block size.  Allocate it separately
    // to avoid wasting too much space in leftover bytes.
    char* result = AllocateNewBlock(bytes);
    return result;
  }

  // We waste the remaining space in the current block.
  //如果请求量小于四分之一，则将之前剩余的内存丢弃
  alloc_ptr_ = AllocateNewBlock(kBlockSize);
  alloc_bytes_remaining_ = kBlockSize;

  char* result = alloc_ptr_;
  alloc_ptr_ += bytes;
  alloc_bytes_remaining_ -= bytes;
  return result;
}

总结

以上分析了levelDB中内存池arena的实现。
它的实现是非常简单的，通过源码也可以看到它的不足之处，因为每次只管理一个块大小的内存，当内存不够用时需要向系统申请新的内存，可能会舍弃调一些空间。