Netty4.0源码分析之PoolChunk

最新推荐文章于 2019-11-05 16:13:09 发布

zhifeng687

最新推荐文章于 2019-11-05 16:13:09 发布

阅读量399

点赞数

分类专栏： NIO & Netty

NIO & Netty 专栏收录该内容

28 篇文章 3 订阅

订阅专栏

1. 伙伴分配算法

JEMalloc分配算法使用伙伴分配算法分配Chunk中的Page节点。Netty实现的伙伴分配算法中，构造了两棵满二叉树，满二叉树非常适合使用数组存储，Netty使用两个字节数组memoryMap和depthMap来表示两棵二叉树，其中MemoryMap存放分配信息，depthMap存放节点的高度信息。为了更好的理解这两棵二叉树，参考下图：

伙伴分配算法二叉树

左图表示每个节点的编号，注意从1开始，省略0是因为这样更容易计算父子关系：子节点加倍，父节点减半，比如512的子节点为1024=512 * 2。右图表示每个节点的深度，注意从0开始。在代表二叉树的数组中，左图中节点上的数字作为数组索引即id，右图节点上的数字作为值。初始状态时，memoryMap和depthMap相等，可知一个id为512节点的初始值为9，即：

    memoryMap[512] = depthMap[512] = 9;

depthMap的值初始化后不再改变，memoryMap的值则随着节点分配而改变。当一个节点被分配以后，该节点的值设置为12（最大高度+1）表示不可用，并且会更新祖先节点的值。下图表示随着4号节点分配而更新祖先节点的过程，其中每个节点的第一个数字表示节点编号，第二个数字表示节点高度值。

伙伴分配算法分配过程

分配过程如下：

4号节点被完全分配，将高度值设置为12表示不可用。
4号节点的父亲节点即2号节点，将高度值更新为两个子节点的较小值；其他祖先节点亦然，直到高度值更新至根节点。

可推知，memoryMap数组的值有如下三种情况：

memoryMap[id] = depthMap[id] -- 该节点没有被分配
memoryMap[id] > depthMap[id] -- 至少有一个子节点被分配，不能再分配该高度满足的内存，但可以根据实际分配较小一些的内存。比如，上图中分配了4号子节点的2号节点，值从1更新为2，表示该节点不能再分配8MB的只能最大分配4MB内存，因为分配了4号节点后只剩下5号节点可用。
mempryMap[id] = 最大高度 + 1（本例中12） -- 该节点及其子节点已被完全分配，没有剩余空间。

明白了这些，再深入源码分析Netty的实现细节。

2. 源码实现

首先看关键成员变量：

    private final byte[] memoryMap; // 分配信息二叉树
    private final byte[] depthMap; // 高度信息二叉树
    private final PoolSubpage<T>[] subpages; // subpage节点数组
    private final int subpageOverflowMask;  // 判断分配请求为Tiny/Small即分配subpage
    private final int pageSize; // 页大小，默认8KB=8192
    private final int pageShifts; // 从1开始左移到页大小的位置，默认13，1<<13 = 8192
    private final int maxOrder; // 最大高度，默认11
    private final int chunkSize; // chunk块大小，默认16MB
    private final int log2ChunkSize; // log2(16MB) = 24
    private final int maxSubpageAllocs; // 可分配subpage的最大节点数即11层节点数，默认2048
    private final byte unusable; // 标记节点不可用，最大高度 + 1， 默认12
    private int freeBytes; // 可分配字节数

此外，还有一些非关键成员变量：

    final PoolArena<T> arena; // chunk所属的arena
    final T memory; // 实际的内存块
    final boolean unpooled; // 是否非池化
    final int offset; // ?
    
    PoolChunkList<T> parent; // poolChunkList专用
    PoolChunk<T> prev;
    PoolChunk<T> next;

该类有两个构造方法，一个用于普通初始化，另一个用于非池化初始化（Huge分配请求）。关注一下对某些值的计算：

    unusable = (byte) (maxOrder + 1);
    log2ChunkSize = log2(chunkSize);
    subpageOverflowMask = ~(pageSize - 1);
    freeBytes = chunkSize;

    maxSubpageAllocs = 1 << maxOrder;
    subpages = new PoolSubpage[maxSubpageAllocs];

在构造方法中对两棵二叉树的初始化代码如下：

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

接下来分析关键的分配方法allocate()：

    long allocate(int normCapacity) {
        if ((normCapacity & subpageOverflowMask) != 0) { // >= pageSize即Normal请求
            return allocateRun(normCapacity);
        } else { // Tiny和Small请求
            return allocateSubpage(normCapacity);
        }
    }

首先看Normal请求，该请求需要分配至少一个Page的内存，代码实现如下：

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

在某一层寻找可用节点的代码如下：

    private int allocateNode(int d) {
        int id = 1;
        // 所有高度<d 的节点 id & initial = 0
        int initial = - (1 << d); 
        byte val = value(id); // = memoryMap[id]
        if (val > d) { // 没有满足需求的节点
            return -1;
        }
        
        // val<d 子节点可满足需求
        // id & initial == 0 高度<d
        while (val < d || (id & initial) == 0) {
            id <<= 1;   // 高度加1，进入子节点
            val = value(id); // = memoryMap[id]
            if (val > d) { // 左节点不满足
                id ^= 1; // 右节点
                val = value(id);
            }
        }
        
        // 此时val = d
        setValue(id, unusable); // 找到符合需求的节点并标记为不可用
        updateParentsAlloc(id); // 更新祖先节点的分配信息
        return id;
    }

这部分代码含有大量位运算，需要仔细体会其中的用法。Netty为了追求性能，位运算也是用到了极致。接着分析更新祖先节点的分配信息的代码如下：

    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; // 递归更新
        }
    }

至此，Normal请求的分配过程分析完毕。为了更好的理解分配过程，以一个Page大小为8KB，pageShifts=13，maxOrder=11的配置为例分析分配32KB=2^15B内存的过程（假设该Chunk首次分配）：

计算满足所需内存的高度d，d= maxOrder-(log2(normCapacity)-pageShifts) = 11-(log2(2^15)-13) = 9。可知，满足需求的节点的最大高度d = 9。
在高度<9的层从左到右寻找满足需求的节点。由于二叉树不便于按层遍历，故需要从根节点1开始遍历。本例中，找到id为512的节点，满足需求，将memory[512]设置为12表示分配。
从512节点开始，依次更新祖先节点的分配信息。

接着分析Tiny/Small请求的分配实现allocateSubpage()，代码如下：

    private long allocateSubpage(int normCapacity) {
        // 找到arena中对应的subpage头节点
        PoolSubpage<T> head = arena.findSubpagePoolHead(normCapacity);
        // 加锁，分配过程会修改链表结构
        synchronized (head) {
            int d = maxOrder; // subpage只能在二叉树的最大高度分配即分配叶子节点
            int id = allocateNode(d); 
            if (id < 0) {
                return id; // 叶子节点全部分配完毕
            }

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

            freeBytes -= pageSize;

            // 得到叶子节点的偏移索引，从0开始，即2048-0,2049-1,...
            int subpageIdx = subpageIdx(id);
            PoolSubpage<T> subpage = subpages[subpageIdx];
            if (subpage == null) {
                subpage = new PoolSubpage<T>(head, this, id, 
                            runOffset(id), pageSize, normCapacity);
                subpages[subpageIdx] = subpage;
            } else {
                subpage.init(head, normCapacity);
            }
            return subpage.allocate();
        }
    }

由于Small/Tiny请求分配的内存小于PageSize，所以分配的节点必然在二叉树的最高层。找到最高层合适的节点后，新建或初始化subpage并加入到chunk的subpages数组，同时将subpage加入到arena的subpage双向链表中，最后完成分配请求的内存。代码中，subpage != null的情况产生的原因是：subpage初始化后分配了内存，但一段时间后该subpage分配的内存释放并从arena的双向链表中删除，此时subpage不为null，当再次请求分配时，只需要调用init()将其加入到areana的双向链表中即可。
Netty优化计算内存相关数据的基本方法，代码如下：

    // 得到第11层节点的偏移索引，= id - 2048
    private int subpageIdx(int memoryMapIdx) {
        return memoryMapIdx ^ maxSubpageAllocs;
    }
    
    // 得到节点对应可分配的字节，1号节点为16MB-ChunkSize，2048节点为8KB-PageSize
    private int runLength(int id) {
        return 1 << log2ChunkSize - depth(id);
    }

    // 得到节点在chunk底层的字节数组中的偏移量
    // 2048-0, 2049-8K，2050-16K
    private int runOffset(int id) {
        int shift = id ^ 1 << depth(id);
        return shift * runLength(id);
    }

注意到PoolSubpage分配的最后结果是一个long整数，其中低32位表示二叉树中的分配的节点，高32位表示subPage中分配的具体位置。相关的计算如下：

    private static int memoryMapIdx(long handle) {
        return (int) handle;
    }

    private static int bitmapIdx(long handle) {
        return (int) (handle >>> Integer.SIZE);
    }

明白了这些，接着分析内存释放过程，代码如下：

    void free(long handle) {
        int memoryMapIdx = memoryMapIdx(handle);
        int bitmapIdx = bitmapIdx(handle);

        if (bitmapIdx != 0) { // 需要释放subpage
            PoolSubpage<T> subpage = subpages[subpageIdx(memoryMapIdx)];

            PoolSubpage<T> head = arena.findSubpagePoolHead(subpage.elemSize);
            synchronized (head) {
                if (subpage.free(head, bitmapIdx & 0x3FFFFFFF)) {
                    return; // 此时释放了subpage中的一部分内存（即请求的）
                }
                // 此时subpage完全释放，可以删除二叉树中的节点
            }
        }
        freeBytes += runLength(memoryMapIdx);
        setValue(memoryMapIdx, depth(memoryMapIdx)); // 节点分配信息还原为高度值
        updateParentsFree(memoryMapIdx); // 更新祖先节点的分配信息
    }

释放过程相对简单，释放时更新祖先节点的分配信息是分配时的逆过程，代码如下：

    private void updateParentsFree(int id) {
        int logChild = depth(id) + 1;
        while (id > 1) {
            int parentId = id >>> 1;
            byte val1 = value(id);
            byte val2 = value(id ^ 1);
            logChild -= 1;

            if (val1 == logChild && val2 == logChild) {
                // 此时子节点均空闲，父节点值高度-1
                setValue(parentId, (byte) (logChild - 1));
            } else {
                // 此时至少有一个子节点被分配，取最小值
                byte val = val1 < val2 ? val1 : val2;
                setValue(parentId, val);
            }

            id = parentId;
        }
    }

至此，PoolChunk分析完毕。

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

zhifeng687

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Netty4.0源码分析之PoolChunk

1. 伙伴分配算法JEMalloc分配算法使用伙伴分配算法分配Chunk中的Page节点。Netty实现的伙伴分配算法中，构造了两棵满二叉树，满二叉树非常适合使用数组存储，Netty使用两个字节数组memoryMap和depthMap来表示两棵二叉树，其中MemoryMap存放分配信息，depthMap存放节点的高度信息。为了更好的理解这两棵二叉树，参考下图：伙伴分配算法二叉树左...
复制链接

扫一扫

专栏目录