Netty源码分析：PoolChunk

Posted 2022-12-11 HelloWorld_EE

Netty源码分析：PoolChunk

Chunk主要用来组织和管理多个Page的内存分配和释放。在Netty中，Chunk中的Page被构建成一颗二叉树。本博文将从源码的角度来看下PoolChunk。

1、属性和构造函数

先看下PoolChunk的属性和构造函数

    final class PoolChunk<T> // PoolChunk会涉及到具体的内存,泛型T表示byte[](堆内存)、或java.nio.ByteBuffer(堆外内存)  

        final PoolArena<T> arena;//表示该PoolChunk所属的PoolArena。  
        final T memory;// 具体用来表示内存；byte[]或java.nio.ByteBuffer。 
        final boolean unpooled;// 是否是可重用的，unpooled=false表示可重用  

        private final byte[] memoryMap;
        private final byte[] depthMap;
        private final PoolSubpage<T>[] subpages;//表示该PoolChunk所包含的PoolSubpage。也就是PoolChunk连续的可用内存。
        /** Used to determine if the requested capacity is equal to or greater than pageSize. */
        private final int subpageOverflowMask;
        private final int pageSize;//每个PoolSubpage的大小，默认为8192个字节（8K)  
        private final int pageShifts;
        private final int maxOrder;
        private final int chunkSize;
        private final int log2ChunkSize;
        private final int maxSubpageAllocs;
        /** Used to mark memory as unusable */
        private final byte unusable;

        private int freeBytes; //当前PoolChunk空闲的内存。 

        PoolChunkList<T> parent;//一个PoolChunk分配后，会根据使用率挂在PoolArena的一个PoolChunkList中
        // PoolChunk本身设计为一个链表结构
        PoolChunk<T> prev;
        PoolChunk<T> next；

        PoolChunk(PoolArena<T> arena, T memory, int pageSize, int maxOrder, int pageShifts, int chunkSize) 
            unpooled = false;
            this.arena = arena;
            this.memory = memory;
            this.pageSize = pageSize;
            this.pageShifts = pageShifts;
            this.maxOrder = maxOrder;
            this.chunkSize = chunkSize;
            unusable = (byte) (maxOrder + 1);
            log2ChunkSize = log2(chunkSize);
            subpageOverflowMask = ~(pageSize - 1);
            freeBytes = chunkSize;

            assert maxOrder < 30 : "maxOrder should be < 30, but is: " + maxOrder;
            maxSubpageAllocs = 1 << maxOrder;

            // Generate the memory map.
            memoryMap = new byte[maxSubpageAllocs << 1];
            depthMap = new byte[memoryMap.length];
            int memoryMapIndex = 1;
            for (int d = 0; d <= maxOrder; ++ d)  // move down the tree one level at a time
                int depth = 1 << d;
                for (int p = 0; p < depth; ++ p) 
                    // in each level traverse left to right and set value to the depth of subtree
                    memoryMap[memoryMapIndex] = (byte) d;
                    depthMap[memoryMapIndex] = (byte) d;
                    memoryMapIndex ++;
                
            

            subpages = newSubpageArray(maxSubpageAllocs);
        

PoolChunk默认情况下：maxOrder = 11，即根据maxSubpageAllocs = 1 << maxOrder可得一个PoolChunk默认情况下由2^11=2048个SubPage构成，而默认情况下一个page默认大小为8k，即pageSize=8K。

重点来看下memoryMap这个字段，PoolChunk中所有的PoolSubpage都放在PoolSubpage[] subpages中，为了更好的分配，Netty用一颗平衡二叉树记录每个PoolSubpage的分配情况。假设PoolChunk由16个PoolSubpage构成（为便于分析，这里就不用默认的2048个page来进行说明chunk的结构了），那么这些PoolSubpage将会按照如下的结构组织起来。

看上面的构造函数中的两层for循环可以得到：从树根到树叶节点按每层将节点所在的（层数）依次保存在memoryMap中，即memoryMap数组中每个位置保存的是该节点所在的层数。如下就是示例的结果。

memoryMap=第0位没用到,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,//memoryMap数组元素长度为 (1<<maxOrder)>>1=32

memoryMap存储二叉树每个节点所在的层数有什么作用呢？

对于下图“圈出来”的节点，在memoryMap的索引为4，其层数是2，则：
1、如果memoryMap[4] = 2，则表示其本身到下面所有的子节点都可以被分配；
2、如果memoryMap[4] = 3， 则表示该节点下有子节点已经分配过，则该节点不能直接被分配，而其子节点中的第3层还存在未分配的节点;例如：当我们请求一个大小为4K存储区域时就会出现这种情况
3、如果memoryMap[4] = 4，则表示该节点下的2个子节点已经被分配过（但是还存在某个子节点没有分完），则该节点和两个子节点不能直接被分配，而其子节点中的第4层还存在未分配的节点。例如：当我们申请一个大小为8K和4K的存储区域是就会出现这种情况
3、如果memoryMap[4] = 5 (即总层数 + 1）, 可分配的深度已经大于总层数, 则表示该节点下的所有子节点都已经被分配。例如：当我们申请一个大小为16K的存储区域时就会出现这种情况

可以这么说：如果memoryMap[i] = maxOrder+1,就表示该位置的PoolSubpage已被分配完，如果memoryMap[i] < maxOrder+1,则说明还可以分配，具体还可以分配多少，就和memoryMap[i]以及其所有子节点的值、pageSize有关。

这里假设一个PoolSubpage的大小为4K，如果申请一个大小为1K的存储区域时，该什么办呢？

对于小于一个Page的内存，Netty在Page中完成分配。每个Page会被切分成大小相同的多个存储块，存储块的大小由第一次申请的内存块大小决定。对于Page的大小为4K，第一次申请的时1K，则这个Page就会被分成4个存储块。

一个Page只能用于分配与第一次申请时大小相同的内存，例如，一个4K的Page，如果第一次分配了1K的内存，那么后面这个Page就只能继续分配1K的内存，如果有一个申请2K内存的请求，就需要在一个新的Page中进行分配。

Page中存储区域的使用状态通过一个long数组来维护，数组中每个long的每一位表示一个块存储区域的占用情况：0表示未占用，1表示占用。例如：对于一个4K的Page来说如果这个Page用来分配1K的存储与区，那么long数组中就只有一个long类型的元素且这个数值的低4危用来指示4个存储区域的占用情况。

下面看看如何向PoolChunk申请一块内存区域，allocate函数的代码如下；

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

从上面的函数可以看到根据用户申请的内存的大小，chunk采用了不同的方式，具体如下：

1、当需要分配的内存大于等于pageSize时，通过调用allocateRun函数实现内存分配。
2、当需要分配的内存小于pageSize时，通过调用allocateSubpage函数实现内存分配。

下面将会这两个函数进行分析。

1、allocateSubpage(normCapacity)

先看 allocateSubpage方法，代码如下：

    private long allocateSubpage(int normCapacity) 
        int d = maxOrder; // subpages are only be allocated from pages i.e., leaves
        int id = allocateNode(d);//找到符合要求的节点的索引。
        if (id < 0) 
            return id;
        

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

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

        int subpageIdx = subpageIdx(id);//求余，得到page在subPages中的索引。
        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();
     

前面提到过，当需要分配的内存小于pageSize时 ，会把一个page分割成多段，进行内存分配。因此，第一步就是要找到一个符合要求的节点。该功能由如下的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);
        if (val > d)  // unusable
            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;
            val = value(id);
            if (val > d) //当前节点不符合要求，需要到兄弟节点来寻找。
                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); // mark as unusable
        updateParentsAlloc(id);
        return id;
     

简单来说：该函数用于在二叉树的第d层寻找一个空闲page节点，返回的是该空闲Page节点在memoryMap的索引。 此时这里的 d = maxOrder。 代码的具体实现思路如下：

1、从根节点开始遍历，如果当前节点的val > d，说明存在子节点已经被分配了且剩余节点的内存大小不够，则此时需要到兄弟节点上继续查找。如果当前节点为根节点，根节点无兄弟节点，直接返回-1表示在该chunk不符合要求不能分配这么大的内存。

2、如果当前节点的val < d，说明该节点的内存可以被分配，则通过 id <<= 1 匹配下一层直到找到value(id) = d 且id在第d层的节点；

3、分配成功的节点需要标记为不可用，防止被再次分配，在memoryMap对应位置进行更新；

4、分配节点完成后，其父节点的状态也需要更新，并可能引起更上一层父节点的更新。父节点的val=min子节点val；

    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;
        
    

看一个例子来说明allocateNode函数中寻找节点的算法的整个过程。

首先假设PoolChunnk由16个PoolSubpage构成，每个Page的大小为4K，那么这些PoolSubpage将会按照如下的结构组织起来。图中标出的数字为：当前节点在memoryMap中的所对应的val。

现假设用户申请一个4K的存储空间，则会将如下图所示用“红椭圆”标示的page分配出去。并进行了标识，修改了相应节点在memoryMap的值。

现在假设用户又申请一个4K的存储空间，则具体的流经过程如下图描述所示。最后的分配结果用“蓝色椭圆”进行了标识。

分配之后，修改相应节点在memoryMap的值的结果如下图所示。

以上几个图就可以很好的了解allocateNode函数中寻找节点的算法了。

回到allocateSubpage方法，在找到节点之后，即找到subpage之后由于申请的内存区域小于pageSize因此就开始调用subpage.allocate()来进行内存分配。具体细节将会在下篇博文讲解PoolSubpage的时候进行介绍，这里不进行介绍。

2、allocateRun(int normCapacity)

当需要分配的内存大于等于pageSize时，通过调用allocateRun函数实现内存分配。

    /**
     * Allocate a run of pages (>=1)
     *
     * @param normCapacity normalized capacity
     * @return index in memoryMap
     */
    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;
    

该函数相比上面介绍的allocateSubpage方法类似且要简单，这个函数主要是利用allocateNode方法来寻找符合要求的节点即可，allocateNode方法在上面有详细的介绍。

这里主要理解下 int d = maxOrder - (log2(normCapacity) - pageShifts);代码。这行代码的作用：根据normCapacity确定需要在二叉树的d层开始节点匹配。

还是以下面这个chunk为例来进行说明。

假设PoolChunnk由16个PoolSubpage构成，则由(maxSubpageAllocs = 1 << maxOrder;)可以得到maxOrder=log(16)=4，而根据每个Page的大小为4K可以得到pageShifts=12。因此假设用户申请一个大小为16K的缓存，则maxOrder - (log2(normCapacity) - pageShifts)=2，如下图“红圈”所示的那一层。

小结

看完PoolChunk，我们需要知道的东西就两点：

1、PoolChunk是通过二叉树的形式来组织Page的。

2、当用户申请内存时，无论是大于等于PageSize的还是小于PageSize的第一步都是通过allocateNode方法来寻找符合要求的节点。其中小于pageSize的内存分配是在PoolSubpage上来进行分配的。

参考资料

1、http://www.jianshu.com/p/c4bd37a3555b

2、http://blog.csdn.net/prestigeding/article/details/54598967

3、《Netty权威指南》