一. 内存池的优势
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() 这两个私有函数。
- 如果需求的内存小于剩余的内存，那么直接从内存池中获取
- 如果需求的内存大于剩余的内存，而且大于1K，则给这内存单独分配一块bytes（函数参数）大小的内存
- 如果需求的内存大于剩余的内存，而且小于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
