IovArray Class — netty Architecture

Source Code

transport-native-unix-common/src/main/java/io/netty/channel/unix/IovArray.java lines 49–314

public final class IovArray implements MessageProcessor {

    /** The size of an address which should be 8 for 64 bits and 4 for 32 bits. */
    private static final int ADDRESS_SIZE = Buffer.addressSize();

    /**
     * The size of an {@code iovec} struct in bytes. This is calculated as we have 2 entries each of the size of the
     * address.
     */
    public static final int IOV_SIZE = 2 * ADDRESS_SIZE;

    /**
     * The needed memory to hold up to {@code IOV_MAX} iov entries, where {@code IOV_MAX} signified
     * the maximum number of {@code iovec} structs that can be passed to {@code writev(...)}.
     */
    private static final int MAX_CAPACITY = IOV_MAX * IOV_SIZE;

    private final long memoryAddress;
    private final ByteBuf memory;
    private final CleanableDirectBuffer cleanable;
    private int count;
    private long size;
    private long maxBytes = SSIZE_MAX;
    private int maxCount;

    /**
     * @deprecated Use {@link #IovArray(int)} instead.
     */
    @Deprecated
    public IovArray() {
        this(IOV_MAX);
    }

    /**
     * Allocate an IovArray with enough room for the given number of <strong>entries</strong> (not bytes).
     * @param numEntries The desired number of entries in the IovArray.
     */
    @SuppressWarnings("deprecation")
    public IovArray(int numEntries) {
        int sizeBytes = Math.multiplyExact(checkPositive(numEntries, "numEntries"), IOV_SIZE);
        cleanable = Buffer.allocateDirectBufferWithNativeOrder(sizeBytes);
        ByteBuf bbuf = Unpooled.wrappedBuffer(cleanable.buffer()).setIndex(0, 0);
        memory = PlatformDependent.hasUnsafe() ? bbuf : bbuf.order(
                PlatformDependent.BIG_ENDIAN_NATIVE_ORDER ? ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN);
        if (memory.hasMemoryAddress()) {
            memoryAddress = memory.memoryAddress();
        } else {
            // Fallback to using JNI as we were not be able to access the address otherwise.

            // Use internalNioBuffer to reduce object creation.
            // It is important to add the position as the returned ByteBuffer might be shared by multiple ByteBuf
            // instances and so has an address that starts before the start of the ByteBuf itself.
            ByteBuffer byteBuffer = memory.internalNioBuffer(0, memory.capacity());
            memoryAddress = Buffer.memoryAddress(byteBuffer) + byteBuffer.position();
        }
        maxCount = IOV_MAX;
    }

    /**
     * @param memory The underlying memory.
     * @deprecated Use {@link #IovArray(int)} instead.
     */
    @Deprecated
    public IovArray(ByteBuf memory) {
        assert memory.writerIndex() == 0;
        assert memory.readerIndex() == 0;
        this.memory = PlatformDependent.hasUnsafe() ? memory : memory.order(
                PlatformDependent.BIG_ENDIAN_NATIVE_ORDER ? ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN);
        if (memory.hasMemoryAddress()) {
            memoryAddress = memory.memoryAddress();
        } else {
            // Fallback to using JNI as we were not be able to access the address otherwise.

            // Use internalNioBuffer to reduce object creation.
            // It is important to add the position as the returned ByteBuffer might be shared by multiple ByteBuf
            // instances and so has an address that starts before the start of the ByteBuf itself.
            ByteBuffer byteBuffer = memory.internalNioBuffer(0, memory.capacity());
            memoryAddress = Buffer.memoryAddress(byteBuffer) + byteBuffer.position();
        }
        cleanable = null;
        maxCount = IOV_MAX;