package io.netty.util.internal.shaded.org.jctools.queues;

import io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue;
import io.netty.util.internal.shaded.org.jctools.util.JvmInfo;
import io.netty.util.internal.shaded.org.jctools.util.UnsafeRefArrayAccess;
import java.util.Objects;

/* JADX INFO: loaded from: classes.dex */
public class MpmcArrayQueue<E> extends MpmcArrayQueueConsumerField<E> implements QueueProgressIndicators {
    static final /* synthetic */ boolean $assertionsDisabled = false;
    static final int RECOMENDED_OFFER_BATCH;
    static final int RECOMENDED_POLL_BATCH;
    long p01;
    long p02;
    long p03;
    long p04;
    long p05;
    long p06;
    long p07;
    long p10;
    long p11;
    long p12;
    long p13;
    long p14;
    long p15;
    long p16;
    long p17;

    static {
        int i = JvmInfo.CPUs;
        RECOMENDED_POLL_BATCH = i * 4;
        RECOMENDED_OFFER_BATCH = i * 4;
    }

    public MpmcArrayQueue(int i) {
        super(validateCapacity(i));
    }

    private static int validateCapacity(int i) {
        if (i >= 2) {
            return i;
        }
        throw new IllegalArgumentException("Minimum size is 2");
    }

    @Override // io.netty.util.internal.shaded.org.jctools.queues.QueueProgressIndicators
    public long currentConsumerIndex() {
        return lvConsumerIndex();
    }

    @Override // io.netty.util.internal.shaded.org.jctools.queues.QueueProgressIndicators
    public long currentProducerIndex() {
        return lvProducerIndex();
    }

    @Override // io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue
    public int drain(MessagePassingQueue.Consumer<E> consumer) {
        int iCapacity = capacity();
        int i = 0;
        while (i < iCapacity) {
            int iDrain = drain(consumer, RECOMENDED_POLL_BATCH);
            if (iDrain == 0) {
                break;
            }
            i += iDrain;
        }
        return i;
    }

    @Override // io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue
    public int fill(MessagePassingQueue.Supplier<E> supplier) {
        int iCapacity = capacity();
        long j = 0;
        do {
            int iFill = fill(supplier, RECOMENDED_OFFER_BATCH);
            if (iFill == 0) {
                return (int) j;
            }
            j += (long) iFill;
        } while (j <= iCapacity);
        return (int) j;
    }

    @Override // java.util.AbstractCollection, java.util.Collection, io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue
    public boolean isEmpty() {
        return lvConsumerIndex() == lvProducerIndex();
    }

    @Override // java.util.Queue, io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue
    public boolean offer(E e2) {
        Objects.requireNonNull(e2);
        long j = this.mask;
        long j2 = j + 1;
        long[] jArr = this.sequenceBuffer;
        long jLvConsumerIndex = Long.MAX_VALUE;
        while (true) {
            long jLvProducerIndex = lvProducerIndex();
            long jCalcSequenceOffset = ConcurrentSequencedCircularArrayQueue.calcSequenceOffset(jLvProducerIndex, j);
            long jLvSequence = lvSequence(jArr, jCalcSequenceOffset);
            if (jLvSequence < jLvProducerIndex) {
                long j3 = jLvProducerIndex - j2;
                if (j3 <= jLvConsumerIndex) {
                    jLvConsumerIndex = lvConsumerIndex();
                    if (j3 <= jLvConsumerIndex) {
                        return false;
                    }
                }
                jLvSequence = jLvProducerIndex + 1;
            }
            if (jLvSequence <= jLvProducerIndex) {
                long j4 = jLvProducerIndex + 1;
                if (casProducerIndex(jLvProducerIndex, j4)) {
                    UnsafeRefArrayAccess.soElement(this.buffer, ConcurrentCircularArrayQueue.calcElementOffset(jLvProducerIndex, j), e2);
                    soSequence(jArr, jCalcSequenceOffset, j4);
                    return true;
                }
            }
        }
    }

    @Override // java.util.Queue, io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue
    public E peek() {
        long jLvConsumerIndex;
        E e2;
        do {
            jLvConsumerIndex = lvConsumerIndex();
            e2 = (E) UnsafeRefArrayAccess.lpElement(this.buffer, calcElementOffset(jLvConsumerIndex));
            if (e2 != null) {
                break;
            }
        } while (jLvConsumerIndex != lvProducerIndex());
        return e2;
    }

    @Override // java.util.Queue, io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue
    public E poll() {
        long[] jArr = this.sequenceBuffer;
        long j = this.mask;
        long jLvProducerIndex = -1;
        while (true) {
            long jLvConsumerIndex = lvConsumerIndex();
            long jCalcSequenceOffset = ConcurrentSequencedCircularArrayQueue.calcSequenceOffset(jLvConsumerIndex, j);
            long jLvSequence = lvSequence(jArr, jCalcSequenceOffset);
            long j2 = jLvConsumerIndex + 1;
            if (jLvSequence < j2) {
                if (jLvConsumerIndex >= jLvProducerIndex) {
                    jLvProducerIndex = lvProducerIndex();
                    if (jLvConsumerIndex == jLvProducerIndex) {
                        return null;
                    }
                }
                jLvSequence = j2 + 1;
            }
            if (jLvSequence <= j2 && casConsumerIndex(jLvConsumerIndex, j2)) {
                long jCalcElementOffset = ConcurrentCircularArrayQueue.calcElementOffset(jLvConsumerIndex, j);
                E e2 = (E) UnsafeRefArrayAccess.lpElement(this.buffer, jCalcElementOffset);
                UnsafeRefArrayAccess.soElement(this.buffer, jCalcElementOffset, null);
                soSequence(jArr, jCalcSequenceOffset, jLvConsumerIndex + j + 1);
                return e2;
            }
        }
    }

    @Override // io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue
    public boolean relaxedOffer(E e2) {
        Objects.requireNonNull(e2);
        long j = this.mask;
        long[] jArr = this.sequenceBuffer;
        while (true) {
            long jLvProducerIndex = lvProducerIndex();
            long jCalcSequenceOffset = ConcurrentSequencedCircularArrayQueue.calcSequenceOffset(jLvProducerIndex, j);
            long jLvSequence = lvSequence(jArr, jCalcSequenceOffset);
            if (jLvSequence < jLvProducerIndex) {
                return false;
            }
            if (jLvSequence <= jLvProducerIndex) {
                long j2 = 1 + jLvProducerIndex;
                if (casProducerIndex(jLvProducerIndex, j2)) {
                    UnsafeRefArrayAccess.soElement(this.buffer, ConcurrentCircularArrayQueue.calcElementOffset(jLvProducerIndex, j), e2);
                    soSequence(jArr, jCalcSequenceOffset, j2);
                    return true;
                }
            }
        }
    }

    @Override // io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue
    public E relaxedPeek() {
        return (E) UnsafeRefArrayAccess.lpElement(this.buffer, calcElementOffset(lvConsumerIndex()));
    }

    @Override // io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue
    public E relaxedPoll() {
        long[] jArr = this.sequenceBuffer;
        long j = this.mask;
        while (true) {
            long jLvConsumerIndex = lvConsumerIndex();
            long jCalcSequenceOffset = ConcurrentSequencedCircularArrayQueue.calcSequenceOffset(jLvConsumerIndex, j);
            long jLvSequence = lvSequence(jArr, jCalcSequenceOffset);
            long j2 = jLvConsumerIndex + 1;
            if (jLvSequence < j2) {
                return null;
            }
            if (jLvSequence <= j2 && casConsumerIndex(jLvConsumerIndex, j2)) {
                long jCalcElementOffset = ConcurrentCircularArrayQueue.calcElementOffset(jLvConsumerIndex, j);
                E e2 = (E) UnsafeRefArrayAccess.lpElement(this.buffer, jCalcElementOffset);
                UnsafeRefArrayAccess.soElement(this.buffer, jCalcElementOffset, null);
                soSequence(jArr, jCalcSequenceOffset, jLvConsumerIndex + j + 1);
                return e2;
            }
        }
    }

    @Override // java.util.AbstractCollection, java.util.Collection, io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue
    public int size() {
        long jLvConsumerIndex = lvConsumerIndex();
        while (true) {
            long jLvProducerIndex = lvProducerIndex();
            long jLvConsumerIndex2 = lvConsumerIndex();
            if (jLvConsumerIndex == jLvConsumerIndex2) {
                return (int) (jLvProducerIndex - jLvConsumerIndex2);
            }
            jLvConsumerIndex = jLvConsumerIndex2;
        }
    }

    /* JADX WARN: Code restructure failed: missing block: B:10:0x002c, code lost:
    
        r2 = io.netty.util.internal.shaded.org.jctools.queues.ConcurrentCircularArrayQueue.calcElementOffset(r0, r9);
        r4 = io.netty.util.internal.shaded.org.jctools.util.UnsafeRefArrayAccess.lpElement(r11, r2);
        io.netty.util.internal.shaded.org.jctools.util.UnsafeRefArrayAccess.soElement(r11, r2, null);
        soSequence(r8, r2, 1 + (r0 + r9));
        r18.accept(r4);
        r12 = r12 + 1;
     */
    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public int drain(io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue.Consumer<E> r18, int r19) {
        /*
            r17 = this;
            r6 = r17
            r7 = r19
            long[] r8 = r6.sequenceBuffer
            long r9 = r6.mask
            E[] r11 = r6.buffer
            r0 = 0
            r12 = r0
        Lc:
            if (r12 >= r7) goto L4e
        Le:
            long r0 = r17.lvConsumerIndex()
            long r2 = io.netty.util.internal.shaded.org.jctools.queues.ConcurrentSequencedCircularArrayQueue.calcSequenceOffset(r0, r9)
            long r4 = r6.lvSequence(r8, r2)
            r13 = 1
            r15 = r2
            long r2 = r0 + r13
            int r4 = (r4 > r2 ? 1 : (r4 == r2 ? 0 : -1))
            if (r4 >= 0) goto L24
            return r12
        L24:
            if (r4 > 0) goto L4b
            boolean r2 = r6.casConsumerIndex(r0, r2)
            if (r2 == 0) goto L4b
            long r2 = io.netty.util.internal.shaded.org.jctools.queues.ConcurrentCircularArrayQueue.calcElementOffset(r0, r9)
            java.lang.Object r4 = io.netty.util.internal.shaded.org.jctools.util.UnsafeRefArrayAccess.lpElement(r11, r2)
            r5 = 0
            io.netty.util.internal.shaded.org.jctools.util.UnsafeRefArrayAccess.soElement(r11, r2, r5)
            long r0 = r0 + r9
            long r13 = r13 + r0
            r0 = r17
            r1 = r8
            r2 = r15
            r15 = r4
            r4 = r13
            r0.soSequence(r1, r2, r4)
            r0 = r18
            r0.accept(r15)
            int r12 = r12 + 1
            goto Lc
        L4b:
            r0 = r18
            goto Le
        L4e:
            return r7
        */
        throw new UnsupportedOperationException("Method not decompiled: io.netty.util.internal.shaded.org.jctools.queues.MpmcArrayQueue.drain(io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue$Consumer, int):int");
    }

    /* JADX WARN: Code restructure failed: missing block: B:10:0x0026, code lost:
    
        io.netty.util.internal.shaded.org.jctools.util.UnsafeRefArrayAccess.soElement(r9, io.netty.util.internal.shaded.org.jctools.queues.ConcurrentCircularArrayQueue.calcElementOffset(r0, r7), r13.get());
        soSequence(r6, r2, r4);
        r10 = r10 + 1;
     */
    @Override // io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public int fill(io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue.Supplier<E> r13, int r14) {
        /*
            r12 = this;
            long[] r6 = r12.sequenceBuffer
            long r7 = r12.mask
            E[] r9 = r12.buffer
            r0 = 0
            r10 = r0
        L8:
            if (r10 >= r14) goto L39
        La:
            long r0 = r12.lvProducerIndex()
            long r2 = io.netty.util.internal.shaded.org.jctools.queues.ConcurrentSequencedCircularArrayQueue.calcSequenceOffset(r0, r7)
            long r4 = r12.lvSequence(r6, r2)
            int r4 = (r4 > r0 ? 1 : (r4 == r0 ? 0 : -1))
            if (r4 >= 0) goto L1b
            return r10
        L1b:
            if (r4 > 0) goto La
            r4 = 1
            long r4 = r4 + r0
            boolean r11 = r12.casProducerIndex(r0, r4)
            if (r11 == 0) goto La
            long r0 = io.netty.util.internal.shaded.org.jctools.queues.ConcurrentCircularArrayQueue.calcElementOffset(r0, r7)
            java.lang.Object r11 = r13.get()
            io.netty.util.internal.shaded.org.jctools.util.UnsafeRefArrayAccess.soElement(r9, r0, r11)
            r0 = r12
            r1 = r6
            r0.soSequence(r1, r2, r4)
            int r10 = r10 + 1
            goto L8
        L39:
            return r14
        */
        throw new UnsupportedOperationException("Method not decompiled: io.netty.util.internal.shaded.org.jctools.queues.MpmcArrayQueue.fill(io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue$Supplier, int):int");
    }

    @Override // io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue
    public void fill(MessagePassingQueue.Supplier<E> supplier, MessagePassingQueue.WaitStrategy waitStrategy, MessagePassingQueue.ExitCondition exitCondition) {
        while (true) {
            int iIdle = 0;
            while (exitCondition.keepRunning()) {
                if (fill(supplier, RECOMENDED_OFFER_BATCH) == 0) {
                    iIdle = waitStrategy.idle(iIdle);
                }
            }
            return;
        }
    }

    @Override // io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue
    public void drain(MessagePassingQueue.Consumer<E> consumer, MessagePassingQueue.WaitStrategy waitStrategy, MessagePassingQueue.ExitCondition exitCondition) {
        while (true) {
            int iIdle = 0;
            while (exitCondition.keepRunning()) {
                if (drain(consumer, RECOMENDED_POLL_BATCH) == 0) {
                    iIdle = waitStrategy.idle(iIdle);
                }
            }
            return;
        }
    }
}