andreacavalli/netty-incubator-buffer-api
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Implement Composite buffers

Browse Source 
Motivation:
Composite buffers make it possible to combine the data from multiple buffers and present them as one, without copying the contents. Each access primitive has slightly higher overhead, though, so it is encouraged to make measurements before decided whether to compose or copy.

Modification:
A CompositeBuf implementation has been added, along with a Buf#compose factory method.
The composite buffer behaves exactly the same as non-composed buffers.
This commit is contained in:
Chris Vest 2020-10-28 14:38:14 +01:00
parent 7f9ed7dec7
commit 6d4ad29149
26 changed files with 1962 additions and 666 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
buffer/src/main/java/io/netty/buffer/b2/Allocator.java
View File

@ -5,7 +5,7 @@
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
@ -73,7 +73,7 @@ public interface Allocator extends AutoCloseable {
@Override
public Buf allocate(long size) {
checkSize(size);
return man.allocateConfined(size, man.drop());
return man.allocateConfined(size, man.drop(), null);
}
};
}
@ -84,7 +84,7 @@ public interface Allocator extends AutoCloseable {
@Override
public Buf allocate(long size) {
checkSize(size);
return man.allocateConfined(size, man.drop());
return man.allocateConfined(size, man.drop(), null);
}
};
}
@ -95,9 +95,7 @@ public interface Allocator extends AutoCloseable {
@Override
public Buf allocate(long size) {
checkSize(size);
var buf = man.allocateConfined(size, man.drop());
man.registerCleaner(buf, Statics.CLEANER);
return buf;
return man.allocateConfined(size, man.drop(), Statics.CLEANER);
}
};
}

652
buffer/src/main/java/io/netty/buffer/b2/Buf.java
View File

@ -5,7 +5,7 @@
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
@ -20,7 +20,52 @@ import java.nio.ByteOrder;
/**
* A reference counted buffer API with separate reader and writer indexes.
*/
public interface Buf extends Rc<Buf> {
public interface Buf extends Rc<Buf>, BufAccessors {
/**
* Compose the given sequence of buffers and present them as a single buffer.
* <p>
* <strong>Note:</strong> The composite buffer increments the reference count on all the constituent buffers,
* and holds a reference to them until the composite buffer is deallocated.
* This means the constituent buffers must still have their outside-reference count decremented as normal.
* If the buffers are allocated for the purpose of participating in the composite buffer,
* then they should be closed as soon as the composite buffer has been created, like in this example:
* <pre>{@code
* try (Buf a = allocator.allocate(size);
* Buf b = allocator.allocate(size)) {
* return Buf.compose(a, b); // Reference counts for 'a' and 'b' incremented here.
* } // Reference count for 'a' and 'b' decremented here; composite buffer now holds the last references.
* }</pre>
* <p>
* {@linkplain #send() Sending} a composite buffer implies sending all of its constituent buffers.
* <p>
* All of the constituent buffers must have the same {@linkplain #order() byte order}.
* An exception will be thrown if you attempt to compose buffers that have different byte orders,
* and changing the byte order of the constituent buffers so they become inconsistent after construction,
* will result in unspecified behaviour.
* <p>
* The read and write offsets of the constituent buffers must be arranged such that there are no "gaps" when viewed
* as a single connected chunk of memory.
* Specifically, there can be at most one buffer whose write offset is neither zero nor at capacity,
* and all buffers prior to it must have their write indexes at capacity, and all buffers after it must have a write
* offset of zero.
* Likewise, there can be at most one buffer whose read offset is neither zero nor at capacity,
* and all buffers prior to it must have their read indexes at capacity, and all buffers after it must have a read
* offset of zero.
* Furthermore, the sum of the read offsets must be less than or equal to the sum of the write offsets.
* <p>
* Reads and writes to the composite buffer that modifies the read or write offsets, will also modify the relevant
* offsets in the constituent buffers.
* <p>
* It is not a requirement that the buffers have the same size.
*
* @param bufs The buffers to compose into a single buffer view.
* @return A buffer composed of, and backed by, the given buffers.
* @throws IllegalArgumentException if the given buffers have an inconsistent {@linkplain #order() byte order}.
*/
static Buf compose(Buf... bufs) {
return new CompositeBuf(bufs);
}
/**
* Change the default byte order of this buffer, and return this buffer.
*
@ -79,12 +124,16 @@ public interface Buf extends Rc<Buf> {
/**
* Returns the number of readable bytes which is equal to {@code (writerIndex() - readerIndex())}.
*/
int readableBytes();
default int readableBytes() {
return writerIndex() - readerIndex();
}
/**
* Returns the number of writable bytes which is equal to {@code (capacity() - writerIndex())}.
*/
int writableBytes();
default int writableBytes() {
return capacity() - writerIndex();
}
/**
* Fill the buffer with the given byte value. This method does not respect the {@link #readerIndex()} or {@link
@ -106,7 +155,7 @@ public interface Buf extends Rc<Buf> {
byte[] copy();
/**
* Give the native memory address backing this buffer, or return 0 if this is a heap backed buffer.
* Give the native memory address backing this buffer, or return 0 if this buffer has no native memory address.
* @return The native memory address, if any, otherwise 0.
*/
long getNativeAddress();
@ -141,597 +190,4 @@ public interface Buf extends Rc<Buf> {
* that is a view of the given region of this buffer.
*/
Buf slice(int offset, int length);
// ### CODEGEN START primitive accessors interface
// <editor-fold defaultstate="collapsed" desc="Generated primitive accessors interface.">
/**
* Get the byte value at the current {@link Buf#readerIndex()},
* and increases the reader offset by {@link Byte#BYTES}.
* The value is read using a two's complement 8-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @return The byte value at the current reader offset.
* @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Byte#BYTES}.
*/
byte readByte();
/**
* Get the byte value at the given reader offset.
* The {@link Buf#readerIndex()} is not modified.
* The value is read using a two's complement 8-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @param roff The read offset, an absolute index into this buffer, to read from.
* @return The byte value at the given offset.
* @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Byte#BYTES}.
*/
byte readByte(int roff);
/**
* Get the unsigned byte value at the current {@link Buf#readerIndex()},
* and increases the reader offset by {@link Byte#BYTES}.
* The value is read using an unsigned two's complement 8-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @return The unsigned byte value at the current reader offset.
* @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Byte#BYTES}.
*/
int readUnsignedByte();
/**
* Get the unsigned byte value at the given reader offset.
* The {@link Buf#readerIndex()} is not modified.
* The value is read using an unsigned two's complement 8-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @param roff The read offset, an absolute index into this buffer, to read from.
* @return The unsigned byte value at the given offset.
* @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Byte#BYTES}.
*/
int readUnsignedByte(int roff);
/**
* Set the given byte value at the current {@link Buf#writerIndex()},
* and increase the writer offset by {@link Byte#BYTES}.
* The value is written using a two's complement 8-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @param value The byte value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Byte#BYTES}.
*/
Buf writeByte(byte value);
/**
* Set the given byte value at the given write offset. The {@link Buf#writerIndex()} is not modified.
* The value is written using a two's complement 8-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @param woff The write offset, an absolute index into this buffer to write to.
* @param value The byte value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Byte#BYTES}.
*/
Buf writeByte(int woff, byte value);
/**
* Set the given unsigned byte value at the current {@link Buf#writerIndex()},
* and increase the writer offset by {@link Byte#BYTES}.
* The value is written using an unsigned two's complement 8-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @param value The int value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Byte#BYTES}.
*/
Buf writeUnsignedByte(int value);
/**
* Set the given unsigned byte value at the given write offset. The {@link Buf#writerIndex()} is not modified.
* The value is written using an unsigned two's complement 8-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @param woff The write offset, an absolute index into this buffer to write to.
* @param value The int value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Byte#BYTES}.
*/
Buf writeUnsignedByte(int woff, int value);
/**
* Get the char value at the current {@link Buf#readerIndex()},
* and increases the reader offset by 2.
* The value is read using a 2-byte UTF-16 encoding,
* with the {@link #order() configured} default byte order.
*
* @return The char value at the current reader offset.
* @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than 2.
*/
char readChar();
/**
* Get the char value at the given reader offset.
* The {@link Buf#readerIndex()} is not modified.
* The value is read using a 2-byte UTF-16 encoding,
* with the {@link #order() configured} default byte order.
*
* @param roff The read offset, an absolute index into this buffer, to read from.
* @return The char value at the given offset.
* @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus 2.
*/
char readChar(int roff);
/**
* Set the given char value at the current {@link Buf#writerIndex()},
* and increase the writer offset by 2.
* The value is written using a 2-byte UTF-16 encoding,
* with the {@link #order() configured} default byte order.
*
* @param value The char value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than 2.
*/
Buf writeChar(char value);
/**
* Set the given char value at the given write offset. The {@link Buf#writerIndex()} is not modified.
* The value is written using a 2-byte UTF-16 encoding,
* with the {@link #order() configured} default byte order.
*
* @param woff The write offset, an absolute index into this buffer to write to.
* @param value The char value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus 2.
*/
Buf writeChar(int woff, char value);
/**
* Get the short value at the current {@link Buf#readerIndex()},
* and increases the reader offset by {@link Short#BYTES}.
* The value is read using a two's complement 16-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @return The short value at the current reader offset.
* @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Short#BYTES}.
*/
short readShort();
/**
* Get the short value at the given reader offset.
* The {@link Buf#readerIndex()} is not modified.
* The value is read using a two's complement 16-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @param roff The read offset, an absolute index into this buffer, to read from.
* @return The short value at the given offset.
* @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Short#BYTES}.
*/
short readShort(int roff);
/**
* Get the unsigned short value at the current {@link Buf#readerIndex()},
* and increases the reader offset by {@link Short#BYTES}.
* The value is read using an unsigned two's complement 16-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @return The unsigned short value at the current reader offset.
* @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Short#BYTES}.
*/
int readUnsignedShort();
/**
* Get the unsigned short value at the given reader offset.
* The {@link Buf#readerIndex()} is not modified.
* The value is read using an unsigned two's complement 16-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @param roff The read offset, an absolute index into this buffer, to read from.
* @return The unsigned short value at the given offset.
* @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Short#BYTES}.
*/
int readUnsignedShort(int roff);
/**
* Set the given short value at the current {@link Buf#writerIndex()},
* and increase the writer offset by {@link Short#BYTES}.
* The value is written using a two's complement 16-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @param value The short value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Short#BYTES}.
*/
Buf writeShort(short value);
/**
* Set the given short value at the given write offset. The {@link Buf#writerIndex()} is not modified.
* The value is written using a two's complement 16-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @param woff The write offset, an absolute index into this buffer to write to.
* @param value The short value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Short#BYTES}.
*/
Buf writeShort(int woff, short value);
/**
* Set the given unsigned short value at the current {@link Buf#writerIndex()},
* and increase the writer offset by {@link Short#BYTES}.
* The value is written using an unsigned two's complement 16-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @param value The int value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Short#BYTES}.
*/
Buf writeUnsignedShort(int value);
/**
* Set the given unsigned short value at the given write offset. The {@link Buf#writerIndex()} is not modified.
* The value is written using an unsigned two's complement 16-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @param woff The write offset, an absolute index into this buffer to write to.
* @param value The int value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Short#BYTES}.
*/
Buf writeUnsignedShort(int woff, int value);
/**
* Get the int value at the current {@link Buf#readerIndex()},
* and increases the reader offset by 3.
* The value is read using a two's complement 24-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @return The int value at the current reader offset.
* @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than 3.
*/
int readMedium();
/**
* Get the int value at the given reader offset.
* The {@link Buf#readerIndex()} is not modified.
* The value is read using a two's complement 24-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @param roff The read offset, an absolute index into this buffer, to read from.
* @return The int value at the given offset.
* @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus 3.
*/
int readMedium(int roff);
/**
* Get the unsigned int value at the current {@link Buf#readerIndex()},
* and increases the reader offset by 3.
* The value is read using an unsigned two's complement 24-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @return The unsigned int value at the current reader offset.
* @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than 3.
*/
int readUnsignedMedium();
/**
* Get the unsigned int value at the given reader offset.
* The {@link Buf#readerIndex()} is not modified.
* The value is read using an unsigned two's complement 24-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @param roff The read offset, an absolute index into this buffer, to read from.
* @return The unsigned int value at the given offset.
* @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus 3.
*/
int readUnsignedMedium(int roff);
/**
* Set the given int value at the current {@link Buf#writerIndex()},
* and increase the writer offset by 3.
* The value is written using a two's complement 24-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @param value The int value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than 3.
*/
Buf writeMedium(int value);
/**
* Set the given int value at the given write offset. The {@link Buf#writerIndex()} is not modified.
* The value is written using a two's complement 24-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @param woff The write offset, an absolute index into this buffer to write to.
* @param value The int value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus 3.
*/
Buf writeMedium(int woff, int value);
/**
* Set the given unsigned int value at the current {@link Buf#writerIndex()},
* and increase the writer offset by 3.
* The value is written using an unsigned two's complement 24-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @param value The int value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than 3.
*/
Buf writeUnsignedMedium(int value);
/**
* Set the given unsigned int value at the given write offset. The {@link Buf#writerIndex()} is not modified.
* The value is written using an unsigned two's complement 24-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @param woff The write offset, an absolute index into this buffer to write to.
* @param value The int value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus 3.
*/
Buf writeUnsignedMedium(int woff, int value);
/**
* Get the int value at the current {@link Buf#readerIndex()},
* and increases the reader offset by {@link Integer#BYTES}.
* The value is read using a two's complement 32-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @return The int value at the current reader offset.
* @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Integer#BYTES}.
*/
int readInt();
/**
* Get the int value at the given reader offset.
* The {@link Buf#readerIndex()} is not modified.
* The value is read using a two's complement 32-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @param roff The read offset, an absolute index into this buffer, to read from.
* @return The int value at the given offset.
* @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Integer#BYTES}.
*/
int readInt(int roff);
/**
* Get the unsigned int value at the current {@link Buf#readerIndex()},
* and increases the reader offset by {@link Integer#BYTES}.
* The value is read using an unsigned two's complement 32-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @return The unsigned int value at the current reader offset.
* @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Integer#BYTES}.
*/
long readUnsignedInt();
/**
* Get the unsigned int value at the given reader offset.
* The {@link Buf#readerIndex()} is not modified.
* The value is read using an unsigned two's complement 32-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @param roff The read offset, an absolute index into this buffer, to read from.
* @return The unsigned int value at the given offset.
* @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Integer#BYTES}.
*/
long readUnsignedInt(int roff);
/**
* Set the given int value at the current {@link Buf#writerIndex()},
* and increase the writer offset by {@link Integer#BYTES}.
* The value is written using a two's complement 32-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @param value The int value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Integer#BYTES}.
*/
Buf writeInt(int value);
/**
* Set the given int value at the given write offset. The {@link Buf#writerIndex()} is not modified.
* The value is written using a two's complement 32-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @param woff The write offset, an absolute index into this buffer to write to.
* @param value The int value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Integer#BYTES}.
*/
Buf writeInt(int woff, int value);
/**
* Set the given unsigned int value at the current {@link Buf#writerIndex()},
* and increase the writer offset by {@link Integer#BYTES}.
* The value is written using an unsigned two's complement 32-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @param value The long value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Integer#BYTES}.
*/
Buf writeUnsignedInt(long value);
/**
* Set the given unsigned int value at the given write offset. The {@link Buf#writerIndex()} is not modified.
* The value is written using an unsigned two's complement 32-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @param woff The write offset, an absolute index into this buffer to write to.
* @param value The long value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Integer#BYTES}.
*/
Buf writeUnsignedInt(int woff, long value);
/**
* Get the float value at the current {@link Buf#readerIndex()},
* and increases the reader offset by {@link Float#BYTES}.
* The value is read using a 32-bit IEEE floating point encoding,
* with the {@link #order() configured} default byte order.
*
* @return The float value at the current reader offset.
* @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Float#BYTES}.
*/
float readFloat();
/**
* Get the float value at the given reader offset.
* The {@link Buf#readerIndex()} is not modified.
* The value is read using a 32-bit IEEE floating point encoding,
* with the {@link #order() configured} default byte order.
*
* @param roff The read offset, an absolute index into this buffer, to read from.
* @return The float value at the given offset.
* @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Float#BYTES}.
*/
float readFloat(int roff);
/**
* Set the given float value at the current {@link Buf#writerIndex()},
* and increase the writer offset by {@link Float#BYTES}.
* The value is written using a 32-bit IEEE floating point encoding,
* with the {@link #order() configured} default byte order.
*
* @param value The float value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Float#BYTES}.
*/
Buf writeFloat(float value);
/**
* Set the given float value at the given write offset. The {@link Buf#writerIndex()} is not modified.
* The value is written using a 32-bit IEEE floating point encoding,
* with the {@link #order() configured} default byte order.
*
* @param woff The write offset, an absolute index into this buffer to write to.
* @param value The float value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Float#BYTES}.
*/
Buf writeFloat(int woff, float value);
/**
* Get the long value at the current {@link Buf#readerIndex()},
* and increases the reader offset by {@link Long#BYTES}.
* The value is read using a two's complement 64-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @return The long value at the current reader offset.
* @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Long#BYTES}.
*/
long readLong();
/**
* Get the long value at the given reader offset.
* The {@link Buf#readerIndex()} is not modified.
* The value is read using a two's complement 64-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @param roff The read offset, an absolute index into this buffer, to read from.
* @return The long value at the given offset.
* @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Long#BYTES}.
*/
long readLong(int roff);
/**
* Set the given long value at the current {@link Buf#writerIndex()},
* and increase the writer offset by {@link Long#BYTES}.
* The value is written using a two's complement 64-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @param value The long value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Long#BYTES}.
*/
Buf writeLong(long value);
/**
* Set the given long value at the given write offset. The {@link Buf#writerIndex()} is not modified.
* The value is written using a two's complement 64-bit encoding,
* with the {@link #order() configured} default byte order.
*
* @param woff The write offset, an absolute index into this buffer to write to.
* @param value The long value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Long#BYTES}.
*/
Buf writeLong(int woff, long value);
/**
* Get the double value at the current {@link Buf#readerIndex()},
* and increases the reader offset by {@link Double#BYTES}.
* The value is read using a 64-bit IEEE floating point encoding,
* with the {@link #order() configured} default byte order.
*
* @return The double value at the current reader offset.
* @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Double#BYTES}.
*/
double readDouble();
/**
* Get the double value at the given reader offset.
* The {@link Buf#readerIndex()} is not modified.
* The value is read using a 64-bit IEEE floating point encoding,
* with the {@link #order() configured} default byte order.
*
* @param roff The read offset, an absolute index into this buffer, to read from.
* @return The double value at the given offset.
* @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Double#BYTES}.
*/
double readDouble(int roff);
/**
* Set the given double value at the current {@link Buf#writerIndex()},
* and increase the writer offset by {@link Double#BYTES}.
* The value is written using a 64-bit IEEE floating point encoding,
* with the {@link #order() configured} default byte order.
*
* @param value The double value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Double#BYTES}.
*/
Buf writeDouble(double value);
/**
* Set the given double value at the given write offset. The {@link Buf#writerIndex()} is not modified.
* The value is written using a 64-bit IEEE floating point encoding,
* with the {@link #order() configured} default byte order.
*
* @param woff The write offset, an absolute index into this buffer to write to.
* @param value The double value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Double#BYTES}.
*/
Buf writeDouble(int woff, double value);
// </editor-fold>
// ### CODEGEN END primitive accessors interface
}

616
buffer/src/main/java/io/netty/buffer/b2/BufAccessors.java Normal file
View File

@ -0,0 +1,616 @@
/*
* Copyright 2020 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package io.netty.buffer.b2;
/**
* This interface is just the primitive data accessor methods that {@link Buf} exposes.
* It can be useful if you only need the data access methods, and perhaps wish to decorate or modify their behaviour.
* Usually, you'd use the {@link Buf} interface directly, since this lets you properly control the buffer reference count.
*/
public interface BufAccessors {
// ### CODEGEN START primitive accessors interface
// <editor-fold defaultstate="collapsed" desc="Generated primitive accessors interface.">
/**
* Get the byte value at the current {@link Buf#readerIndex()},
* and increases the reader offset by {@link Byte#BYTES}.
* The value is read using a two's complement 8-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @return The byte value at the current reader offset.
* @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Byte#BYTES}.
*/
byte readByte();
/**
* Get the byte value at the given reader offset.
* The {@link Buf#readerIndex()} is not modified.
* The value is read using a two's complement 8-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param roff The read offset, an absolute index into this buffer, to read from.
* @return The byte value at the given offset.
* @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Byte#BYTES}.
*/
byte readByte(int roff);
/**
* Get the unsigned byte value at the current {@link Buf#readerIndex()},
* and increases the reader offset by {@link Byte#BYTES}.
* The value is read using an unsigned two's complement 8-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @return The unsigned byte value at the current reader offset.
* @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Byte#BYTES}.
*/
int readUnsignedByte();
/**
* Get the unsigned byte value at the given reader offset.
* The {@link Buf#readerIndex()} is not modified.
* The value is read using an unsigned two's complement 8-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param roff The read offset, an absolute index into this buffer, to read from.
* @return The unsigned byte value at the given offset.
* @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Byte#BYTES}.
*/
int readUnsignedByte(int roff);
/**
* Set the given byte value at the current {@link Buf#writerIndex()},
* and increase the writer offset by {@link Byte#BYTES}.
* The value is written using a two's complement 8-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param value The byte value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Byte#BYTES}.
*/
Buf writeByte(byte value);
/**
* Set the given byte value at the given write offset. The {@link Buf#writerIndex()} is not modified.
* The value is written using a two's complement 8-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param woff The write offset, an absolute index into this buffer to write to.
* @param value The byte value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Byte#BYTES}.
*/
Buf writeByte(int woff, byte value);
/**
* Set the given unsigned byte value at the current {@link Buf#writerIndex()},
* and increase the writer offset by {@link Byte#BYTES}.
* The value is written using an unsigned two's complement 8-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param value The int value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Byte#BYTES}.
*/
Buf writeUnsignedByte(int value);
/**
* Set the given unsigned byte value at the given write offset. The {@link Buf#writerIndex()} is not modified.
* The value is written using an unsigned two's complement 8-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param woff The write offset, an absolute index into this buffer to write to.
* @param value The int value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Byte#BYTES}.
*/
Buf writeUnsignedByte(int woff, int value);
/**
* Get the char value at the current {@link Buf#readerIndex()},
* and increases the reader offset by 2.
* The value is read using a 2-byte UTF-16 encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @return The char value at the current reader offset.
* @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than 2.
*/
char readChar();
/**
* Get the char value at the given reader offset.
* The {@link Buf#readerIndex()} is not modified.
* The value is read using a 2-byte UTF-16 encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param roff The read offset, an absolute index into this buffer, to read from.
* @return The char value at the given offset.
* @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus 2.
*/
char readChar(int roff);
/**
* Set the given char value at the current {@link Buf#writerIndex()},
* and increase the writer offset by 2.
* The value is written using a 2-byte UTF-16 encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param value The char value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than 2.
*/
Buf writeChar(char value);
/**
* Set the given char value at the given write offset. The {@link Buf#writerIndex()} is not modified.
* The value is written using a 2-byte UTF-16 encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param woff The write offset, an absolute index into this buffer to write to.
* @param value The char value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus 2.
*/
Buf writeChar(int woff, char value);
/**
* Get the short value at the current {@link Buf#readerIndex()},
* and increases the reader offset by {@link Short#BYTES}.
* The value is read using a two's complement 16-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @return The short value at the current reader offset.
* @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Short#BYTES}.
*/
short readShort();
/**
* Get the short value at the given reader offset.
* The {@link Buf#readerIndex()} is not modified.
* The value is read using a two's complement 16-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param roff The read offset, an absolute index into this buffer, to read from.
* @return The short value at the given offset.
* @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Short#BYTES}.
*/
short readShort(int roff);
/**
* Get the unsigned short value at the current {@link Buf#readerIndex()},
* and increases the reader offset by {@link Short#BYTES}.
* The value is read using an unsigned two's complement 16-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @return The unsigned short value at the current reader offset.
* @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Short#BYTES}.
*/
int readUnsignedShort();
/**
* Get the unsigned short value at the given reader offset.
* The {@link Buf#readerIndex()} is not modified.
* The value is read using an unsigned two's complement 16-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param roff The read offset, an absolute index into this buffer, to read from.
* @return The unsigned short value at the given offset.
* @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Short#BYTES}.
*/
int readUnsignedShort(int roff);
/**
* Set the given short value at the current {@link Buf#writerIndex()},
* and increase the writer offset by {@link Short#BYTES}.
* The value is written using a two's complement 16-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param value The short value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Short#BYTES}.
*/
Buf writeShort(short value);
/**
* Set the given short value at the given write offset. The {@link Buf#writerIndex()} is not modified.
* The value is written using a two's complement 16-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param woff The write offset, an absolute index into this buffer to write to.
* @param value The short value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Short#BYTES}.
*/
Buf writeShort(int woff, short value);
/**
* Set the given unsigned short value at the current {@link Buf#writerIndex()},
* and increase the writer offset by {@link Short#BYTES}.
* The value is written using an unsigned two's complement 16-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param value The int value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Short#BYTES}.
*/
Buf writeUnsignedShort(int value);
/**
* Set the given unsigned short value at the given write offset. The {@link Buf#writerIndex()} is not modified.
* The value is written using an unsigned two's complement 16-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param woff The write offset, an absolute index into this buffer to write to.
* @param value The int value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Short#BYTES}.
*/
Buf writeUnsignedShort(int woff, int value);
/**
* Get the int value at the current {@link Buf#readerIndex()},
* and increases the reader offset by 3.
* The value is read using a two's complement 24-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @return The int value at the current reader offset.
* @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than 3.
*/
int readMedium();
/**
* Get the int value at the given reader offset.
* The {@link Buf#readerIndex()} is not modified.
* The value is read using a two's complement 24-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param roff The read offset, an absolute index into this buffer, to read from.
* @return The int value at the given offset.
* @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus 3.
*/
int readMedium(int roff);
/**
* Get the unsigned int value at the current {@link Buf#readerIndex()},
* and increases the reader offset by 3.
* The value is read using an unsigned two's complement 24-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @return The unsigned int value at the current reader offset.
* @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than 3.
*/
int readUnsignedMedium();
/**
* Get the unsigned int value at the given reader offset.
* The {@link Buf#readerIndex()} is not modified.
* The value is read using an unsigned two's complement 24-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param roff The read offset, an absolute index into this buffer, to read from.
* @return The unsigned int value at the given offset.
* @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus 3.
*/
int readUnsignedMedium(int roff);
/**
* Set the given int value at the current {@link Buf#writerIndex()},
* and increase the writer offset by 3.
* The value is written using a two's complement 24-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param value The int value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than 3.
*/
Buf writeMedium(int value);
/**
* Set the given int value at the given write offset. The {@link Buf#writerIndex()} is not modified.
* The value is written using a two's complement 24-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param woff The write offset, an absolute index into this buffer to write to.
* @param value The int value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus 3.
*/
Buf writeMedium(int woff, int value);
/**
* Set the given unsigned int value at the current {@link Buf#writerIndex()},
* and increase the writer offset by 3.
* The value is written using an unsigned two's complement 24-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param value The int value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than 3.
*/
Buf writeUnsignedMedium(int value);
/**
* Set the given unsigned int value at the given write offset. The {@link Buf#writerIndex()} is not modified.
* The value is written using an unsigned two's complement 24-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param woff The write offset, an absolute index into this buffer to write to.
* @param value The int value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus 3.
*/
Buf writeUnsignedMedium(int woff, int value);
/**
* Get the int value at the current {@link Buf#readerIndex()},
* and increases the reader offset by {@link Integer#BYTES}.
* The value is read using a two's complement 32-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @return The int value at the current reader offset.
* @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Integer#BYTES}.
*/
int readInt();
/**
* Get the int value at the given reader offset.
* The {@link Buf#readerIndex()} is not modified.
* The value is read using a two's complement 32-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param roff The read offset, an absolute index into this buffer, to read from.
* @return The int value at the given offset.
* @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Integer#BYTES}.
*/
int readInt(int roff);
/**
* Get the unsigned int value at the current {@link Buf#readerIndex()},
* and increases the reader offset by {@link Integer#BYTES}.
* The value is read using an unsigned two's complement 32-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @return The unsigned int value at the current reader offset.
* @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Integer#BYTES}.
*/
long readUnsignedInt();
/**
* Get the unsigned int value at the given reader offset.
* The {@link Buf#readerIndex()} is not modified.
* The value is read using an unsigned two's complement 32-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param roff The read offset, an absolute index into this buffer, to read from.
* @return The unsigned int value at the given offset.
* @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Integer#BYTES}.
*/
long readUnsignedInt(int roff);
/**
* Set the given int value at the current {@link Buf#writerIndex()},
* and increase the writer offset by {@link Integer#BYTES}.
* The value is written using a two's complement 32-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param value The int value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Integer#BYTES}.
*/
Buf writeInt(int value);
/**
* Set the given int value at the given write offset. The {@link Buf#writerIndex()} is not modified.
* The value is written using a two's complement 32-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param woff The write offset, an absolute index into this buffer to write to.
* @param value The int value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Integer#BYTES}.
*/
Buf writeInt(int woff, int value);
/**
* Set the given unsigned int value at the current {@link Buf#writerIndex()},
* and increase the writer offset by {@link Integer#BYTES}.
* The value is written using an unsigned two's complement 32-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param value The long value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Integer#BYTES}.
*/
Buf writeUnsignedInt(long value);
/**
* Set the given unsigned int value at the given write offset. The {@link Buf#writerIndex()} is not modified.
* The value is written using an unsigned two's complement 32-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param woff The write offset, an absolute index into this buffer to write to.
* @param value The long value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Integer#BYTES}.
*/
Buf writeUnsignedInt(int woff, long value);
/**
* Get the float value at the current {@link Buf#readerIndex()},
* and increases the reader offset by {@link Float#BYTES}.
* The value is read using a 32-bit IEEE floating point encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @return The float value at the current reader offset.
* @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Float#BYTES}.
*/
float readFloat();
/**
* Get the float value at the given reader offset.
* The {@link Buf#readerIndex()} is not modified.
* The value is read using a 32-bit IEEE floating point encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param roff The read offset, an absolute index into this buffer, to read from.
* @return The float value at the given offset.
* @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Float#BYTES}.
*/
float readFloat(int roff);
/**
* Set the given float value at the current {@link Buf#writerIndex()},
* and increase the writer offset by {@link Float#BYTES}.
* The value is written using a 32-bit IEEE floating point encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param value The float value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Float#BYTES}.
*/
Buf writeFloat(float value);
/**
* Set the given float value at the given write offset. The {@link Buf#writerIndex()} is not modified.
* The value is written using a 32-bit IEEE floating point encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param woff The write offset, an absolute index into this buffer to write to.
* @param value The float value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Float#BYTES}.
*/
Buf writeFloat(int woff, float value);
/**
* Get the long value at the current {@link Buf#readerIndex()},
* and increases the reader offset by {@link Long#BYTES}.
* The value is read using a two's complement 64-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @return The long value at the current reader offset.
* @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Long#BYTES}.
*/
long readLong();
/**
* Get the long value at the given reader offset.
* The {@link Buf#readerIndex()} is not modified.
* The value is read using a two's complement 64-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param roff The read offset, an absolute index into this buffer, to read from.
* @return The long value at the given offset.
* @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Long#BYTES}.
*/
long readLong(int roff);
/**
* Set the given long value at the current {@link Buf#writerIndex()},
* and increase the writer offset by {@link Long#BYTES}.
* The value is written using a two's complement 64-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param value The long value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Long#BYTES}.
*/
Buf writeLong(long value);
/**
* Set the given long value at the given write offset. The {@link Buf#writerIndex()} is not modified.
* The value is written using a two's complement 64-bit encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param woff The write offset, an absolute index into this buffer to write to.
* @param value The long value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Long#BYTES}.
*/
Buf writeLong(int woff, long value);
/**
* Get the double value at the current {@link Buf#readerIndex()},
* and increases the reader offset by {@link Double#BYTES}.
* The value is read using a 64-bit IEEE floating point encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @return The double value at the current reader offset.
* @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Double#BYTES}.
*/
double readDouble();
/**
* Get the double value at the given reader offset.
* The {@link Buf#readerIndex()} is not modified.
* The value is read using a 64-bit IEEE floating point encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param roff The read offset, an absolute index into this buffer, to read from.
* @return The double value at the given offset.
* @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Double#BYTES}.
*/
double readDouble(int roff);
/**
* Set the given double value at the current {@link Buf#writerIndex()},
* and increase the writer offset by {@link Double#BYTES}.
* The value is written using a 64-bit IEEE floating point encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param value The double value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Double#BYTES}.
*/
Buf writeDouble(double value);
/**
* Set the given double value at the given write offset. The {@link Buf#writerIndex()} is not modified.
* The value is written using a 64-bit IEEE floating point encoding,
* with the {@link Buf#order() configured} default byte order.
*
* @param woff The write offset, an absolute index into this buffer to write to.
* @param value The double value to write.
* @return This Buf.
* @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or
* greater than or equal to {@link Buf#capacity()} minus {@link Double#BYTES}.
*/
Buf writeDouble(int woff, double value);
// </editor-fold>
// ### CODEGEN END primitive accessors interface
}

1124
buffer/src/main/java/io/netty/buffer/b2/CompositeBuf.java Normal file
View File

File diff suppressed because it is too large Load Diff

2
buffer/src/main/java/io/netty/buffer/b2/Drop.java
View File

@ -5,7 +5,7 @@
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

20
buffer/src/main/java/io/netty/buffer/b2/MemSegBuf.java
View File

@ -5,7 +5,7 @@
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
@ -52,7 +52,7 @@ class MemSegBuf extends RcSupport<Buf, MemSegBuf> implements Buf {
static final Drop<MemSegBuf> SEGMENT_CLOSE = buf -> buf.seg.close();
final MemorySegment seg;
private boolean isBigEndian;
private boolean isSendable;
private final boolean isSendable;
private int roff;
private int woff;
@ -107,16 +107,6 @@ class MemSegBuf extends RcSupport<Buf, MemSegBuf> implements Buf {
return this;
}
@Override
public int readableBytes() {
return writerIndex() - readerIndex();
}
@Override
public int writableBytes() {
return capacity() - writerIndex();
}
@Override
public Buf fill(byte value) {
seg.fill(value);
@ -623,11 +613,11 @@ getByteAtOffset_BE(seg, roff) & 0xFF |
}
MemSegBuf outer = this;
boolean isConfined = seg.ownerThread() == null;
MemorySegment transferSegment = isConfined? seg : seg.withOwnerThread(null);
MemorySegment transferSegment = isConfined? seg : seg.share();
return new Owned<MemSegBuf>() {
@Override
public MemSegBuf transferOwnership(Thread recipient, Drop<MemSegBuf> drop) {
var newSegment = isConfined? transferSegment.withOwnerThread(recipient) : transferSegment;
public MemSegBuf transferOwnership(Drop<MemSegBuf> drop) {
var newSegment = isConfined? transferSegment.handoff(Thread.currentThread()) : transferSegment;
MemSegBuf copy = new MemSegBuf(newSegment, drop);
copy.isBigEndian = outer.isBigEndian;
copy.roff = outer.roff;

29
buffer/src/main/java/io/netty/buffer/b2/MemoryManager.java
View File

@ -5,7 +5,7 @@
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
@ -29,10 +29,9 @@ public interface MemoryManager {
}
boolean isNative();
Buf allocateConfined(long size, Drop<Buf> drop);
Buf allocateShared(long size, Drop<Buf> drop);
Buf allocateConfined(long size, Drop<Buf> drop, Cleaner cleaner);
Buf allocateShared(long size, Drop<Buf> drop, Cleaner cleaner);
Drop<Buf> drop();
void registerCleaner(Buf buf, Cleaner cleaner);
Object unwrapRecoverableMemory(Buf buf);
Buf recoverMemory(Object recoverableMemory, Drop<Buf> drop);
@ -41,14 +40,20 @@ public interface MemoryManager {
public abstract boolean isNative();
@Override
public Buf allocateConfined(long size, Drop<Buf> drop) {
public Buf allocateConfined(long size, Drop<Buf> drop, Cleaner cleaner) {
var segment = createSegment(size);
if (cleaner != null) {
segment = segment.registerCleaner(cleaner);
}
return new MemSegBuf(segment, convert(drop));
}
@Override
public Buf allocateShared(long size, Drop<Buf> drop) {
var segment = createSegment(size).withOwnerThread(null);
public Buf allocateShared(long size, Drop<Buf> drop, Cleaner cleaner) {
var segment = createSegment(size).share();
if (cleaner != null) {
segment = segment.registerCleaner(cleaner);
}
return new MemSegBuf(segment, convert(drop));
}
@ -59,12 +64,6 @@ public interface MemoryManager {
return convert(MemSegBuf.SEGMENT_CLOSE);
}
@Override
public void registerCleaner(Buf buf, Cleaner cleaner) {
var b = (MemSegBuf) buf;
b.seg.registerCleaner(cleaner);
}
@Override
public Object unwrapRecoverableMemory(Buf buf) {
var b = (MemSegBuf) buf;
@ -103,8 +102,8 @@ public interface MemoryManager {
@Override
protected MemorySegment createSegment(long size) {
var segment = MemorySegment.allocateNative(size)
.withCleanupAction(Statics.getCleanupAction(size));
var segment = MemorySegment.allocateNative(size);
// .withCleanupAction(Statics.getCleanupAction(size));
Statics.MEM_USAGE_NATIVE.add(size);
return segment;
}

2
buffer/src/main/java/io/netty/buffer/b2/NativeMemoryCleanerDrop.java
View File

@ -5,7 +5,7 @@
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

7
buffer/src/main/java/io/netty/buffer/b2/Owned.java
View File

@ -5,7 +5,7 @@
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
@ -24,16 +24,15 @@ package io.netty.buffer.b2;
@SuppressWarnings("InterfaceMayBeAnnotatedFunctional")
public interface Owned<T> {
/**
* Transfer the ownership of the owned Rc, to the given recipient thread. The owned Rc is invalidated but without
* Transfer the ownership of the owned Rc, to the calling thread. The owned Rc is invalidated but without
* disposing of its internal state. Then a new Rc with the given owner is produced in its stead.
* <p>
* This method is called by {@link Send} implementations. These implementations will ensure that the transfer of
* ownership (the calling of this method) happens-before the new owner begins accessing the new object. This ensures
* that the new Rc is safely published to the new owners.
*
* @param recipient The new owner of the state represented by this Rc.
* @param drop The drop object that knows how to dispose of the state represented by this Rc.
* @return A new Rc instance that is exactly the same as this Rc, except it has the new owner.
*/
T transferOwnership(Thread recipient, Drop<T> drop);
T transferOwnership(Drop<T> drop);
}

8
buffer/src/main/java/io/netty/buffer/b2/Rc.java
View File

@ -5,7 +5,7 @@
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
@ -47,14 +47,10 @@ public interface Rc<I extends Rc<I>> extends AutoCloseable {
void close();
/**
* Send this Rc instance to another Thread, transferring the ownership to the recipient. This method can be used
* when the receiving thread is not known up front.
* Send this Rc instance to another Thread, transferring the ownership to the recipient.
* <p>
* This instance immediately becomes inaccessible, and all attempts at accessing this Rc will throw. Calling {@link
* #close()} will have no effect, so this method is safe to call within a try-with-resources statement.
*
* @implNote Not possible without hacks because we need the receiving thread in order to set the new owner in the
* currently owning thread.
*/
Send<I> send();
}

4
buffer/src/main/java/io/netty/buffer/b2/RcSupport.java
View File

@ -5,7 +5,7 @@
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
@ -84,7 +84,7 @@ public abstract class RcSupport<I extends Rc<I>, T extends RcSupport<I, T>> impl
/**
* Prepare this instance for ownsership transfer. This method is called from {@link #send()} in the sending thread.
* This method should put this Rc in a deactivated state where it is no longer accessible from the currently owning
* thread. In this state, the Rc instance should only allow a call to {@link Owned#transferOwnership(Thread, Drop)} in
* thread. In this state, the Rc instance should only allow a call to {@link Owned#transferOwnership(Drop)} in
* the recipient thread.
*
* @return This Rc instance in a deactivated state.

2
buffer/src/main/java/io/netty/buffer/b2/ResourceDisposeFailedException.java
View File

@ -5,7 +5,7 @@
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

2
buffer/src/main/java/io/netty/buffer/b2/Send.java
View File

@ -5,7 +5,7 @@
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

4
buffer/src/main/java/io/netty/buffer/b2/SizeClassedMemoryPool.java
View File

@ -5,7 +5,7 @@
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
@ -51,7 +51,7 @@ class SizeClassedMemoryPool implements Allocator, Drop<Buf> {
}
protected Buf createBuf(long size, Drop<Buf> drop) {
var buf = manager.allocateShared(size, drop);
var buf = manager.allocateShared(size, drop, null);
drop.accept(buf);
return buf;
}

2
buffer/src/main/java/io/netty/buffer/b2/Statics.java
View File

@ -5,7 +5,7 @@
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

8
buffer/src/main/java/io/netty/buffer/b2/TransferSend.java
View File

@ -5,7 +5,7 @@
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
@ -17,8 +17,8 @@ package io.netty.buffer.b2;
import java.lang.invoke.VarHandle;
import static io.netty.buffer.b2.Statics.*;
import static java.lang.invoke.MethodHandles.*;
import static io.netty.buffer.b2.Statics.findVarHandle;
import static java.lang.invoke.MethodHandles.lookup;
class TransferSend<I extends Rc<I>, T extends Rc<I>> implements Send<I> {
private static final VarHandle RECEIVED = findVarHandle(lookup(), TransferSend.class, "received", boolean.class);
@ -38,7 +38,7 @@ class TransferSend<I extends Rc<I>, T extends Rc<I>> implements Send<I> {
if (!RECEIVED.compareAndSet(this, false, true)) {
throw new IllegalStateException("This object has already been received.");
}
var copy = outgoing.transferOwnership(Thread.currentThread(), drop);
var copy = outgoing.transferOwnership(drop);
drop.accept(copy);
return (I) copy;
}

2
buffer/src/main/java/io/netty/buffer/b2/package-info.java
View File

@ -5,7 +5,7 @@
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

5
buffer/src/test/java/io/netty/buffer/b2/BufTest.java
View File

@ -5,7 +5,7 @@
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
@ -18,6 +18,7 @@ package io.netty.buffer.b2;
import org.junit.After;
import org.junit.AssumptionViolatedException;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import java.nio.ByteOrder;
@ -181,6 +182,7 @@ public abstract class BufTest {
}
}
@Ignore // This test uses too much memory.
@Test
public void mustThrowWhenAllocatingOverSizedBuffer() {
try {
@ -190,6 +192,7 @@ public abstract class BufTest {
}
}
@Ignore // This test uses too much memory.
@Test
public void mustAllowAllocatingMaxArraySizedBuffer() {
try {

19
buffer/src/test/java/io/netty/buffer/b2/Codegen.java
View File

@ -1,3 +1,18 @@
/*
* Copyright 2020 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package io.netty.buffer.b2;
import java.io.IOException;
@ -42,7 +57,7 @@ public final class Codegen {
case BE: return "big-endian";
case LE: return "little-endian";
}
return "the {@link #order() configured} default";
return "the {@link Buf#order() configured} default";
}
}
@ -569,7 +584,7 @@ public final class Codegen {
}
public static void main(String[] args) throws Exception {
generateCodeInline(Path.of("buffer/src/main/java/io/netty/buffer/b2/Buf.java"));
generateCodeInline(Path.of("buffer/src/main/java/io/netty/buffer/b2/BufAccessors.java"));
generateCodeInline(Path.of("buffer/src/main/java/io/netty/buffer/b2/MemSegBuf.java"));
generateCodeInline(Path.of("buffer/src/test/java/io/netty/buffer/b2/BufTest.java"));
}

81
buffer/src/test/java/io/netty/buffer/b2/CompositeBufTest.java Normal file
View File

@ -0,0 +1,81 @@
/*
* Copyright 2020 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package io.netty.buffer.b2;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.function.Supplier;
@RunWith(Parameterized.class)
public class CompositeBufTest extends BufTest {
@Parameters(name = "{0}")
public static Iterable<Object[]> parameters() {
Map<String, Supplier<Allocator>> subAllocators = Map.of(
"heap", Allocator::heap,
"direct", Allocator::direct,
"directWithCleaner", Allocator::directWithCleaner,
"pooledHeap", Allocator::pooledHeap,
"pooledDirect", Allocator::pooledDirect,
"pooledDirectWithCleaner", Allocator::pooledDirectWithCleaner);
List<Object[]> combinations = new ArrayList<>(subAllocators.size() * subAllocators.size());
for (Entry<String, Supplier<Allocator>> first : subAllocators.entrySet()) {
for (Entry<String, Supplier<Allocator>> second : subAllocators.entrySet()) {
String name = "compose(" + first.getKey() + ", " + second.getKey() + ')';
var firstAllocator = first.getValue();
var secondAllocator = second.getValue();
Supplier<Allocator> allocator = () -> {
var a = firstAllocator.get();
var b = secondAllocator.get();
return new Allocator() {
@Override
public Buf allocate(long size) {
long half = size / 2;
try (Buf firstHalf = a.allocate(half);
Buf secondHalf = b.allocate(size - half)) {
return Buf.compose(firstHalf, secondHalf);
}
}
@Override
public void close() {
a.close();
b.close();
}
};
};
combinations.add(new Object[]{name, allocator});
}
}
return combinations;
}
private final Supplier<Allocator> allocatorFactory;
public CompositeBufTest(String testName, Supplier<Allocator> allocatorFactory) {
this.allocatorFactory = allocatorFactory;
}
@Override
protected Allocator createAllocator() {
return allocatorFactory.get();
}
}

2
buffer/src/test/java/io/netty/buffer/b2/DirectBufTest.java
View File

@ -5,7 +5,7 @@
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

17
buffer/src/test/java/io/netty/buffer/b2/DirectBufWithCleanerTest.java
View File

@ -1,5 +1,21 @@
/*
* Copyright 2020 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package io.netty.buffer.b2;
import org.junit.Ignore;
import org.junit.Test;
import static org.hamcrest.Matchers.*;
@ -11,6 +27,7 @@ public class DirectBufWithCleanerTest extends DirectBufTest {
return Allocator.directWithCleaner();
}
@Ignore // Precise native memory accounting does not work since recent panama-foreign changes.
@Test
public void bufferMustBeClosedByCleaner() throws InterruptedException {
var allocator = createAllocator();

2
buffer/src/test/java/io/netty/buffer/b2/HeapBufTest.java
View File

@ -5,7 +5,7 @@
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

2
buffer/src/test/java/io/netty/buffer/b2/PooledDirectBufTest.java
View File

@ -5,7 +5,7 @@
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

4
buffer/src/test/java/io/netty/buffer/b2/PooledDirectBufWithCleanerTest.java
View File

@ -5,7 +5,7 @@
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
@ -15,6 +15,7 @@
*/
package io.netty.buffer.b2;
import org.junit.Ignore;
import org.junit.Test;
import static org.hamcrest.Matchers.*;
@ -26,6 +27,7 @@ public class PooledDirectBufWithCleanerTest extends DirectBufWithCleanerTest {
return Allocator.pooledDirectWithCleaner();
}
@Ignore // Precise native memory accounting does not work since recent panama-foreign changes.
@Test
public void buffersMustBeReusedByPoolingAllocatorEvenWhenDroppedByCleanerInsteadOfExplicitly()
throws InterruptedException {

2
buffer/src/test/java/io/netty/buffer/b2/PooledHeapBufTest.java
View File

@ -5,7 +5,7 @@
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT