如果你还对jemalloc分配算法不太了解，可以查看前情回顾：jemalloc分配算法。
1. 伙伴分配算法
JEMalloc分配算法使用伙伴分配算法分配Chunk中的Page节点。Netty实现的伙伴分配算法中，构造了两棵满二叉树，满二叉树非常适合使用数组存储，Netty使用两个字节数组memoryMap和depthMap来表示两棵二叉树，其中MemoryMap存放分配信息，depthMap存放节点的高度信息。为了更好的理解这两棵二叉树，参考下图：
伙伴分配算法二叉树
左图表示每个节点的编号，注意从1开始，省略0是因为这样更容易计算父子关系：子节点加倍，父节点减半，比如512的子节点为1024=512 * 2。右图表示每个节点的深度，注意从0开始。在代表二叉树的数组中，左图中节点上的数字作为数组索引即id，右图节点上的数字作为值。初始状态时，
memoryMap和depthMap相等，可知一个id为512节点的初始值为9，即：
memoryMap[512] = depthMap[512] = 9;
depthMap的值初始化后不再改变，memoryMap的值则随着节点分配而改变。当一个节点被分配以后，该节点的值设置为12（最大高度+1）表示不可用，并且会更新祖先节点的值。下图表示随着4号节点分配而更新祖先节点的过程，其中每个节点的第一个数字表示节点编号，第二个数字表示节点高度值。
伙伴分配算法分配过程
分配过程如下：
- 4号节点被完全分配，将高度值设置为12表示不可用。
- 4号节点的父亲节点即2号节点，将高度值更新为两个子节点的较小值；其他祖先节点亦然，直到高度值更新至根节点。
可推知，memoryMap数组的值有如下三种情况：
- memoryMap[id] = depthMap[id] -- 该节点没有被分配
- memoryMap[id] > depthMap[id] -- 至少有一个子节点被分配，不能再分配该高度满足的内存，但可以根据实际分配较小一些的内存。比如，上图中分配了4号子节点的2号节点，值从1更新为2，表示该节点不能再分配8MB的只能最大分配4MB内存，因为分配了4号节点后只剩下5号节点可用。
- mempryMap[id] = 最大高度 + 1（本例中12） -- 该节点及其子节点已被完全分配， 没有剩余空间。
明白了这些，再深入源码分析Netty的实现细节。
2. 源码实现
首先看关键成员变量：
private final byte[] memoryMap; // 分配信息二叉树
private final byte[] depthMap; // 高度信息二叉树
private final PoolSubpage<T>[] subpages; // subpage节点数组
private final int subpageOverflowMask; // 判断分配请求为Tiny/Small即分配subpage
private final int pageSize; // 页大小，默认8KB=8192
private final int pageShifts; // 从1开始左移到页大小的位置，默认13，1<<13 = 8192
private final int maxOrder; // 最大高度，默认11
private final int chunkSize; // chunk块大小，默认16MB
private final int log2ChunkSize; // log2(16MB) = 24
private final int maxSubpageAllocs; // 可分配subpage的最大节点数即11层节点数，默认2048
private final byte unusable; // 标记节点不可用，最大高度 + 1， 默认12
private int freeBytes; // 可分配字节数
此外，还有一些非关键成员变量：
final PoolArena<T> arena; // chunk所属的arena
final T memory; // 实际的内存块
final boolean unpooled; // 是否非池化
final int offset; // ?
PoolChunkList<T> parent; // poolChunkList专用
PoolChunk<T> prev;
PoolChunk<T> next;
该类有两个构造方法，一个用于普通初始化，另一个用于非池化初始化（Huge分配请求）。关注一下对某些值的计算：
unusable = (byte) (maxOrder + 1);
log2ChunkSize = log2(chunkSize);
subpageOverflowMask = ~(pageSize - 1);
freeBytes = chunkSize;
maxSubpageAllocs = 1 << maxOrder;
subpages = new PoolSubpage[maxSubpageAllocs];
在构造方法中对两棵二叉树的初始化代码如下：
memoryMap = new byte[maxSubpageAllocs << 1];
depthMap = new byte[memoryMap.length];
int memoryMapIndex = 1;
for (int d = 0; d <= maxOrder; ++ d) {
int depth = 1 << d;
for (int p = 0; p < depth; ++ p) {
memoryMap[memoryMapIndex] = (byte) d; // 设置高度
depthMap[memoryMapIndex] = (byte) d;
memoryMapIndex ++;
}
}
接下来分析关键的分配方法allocate()：
long allocate(int normCapacity) {
if ((normCapacity & subpageOverflowMask) != 0) { // >= pageSize即Normal请求
return allocateRun(normCapacity);
} else { // Tiny和Small请求
return allocateSubpage(normCapacity);
}
}
首先看Normal请求，该请求需要分配至少一个Page的内存，代码实现如下：
private long allocateRun(int normCapacity) {
// 计算满足需求的节点的高度
int d = maxOrder - (log2(normCapacity) - pageShifts);
// 在该高度层找到空闲的节点
int id = allocateNode(d);
if (id < 0) {
return id; // 没有找到
}
freeBytes -= runLength(id); // 分配后剩余的字节数
return id;
}
在某一层寻找可用节点的代码如下：
private int allocateNode(int d) {
int id = 1;
// 所有高度<d 的节点 id & initial = 0
int initial = - (1 << d);
byte val = value(id); // = memoryMap[id]
if (val > d) { // 没有满足需求的节点
return -1;
}
// val<d 子节点可满足需求
// id & initial == 0 高度<d
while (val < d || (id & initial) == 0) {
id <<= 1; // 高度加1，进入子节点
val = value(id); // = memoryMap[id]
if (val > d) { // 左节点不满足
id ^= 1; // 右节点
val = value(id);
}
}
// 此时val = d
setValue(id, unusable); // 找到符合需求的节点并标记为不可用
updateParentsAlloc(id); // 更新祖先节点的分配信息
return id;
}
这部分代码含有大量位运算，需要仔细体会其中的用法。Netty为了追求性能，位运算也是用到了极致。接着分析更新祖先节点的分配信息的代码如下：
private void updateParentsAlloc(int id) {
while (id > 1) {
int parentId = id >>> 1;
byte val1 = value(id); // 父节点值
byte val2 = value(id ^ 1); // 父节点的兄弟（左或者右）节点值
byte val = val1 < val2 ? val1 : val2; // 取较小值
setValue(parentId, val);
id = parentId; // 递归更新
}
}
至此，Normal请求的分配过程分析完毕。为了更好的理解分配过程，以一个Page大小为8KB，pageShifts=13，maxOrder=11的配置为例分析分配32KB=2^15B内存的过程（假设该Chunk首次分配）：
- 计算满足所需内存的高度d，d= maxOrder-(log2(normCapacity)-pageShifts) = 11-(log2(2^15)-13) = 9。可知，满足需求的节点的最大高度d = 9。
- 在高度<9的层从左到右寻找满足需求的节点。由于二叉树不便于按层遍历，故需要从根节点1开始遍历。本例中，找到id为512的节点，满足需求，将memory[512]设置为12表示分配。
- 从512节点开始，依次更新祖先节点的分配信息。
接着分析Tiny/Small请求的分配实现allocateSubpage()，代码如下：
private long allocateSubpage(int normCapacity) {
// 找到arena中对应的subpage头节点
PoolSubpage<T> head = arena.findSubpagePoolHead(normCapacity);
// 加锁，分配过程会修改链表结构
synchronized (head) {
int d = maxOrder; // subpage只能在二叉树的最大高度分配即分配叶子节点
int id = allocateNode(d);
if (id < 0) {
return id; // 叶子节点全部分配完毕
}
final PoolSubpage<T>[] subpages = this.subpages;
final int pageSize = this.pageSize;
freeBytes -= pageSize;
// 得到叶子节点的偏移索引，从0开始，即2048-0,2049-1,...
int subpageIdx = subpageIdx(id);
PoolSubpage<T> subpage = subpages[subpageIdx];
if (subpage == null) {
subpage = new PoolSubpage<T>(head, this, id,
runOffset(id), pageSize, normCapacity);
subpages[subpageIdx] = subpage;
} else {
subpage.init(head, normCapacity);
}
return subpage.allocate();
}
}
由于Small/Tiny请求分配的内存小于PageSize，所以分配的节点必然在二叉树的最高层。找到最高层合适的节点后，新建或初始化subpage并加入到chunk的subpages数组，同时将subpage加入到arena的subpage双向链表中，最后完成分配请求的内存。代码中，subpage != null的情况产生的原因是：subpage初始化后分配了内存，但一段时间后该subpage分配的内存释放并从arena的双向链表中删除，此时subpage不为null，当再次请求分配时，只需要调用init()将其加入到areana的双向链表中即可。
Netty优化计算内存相关数据的基本方法， 代码如下：
// 得到第11层节点的偏移索引，= id - 2048
private int subpageIdx(int memoryMapIdx) {
return memoryMapIdx ^ maxSubpageAllocs;
}
// 得到节点对应可分配的字节，1号节点为16MB-ChunkSize，2048节点为8KB-PageSize
private int runLength(int id) {
return 1 << log2ChunkSize - depth(id);
}
// 得到节点在chunk底层的字节数组中的偏移量
// 2048-0, 2049-8K，2050-16K
private int runOffset(int id) {
int shift = id ^ 1 << depth(id);
return shift * runLength(id);
}
注意到PoolSubpage分配的最后结果是一个long整数，其中低32位表示二叉树中的分配的节点，高32位表示subPage中分配的具体位置。相关的计算如下：
private static int memoryMapIdx(long handle) {
return (int) handle;
}
private static int bitmapIdx(long handle) {
return (int) (handle >>> Integer.SIZE);
}
明白了这些，接着分析内存释放过程，代码如下：
void free(long handle) {
int memoryMapIdx = memoryMapIdx(handle);
int bitmapIdx = bitmapIdx(handle);
if (bitmapIdx != 0) { // 需要释放subpage
PoolSubpage<T> subpage = subpages[subpageIdx(memoryMapIdx)];
PoolSubpage<T> head = arena.findSubpagePoolHead(subpage.elemSize);
synchronized (head) {
if (subpage.free(head, bitmapIdx & 0x3FFFFFFF)) {
return; // 此时释放了subpage中的一部分内存（即请求的）
}
// 此时subpage完全释放，可以删除二叉树中的节点
}
}
freeBytes += runLength(memoryMapIdx);
setValue(memoryMapIdx, depth(memoryMapIdx)); // 节点分配信息还原为高度值
updateParentsFree(memoryMapIdx); // 更新祖先节点的分配信息
}
释放过程相对简单，释放时更新祖先节点的分配信息是分配时的逆过程，代码如下：
private void updateParentsFree(int id) {
int logChild = depth(id) + 1;
while (id > 1) {
int parentId = id >>> 1;
byte val1 = value(id);
byte val2 = value(id ^ 1);
logChild -= 1;
if (val1 == logChild && val2 == logChild) {
// 此时子节点均空闲，父节点值高度-1
setValue(parentId, (byte) (logChild - 1));
} else {
// 此时至少有一个子节点被分配，取最小值
byte val = val1 < val2 ? val1 : val2;
setValue(parentId, val);
}
id = parentId;
}
}
至此，PoolChunk分析完毕。
相关链接：
