2023-09-13  阅读(227)
原文作者:https://blog.csdn.net/wangwei19871103/category_9681495_2.html 原文地址: https://blog.csdn.net/wangwei19871103/article/details/104344446

PoolChunk的allocateSubpage

这个比上篇那个要再进一步划分内存,这个是小于页大小的分配方式。

    private long allocateSubpage(int normCapacity) {
    		//获取子页数组的头结点,可以是ting数组也可以是small数组的
            PoolSubpage<T> head = arena.findSubpagePoolHead(normCapacity);
            int d = maxOrder; // 11
            synchronized (head) {//修改数据要同步
                int id = allocateNode(d);//找到能分配的内存映射索引
                if (id < 0) {
                    return id;//没找到
                }
    
                final PoolSubpage<T>[] subpages = this.subpages;//满二叉树的叶子节点数组
                final int pageSize = this.pageSize;//8k
                //减少一页大小的可用字节
                freeBytes -= pageSize;
                //获取子页数组索引,其实跟取模一样 0-2047
                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();
            }
        }

PoolArena的findSubpagePoolHead

根据传进来的规范后的申请容量,找出PoolArena里的tinySubpagePoolssmallSubpagePools数组里的匹配容量的PoolSubpage,其实是PoolSubpage链表的头结点head

     PoolSubpage<T> findSubpagePoolHead(int elemSize) {
            int tableIdx;
            PoolSubpage<T>[] table;
            if (isTiny(elemSize)) { // < 512
                tableIdx = elemSize >>> 4;//获取索引
                table = tinySubpagePools;//获取子页数组
            } else {
                tableIdx = 0;
                elemSize >>>= 10;
                while (elemSize != 0) {//[512-pageSize) 尺寸和索引对应: 512->0 1024->1 2048->2 4096->3 刚是smallSubpagePoolsde的全部索引
                    elemSize >>>= 1;
                    tableIdx ++;
                }
                table = smallSubpagePools;
            }
    
            return table[tableIdx];
        }

PoolChunk的subpageIdx

获取页索引 位运算 其实跟取模结果一样,memoryMapIdxmaxSubpageAllocs(2048)求余数,因为memoryMapIdx在这里的范围是[2048-4095],刚好对应余数是[0-2047]

        private int subpageIdx(int memoryMapIdx) {
            return memoryMapIdx ^ maxSubpageAllocs; // remove highest set bit, to get offset
        }

runOffset

获得id节点对应的内存在块chunk中的偏移量,或者说起始地址。
depthrunLength在上一篇中已经讲过,这里主要是先计算偏移位数shift ,然后计算节点可分配内存大小runLength,偏移量就是偏移大小x节点大小。 int shift = id ^ 1 << depth(id);这里先算1 << depth(id),找出某一深度的第一个内存映射索引,然后和id做异或,即是求出id对于这个索引的偏移位数。比如id=1025,1 << depth(id)=1024,1024^1025=1。即shift =1,同理id=1024,shift =0,id=1026,shift =2,以此类推。

    //计算内存偏移 即内存映射索引id对应的节点在块chunk中的偏移量 范围是[0 - chunkSize),比如2048是0 x 8k=0 2049是1 x 8k=8k 1024是0 x 16k=0 1025是1 x 16k=16k
        private int runOffset(int id) {
            // 其实每一个节点的偏移位置就是他的左节点的偏移,叶子节点就是自身的偏移量
            int shift = id ^ 1 << depth(id);//节点的偏移位数 比如2048是0 2049是1 2050是2 ..4095是2047 也就是某个深度中从左到右的编号,从0开始。
            return shift * runLength(id);//偏移量=偏移位数x可分配内存大小
        }

PoolSubpage构造函数

PoolSubpage其实不会实际分配内存,只是做了分配内存的记录,记录一个页中哪些分配完了,哪些可以分配 ,实际的内存分配是在PoolChunkmemory属性中,前面讲过如果是申请堆内存,memory就是数组,否则如果申请直接内存,memory就是直接缓冲区。PoolSubpage在页空间分配满之后就会被删除释放。

        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;//页大小
            bitmap = new long[pageSize >>> 10]; //最多需要多少个long类型的位图来描述一页分割成16B的所有内存的状态
            init(head, elemSize);
        }

bitmap = new long[pageSize >>> 10]; 这里解释下:这里的10,其实是4+6,4是表示1624次方,6表示6426次方,所以加起来是10,即用页大小8k除以16除以64,这里的意思就是以最小的尺寸16B来计算,一页能分几个16B大小的内存,然后用位图表示这个内存是否被用需要1位,如果用long类型的位图就是64位,所以除以64,就知道需要多少个64位的位图来表示这些16B的内存的状态。默认页大小8k,算出来需要8个这样的位图,所以位图数组长度是8

一些主要属性

老规矩,先看一些主要的属性,后面就用到了。

        final PoolChunk<T> chunk;
        private final int memoryMapIdx;//内存映射索引
        private final int runOffset;//chunk中的偏移
        private final int pageSize;//页大小
        private final long[] bitmap;//64位的位图数组,描述某一尺寸内存的状态 每一位都可以表示是该内存否可用了 1表示不可用 0表示可用
    
        PoolSubpage<T> prev;//前驱
        PoolSubpage<T> next;//后继
    
        boolean doNotDestroy;//是否销毁
        int elemSize;//分割的内存尺寸大小
        private int maxNumElems;//一页存能存多少个尺寸都为elemSize的内存,即即最大可分配的内存数
        private int bitmapLength;//实际用到的位图数
        private int nextAvail;//下一个可用的位图索引
        private int numAvail;//可用内存的个数

init

进行一些属性的初始化,并将自身添加到头节点的后面。

    void init(PoolSubpage<T> head, int elemSize) {
            doNotDestroy = true;
            this.elemSize = elemSize;
            if (elemSize != 0) {
                maxNumElems = numAvail = pageSize / elemSize;//获取能分割成多少elemSize大小的内存
                nextAvail = 0;
                bitmapLength = maxNumElems >>> 6;//实际需要用的到的long类型的位图的个数,每个位图有64位,取整
                if ((maxNumElems & 63) != 0) {//有余数就多一个
                    bitmapLength ++;
                }
                //实际用到的位图数
                for (int i = 0; i < bitmapLength; i ++) {
                    bitmap[i] = 0;//初始化位图
                }
            }
            addToPool(head);
        }

addToPool

将当前子页加到head的后面,是个 双向循环链表

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

我画个示意图吧,一开始就只有head是这样的:

202309132201587751.png
加一个之后:

202309132201591672.png后续如果有相同尺寸的请求,都会在这个子页里分配,直到子页满了后,会链表中删除。

可见prednext都可以循环起来。

添加到chunk子页数组里

subpages[subpageIdx] = subpage子页创建后就被添加到了子页数组里,这里还有另外一个结构关系,就是PoolArena里的tinySubpagePoolssmallSubpagePoolsPoolChunksubpages的关系,因为headtinySubpagePoolssmallSubpagePools元素,后续添加的PoolSubpage都会添加进head形成的双向循环链表中。用图来表示的话应该是这样,注意 这里的双向连线是双向循环链表,避免太乱所以这样表示

202309132202002973.png
后面就是讲subpage.allocate()子页的分配逻辑了,其实也就是一些分配记录,会降到位图的使用,这个还是挺关键的,位图在做记录信息的时候还是很有用的,占用空间又小,位运算速度又快。比如这个子页就用了64B的位图就可以记录8kB的内存分配信息。

好了,今天就到这里了,希望对学习理解有帮助,大神看见勿喷,仅为自己的学习理解,能力有限,请多包涵。

阅读全文
  • 点赞