一. 内存池的优势

1. 直接使用系统调用的弊端

• 调用malloc/new,系统需要根据“最先匹配”、“最优匹配”或其他算法在内存空闲块表中查找一块空闲内存，调用free/delete,系统可能需要合并空闲内存块，这些会产生额外开销
• 频繁使用时会产生大量内存碎片，从而降低程序运行效率(对于内存碎片问题上这篇博文有着不一样的看法，有一定道理，可以参考一下^_)
• 容易造成内存泄漏

2. 内存池的优点

• 比malloc/free进行内存申请/释放的方式快(向内存池请求，而不是直接向操作系统请求)
• 不会产生或很少产生堆碎片
• 可避免内存泄漏

二. Arena内存池的实现

1. Arena类的成员变量

// 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.
port::AtomicPointer memory_usage_;

Arena类的成员变量还是相对比较简单的，alloc_ptr_表示当前内存块(block)偏移量指针，也就是未使用内存的首地址。 alloc_bytes_remaining_表示当前块所未使用的空间大小。blocks_是一个vector用来存储每一次向系统请求的分配的内存指针。 memory_usage_则是用来记录Arena类内存使用情况的。

2. Arena类的成员函数

a. 构造函数

Arena::Arena() : memory_usage_(0) {
  alloc_ptr_ = NULL;  // First allocation will allocate a block
  alloc_bytes_remaining_ = 0;
}

非常简单的一个构造函数，负责初始化一些变量，注意刚开始是没有立刻分配内存的

b. 析构函数

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

析构函数负责将从系统中申请的内存返还给系统。

c. Allocate() && AllocateFallback() && AllocateNewBlock()

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);
}

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;
}

char* Arena::AllocateNewBlock(size_t 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是Arena向外界提供的接口，该函数会调用AllocateFallback() && AllocateNewBlock() 这两个私有函数。

1. 如果需求的内存小于剩余的内存，那么直接从内存池中获取
2. 如果需求的内存大于剩余的内存，而且大于1K，则给这内存单独分配一块bytes（函数参数）大小的内存
3. 如果需求的内存大于剩余的内存，而且小于4096/4，则重新分配一个内存块，默认大小4096，用于存储数据。原有的剩余空间浪费掉。

d. AllocateAligned()

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;
}

Arena还提供了字节对齐内存分配，一般情况是8个字节对齐分配。对齐内存的好处简单的说就是加速内存访问。具体实现源码已经写的非常详细了，稍微有点疑惑的地方也都有了注释。

e. MemoryUsage()

size_t MemoryUsage() const {
    return reinterpret_cast<uintptr_t>(memory_usage_.NoBarrier_Load());
  }

Arena最后一个对外接口是返回这个内存池分配总的内存大小。

icecity96 liuhiter@gmail.com