netty源码阅读之ByteBuf之内存概念arena、chunk、page、subpage

﹏ヽ暗。殇╰゛Y 2022-05-14 12:24 230阅读 0赞

在PoolThreadCache里面，分两种区域，cache和arena。前面我们讲解了cache，也就是之前存在过，我们直接在cache里面获取或者分配。但是第一次的时候，cache肯定是没有的，所以就要使用到内存区域arena。

我们来看源码：

final class PoolThreadCache {
    
        private static final InternalLogger logger = InternalLoggerFactory.getInstance(PoolThreadCache.class);
    
        final PoolArena<byte[]> heapArena;
        final PoolArena<ByteBuffer> directArena;
    
        // Hold the caches for the different size classes, which are tiny, small and normal.
        private final MemoryRegionCache<byte[]>[] tinySubPageHeapCaches;
        private final MemoryRegionCache<byte[]>[] smallSubPageHeapCaches;
        private final MemoryRegionCache<ByteBuffer>[] tinySubPageDirectCaches;
        private final MemoryRegionCache<ByteBuffer>[] smallSubPageDirectCaches;
        private final MemoryRegionCache<byte[]>[] normalHeapCaches;
        private final MemoryRegionCache<ByteBuffer>[] normalDirectCaches;
    }

前面我们讲解了MemoryRegionCache六个cache数组，现在我们讲解heapArena和directArena。

首先我们看arena的数据结构：

![70][]

我们看到一个Arena由多个ChunkList组成，每个ChunkList之间通过双向链表的方式连接。一个ChunkList又由多个Chunk通过双向链表的方式组成。也就是各个Chunlist组成双向链表，ChunkList里面的Chunk又各自组成双向链表。

ChunList之间为什么要通过双向链表的方式连接？先给出答案：每个ChunkList里面的Chunk的使用率是不同的，Chunk使用率相同的归位一个ChunList，这样netty就能通过一定的算法找到合适的Chunk，提高内存分配的效率。

先看PoolArena里面的ChunkList的源码：

abstract class PoolArena<T> implements PoolArenaMetric {
    
        ...
    
        private final PoolChunkList<T> q050;
        private final PoolChunkList<T> q025;
        private final PoolChunkList<T> q000;
        private final PoolChunkList<T> qInit;
        private final PoolChunkList<T> q075;
        private final PoolChunkList<T> q100;
    
        ...
    
        protected PoolArena(PooledByteBufAllocator parent, int pageSize, int maxOrder, int pageShifts, int chunkSize) {
    
            ...
    
            q100 = new PoolChunkList<T>(null, 100, Integer.MAX_VALUE, chunkSize);
            q075 = new PoolChunkList<T>(q100, 75, 100, chunkSize);
            q050 = new PoolChunkList<T>(q075, 50, 100, chunkSize);
            q025 = new PoolChunkList<T>(q050, 25, 75, chunkSize);
            q000 = new PoolChunkList<T>(q025, 1, 50, chunkSize);
            qInit = new PoolChunkList<T>(q000, Integer.MIN_VALUE, 25, chunkSize);
    
            q100.prevList(q075);
            q075.prevList(q050);
            q050.prevList(q025);
            q025.prevList(q000);
            q000.prevList(null);
            qInit.prevList(qInit);
    
            ...
    
        }
    
    }

通过以下代码我们可以知道，一个Arena里面有6个ChunkList：

private final PoolChunkList<T> q050;
        private final PoolChunkList<T> q025;
        private final PoolChunkList<T> q000;
        private final PoolChunkList<T> qInit;
        private final PoolChunkList<T> q075;
        private final PoolChunkList<T> q100;

通过一下代码我么可以知道，q100里面的Chunk的内存已经使用100%以上，q075里面的Chunk的内存已经使用75%到100%之间，q050代表它里面的Chunk的内存已经使用50%到100%之间，以此类推。所以netty就可以通过这种方式找到需要的特定的内存，提高效率。

q100 = new PoolChunkList<T>(null, 100, Integer.MAX_VALUE, chunkSize);
            q075 = new PoolChunkList<T>(q100, 75, 100, chunkSize);
            q050 = new PoolChunkList<T>(q075, 50, 100, chunkSize);
            q025 = new PoolChunkList<T>(q050, 25, 75, chunkSize);
            q000 = new PoolChunkList<T>(q025, 1, 50, chunkSize);
            qInit = new PoolChunkList<T>(q000, Integer.MIN_VALUE, 25, chunkSize);

看PoolChunkList的构造函数：

PoolChunkList(PoolChunkList<T> nextList, int minUsage, int maxUsage, int chunkSize) {
            assert minUsage <= maxUsage;
            this.nextList = nextList;
            this.minUsage = minUsage;
            this.maxUsage = maxUsage;
            maxCapacity = calculateMaxCapacity(minUsage, chunkSize);
        }

this.nextList=nextList,结合上一段的代码，我们可以知道chunlist之间是这么连接的：

qInit->q00->q025->q050->q075->q100

然后通过下面的代码：

q100.prevList(q075);
            q075.prevList(q050);
            q050.prevList(q025);
            q025.prevList(q000);
            q000.prevList(null);
            qInit.prevList(qInit);

我们知道最终这些Chunlist之间是这样连接的双向链表：

qInit<=>q00<=>q025<=>q050<=>q075<=>q100

如果我们要分配的内存小于Chunk也就是16M，我们用chunk来分配不划算，浪费空间，所以就有了page。一个page的大小是8k，如果我们要分配内存是10k，那么我们用chunk里面的两个page来分配就很划算了。但是如果只要2k呢，一个page也显得不划算，所有又有了subpage。subpage的大小介于0~8k之间。我们看到PoolArena里面有个：

private final PoolSubpage<T>[] tinySubpagePools;
        private final PoolSubpage<T>[] smallSubpagePools;

这就是subpage，点击去：

final class PoolSubpage<T> implements PoolSubpageMetric {
    
        final PoolChunk<T> chunk;
        private final int memoryMapIdx;
        private final int runOffset;
        private final int pageSize;
        private final long[] bitmap;
    
        PoolSubpage<T> prev;
        PoolSubpage<T> next;
    
        boolean doNotDestroy;
        int elemSize;
        private int maxNumElems;
        private int bitmapLength;
        private int nextAvail;
        private int numAvail;
    }

留意到有个elemSize，这个就是subpage的大小。可以为0~8k之间的值（当然要小于8k）

然后又个bitmap，这里先提前透露，bitmap里面如果值为1，就说明被分配了，如果为0就未分配，后面还会细讲。

然后又prev和next指针，说明subpage之间也就通过双向链表链接的。

然后第一个成员变量final PoolChunk<T> chunk，说明了这个subpage属于哪个chunk。

[70]: /images/20220514/15112e878cd24dd28c90ad19c470444b.png