package io.netty.buffer;

/* JADX INFO: loaded from: classes.dex */
final class PoolChunk<T> implements PoolChunkMetric {
    static final /* synthetic */ boolean $assertionsDisabled = false;
    private static final int INTEGER_SIZE_MINUS_ONE = 31;
    final PoolArena<T> arena;
    private final int chunkSize;
    private final byte[] depthMap;
    private int freeBytes;
    private final int log2ChunkSize;
    private final int maxOrder;
    private final int maxSubpageAllocs;
    final T memory;
    private final byte[] memoryMap;
    PoolChunk<T> next;
    private final int pageShifts;
    private final int pageSize;
    PoolChunkList<T> parent;
    PoolChunk<T> prev;
    private final int subpageOverflowMask;
    private final PoolSubpage<T>[] subpages;
    final boolean unpooled;
    private final byte unusable;

    PoolChunk(PoolArena<T> poolArena, T t, int i2, int i3, int i4, int i5) {
        this.unpooled = false;
        this.arena = poolArena;
        this.memory = t;
        this.pageSize = i2;
        this.pageShifts = i4;
        this.maxOrder = i3;
        this.chunkSize = i5;
        this.unusable = (byte) (i3 + 1);
        this.log2ChunkSize = log2(i5);
        this.subpageOverflowMask = ~(i2 - 1);
        this.freeBytes = i5;
        int i6 = 1 << i3;
        this.maxSubpageAllocs = i6;
        byte[] bArr = new byte[i6 << 1];
        this.memoryMap = bArr;
        this.depthMap = new byte[bArr.length];
        int i7 = 1;
        for (int i8 = 0; i8 <= i3; i8++) {
            int i9 = 1 << i8;
            for (int i10 = 0; i10 < i9; i10++) {
                byte b2 = (byte) i8;
                this.memoryMap[i7] = b2;
                this.depthMap[i7] = b2;
                i7++;
            }
        }
        this.subpages = newSubpageArray(this.maxSubpageAllocs);
    }

    private int allocateNode(int i2) {
        int i3 = 1;
        int i4 = -(1 << i2);
        byte bValue = value(1);
        if (bValue > i2) {
            return -1;
        }
        while (true) {
            if (bValue >= i2 && (i3 & i4) != 0) {
                value(i3);
                setValue(i3, this.unusable);
                updateParentsAlloc(i3);
                return i3;
            }
            i3 <<= 1;
            bValue = value(i3);
            if (bValue > i2) {
                i3 ^= 1;
                bValue = value(i3);
            }
        }
    }

    private long allocateRun(int i2) {
        int iAllocateNode = allocateNode(this.maxOrder - (log2(i2) - this.pageShifts));
        if (iAllocateNode < 0) {
            return iAllocateNode;
        }
        this.freeBytes -= runLength(iAllocateNode);
        return iAllocateNode;
    }

    private long allocateSubpage(int i2) {
        PoolSubpage<T> poolSubpageFindSubpagePoolHead = this.arena.findSubpagePoolHead(i2);
        synchronized (poolSubpageFindSubpagePoolHead) {
            int iAllocateNode = allocateNode(this.maxOrder);
            if (iAllocateNode < 0) {
                return iAllocateNode;
            }
            PoolSubpage<T>[] poolSubpageArr = this.subpages;
            int i3 = this.pageSize;
            this.freeBytes -= i3;
            int iSubpageIdx = subpageIdx(iAllocateNode);
            PoolSubpage<T> poolSubpage = poolSubpageArr[iSubpageIdx];
            if (poolSubpage == null) {
                PoolSubpage<T> poolSubpage2 = new PoolSubpage<>(poolSubpageFindSubpagePoolHead, this, iAllocateNode, runOffset(iAllocateNode), i3, i2);
                poolSubpageArr[iSubpageIdx] = poolSubpage2;
                poolSubpage = poolSubpage2;
            } else {
                poolSubpage.init(poolSubpageFindSubpagePoolHead, i2);
            }
            return poolSubpage.allocate();
        }
    }

    private static int bitmapIdx(long j2) {
        return (int) (j2 >>> 32);
    }

    private byte depth(int i2) {
        return this.depthMap[i2];
    }

    private static int log2(int i2) {
        return 31 - Integer.numberOfLeadingZeros(i2);
    }

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

    private PoolSubpage<T>[] newSubpageArray(int i2) {
        return new PoolSubpage[i2];
    }

    private int runLength(int i2) {
        return 1 << (this.log2ChunkSize - depth(i2));
    }

    private int runOffset(int i2) {
        return ((1 << depth(i2)) ^ i2) * runLength(i2);
    }

    private void setValue(int i2, byte b2) {
        this.memoryMap[i2] = b2;
    }

    private int subpageIdx(int i2) {
        return i2 ^ this.maxSubpageAllocs;
    }

    private void updateParentsAlloc(int i2) {
        while (i2 > 1) {
            int i3 = i2 >>> 1;
            byte bValue = value(i2);
            byte bValue2 = value(i2 ^ 1);
            if (bValue >= bValue2) {
                bValue = bValue2;
            }
            setValue(i3, bValue);
            i2 = i3;
        }
    }

    private void updateParentsFree(int i2) {
        int iDepth = depth(i2) + 1;
        while (i2 > 1) {
            int i3 = i2 >>> 1;
            byte bValue = value(i2);
            byte bValue2 = value(i2 ^ 1);
            iDepth--;
            if (bValue == iDepth && bValue2 == iDepth) {
                setValue(i3, (byte) (iDepth - 1));
            } else {
                if (bValue >= bValue2) {
                    bValue = bValue2;
                }
                setValue(i3, bValue);
            }
            i2 = i3;
        }
    }

    private byte value(int i2) {
        return this.memoryMap[i2];
    }

    long allocate(int i2) {
        return (this.subpageOverflowMask & i2) != 0 ? allocateRun(i2) : allocateSubpage(i2);
    }

    @Override // io.netty.buffer.PoolChunkMetric
    public int chunkSize() {
        return this.chunkSize;
    }

    void free(long j2) {
        int iMemoryMapIdx = memoryMapIdx(j2);
        int iBitmapIdx = bitmapIdx(j2);
        if (iBitmapIdx != 0) {
            PoolSubpage<T> poolSubpage = this.subpages[subpageIdx(iMemoryMapIdx)];
            PoolSubpage<T> poolSubpageFindSubpagePoolHead = this.arena.findSubpagePoolHead(poolSubpage.elemSize);
            synchronized (poolSubpageFindSubpagePoolHead) {
                if (poolSubpage.free(poolSubpageFindSubpagePoolHead, iBitmapIdx & 1073741823)) {
                    return;
                }
            }
        }
        this.freeBytes += runLength(iMemoryMapIdx);
        setValue(iMemoryMapIdx, depth(iMemoryMapIdx));
        updateParentsFree(iMemoryMapIdx);
    }

    @Override // io.netty.buffer.PoolChunkMetric
    public int freeBytes() {
        return this.freeBytes;
    }

    void initBuf(PooledByteBuf<T> pooledByteBuf, long j2, int i2) {
        int iMemoryMapIdx = memoryMapIdx(j2);
        int iBitmapIdx = bitmapIdx(j2);
        if (iBitmapIdx != 0) {
            initBufWithSubpage(pooledByteBuf, j2, iBitmapIdx, i2);
        } else {
            value(iMemoryMapIdx);
            pooledByteBuf.init(this, j2, runOffset(iMemoryMapIdx), i2, runLength(iMemoryMapIdx), this.arena.parent.threadCache());
        }
    }

    void initBufWithSubpage(PooledByteBuf<T> pooledByteBuf, long j2, int i2) {
        initBufWithSubpage(pooledByteBuf, j2, bitmapIdx(j2), i2);
    }

    public String toString() {
        return "Chunk(" + Integer.toHexString(System.identityHashCode(this)) + ": " + usage() + "%, " + (this.chunkSize - this.freeBytes) + '/' + this.chunkSize + ')';
    }

    @Override // io.netty.buffer.PoolChunkMetric
    public int usage() {
        int i2 = this.freeBytes;
        if (i2 == 0) {
            return 100;
        }
        int i3 = (int) ((((long) i2) * 100) / ((long) this.chunkSize));
        if (i3 == 0) {
            return 99;
        }
        return 100 - i3;
    }

    private void initBufWithSubpage(PooledByteBuf<T> pooledByteBuf, long j2, int i2, int i3) {
        int iMemoryMapIdx = memoryMapIdx(j2);
        PoolSubpage<T> poolSubpage = this.subpages[subpageIdx(iMemoryMapIdx)];
        int iRunOffset = runOffset(iMemoryMapIdx);
        int i4 = poolSubpage.elemSize;
        pooledByteBuf.init(this, j2, iRunOffset + ((i2 & 1073741823) * i4), i3, i4, this.arena.parent.threadCache());
    }

    PoolChunk(PoolArena<T> poolArena, T t, int i2) {
        this.unpooled = true;
        this.arena = poolArena;
        this.memory = t;
        this.memoryMap = null;
        this.depthMap = null;
        this.subpages = null;
        this.subpageOverflowMask = 0;
        this.pageSize = 0;
        this.pageShifts = 0;
        this.maxOrder = 0;
        this.unusable = (byte) (1 + 0);
        this.chunkSize = i2;
        this.log2ChunkSize = log2(i2);
        this.maxSubpageAllocs = 0;
    }
}