Netty内存池之PoolSubPage

在前一篇中刚刚分析了PoolChunk的内存管理策略，简单回顾下PoolChunk的分配原则：
1） 平衡二叉树维护标记内存块的使用情况
2） > 8k, PoolChunk直接在二叉树上标记并分配内存
3） < 8k,在PoolChunk的叶子节点进行相应标记，并交粒度更细的分配工作交给PoolSubPage处理
本文接着PoolChunk中的内存申请<8k的线路分析PoolSubPage的内存分配和释放流程

private long allocateSubpage(int normCapacity) {
    int d = maxOrder;
    int id = allocateNode(d);//在chunk的叶子节点标记
    if (id < 0) {
        return id;
    }
    final PoolSubpage<T>[] subpages = this.subpages;
    final int pageSize = this.pageSize;
    freeBytes -= pageSize;
    int subpageIdx = subpageIdx(id);//找到叶子节点对应的subpage索引
    PoolSubpage<T> subpage = subpages[subpageIdx];
    if (subpage == null) {
        subpage = new PoolSubpage<T>(this, id, runOffset(id), pageSize, normCapacity);
        subpages[subpageIdx] = subpage;
    } else {
        subpage.init(normCapacity);
    }
    return subpage.allocate();
}

回顾PoolChunk中分配规则，当申请内存小于8k时，有allocatSubPage分配，首先标记二叉树中可用的叶子节点，找出与与叶子节点subpage在数组中的位置，如果数组为空，创建subpage对象；接着调用subpage的allocat（）方法来分配

PoolSubpage(PoolChunk<T> chunk, int memoryMapIdx, int runOffset, int pageSize, int elemSize) {
    this.chunk = chunk;
    this.memoryMapIdx = memoryMapIdx; //二叉树叶子节点位置
    this.runOffset = runOffset;       //偏移量
    this.pageSize = pageSize;
    bitmap = new long[pageSize >>> 10]; // pageSize / 16 / 64
    init(elemSize);
}

初始化相应成员之后，调用init（int）方法。
关于bitmap数组说明,PoolSubPage利于bitmap数组来标记内存的使用情况。在Netty内存池管理中，内存最小划分单位为16的字节，那么对于pageSize大小的内存块包含的最小内存块为pageSize/16；当用long类型(64位)的数组bitmap记录内存的使用情况时；PoolSubpage中的bitmap采用long类型的每一位表示一段16字节内存段，因此bitmap数组最大长度为pageSize/16/64即可记录pageSize的内存分配状态。

void init(int elemSize) {
    doNotDestroy = true;
    this.elemSize = elemSize;
    if (elemSize != 0) {
        maxNumElems = numAvail = pageSize / elemSize;//按申请内存大小将pageSize划分
        nextAvail = 0;
        bitmapLength = maxNumElems >>> 6;  //bitmap中描述内存块的长度
        if ((maxNumElems & 63) != 0) {
            bitmapLength ++;
        }
        for (int i = 0; i < bitmapLength; i ++) {
            bitmap[i] = 0;
        }
    }
    addToPool(); //加入环形链表缓存
}

在init（int）中根据请求内存大小，将PoolChunk叶节点pageSize大小内存块切分位maxNumElems块，而故只需要maxNumElems/64或其+1长度的bitmap即可描述其内存占用状态；然后将PoolsubPage纳入内存池管理

private void addToPool() {
    PoolSubpage<T> head = chunk.arena.findSubpagePoolHead(elemSize);
    assert prev == null && next == null;
    prev = head;
    next = head.next;
    next.prev = this;
    head.next = this;
}

addToPool即将PoolSubpage加入到环形链表中
在subpage初始化完成之后，调用subpage的allocate()

long allocate() {
    if (elemSize == 0) {
        return toHandle(0);   
    }
    if (numAvail == 0 || !doNotDestroy) {//无法分配
        return -1;
    }
    final int bitmapIdx = getNextAvail();//获取可用段
    int q = bitmapIdx >>> 6;   //bitmap数组中的位置
    int r = bitmapIdx & 63;    //数组中在long中位的位置
    assert (bitmap[q] >>> r & 1) == 0;
    bitmap[q] |= 1L << r;      //将数组中long的对于位标记
    if (-- numAvail == 0) {    //可用段减1
        removeFromPool();      //移除subpage
    }
    return toHandle(bitmapIdx);
}

在allocate中，进行参数检查之后，获取bitmap中可以分配的索引段

private int getNextAvail() {
    int nextAvail = this.nextAvail;
    if (nextAvail >= 0) {
        this.nextAvail = -1;
        return nextAvail;
    }
    return findNextAvail();
}

除第一次查找直接返会0，以后均会调用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];
        if (~bits != 0) {  //bits位不全为0，可分配
            return findNextAvail0(i, bits);
        }
    }
    return -1;
}

当数组bitmap[i]中数组64位不全为0，即数组索引i中管理内存段可分配，调用findNextAvail（i，bits）；

    final int maxNumElems = this.maxNumElems;
    final int baseVal = i << 6;   //基准位置段
    for (int j = 0; j < 64; j ++) { //从第1位到64位
        if ((bits & 1) == 0) {  //第（j+1） 位不为0，可分配
            int val = baseVal | j;  // 加偏移段 
            if (val < maxNumElems) {  //确定位置
                return val;
            } else {
                break;
            }
        }
        bits >>>= 1;
    }
    return -1;
}

在bitmap可用数组元素中，基准位置段为64*i(数组下标),偏移段为首位=0的位，基准段与偏移段相加即为最终可分配内存段位置
而可分配位置bitmapIdx上，对于bitmap的数组元素下表q =bitmapIdx/64，
该元素中r位(bitmapIdx&63)记录，故将r为标记为不可用1；bitmap[q]|=1L<

boolean free(int bitmapIdx) {
    if (elemSize == 0) {
        return true;
    }
    int q = bitmapIdx >>> 6;//bitmap[q]管理该段内存
    int r = bitmapIdx & 63;
    assert (bitmap[q] >>> r & 1) != 0;  //内存已被分配
    bitmap[q] ^= 1L << r;   //清除分配标记
    setNextAvail(bitmapIdx);   //bitmapIdx标记为可用
    if (numAvail ++ == 0) {    //可用段=0
        addToPool();           //将PoolSubPage释放至环形链表
        return true;
    }
    if (numAvail != maxNumElems) { //可用段 没达到最大可以上限
        return true;
    } else {
        if (prev == next) {         //SubPage完全未被分配
            return true;
        }
        doNotDestroy = false;
        removeFromPool();
        return false;
    }
}

至此，PoolSubPage内存管理规则介绍完毕，它与PoolChunk配合分配与管理不同量级的内存分配与释放