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
的实现。
它的实现是非常简单的,通过源码也可以看到它的不足之处,因为每次只管理一个块大小的内存,当内存不够用时需要向系统申请新的内存,可能会舍弃调一些空间。