死磕Netty源码之内存分配详解(四)PoolArena全局内存分配

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/RobertoHuang/article/details/81047127

内存分配

关于我:http://huangth.com

GitHub地址:https://github.com/RobertoHuang

免责声明:本系列博客并非原创，主要借鉴和抄袭闪电侠，占小狼等知名博主博客。如有侵权请及时联系

全局分配

内存池的初始阶段线程是没有内存缓存的，所以最开始的内存分配都需要在全局分配区进行分配

全局分配区的内存构造和线程私有分配区的类似(包含Tiny、Small、Normal几种规模 计算索引的方式也都是一模一样的)，无论是TinySubpagePools还是SmallSubpagePools成员在内存池初始化时是不会预置内存的，所以最开始内存分配阶段都会进入PoolArena的allocateNormal方法，代码如下

private void allocateNormal(PooledByteBuf<T> buf, int reqCapacity, int normCapacity) {
    // 1.尝试从现有的Chunk进行分配
    if (q050.allocate(buf, reqCapacity, normCapacity) || q025.allocate(buf, reqCapacity, normCapacity) || q000.allocate(buf, reqCapacity, normCapacity) || qInit.allocate(buf, reqCapacity, normCapacity) || q075.allocate(buf, reqCapacity, normCapacity)) {
        return;
    }

    // 2.尝试创建一个Chuank进行内存分配
    PoolChunk<T> c = newChunk(pageSize, maxOrder, pageShifts, chunkSize);
    long handle = c.allocate(normCapacity);
    assert handle > 0;
    // 3.初始化PooledByteBuf
    c.initBuf(buf, handle, reqCapacity);
    // 4.将PoolChunk添加到PoolChunkList中
    qInit.add(c);
}

分配内存时为什么选择从q050开始

1.qinit的chunk利用率低，但不会被回收
2.q075和q100由于内存利用率太高，导致内存分配的成功率大大降低，因此放到最后
3.q050保存的是内存利用率50%~100%的Chunk，这应该是个折中的选择。这样能保证Chunk的利用率都会保持在一个较高水平提高整个应用的内存利用率，并且内存利用率在50%~100%的Chunk内存分配的成功率有保障
4.当应用在实际运行过程中碰到访问高峰，这时需要分配的内存是平时的好几倍需要创建好几倍的Chunk，如果先从q0000开始，这些在高峰期创建的chunk被回收的概率会大大降低，延缓了内存的回收进度，造成内存使用的浪费

1.尝试从现有的Chunk进行分配

boolean allocate(PooledByteBuf<T> buf, int reqCapacity, int normCapacity) {
    if (head == null || normCapacity > maxCapacity) {
        return false;
    }

    // 从head节点开始遍历
    for (PoolChunk<T> cur = head;;) {
        // 尝试使用已有PoolChunk进行分配
        long handle = cur.allocate(normCapacity);
        if (handle < 0) {
            cur = cur.next;
            // 如果到了尾节点还没分配成功
            // 说明当前PoolChunkList无法分配内存
            if (cur == null) {
                return false;
            }
        } else {
            // 如果分配内存成功 初始化ByteBuf
            cur.initBuf(buf, handle, reqCapacity);
            // 判断PoolChunkList是否需要重新调整
            if (cur.usage() >= maxUsage) {
                remove(cur);
                nextList.add(cur);
            }
            return true;
        }
    }
}

2.尝试创建一个Chuank进行内存分配

使用newChunk(pageSize, maxOrder, pageShifts, chunkSize)对PoolChunk进行初始化，后再调用PoolChunk.allocate方法进行真正的内存分配动作，在分析这个分配动作之前先来了解一下PoolChunk。下图是PoolChunk的数据结构

PoolChunk默认由2048个Page组成(Page默认大小为8k)，图中节点的值为在数组MemoryMap的下标
1、如果需要分配大小8k的内存则只需要在第11层找到第一个可用节点即可
2、如果需要分配大小16k的内存则只需要在第10层找到第一个可用节点即可
3、如果节点1024存在一个已经被分配的子节点2048则该节点不能被分配，如需要分配大小16k的内存，这个时候节点2048已被分配节点2049未被分配，就不能直接分配节点1024，因为该节点目前只剩下8k内存

PoolChunk内部会保证每次分配内存大小为8K*(2n)，为了分配一个大小为ChunkSize/(2k)的节点，需要在深度为K的层从左开始匹配节点，那么如何快速的分配到指定内存？memoryMap初始化

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

分配完成后 
        depthMap->[0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3…]
        memoryMap->[0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3…]

MemoryMap数组中每个位置保存的是该节点所在的层数，有什么作用？

对于节点512其层数是9则：
1、如果memoryMap[512]=9，则表示其本身到下面所有的子节点都可以被分配
2、如果memoryMap[512]=10，则表示节点512下有子节点已经分配过，而其子节点中的第10层还存在未分配的节点
3、如果memoryMap[512]=12(即总层数+1)可分配的深度已经大于总层数, 则表示该节点下的所有子节点都已经被分配

下面看看如何向PoolChunk申请一段内存

long allocate(int normCapacity) {
    // 当需要分配的内存大于pageSize时
    if ((normCapacity & subpageOverflowMask) != 0) {
        return allocateRun(normCapacity);
    } else {
        // 否则使用方法allocateSubpage分配内存
        return allocateSubpage(normCapacity);
    }
}

PoolChunk分配

Page级别内存分配

当需要分配的内存大于PageSize的时候，使用allocateRun()进行分配

private long allocateRun(int normCapacity) {
    // 计算出当前要分配的节点在Page树结构中的层级
    int d = maxOrder - (log2(normCapacity) - pageShifts);
    // 根据层级在Page树找出可分配内存节点进行内存分配并返回节点编号
    // 并将当前节点状态置为被使用状态 且父结构的节点设置为被使用状态
    int id = allocateNode(d);
    if (id < 0) {
        return id;
    }
    freeBytes -= runLength(id);
    return id;
}

Page级别内存分配 PooledByteBuf的初始化

void initBuf(PooledByteBuf<T> buf, long handle, int reqCapacity) {
    int memoryMapIdx = memoryMapIdx(handle);
    int bitmapIdx = bitmapIdx(handle);
    if (bitmapIdx == 0) {
        byte val = value(memoryMapIdx);
        // 断言该节点未被使用
        assert val == unusable : String.valueOf(val);
        // Page级别PooledByteBuf初始化
        // runOffset(memoryMapIdx)计算偏移量 runLength(memoryMapIdx)获取当前节点长度
        buf.init(this, handle, runOffset(memoryMapIdx) + offset, reqCapacity, runLength(memoryMapIdx), arena.parent.threadCache());
    } else {
        // SubPage级别PooledByteBuf初始化
        initBufWithSubpage(buf, handle, bitmapIdx, reqCapacity);
    }
}

void init(PoolChunk<T> chunk, long handle, int offset, int length, int maxLength, PoolThreadCache cache) {
    init0(chunk, handle, offset, length, maxLength, cache);
}

private void init0(PoolChunk<T> chunk, long handle, int offset, int length, int maxLength, PoolThreadCache cache) {
    assert handle >= 0;
    assert chunk != null;

    this.chunk = chunk;
    memory = chunk.memory;
    allocator = chunk.arena.parent;
    this.cache = cache;
    this.handle = handle;
    this.offset = offset;
    this.length = length;
    this.maxLength = maxLength;
    tmpNioBuf = null;
}

SubPage级别内存分配

当需要分配的内存小于PageSize的时候，使用allocateSubpage()进行分配

private long allocateSubpage(int normCapacity) {
    // 获取规格对应的PoolSubpage
    PoolSubpage<T> head = arena.findSubpagePoolHead(normCapacity);
    synchronized (head) {
        int d = maxOrder; 
        // 找到一个可分配的Page的ID
        int id = allocateNode(d);
        if (id < 0) {
            return id;
        }

        final PoolSubpage<T>[] subpages = this.subpages;
        final int pageSize = this.pageSize;

        // 修改该chunk的空闲内存大小
        freeBytes -= pageSize;

        // 获取page在subPages中的索引
        int subpageIdx = subpageIdx(id);
        PoolSubpage<T> subpage = subpages[subpageIdx];
        if (subpage == null) {
            // 新建PoolSubpage 并添加到tinySubpagePools或smallSubpagePools中的一个缓存中
            subpage = new PoolSubpage<T>(head, this, id, runOffset(id), pageSize, normCapacity);
            subpages[subpageIdx] = subpage;
        } else {
            subpage.init(head, normCapacity);
        }
        // 使用subpage分配内存(从位图中找到一个未被使用的子Page)
        return subpage.allocate();
    }
}

SubPage级别内存分配 PooledByteBuf的初始化

void initBuf(PooledByteBuf<T> buf, long handle, int reqCapacity) {
    int memoryMapIdx = memoryMapIdx(handle);
    int bitmapIdx = bitmapIdx(handle);
    if (bitmapIdx == 0) {
        byte val = value(memoryMapIdx);
        // 断言该节点未被使用
        assert val == unusable : String.valueOf(val);
        // Page级别PooledByteBuf初始化
        // runOffset(memoryMapIdx)计算偏移量 runLength(memoryMapIdx)获取当前节点长度
        buf.init(this, handle, runOffset(memoryMapIdx) + offset, reqCapacity, runLength(memoryMapIdx), arena.parent.threadCache());
    } else {
        // SubPage级别PooledByteBuf初始化
        initBufWithSubpage(buf, handle, bitmapIdx, reqCapacity);
    }
}

private void initBufWithSubpage(PooledByteBuf<T> buf, long handle, int bitmapIdx, int reqCapacity) {
    assert bitmapIdx != 0;

    int memoryMapIdx = memoryMapIdx(handle);

    PoolSubpage<T> subpage = subpages[subpageIdx(memoryMapIdx)];
    assert subpage.doNotDestroy;
    assert reqCapacity <= subpage.elemSize;
    // runOffset(memoryMapIdx)计算偏移量 runLength(memoryMapIdx)获取当前节点长度
    buf.init(this, handle, runOffset(memoryMapIdx) + (bitmapIdx & 0x3FFFFFFF) * subpage.elemSize + offset, reqCapacity, subpage.elemSize, arena.parent.threadCache());
}

private void init0(PoolChunk<T> chunk, long handle, int offset, int length, int maxLength, PoolThreadCache cache) {
    assert handle >= 0;
    assert chunk != null;

    this.chunk = chunk;
    memory = chunk.memory;
    allocator = chunk.arena.parent;
    this.cache = cache;
    this.handle = handle;
    this.offset = offset;
    this.length = length;
    this.maxLength = maxLength;
    tmpNioBuf = null;
}

最终ByteBuf可根据chunk，memory ，handle ，offset 等找到对应的内存信息

将PoolChunk添加到PoolChunkList中

初始状态下所有的PoolChunkList都是空的，所以在此先创建chunk块要添加到PoolChunkList中，需要注意的是虽然都是通过qInit.add添加chunk，这并不代表chunk都会被添加到qInit这个PoolChunkList，看一下PoolChunkList的add方法就可以知道

void add(PoolChunk<T> chunk) {
    if (chunk.usage() >= maxUsage) {
        nextList.add(chunk);
        return;
    }
    add0(chunk);
}

void add0(PoolChunk<T> chunk) {
    chunk.parent = this;
    if (head == null) {
        head = chunk;
        chunk.prev = null;
        chunk.next = null;
    } else {
        chunk.prev = null;
        chunk.next = head;
        head.prev = chunk;
        head = chunk;
    }
}

PoolChunkList有两个重要的参数MinUsage和MaxUsage(最小/大使用率)，当Chunk中内存可用率在[MinUsage,MaxUsage]区间时这个Chunk才会落到该PoolChunkList中，否则把Chunk传到下一个PoolChunkList进行检查。从这里可以看出Chunk只会被添加到内存匹配的PoolChunkList中，为了更有说服力，再看一下free方法的代码

void free(PoolChunk<T> chunk, long handle) {  
    chunk.free(handle);  
    if (chunk.usage() < minUsage) {  
        remove(chunk);  
        if (prevList == null) {  
            // 如果前置节点为空
            // 并且使用率为0 则释放内存
            assert chunk.usage() == 0;  
            arena.destroyChunk(chunk);  
        } else {  
            prevList.add(chunk);  
        }  
    }  
} 

在释放内存时也会检查MinUsage如果不匹配传到上一个PoolChunkList进行检查，最终归还到大小跟它匹配的PoolChunkList中

PoolSubpage

关于PoolSubpage应该是在之前的博客[02.死磕Netty源码之内存分配详解(二)PoolArena内存分配结构分析]就已经提及过的，这里我们将对PoolSubpage进行详细解析。Netty提供了PoolSubpage把PoolChunk的一个Page节点8k内存划分成更小的内存段，通过对每个内存段的标记与清理标记进行内存的分配与释放，它的数据结构如下

成员变量

// 当前page所属的chunk
final PoolChunk<T> chunk;
// 当前page在chunk中的id
private final int memoryMapIdx;
// 当前page在chunk.memory的偏移量
private final int runOffset;

// page大小
private final int pageSize;
// 每个元素是一个长整形数数记录内存页的分配信息，每个二进制位都代表页内的一个内存单元
// 当二进制位为1表示对应的内存块被分配过，第一个元素对应0-63号内存单元 第二个元素对应64-127号内存单元，第三个元素对应128-191号内存单元等等
// bitmap[0]=0b0000000...0001111表示0,1,2,3这四个内存单元都已经被分配给对应的请求了。这个bitmap用来辅助计算下一个分配块的索引也即上面的nextAvail参数
private final long[] bitmap;

// 维护链表结构
PoolSubpage<T> prev;
PoolSubpage<T> next;

// 当前PoolSubpage不能销毁
boolean doNotDestroy;
// 该page切分后每一段的大小
int elemSize;
// 该page包含的段数量 (maxNumElems=pageSize/elemSize)
private int maxNumElems;
private int bitmapLength;
// 下一个可用的位置
private int nextAvail;
// 内存页还能分配多少次，它的初始值等同于maxNumElems 分配一次值递减
private int numAvail;

构造方法

PoolSubpage(PoolSubpage<T> head, PoolChunk<T> chunk, int memoryMapIdx, int runOffset, int pageSize, int elemSize) {
    this.chunk = chunk;
    this.memoryMapIdx = memoryMapIdx;
    this.runOffset = runOffset;
    this.pageSize = pageSize;
    // pageSize >>> 10 => pageSize/16/64
    bitmap = new long[pageSize >>> 10]; 
    init(head, elemSize);
}

默认初始化bitmap长度为8，这里解释一下为什么只需要8个元素

其实分配内存大小都是处理过的最小为16，说明一个Page可以分成8192/16=512个内存段，一个long有64位可以描述64个内存段，这样只需要512/64=8个long就可以描述全部内存段了

init根据当前需要分配的内存大小，确定需要多少个bitmap元素，实现如下

void init(PoolSubpage<T> head, int elemSize) {
    doNotDestroy = true;
    this.elemSize = elemSize;
    if (elemSize != 0) {
        maxNumElems = numAvail = pageSize / elemSize;
        nextAvail = 0;
        bitmapLength = maxNumElems >>> 6;
        if ((maxNumElems & 63) != 0) {
            bitmapLength ++;
        }

        for (int i = 0; i < bitmapLength; i ++) {
            bitmap[i] = 0;
        }
    }
    addToPool(head);
}

下面通过分布申请4096和32大小的内存，说明如何确定bitmapLength的值

比如当前申请大小4096的内存maxNumElems和numAvail为2，说明一个page被拆分成2个内存段，2>>>6=0且2&63=0，所以bitmapLength为1，说明只需要一个long就可以描述2个内存段状态。如果当前申请大小32的内存maxNumElems和numAvail为256，说明一个page被拆分成256个内存段，256>>>6=4，说明需要4个long描述256个内存段状态

内存分配

PoolSubpage的内存分配由allocate()完成

long allocate() {
    if (elemSize == 0) {
        return toHandle(0);
    }

    if (numAvail == 0 || !doNotDestroy) {
        return -1;
    }

    // 找到当前page中可分配内存段的bitmapIdx
    final int bitmapIdx = getNextAvail();
    // 确定bitmap数组下标为q的long数 用来描述bitmapIdx内存段的状态
    int q = bitmapIdx >>> 6;
    // 将超出64的那一部分二进制数抹掉得到一个小于64的数
    int r = bitmapIdx & 63;
    // 断言该内存段未被使用
    assert (bitmap[q] >>> r & 1) == 0;
    // 将对应位置设置为1
    bitmap[q] |= 1L << r;

    if (-- numAvail == 0) {
        removeFromPool();
    }

    return toHandle(bitmapIdx);
}

GetNextAvail如何实现找到下一个可分配的内存段？

private int getNextAvail() {
    int nextAvail = this.nextAvail;
    // 如果nextAvail大于等于0
    // 说明nextAvail指向了下一个可分配的内存段，直接返回nextAvail值
    if (nextAvail >= 0) {
        this.nextAvail = -1;
        return nextAvail;
    }
    // 每次分配完成nextAvail被置为-1，这时只能通过方法findNextAvail重新计算出下一个可分配的内存段位置
    return findNextAvail();
}

FindNextAvail查找下一个可分配内存

private int findNextAvail() {
    final long[] bitmap = this.bitmap;
    final int bitmapLength = this.bitmapLength;
    for (int i = 0; i < bitmapLength; i ++) {
        long bits = bitmap[i];
        // ~bits != 0说明这个long所描述的64个内存段还有未分配的
        if (~bits != 0) {
            return findNextAvail0(i, bits);
        }
    }
    return -1;
}

private int findNextAvail0(int i, long bits) {
    final int maxNumElems = this.maxNumElems;
    final int baseVal = i << 6;

    for (int j = 0; j < 64; j ++) {
        // 来判断该位置是否未分配
        // 否则bits右移一位，从左到右遍历值为0的位置
        if ((bits & 1) == 0) {
            int val = baseVal | j;
            if (val < maxNumElems) {
                return val;
            } else {
                break;
            }
        }
        bits >>>= 1;
    }
    return -1;
}

至此关于Netty的内存分配告一段落……