Netty源码分析----PoolChunk

（*文章基于Netty4.1.22版本）
Netty内存管理这块比较复杂，断断续续看了一个多月了，总要有点输出，写几篇文章稍微分析总结一下

整体介绍

PoolChunk的结构是一颗平衡二叉树，如下：

注：左边代表的是节点的序号，右边的深度，例如512号节点深度为9，其数据结构为数组memoryMap和depthMap，初始化时相等

PoolChunk默认深度为11，一个节点默认为8KB，上图中，最下面有Subpage这个结构，这个是用来分配小于8KB的内存，数量和叶子节点数一样

举几个个例子来说明一下分配过程：
1.需要分配8KB的内存
在叶子节点寻找一个空的位置进行分配即可，此时节点的变化如下：

3个格子分别代表的意思是：深度，memoryMap[id]，depthMap[id]，在未分配前，3者是相等。
当一个节点分配之后，其memoryMap[id]=深度+1，变成右图左下角的状态，另外其父节点的memoryMap[id]=min(左右孩子memoryMap值)，以此类推，一直到根节点

2.需要分配16KB的内存
在第10层分配一个节点即可，因为其两个孩子节点分别为8KB

那么就有几种分配状态：
1. memoryMap[id] == depthMap[id]：该节点以及子节点未被分配
2. memoryMap[id] > depthMap[id]：该节点被分配 or 该节点下有一个节点被分配
3. memoryMap[id] == 深度+1：该节点被分配 or 该节点下所有孩子节点全被分配

注意，第二种情况下，不能分配16KB的内存，因为其子节点被分配，所剩空间不足

源码实现

源码中有大量的位运算，可能看起来不太直观，举个例子算一下就清晰了

初始化

    PoolChunk(PoolArena<T> arena, T memory, int pageSize, int maxOrder, int pageShifts, int chunkSize, int offset) {
        // ....省略部分赋值
        unusable = (byte) (maxOrder + 1);// unusable = 深度+1，即上面图中的12
        maxSubpageAllocs = 1 << maxOrder;// Subpage数 2的maxOrder次方 即2048

        memoryMap = new byte[maxSubpageAllocs << 1];// maxSubpageAllocs << 1 = 2的maxOrder+1次方，即4096
        depthMap = new byte[memoryMap.length];
        int memoryMapIndex = 1;
        // 有maxOrder层，从上往下，从左往右赋值
        for (int d = 0; d <= maxOrder; ++ d) { 
            int depth = 1 << d;// 2的d次方
            for (int p = 0; p < depth; ++ p) {
                // 每一层的深度都是d，赋值给memoryMap和depthMap，所以depthMap和memoryMap初始化时是相同的
                memoryMap[memoryMapIndex] = (byte) d;
                depthMap[memoryMapIndex] = (byte) d;
                memoryMapIndex ++;
            }
        }
        // 初始化subpage
        subpages = newSubpageArray(maxSubpageAllocs);
    }

分配

    long allocate(int normCapacity) {
        if ((normCapacity & subpageOverflowMask) != 0) { // >= pageSize
            return allocateRun(normCapacity);
        } else {
            return allocateSubpage(normCapacity);
        }
    }

分配方法有两个分支流程，一个是大于8KB的，走poolChunk，小于8KB的，走Subpage

allocateRun

    private long allocateRun(int normCapacity) {
        // 根据需要的空间，计算应该在哪一层分配
        int d = maxOrder - (log2(normCapacity) - pageShifts);
        int id = allocateNode(d);//从该深度的节点中，找出一个空闲的节点
        if (id < 0) {
            return id;
        }
        freeBytes -= runLength(id);//计算该节点所占内存并减去，freeBytes为剩余空闲内存
        return id;
    }

由于一个Chunk为8KB，即8192，即2的13次方，所以pageShitfs为13。
至于 maxOrder - (log2(normCapacity) - pageShifts); 怎么理解呢，由于normCapacity在外层传入的时候就已经做过纠正，其值为2的N次方，那么假设normCapacity为8KB，log2(normCapacity)为13，减去pageShifts，最后算出来的就是maxOrder层，以此类推

allocateNode

    private int allocateNode(int d) {
        int id = 1;
        int initial = - (1 << d); // has last d bits = 0 and rest all = 1
        byte val = value(id);// memoryMap[id]
        if (val > d) { // 一开始说的第二种分配状态
            return -1;
        }
        while (val < d || (id & initial) == 0) { // id & initial == 1 << d for all ids at depth d, for < d it is 0
            id <<= 1;// 2 4 6 8 .... 512 1024 2048，即在树中最左边的那条路径
            val = value(id);
            if (val > d) {// 即memoryMap[id] > depthMap[id]：该节点被分配 or 该节点下有一个节点被分配
                id ^= 1;// 兄弟节点
                val = value(id);
            }
        }
        byte value = value(id);
        assert value == d && (id & initial) == 1 << d : String.format("val = %d, id & initial = %d, d = %d",
                value, id & initial, d);
        setValue(id, unusable); // 将该节点的memoryMap设置为深度+1，表示分配
        updateParentsAlloc(id);// 将父节点设置为其孩子节点memoryMap最小的那个值
        return id;
    }

大概的流程就是：
1. 先从最左边的叶子节点匹配，如果该节点为分配，则分配该节点
2. 如果该节点已分配，那么判断兄弟节点是否分配，如果未分配，则分配该节点
3. 如果兄弟节点已经分配，那么从父节点的兄弟节点的孩子节点继续该过程

总的就是在一层中从左往右寻找匹配节点，其中兄弟节点的获取是id^1，刚好就是兄弟节点的值

释放

    void free(long handle) {
        int memoryMapIdx = memoryMapIdx(handle);// 将long类型的转换成int，即保留低位信息
        int bitmapIdx = bitmapIdx(handle);//id >>> Integer.SIZE，右移32位，高位补0

        if (bitmapIdx != 0) { // 如果是Chunk分配的，右移后，bitmapIdx会变成0，具体原因要看下Page的分析
            //获取对应的Page
            PoolSubpage<T> subpage = subpages[subpageIdx(memoryMapIdx)];
            assert subpage != null && subpage.doNotDestroy;

            PoolSubpage<T> head = arena.findSubpagePoolHead(subpage.elemSize);
            synchronized (head) {
                //调用Page的释放方法
                if (subpage.free(head, bitmapIdx & 0x3FFFFFFF)) {
                    return;
                }
            }
        }
        freeBytes += runLength(memoryMapIdx);
        // 和分配是逆过程
        setValue(memoryMapIdx, depth(memoryMapIdx));
        updateParentsFree(memoryMapIdx);
    }