Netty4.0源码分析之PoolSubpage

在PoolArena中由PoolSubpage双向链表分配内存小于PageSize（Netty默认8KB）的请求。在JEMalloc分配算法一文中介绍过，其中的结构如下图：

Subpage双向链表

而Subpage又是由PoolChunk中的一个Page依照第一次分配请求的大小均等切分而成。可推知，小于PageSize的分配请求执行过程如下：

 

1. 首次请求Arena分配，Arena中的双向链表为空，不能分配；传递给Chunk分配，Chunk找到一个空闲的Page，然后均等切分并加入到Arena链表中，最后分配满足要求的大小。
2. 之后请求分配同样大小的内存，则直接在Arena中的PoolSubpage双向链表进行分配；如果链表中的节点都没有空间分配，则重复1步骤。

Netty使用一个long整型表示在PoolSubpage中分配的结果，其中低32位表示PoolSubpage所属的Page的标号，高32位表示均等切分小块的块号。实际中，Netty使用位图来表示均等小块的分配信息，其中位图有用long数组表示，所以对于高32位，其中的低6位用来表示64位即一个long的分配信息，其余位用来表示long数组的索引。可参见下图示意：

    |<--   24   -->| <--   6      --> | <--         32         --> |
    |  long数组偏移 |  long的二进制位偏移|       所属Chunk标号         |

明白了这些，开始分析源码实现。首先看成员变量：

    private final int memoryMapIdx; // 所属Page的标号
    private final int runOffset; // 在整个Chunk的偏移字节数
    private final int pageSize; // 页大小
    private final long[] bitmap; // 均等小块的分配信息

    boolean doNotDestroy; // 是否需要释放整个Page
    int elemSize; // 均等切分的大小
    private int maxNumElems; // 最多可以切分的小块数
    private int bitmapLength; // 位图信息的长度,long的个数
    private int nextAvail; // 下一个可分配的小块位置信息
    private int numAvail; // 可用的小块数
    
    final PoolChunk<T> chunk; // 所属的Chunk
    PoolSubpage<T> next; // arena双向链表的后继节点
    PoolSubpage<T> prev; // arena双向链表的前驱节点

构造方法有两个，其中一个用于构造双向链表的头节点Head，这是一个特殊节点，不进行分配，不列出代码。重点关注普通节点构造方法：

    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;
        // 此处使用最大值，最小分配16B所需的long个数 
        bitmap = new long[pageSize >>> 10]; // pageSize / 16 / 64
        init(head, elemSize);
    }

    void init(PoolSubpage<T> head, int elemSize) {
        doNotDestroy = true;
        this.elemSize = elemSize;
        if (elemSize != 0) {
            maxNumElems = numAvail = pageSize / elemSize;
            nextAvail = 0;
            bitmapLength = maxNumElems >>> 6; // /64 表示long的个数
            if ((maxNumElems & 63) != 0) {
                bitmapLength ++; // subpage不是64倍，多需要一个long
            }

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

需要注意的是：Netty使用了多个long整数的位数表示位图信息，这部分代码主要是在初始化位图结构。bitmap的最大长度为pageSize >>> 10表示最小分配16(1>>>4)B所需的long(1>>>6)个数，此处不使用pageSize/elemSize/64是因为考虑到复用。当一个PoolSubpage以32B均等切分，然后释放返回给Chunk，当Chunk再次被分配时，比如16B，此时只需调用init()方法即可而不再需要初始其他数据。
最后的addToPool()方法将该PoolSubpage加入到Arena的双向链表中，代码如下：

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

这是经典的双向链表操作，只需注意每次新加入的节点都在Head节点之后。从链表中删除的操作是该操作的逆操作，实现代码如下：

    private void removeFromPool() {
        assert prev != null && next != null;
        prev.next = next;
        next.prev = prev;
        next = null;
        prev = null;
    }

接着分析关键的分配过程，代码如下：

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

        // 1.没有可分配均等小块 2.需要销毁(arena池中有其他可分配subpage)
        if (numAvail == 0 || !doNotDestroy) {
            return -1;
        }
        
        final int bitmapIdx = getNextAvail();
        int q = bitmapIdx >>> 6; // 高24为表示long数组索引
        int r = bitmapIdx & 63; // 低6位表示在long中实际分配的二进制位
        assert (bitmap[q] >>> r & 1) == 0;
        bitmap[q] |= 1L << r; // 将该信息加入到分配信息中

        if (-- numAvail == 0) {
            removeFromPool(); // 没有可分配的均等块则从arena双向链表删除
        }

        return toHandle(bitmapIdx); // 转换为64位分配信息
    }
    
    private long toHandle(int bitmapIdx) {
        return 0x4000000000000000L | (long) bitmapIdx << 32 | memoryMapIdx;
    }

其中较难理解的位运算部分，转化为bitSet则只是bitSet.set(i, true)，Netty为了效率使用了long数组表示位图信息，所以稍显复杂。接着分析其中的getNextAvail()方法，该方法用来寻找在位图中可用的下一个位，代码如下：

    private int getNextAvail() {
        int nextAvail = this.nextAvail;
        if (nextAvail >= 0) {
            // 此时的nextAvail是上一个释放的均等小块
            this.nextAvail = -1;
            return nextAvail;
        }
        return 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) {
                // 还有可用的均等小块
                return findNextAvail0(i, bits);
            }
        }
        return -1;
    }
    
    private int findNextAvail0(int i, long bits) {
        final int maxNumElems = this.maxNumElems;
        final int baseVal = i << 6;

        // long从低位开始表示分配信息，最低位表示第1块分配
        for (int j = 0; j < 64; j ++) {
            if ((bits & 1) == 0) {
                int val = baseVal | j;
                if (val < maxNumElems) {
                    return val;
                } else {
                    break;
                }
            }
            bits >>>= 1;
        }
        return -1;
    }

寻找可用分配块，即按序寻找long数组中，二进制为0的位即表示可用的小块序列。对应的释放方法free()代码如下：

    boolean free(PoolSubpage<T> head, int bitmapIdx) {
        if (elemSize == 0) {
            return true;
        }
        int q = bitmapIdx >>> 6; // long数组索引
        int r = bitmapIdx & 63; // long的二进制位偏移
        assert (bitmap[q] >>> r & 1) != 0;
        bitmap[q] ^= 1L << r; // 异或运算清除改位

        setNextAvail(bitmapIdx); // 该位置的小块可用于下次分配

        if (numAvail ++ == 0) {
            // 该page已分配了至少一个subpage，加入到arena双向链表
            addToPool(head); 
            return true;
        }

        if (numAvail != maxNumElems) {
            return true;
        } else {
            if (prev == next) {
                // prev==next==head 只有头结点和该节点
                return true;
            }

            // 从双向链表中释放，因为双向链表中至少有一个可用节点   
            doNotDestroy = false;
            removeFromPool();
            return false;
        }
    }

需要注意的是该方法的返回值，返回true表示该subpage在使用中，返回false表示该subPage不再由chunk使用可以释放。

转载自：简书 自顶向下深入分析Netty（十）--PoolSubpage