Class IoUringBufferRing

java.lang.Object
io.netty.channel.uring.IoUringBufferRing
final class IoUringBufferRing extends java.lang.Object

  • Field Details

    • SHORT_HANDLE

      private static final VarHandle SHORT_HANDLE

    • ioUringBufRing

      private final java.nio.ByteBuffer ioUringBufRing

    • tailFieldPosition

      private final int tailFieldPosition

    • entries

      private final short entries

    • mask

      private final short mask

    • bufferGroupId

      private final short bufferGroupId

    • ringFd

      private final int ringFd

    • buffers

      private final ByteBuf[] buffers

    • allocator

      private final IoUringBufferRingAllocator allocator

    • batchAllocation

      private final boolean batchAllocation

    • exhaustedEvent

      private final IoUringBufferRingExhaustedEvent exhaustedEvent

    • ringConsumer

      private final IoUringBufferRing.RingConsumer ringConsumer

    • incremental

      private final boolean incremental

    • batchSize

      private final int batchSize

    • corrupted

      private boolean corrupted

    • closed

      private boolean closed

    • usableBuffers

      private int usableBuffers

    • allocatedBuffers

      private int allocatedBuffers

    • needExpand

      private boolean needExpand

    • lastGeneratedBid

      private short lastGeneratedBid

  • Constructor Details

    • IoUringBufferRing

      IoUringBufferRing(int ringFd, java.nio.ByteBuffer ioUringBufRing, short entries, int batchSize, short bufferGroupId, boolean incremental, IoUringBufferRingAllocator allocator, boolean batchAllocation)

  • Method Details

    • isUsable

      boolean isUsable()

    • initialize

      void initialize()

    • expand

      boolean expand()
      Try to expand by adding more buffers to the ring if there is any space left, this will be done lazy.
      Returns:
      true if we can expand the number of buffers in the ring, false otherwise.

    • fill

      private void fill(short startBid, int buffers)

    • fill

      private void fill(short bid)

    • getExhaustedEvent

      IoUringBufferRingExhaustedEvent getExhaustedEvent()
      Returns:
      the IoUringBufferRingExhaustedEvent that should be used to signal that there were no buffers left for this buffer ring.

    • attemptedBytesRead

      int attemptedBytesRead(short bid)
      Return the amount of bytes that we attempted to read for the given id. This method must be called before useBuffer(short, int, boolean).
      Parameters:
      bid - the id of the buffer.
      Returns:
      the attempted bytes.

    • calculateNextBufferBatch

      private int calculateNextBufferBatch()

    • useBuffer

      ByteBuf useBuffer(short bid, int read, boolean more)
      Use the buffer for the given buffer id. The returned ByteBuf must be released once not used anymore.
      Parameters:
      bid - the id of the buffer
      read - the number of bytes that could be read. This value might be larger then what a single ByteBuf can hold. Because of this, the caller should call

    • allocatedBuffers

      int allocatedBuffers()
      The number of buffers that are currently allocated (and so posted) in this buffer ring. This value can change every time useBuffer(short, int, boolean) is called as it might grow the ring. Because of this, callers that need to walk a sequence of consecutive buffer ids that belong to the same completion (for example a IORING_RECVSEND_BUNDLE completion) must capture this value before calling useBuffer(short, int, boolean) and pass it to nextBid(short, int) afterwards, so the wrap-around is computed using the size of the ring as the kernel observed it when it produced the bundle, not the (possibly already grown) size afterwards.
      Returns:
      the number of allocated buffers.

    • nextBid

      short nextBid(short bid, int allocatedBuffers)
      Return the next buffer id that follows bid in ring order, wrapping around after allocatedBuffers ids.
      Parameters:
      bid - the current buffer id.
      allocatedBuffers - the number of allocated buffers to use for the wrap-around computation. This should be a value obtained from allocatedBuffers() before the corresponding useBuffer(short, int, boolean) call for bid, as that call might have grown the ring already.
      Returns:
      the next buffer id.

    • bufferGroupId

      short bufferGroupId()
      The group id that is assigned to this buffer ring.
      Returns:
      group id.

    • close

      void close()
      Close this IoUringBufferRing, using it after this method is called will lead to undefined behaviour.