Box2D源码分析：栈内存分配B2StackAllocator

B2StackAllocator主要是为了运行一个步长时满足box2d需要的临时内存空间，作为栈分配器来防止单步堆分配。（这是官方的说明，我没弄懂是什么意思，有知道的希望能说明一下:-D）

首先给出大概的图给大家一个感受，对于代码更容易理解。

它使用了数据结构stack的后进先出(LIFO)的方式。所以Allocate和Free需要成对使用。



在我看来，它相对于使用SOA实现的B2BlockAllocator主要有以下区别：

a)B2StackAllocator可使用的内存大小固定，而B2BlockAllocator可以扩大内存池；

b)B2StackAllocator内分配的内存大小没有具体要求，只要不超过内存数组剩余大小即可，而B2BlockAllocator只能分配早已指定好的几种block大小类型；

c)B2StackAllocator使用栈思想，后进先出(LIFO)，故其分配的空间是连续的。B2BlockAllocator使用链表形式，并利用m_freeLists在这些链表节点中指来指去，故分配的空间可以说是不连续的；

暂时只能想到这些，如有错误或者补充欢迎提出，如果有人能指出两者较为具体的使用环境就更好了。:-D

好了，知道了结构，下面的代码应该问题不大。

首先看一下头文件：

const int32 b2_stackSize = 100 * 1024;	   //内存数组最大内存100k
const int32 b2_maxStackEntries = 32;    //能存储的最多的栈实体数量

struct b2StackEntry
{
char* data;         //指向使用的内存头位置
int32 size;         //该内存大小
bool usedMalloc;   //是否在堆上申请
};

// This is a stack allocator used for fast per step allocations.
// You must nest allocate/free pairs. The code will assert
// if you try to interleave multiple allocate/free pairs.
class b2StackAllocator
{
public:
b2StackAllocator();
~b2StackAllocator();

void* Allocate(int32 size);
void Free(void* p);

int32 GetMaxAllocation() const;    //获取历史总分配内存大小（不扣释放掉的）

private:
//内存数组，看成内存池呗
char m_data[b2_stackSize];
//内存池中已使用的内存大小
//可用来获取内存池未使用的内存头位置
int32 m_index;
//栈实体数组m_entries中所有实体的内存总大小
//与上面m_index不同的是
//m_allocation包括了在堆上分配的内存大小
int32 m_allocation;
//历史上总分配内存大小
int32 m_maxAllocation;
//栈实体数组
b2StackEntry m_entries[b2_maxStackEntries];
//栈实体数组中实体数量
int32 m_entryCount;
};

说明已在注释中，下面介绍实现文件。

构造函数

b2StackAllocator::b2StackAllocator()
{
m_index = 0;
m_allocation = 0;
m_maxAllocation = 0;
m_entryCount = 0;
}

初始化内存池中已使用的内存大小m_index = 0，总分配内存大小（包括堆中）m_allocation = 0，历史总分配内存大小m_maxAllocation = 0，栈实体数量m_entryCount = 0.

析构函数

b2StackAllocator::~b2StackAllocator()
{
b2Assert(m_index == 0);
b2Assert(m_entryCount == 0);
}

只需要确保内存池已使用的内存大小以及栈实体数量为0。即验证内存是否完全释放和元素是否完全出栈。故Allocate与free务必成对使用。

内存分配

void* b2StackAllocator::Allocate(int32 size)
{
//确保栈实体数组还未使用完毕
b2Assert(m_entryCount < b2_maxStackEntries);
//获取实体数组中未使用的头位置
//不过，既然是数组
//为什么不直接使用b2StackEntry entry = m_entries[m_entryCount]呢？
b2StackEntry* entry = m_entries + m_entryCount;
entry->size = size;
if (m_index + size > b2_stackSize)
{
//若申请的大小超过剩余可分配数
//则在堆上申请内存
//同时设usedMalloc = true
entry->data = (char*)b2Alloc(size);
entry->usedMalloc = true;
}
else
{
//若申请的大小未超过剩余可分配数
//直接在内存池中申请内存
//获取内存池中未使用的内存首地址
entry->data = m_data + m_index;
//设usedMalloc = false
entry->usedMalloc = false;
//增加内存池中内存使用量
m_index += size;
}
//增加内存使用量（包括堆中）
m_allocation += size;
//设置历史最大分配内存
m_maxAllocation = b2Max(m_maxAllocation, m_allocation);
//增加栈实体使用数
++m_entryCount;

return entry->data;
}

该部分代码也是简洁易懂，只需注意申请的内存是否超过内存池剩余可用内存。

释放函数

void b2StackAllocator::Free(void* p)
{
//要释放自然要有可以释放的元素啦
//确保有元素可以释放
b2Assert(m_entryCount > 0);
//获取最后一个实体，即准备要POP栈顶部啦
b2StackEntry* entry = m_entries + m_entryCount - 1;
//保证释放的内存确实是参数内存
//这里再次提醒，一个Allocate务必对应一个Free
//否则会造成这里assert
b2Assert(p == entry->data);
if (entry->usedMalloc)
{
//在堆中申请的
//释放堆中内存
b2Free(p);
}
else
{
//在内存池中申请的
//减少已使用的内存
//相当于设置其为可以被使用
//下次有新申请直接把它送出去，任由其被覆盖
m_index -= entry->size;
}
//减少总分配内存量
m_allocation -= entry->size;
//减少实体数组中已使用的实体量
--m_entryCount;
//注意设置p为null
p = NULL;
}

值得注意的只有设置p为NULL吧，其他部分在代码注释中已经说明。

获取历史最大内存分配量

int32 b2StackAllocator::GetMaxAllocation() const
{
//直接返回成员变量m_maxAllocation即可
return m_maxAllocation;
}