leveldb 源码剖析之二 内存管理 arena.cc arena.h

leveldb内存管理主要是通过arena.cc arena.h这两个文件来实现的，其中arena.h定义了一个Arena类，arena.cc为各种成员函数的具体实现。相比于STL的空间配置，leveldb的整个框架还是比较简单的。

首先给出大概框架：

首先看arena.h头文件：

#ifndef STORAGE_LEVELDB_UTIL_ARENA_H_
#define STORAGE_LEVELDB_UTIL_ARENA_H_

#include <atomic>
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <vector>

namespace leveldb {

class Arena {
 public:
  Arena();

  Arena(const Arena&) = delete;
  Arena& operator=(const Arena&) = delete;

  ~Arena();

  // Return a pointer to a newly allocated memory block of "bytes" bytes.
  char* Allocate(size_t bytes);

  // Allocate memory with the normal alignment guarantees provided by malloc.
  char* AllocateAligned(size_t bytes);

  // Returns an estimate of the total memory usage of data allocated
  // by the arena.
  size_t MemoryUsage() const {
    return memory_usage_.load(std::memory_order_relaxed);
  }

 private:
  char* AllocateFallback(size_t bytes);
  char* AllocateNewBlock(size_t block_bytes);

  // Allocation state
  char* alloc_ptr_;
  size_t alloc_bytes_remaining_;

  // Array of new[] allocated memory blocks
  std::vector<char*> blocks_;

  // Total memory usage of the arena.
  //
  // TODO(costan): This member is accessed via atomics, but the others are
  //               accessed without any locking. Is this OK?
  std::atomic<size_t> memory_usage_;
};
//申请bytes字节个空间，如果内存池充足就直接返回；否则调用AllocateFallback（）函数申请新的内存块
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;
  }
  return AllocateFallback(bytes);
}

}  // namespace leveldb

#endif  // STORAGE_LEVELDB_UTIL_ARENA_H_

size_t alloc_bytes_remaining_表示剩余空间的大小，当调用Allocate（）申请bytes个字节时，如果剩余空间足够直接将地址返回就可以；否则需要调用AllocateFallback（）重新分配。

下面是arena.cc文件：

#include "util/arena.h"

namespace leveldb {

static const int kBlockSize = 4096;

//构造函数
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];
    }
}
//申请内存，如果bytes大小大于1024就直接申请大小的内存，否则一律申请1024个字节，多余的空间留下次使用
//存在一定程度的浪费，有大量的碎片化内存没有利用
char* Arena::AllocateFallback(size_t 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;
}

//升级版的allocate函数，内存对齐
char* Arena::AllocateAligned(size_t bytes) {
    const int align = (sizeof(void*) > 8) ? sizeof(void*) : 8;
    //首先align是当前系统环境下一个指针所占的字节，一般与系统位数对应，4或者8
    //align必须是2的幂级数 2 ,4,8...
    static_assert((align & (align - 1)) == 0,
                  "Pointer size should be a power of 2");
    //将当前指针进行类型转换为unsigned int,然后与align - 1相与,current_mod表示当前地址超过了上一个对其位置的字节数；
    //slop等于下一个对其位置减掉current_mod,就是为了进行内存对齐,需要多移动的字节数；
    //例如在32为系统下,align=4,假设alloc_ptr_=0x0005,那么current_mod=1,slop,3；
    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;
}

//申请一块内存，并将该内存的首地址放入block_数组中,以便之后析构函数依次释放
char* Arena::AllocateNewBlock(size_t block_bytes) {
    char* result = new char[block_bytes];
    blocks_.push_back(result);
    memory_usage_.fetch_add(block_bytes + sizeof(char*),
                            std::memory_order_relaxed);
    return result;
}

}  // namespace leveldb

代码当中已经注释的比较清楚了，个人觉得比较关键的几点：

1. AllocateFallback（）函数中对不同大小的bytes的区分处理，如果大于1024kb就简单的申请然后返回；如果小于1024kb,那么一律分配4096个字节，多分配的空间由alloc_bytes_remaining_和alloc_ptr_来指示，留给下一次使用。

这里存在着一些浪费，即碎片化内存没有被使用，考虑如下情况：
如果alloc_ptr_有一定的剩余空间，但是当前申请空间bytes大于alloc_bytes_remaining_,小于1024kb.按照代码逻辑，此时必须重像系统申请4096kb的内存，改变alloc_ptr_指针，那么之前剩余的空间就没有被利用。

2.内存对齐操作，具体就是如下几行代码：

const int align = (sizeof(void*) > 8) ? sizeof(void*) : 8;
    //首先align是当前系统环境下一个指针所占的字节，一般为4或者8
    //align必须是2的幂级数 2 ,4,8...
    static_assert((align & (align - 1)) == 0,
                  "Pointer size should be a power of 2");
    //将当前指针进行类型转换为unsigned int,然后与align - 1相与,current_mod表示当前地址超过了上一个对其位置的字节数；
    //slop等于下一个对其位置减掉current_mod,就是为了进行内存对齐,需要多移动的字节数；
    //例如在32为系统下,align=4,假设alloc_ptr_=0x0005,那么current_mod=1,slop,3；
    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;

3.AllocateNewBlock（）函数是一个底层的函数，负责直接向系统申请空间，并且将返回的首地址保存在一个数组当中。在之后的析构操作中，只需要遍历数组依次释放所有空间。

//析构函数，依次释放所有的内存池
Arena::~Arena() {
    for (size_t i = 0; i < blocks_.size(); i++) {
        delete[] blocks_[i];
    }

最后给出内存结构：

图片参考http://www.cppblog.com/sandy/archive/2012/03/28/leveldb-trick1.html