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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    void free(long j) {
        int iMemoryMapIdx = memoryMapIdx(j);
        int iBitmapIdx = bitmapIdx(j);
        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 j, int i) {
        int iMemoryMapIdx = memoryMapIdx(j);
        int iBitmapIdx = bitmapIdx(j);
        if (iBitmapIdx != 0) {
            initBufWithSubpage(pooledByteBuf, j, iBitmapIdx, i);
        } else {
            value(iMemoryMapIdx);
            pooledByteBuf.init(this, j, runOffset(iMemoryMapIdx), i, runLength(iMemoryMapIdx), this.arena.parent.threadCache());
        }
    }

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

    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 i = this.freeBytes;
        if (i == 0) {
            return 100;
        }
        int i2 = (int) ((((long) i) * 100) / ((long) this.chunkSize));
        if (i2 == 0) {
            return 99;
        }
        return 100 - i2;
    }

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

    PoolChunk(PoolArena<T> poolArena, T t, int i) {
        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 = i;
        this.log2ChunkSize = log2(i);
        this.maxSubpageAllocs = 0;
    }
}