MemorySegment (flink 1.0-SNAPSHOT API)

java.lang.Object
- org.apache.flink.core.memory.MemorySegment

Direct Known Subclasses:

HeapMemorySegment, HybridMemorySegment
```
@Internal
public abstract class MemorySegment
extends Object
```
This class represents a piece of memory managed by Flink. The segment may be backed by heap memory (byte array) or by off-heap memory.
The methods for individual memory access are specialized in the classes HeapMemorySegment and HybridMemorySegment. All methods that operate across two memory segments are implemented in this class, to transparently handle the mixing of memory segment types.
This class fulfills conceptually a similar purpose as Java's ByteBuffer. We add this specialized class for various reasons:
- It offers additional binary compare, swap, and copy methods.
- It uses collapsed checks for range check and memory segment disposal.
- It offers absolute positioning methods for bulk put/get methods, to guarantee thread safe use.
- It offers explicit big-endian / little-endian access methods, rather than tracking internally a byte order.
- It transparently and efficiently moves data between on-heap and off-heap variants.
Comments on the implementation: We make heavy use of operations that are supported by native instructions, to achieve a high efficiency. Multi byte types (int, long, float, double, ...) are read and written with "unsafe" native commands.
Below is an example of the code generated for the putLongBigEndian(int, long) function by the just-in-time compiler. The code is grabbed from an Oracle JVM 7 using the hotspot disassembler library (hsdis32.dll) and the jvm command -XX:+UnlockDiagnosticVMOptions -XX:CompileCommand=print,*MemorySegment.putLongBigEndian. Note that this code realizes both the byte order swapping and the reinterpret cast access to get a long from the byte array.
```
 [Verified Entry Point]
   0x00007fc403e19920: sub    $0x18,%rsp
   0x00007fc403e19927: mov    %rbp,0x10(%rsp)    ;*synchronization entry
                                                 ; - org.apache.flink.runtime.memory.UnsafeMemorySegment::putLongBigEndian@-1 (line 652)
   0x00007fc403e1992c: mov    0xc(%rsi),%r10d    ;*getfield memory
                                                 ; - org.apache.flink.runtime.memory.UnsafeMemorySegment::putLong@4 (line 611)
                                                 ; - org.apache.flink.runtime.memory.UnsafeMemorySegment::putLongBigEndian@12 (line 653)
   0x00007fc403e19930: bswap  %rcx
   0x00007fc403e19933: shl    $0x3,%r10
   0x00007fc403e19937: movslq %edx,%r11
   0x00007fc403e1993a: mov    %rcx,0x10(%r10,%r11,1)  ;*invokevirtual putLong
                                                 ; - org.apache.flink.runtime.memory.UnsafeMemorySegment::putLong@14 (line 611)
                                                 ; - org.apache.flink.runtime.memory.UnsafeMemorySegment::putLongBigEndian@12 (line 653)
   0x00007fc403e1993f: add    $0x10,%rsp
   0x00007fc403e19943: pop    %rbp
   0x00007fc403e19944: test   %eax,0x5ba76b6(%rip)        # 0x00007fc4099c1000
                                                 ;   {poll_return}
   0x00007fc403e1994a: retq 
 
```
Note on efficiency: For best efficiency, the code that uses this class should make sure that only one subclass is loaded, or that the methods that are abstract in this class are used only from one of the subclasses (either the HeapMemorySegment, or the HybridMemorySegment). That way, all the abstract methods in the MemorySegment base class have only one loaded actual implementation. This is easy for the JIT to recognize through class hierarchy analysis, or by identifying that the invocations are monomorphic (all go to the same concrete method implementation). Under these conditions, the JIT can perfectly inline methods.

Field Summary

Fields
Modifier and Type	Field and Description
`protected long`	`address` The address to the data, relative to the heap memory byte array.
`protected long`	`addressLimit` The address one byte after the last addressable byte.
`protected static long`	`BYTE_ARRAY_BASE_OFFSET` The beginning of the byte array contents, relative to the byte array object
`protected byte[]`	`heapMemory` The heap byte array object relative to which we access the memory.
`protected int`	`size` The size in bytes of the memory segment
`protected static sun.misc.Unsafe`	`UNSAFE` The unsafe handle for transparent memory copied (heap / off-heap)

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`int`	`compare(MemorySegment seg2, int offset1, int offset2, int len)` Compares two memory segment regions.
`void`	`copyTo(int offset, MemorySegment target, int targetOffset, int numBytes)` Bulk copy method.
`void`	`free()` Frees this memory segment.
`abstract void`	`get(DataOutput out, int offset, int length)`
`abstract byte`	`get(int index)` Reads the byte at the given position.
`abstract void`	`get(int index, byte[] dst)` Bulk get method.
`abstract void`	`get(int index, byte[] dst, int offset, int length)` Bulk get method.
`abstract void`	`get(int offset, ByteBuffer target, int numBytes)` Bulk get method.
`abstract boolean`	`getBoolean(int index)` Reads one byte at the given position and returns its boolean representation.
`char`	`getChar(int index)` Reads a char value from the given position, in the system's native byte order.
`char`	`getCharBigEndian(int index)` Reads an character value (16 bit, 2 bytes) from the given position, in big-endian byte order.
`char`	`getCharLittleEndian(int index)` Reads an character value (16 bit, 2 bytes) from the given position, in little-endian byte order.
`double`	`getDouble(int index)` Reads a double-precision floating point value (64bit, 8 bytes) from the given position, in the system's native byte order.
`double`	`getDoubleBigEndian(int index)` Reads a double-precision floating point value (64bit, 8 bytes) from the given position, in big endian byte order.
`double`	`getDoubleLittleEndian(int index)` Reads a double-precision floating point value (64bit, 8 bytes) from the given position, in little endian byte order.
`float`	`getFloat(int index)` Reads a single-precision floating point value (32bit, 4 bytes) from the given position, in the system's native byte order.
`float`	`getFloatBigEndian(int index)` Reads a single-precision floating point value (32bit, 4 bytes) from the given position, in big endian byte order.
`float`	`getFloatLittleEndian(int index)` Reads a single-precision floating point value (32bit, 4 bytes) from the given position, in little endian byte order.
`int`	`getInt(int index)` Reads an int value (32bit, 4 bytes) from the given position, in the system's native byte order.
`int`	`getIntBigEndian(int index)` Reads an int value (32bit, 4 bytes) from the given position, in big-endian byte order.
`int`	`getIntLittleEndian(int index)` Reads an int value (32bit, 4 bytes) from the given position, in little-endian byte order.
`long`	`getLong(int index)` Reads a long value (64bit, 8 bytes) from the given position, in the system's native byte order.
`long`	`getLongBigEndian(int index)` Reads a long integer value (64bit, 8 bytes) from the given position, in big endian byte order.
`long`	`getLongLittleEndian(int index)` Reads a long integer value (64bit, 8 bytes) from the given position, in little endian byte order.
`Object`	`getOwner()` Gets the owner of this memory segment.
`short`	`getShort(int index)` Reads two memory at the given position, composing them into a short value according to the current byte order.
`short`	`getShortBigEndian(int index)` Reads an short integer value (16 bit, 2 bytes) from the given position, in big-endian byte order.
`short`	`getShortLittleEndian(int index)` Reads an short integer value (16 bit, 2 bytes) from the given position, in little-endian byte order.
`boolean`	`isFreed()` Checks whether the memory segment was freed.
`boolean`	`isOffHeap()` Checks whether this memory segment is backed by off-heap memory.
`abstract void`	`put(DataInput in, int offset, int length)` Bulk put method.
`abstract void`	`put(int index, byte b)` Writes the given byte into this buffer at the given position.
`abstract void`	`put(int index, byte[] src)` Bulk put method.
`abstract void`	`put(int index, byte[] src, int offset, int length)` Bulk put method.
`abstract void`	`put(int offset, ByteBuffer source, int numBytes)` Bulk put method.
`abstract void`	`putBoolean(int index, boolean value)` Writes one byte containing the byte value into this buffer at the given position.
`void`	`putChar(int index, char value)` Writes a char value to teh given position, in the system's native byte order.
`void`	`putCharBigEndian(int index, char value)` Writes the given character (16 bit, 2 bytes) to the given position in big-endian byte order.
`void`	`putCharLittleEndian(int index, char value)` Writes the given character (16 bit, 2 bytes) to the given position in little-endian byte order.
`void`	`putDouble(int index, double value)` Writes the given double-precision floating-point value (64bit, 8 bytes) to the given position in the system's native byte order.
`void`	`putDoubleBigEndian(int index, double value)` Writes the given double-precision floating-point value (64bit, 8 bytes) to the given position in big endian byte order.
`void`	`putDoubleLittleEndian(int index, double value)` Writes the given double-precision floating-point value (64bit, 8 bytes) to the given position in little endian byte order.
`void`	`putFloat(int index, float value)` Writes the given single-precision float value (32bit, 4 bytes) to the given position in the system's native byte order.
`void`	`putFloatBigEndian(int index, float value)` Writes the given single-precision float value (32bit, 4 bytes) to the given position in big endian byte order.
`void`	`putFloatLittleEndian(int index, float value)` Writes the given single-precision float value (32bit, 4 bytes) to the given position in little endian byte order.
`void`	`putInt(int index, int value)` Writes the given int value (32bit, 4 bytes) to the given position in the system's native byte order.
`void`	`putIntBigEndian(int index, int value)` Writes the given int value (32bit, 4 bytes) to the given position in big endian byte order.
`void`	`putIntLittleEndian(int index, int value)` Writes the given int value (32bit, 4 bytes) to the given position in little endian byte order.
`void`	`putLong(int index, long value)` Writes the given long value (64bit, 8 bytes) to the given position in the system's native byte order.
`void`	`putLongBigEndian(int index, long value)` Writes the given long value (64bit, 8 bytes) to the given position in big endian byte order.
`void`	`putLongLittleEndian(int index, long value)` Writes the given long value (64bit, 8 bytes) to the given position in little endian byte order.
`void`	`putShort(int index, short value)` Writes the given short value into this buffer at the given position, using the native byte order of the system.
`void`	`putShortBigEndian(int index, short value)` Writes the given short integer value (16 bit, 2 bytes) to the given position in big-endian byte order.
`void`	`putShortLittleEndian(int index, short value)` Writes the given short integer value (16 bit, 2 bytes) to the given position in little-endian byte order.
`int`	`size()` Gets the size of the memory segment, in bytes.
`void`	`swapBytes(byte[] tempBuffer, MemorySegment seg2, int offset1, int offset2, int len)` Swaps bytes between two memory segments, using the given auxiliary buffer.
`abstract ByteBuffer`	`wrap(int offset, int length)` Wraps the chunk of the underlying memory located between `offset` and `length` in a NIO ByteBuffer.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - UNSAFE
```
protected static final sun.misc.Unsafe UNSAFE
```
    The unsafe handle for transparent memory copied (heap / off-heap)
  - BYTE_ARRAY_BASE_OFFSET
```
protected static final long BYTE_ARRAY_BASE_OFFSET
```
    The beginning of the byte array contents, relative to the byte array object
  - heapMemory
```
protected final byte[] heapMemory
```
    The heap byte array object relative to which we access the memory. Is non-null if the memory is on the heap, and is null, if the memory if off the heap. If we have this buffer, we must never void this reference, or the memory segment will point to undefined addresses outside the heap and may in out-of-order execution cases cause segmentation faults.
  - address
```
protected long address
```
    The address to the data, relative to the heap memory byte array. If the heap memory byte array is null, this becomes an absolute memory address outside the heap.
  - addressLimit
```
protected final long addressLimit
```
    The address one byte after the last addressable byte. This is address + size while the segment is not disposed
  - size
```
protected final int size
```
    The size in bytes of the memory segment
- Method Detail
  - size
```
public int size()
```
    Gets the size of the memory segment, in bytes.
    
    Returns:
    
    The size of the memory segment.
  - isFreed
```
public boolean isFreed()
```
    Checks whether the memory segment was freed.
    
    Returns:
    
    True, if the memory segment has been freed, false otherwise.
  - free
```
public void free()
```
    Frees this memory segment. After this operation has been called, no further operations are possible on the memory segment and will fail. The actual memory (heap or off-heap) will only be released after this memory segment object has become garbage collected.
  - isOffHeap
```
public boolean isOffHeap()
```
    Checks whether this memory segment is backed by off-heap memory.
    
    Returns:
    
    True, if the memory segment is backed by off-heap memory, false if it is backed by heap memory.
  - wrap
```
public abstract ByteBuffer wrap(int offset,
                                int length)
```
    Wraps the chunk of the underlying memory located between offset and length in a NIO ByteBuffer.
    
    Parameters:
    
    offset - The offset in the memory segment.
    
    length - The number of bytes to be wrapped as a buffer.
    
    Returns:
    
    A ByteBuffer backed by the specified portion of the memory segment.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if offset is negative or larger than the memory segment size, or if the offset plus the length is larger than the segment size.
  - getOwner
```
public Object getOwner()
```
    Gets the owner of this memory segment. Returns null, if the owner was not set.
    
    Returns:
    
    The owner of the memory segment, or null, if it does not have an owner.
  - get
```
public abstract byte get(int index)
```
    Reads the byte at the given position.
    
    Parameters:
    
    index - The position from which the byte will be read
    
    Returns:
    
    The byte at the given position.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger or equal to the size of the memory segment.
  - put
```
public abstract void put(int index,
                         byte b)
```
    Writes the given byte into this buffer at the given position.
    
    Parameters:
    
    index - The index at which the byte will be written.
    
    b - The byte value to be written.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger or equal to the size of the memory segment.
  - get
```
public abstract void get(int index,
                         byte[] dst)
```
    Bulk get method. Copies dst.length memory from the specified position to the destination memory.
    
    Parameters:
    
    index - The position at which the first byte will be read.
    
    dst - The memory into which the memory will be copied.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or too large that the data between the index and the memory segment end is not enough to fill the destination array.
  - put
```
public abstract void put(int index,
                         byte[] src)
```
    Bulk put method. Copies src.length memory from the source memory into the memory segment beginning at the specified position.
    
    Parameters:
    
    index - The index in the memory segment array, where the data is put.
    
    src - The source array to copy the data from.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or too large such that the array size exceed the amount of memory between the index and the memory segment's end.
  - get
```
public abstract void get(int index,
                         byte[] dst,
                         int offset,
                         int length)
```
    Bulk get method. Copies length memory from the specified position to the destination memory, beginning at the given offset
    
    Parameters:
    
    index - The position at which the first byte will be read.
    
    dst - The memory into which the memory will be copied.
    
    offset - The copying offset in the destination memory.
    
    length - The number of bytes to be copied.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or too large that the requested number of bytes exceed the amount of memory between the index and the memory segment's end.
  - put
```
public abstract void put(int index,
                         byte[] src,
                         int offset,
                         int length)
```
    Bulk put method. Copies length memory starting at position offset from the source memory into the memory segment starting at the specified index.
    
    Parameters:
    
    index - The position in the memory segment array, where the data is put.
    
    src - The source array to copy the data from.
    
    offset - The offset in the source array where the copying is started.
    
    length - The number of bytes to copy.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or too large such that the array portion to copy exceed the amount of memory between the index and the memory segment's end.
  - getBoolean
```
public abstract boolean getBoolean(int index)
```
    Reads one byte at the given position and returns its boolean representation.
    
    Parameters:
    
    index - The position from which the memory will be read.
    
    Returns:
    
    The boolean value at the given position.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 1.
  - putBoolean
```
public abstract void putBoolean(int index,
                                boolean value)
```
    Writes one byte containing the byte value into this buffer at the given position.
    
    Parameters:
    
    index - The position at which the memory will be written.
    
    value - The char value to be written.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 1.
  - getChar
```
public final char getChar(int index)
```
    Reads a char value from the given position, in the system's native byte order.
    
    Parameters:
    
    index - The position from which the memory will be read.
    
    Returns:
    
    The char value at the given position.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 2.
  - getCharLittleEndian
```
public final char getCharLittleEndian(int index)
```
    Reads an character value (16 bit, 2 bytes) from the given position, in little-endian byte order. This method's speed depends on the system's native byte order, and it is possibly slower than getChar(int). For most cases (such as transient storage in memory or serialization for I/O and network), it suffices to know that the byte order in which the value is written is the same as the one in which it is read, and getChar(int) is the preferable choice.
    
    Parameters:
    
    index - The position from which the value will be read.
    
    Returns:
    
    The character value at the given position.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 2.
  - getCharBigEndian
```
public final char getCharBigEndian(int index)
```
    Reads an character value (16 bit, 2 bytes) from the given position, in big-endian byte order. This method's speed depends on the system's native byte order, and it is possibly slower than getChar(int). For most cases (such as transient storage in memory or serialization for I/O and network), it suffices to know that the byte order in which the value is written is the same as the one in which it is read, and getChar(int) is the preferable choice.
    
    Parameters:
    
    index - The position from which the value will be read.
    
    Returns:
    
    The character value at the given position.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 2.
  - putChar
```
public final void putChar(int index,
                          char value)
```
    Writes a char value to teh given position, in the system's native byte order.
    
    Parameters:
    
    index - The position at which the memory will be written.
    
    value - The char value to be written.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 2.
  - putCharLittleEndian
```
public final void putCharLittleEndian(int index,
                                      char value)
```
    Writes the given character (16 bit, 2 bytes) to the given position in little-endian byte order. This method's speed depends on the system's native byte order, and it is possibly slower than putChar(int, char). For most cases (such as transient storage in memory or serialization for I/O and network), it suffices to know that the byte order in which the value is written is the same as the one in which it is read, and putChar(int, char) is the preferable choice.
    
    Parameters:
    
    index - The position at which the value will be written.
    
    value - The short value to be written.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 2.
  - putCharBigEndian
```
public final void putCharBigEndian(int index,
                                   char value)
```
    Writes the given character (16 bit, 2 bytes) to the given position in big-endian byte order. This method's speed depends on the system's native byte order, and it is possibly slower than putChar(int, char). For most cases (such as transient storage in memory or serialization for I/O and network), it suffices to know that the byte order in which the value is written is the same as the one in which it is read, and putChar(int, char) is the preferable choice.
    
    Parameters:
    
    index - The position at which the value will be written.
    
    value - The short value to be written.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 2.
  - getShort
```
public final short getShort(int index)
```
    Reads two memory at the given position, composing them into a short value according to the current byte order.
    
    Parameters:
    
    index - The position from which the memory will be read.
    
    Returns:
    
    The short value at the given position.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 2.
  - getShortLittleEndian
```
public final short getShortLittleEndian(int index)
```
    Reads an short integer value (16 bit, 2 bytes) from the given position, in little-endian byte order. This method's speed depends on the system's native byte order, and it is possibly slower than getShort(int). For most cases (such as transient storage in memory or serialization for I/O and network), it suffices to know that the byte order in which the value is written is the same as the one in which it is read, and getShort(int) is the preferable choice.
    
    Parameters:
    
    index - The position from which the value will be read.
    
    Returns:
    
    The short value at the given position.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 2.
  - getShortBigEndian
```
public final short getShortBigEndian(int index)
```
    Reads an short integer value (16 bit, 2 bytes) from the given position, in big-endian byte order. This method's speed depends on the system's native byte order, and it is possibly slower than getShort(int). For most cases (such as transient storage in memory or serialization for I/O and network), it suffices to know that the byte order in which the value is written is the same as the one in which it is read, and getShort(int) is the preferable choice.
    
    Parameters:
    
    index - The position from which the value will be read.
    
    Returns:
    
    The short value at the given position.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 2.
  - putShort
```
public final void putShort(int index,
                           short value)
```
    Writes the given short value into this buffer at the given position, using the native byte order of the system.
    
    Parameters:
    
    index - The position at which the value will be written.
    
    value - The short value to be written.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 2.
  - putShortLittleEndian
```
public final void putShortLittleEndian(int index,
                                       short value)
```
    Writes the given short integer value (16 bit, 2 bytes) to the given position in little-endian byte order. This method's speed depends on the system's native byte order, and it is possibly slower than putShort(int, short). For most cases (such as transient storage in memory or serialization for I/O and network), it suffices to know that the byte order in which the value is written is the same as the one in which it is read, and putShort(int, short) is the preferable choice.
    
    Parameters:
    
    index - The position at which the value will be written.
    
    value - The short value to be written.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 2.
  - putShortBigEndian
```
public final void putShortBigEndian(int index,
                                    short value)
```
    Writes the given short integer value (16 bit, 2 bytes) to the given position in big-endian byte order. This method's speed depends on the system's native byte order, and it is possibly slower than putShort(int, short). For most cases (such as transient storage in memory or serialization for I/O and network), it suffices to know that the byte order in which the value is written is the same as the one in which it is read, and putShort(int, short) is the preferable choice.
    
    Parameters:
    
    index - The position at which the value will be written.
    
    value - The short value to be written.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 2.
  - getInt
```
public final int getInt(int index)
```
    Reads an int value (32bit, 4 bytes) from the given position, in the system's native byte order. This method offers the best speed for integer reading and should be used unless a specific byte order is required. In most cases, it suffices to know that the byte order in which the value is written is the same as the one in which it is read (such as transient storage in memory, or serialization for I/O and network), making this method the preferable choice.
    
    Parameters:
    
    index - The position from which the value will be read.
    
    Returns:
    
    The int value at the given position.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 4.
  - getIntLittleEndian
```
public final int getIntLittleEndian(int index)
```
    Reads an int value (32bit, 4 bytes) from the given position, in little-endian byte order. This method's speed depends on the system's native byte order, and it is possibly slower than getInt(int). For most cases (such as transient storage in memory or serialization for I/O and network), it suffices to know that the byte order in which the value is written is the same as the one in which it is read, and getInt(int) is the preferable choice.
    
    Parameters:
    
    index - The position from which the value will be read.
    
    Returns:
    
    The int value at the given position.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 4.
  - getIntBigEndian
```
public final int getIntBigEndian(int index)
```
    Reads an int value (32bit, 4 bytes) from the given position, in big-endian byte order. This method's speed depends on the system's native byte order, and it is possibly slower than getInt(int). For most cases (such as transient storage in memory or serialization for I/O and network), it suffices to know that the byte order in which the value is written is the same as the one in which it is read, and getInt(int) is the preferable choice.
    
    Parameters:
    
    index - The position from which the value will be read.
    
    Returns:
    
    The int value at the given position.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 4.
  - putInt
```
public final void putInt(int index,
                         int value)
```
    Writes the given int value (32bit, 4 bytes) to the given position in the system's native byte order. This method offers the best speed for integer writing and should be used unless a specific byte order is required. In most cases, it suffices to know that the byte order in which the value is written is the same as the one in which it is read (such as transient storage in memory, or serialization for I/O and network), making this method the preferable choice.
    
    Parameters:
    
    index - The position at which the value will be written.
    
    value - The int value to be written.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 4.
  - putIntLittleEndian
```
public final void putIntLittleEndian(int index,
                                     int value)
```
    Writes the given int value (32bit, 4 bytes) to the given position in little endian byte order. This method's speed depends on the system's native byte order, and it is possibly slower than putInt(int, int). For most cases (such as transient storage in memory or serialization for I/O and network), it suffices to know that the byte order in which the value is written is the same as the one in which it is read, and putInt(int, int) is the preferable choice.
    
    Parameters:
    
    index - The position at which the value will be written.
    
    value - The int value to be written.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 4.
  - putIntBigEndian
```
public final void putIntBigEndian(int index,
                                  int value)
```
    Writes the given int value (32bit, 4 bytes) to the given position in big endian byte order. This method's speed depends on the system's native byte order, and it is possibly slower than putInt(int, int). For most cases (such as transient storage in memory or serialization for I/O and network), it suffices to know that the byte order in which the value is written is the same as the one in which it is read, and putInt(int, int) is the preferable choice.
    
    Parameters:
    
    index - The position at which the value will be written.
    
    value - The int value to be written.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 4.
  - getLong
```
public final long getLong(int index)
```
    Reads a long value (64bit, 8 bytes) from the given position, in the system's native byte order. This method offers the best speed for long integer reading and should be used unless a specific byte order is required. In most cases, it suffices to know that the byte order in which the value is written is the same as the one in which it is read (such as transient storage in memory, or serialization for I/O and network), making this method the preferable choice.
    
    Parameters:
    
    index - The position from which the value will be read.
    
    Returns:
    
    The long value at the given position.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 8.
  - getLongLittleEndian
```
public final long getLongLittleEndian(int index)
```
    Reads a long integer value (64bit, 8 bytes) from the given position, in little endian byte order. This method's speed depends on the system's native byte order, and it is possibly slower than getLong(int). For most cases (such as transient storage in memory or serialization for I/O and network), it suffices to know that the byte order in which the value is written is the same as the one in which it is read, and getLong(int) is the preferable choice.
    
    Parameters:
    
    index - The position from which the value will be read.
    
    Returns:
    
    The long value at the given position.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 8.
  - getLongBigEndian
```
public final long getLongBigEndian(int index)
```
    Reads a long integer value (64bit, 8 bytes) from the given position, in big endian byte order. This method's speed depends on the system's native byte order, and it is possibly slower than getLong(int). For most cases (such as transient storage in memory or serialization for I/O and network), it suffices to know that the byte order in which the value is written is the same as the one in which it is read, and getLong(int) is the preferable choice.
    
    Parameters:
    
    index - The position from which the value will be read.
    
    Returns:
    
    The long value at the given position.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 8.
  - putLong
```
public final void putLong(int index,
                          long value)
```
    Writes the given long value (64bit, 8 bytes) to the given position in the system's native byte order. This method offers the best speed for long integer writing and should be used unless a specific byte order is required. In most cases, it suffices to know that the byte order in which the value is written is the same as the one in which it is read (such as transient storage in memory, or serialization for I/O and network), making this method the preferable choice.
    
    Parameters:
    
    index - The position at which the value will be written.
    
    value - The long value to be written.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 8.
  - putLongLittleEndian
```
public final void putLongLittleEndian(int index,
                                      long value)
```
    Writes the given long value (64bit, 8 bytes) to the given position in little endian byte order. This method's speed depends on the system's native byte order, and it is possibly slower than putLong(int, long). For most cases (such as transient storage in memory or serialization for I/O and network), it suffices to know that the byte order in which the value is written is the same as the one in which it is read, and putLong(int, long) is the preferable choice.
    
    Parameters:
    
    index - The position at which the value will be written.
    
    value - The long value to be written.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 8.
  - putLongBigEndian
```
public final void putLongBigEndian(int index,
                                   long value)
```
    Writes the given long value (64bit, 8 bytes) to the given position in big endian byte order. This method's speed depends on the system's native byte order, and it is possibly slower than putLong(int, long). For most cases (such as transient storage in memory or serialization for I/O and network), it suffices to know that the byte order in which the value is written is the same as the one in which it is read, and putLong(int, long) is the preferable choice.
    
    Parameters:
    
    index - The position at which the value will be written.
    
    value - The long value to be written.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 8.
  - getFloat
```
public final float getFloat(int index)
```
    Reads a single-precision floating point value (32bit, 4 bytes) from the given position, in the system's native byte order. This method offers the best speed for float reading and should be used unless a specific byte order is required. In most cases, it suffices to know that the byte order in which the value is written is the same as the one in which it is read (such as transient storage in memory, or serialization for I/O and network), making this method the preferable choice.
    
    Parameters:
    
    index - The position from which the value will be read.
    
    Returns:
    
    The float value at the given position.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 4.
  - getFloatLittleEndian
```
public final float getFloatLittleEndian(int index)
```
    Reads a single-precision floating point value (32bit, 4 bytes) from the given position, in little endian byte order. This method's speed depends on the system's native byte order, and it is possibly slower than getFloat(int). For most cases (such as transient storage in memory or serialization for I/O and network), it suffices to know that the byte order in which the value is written is the same as the one in which it is read, and getFloat(int) is the preferable choice.
    
    Parameters:
    
    index - The position from which the value will be read.
    
    Returns:
    
    The long value at the given position.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 8.
  - getFloatBigEndian
```
public final float getFloatBigEndian(int index)
```
    Reads a single-precision floating point value (32bit, 4 bytes) from the given position, in big endian byte order. This method's speed depends on the system's native byte order, and it is possibly slower than getFloat(int). For most cases (such as transient storage in memory or serialization for I/O and network), it suffices to know that the byte order in which the value is written is the same as the one in which it is read, and getFloat(int) is the preferable choice.
    
    Parameters:
    
    index - The position from which the value will be read.
    
    Returns:
    
    The long value at the given position.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 8.
  - putFloat
```
public final void putFloat(int index,
                           float value)
```
    Writes the given single-precision float value (32bit, 4 bytes) to the given position in the system's native byte order. This method offers the best speed for float writing and should be used unless a specific byte order is required. In most cases, it suffices to know that the byte order in which the value is written is the same as the one in which it is read (such as transient storage in memory, or serialization for I/O and network), making this method the preferable choice.
    
    Parameters:
    
    index - The position at which the value will be written.
    
    value - The float value to be written.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 4.
  - putFloatLittleEndian
```
public final void putFloatLittleEndian(int index,
                                       float value)
```
    Writes the given single-precision float value (32bit, 4 bytes) to the given position in little endian byte order. This method's speed depends on the system's native byte order, and it is possibly slower than putFloat(int, float). For most cases (such as transient storage in memory or serialization for I/O and network), it suffices to know that the byte order in which the value is written is the same as the one in which it is read, and putFloat(int, float) is the preferable choice.
    
    Parameters:
    
    index - The position at which the value will be written.
    
    value - The long value to be written.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 8.
  - putFloatBigEndian
```
public final void putFloatBigEndian(int index,
                                    float value)
```
    Writes the given single-precision float value (32bit, 4 bytes) to the given position in big endian byte order. This method's speed depends on the system's native byte order, and it is possibly slower than putFloat(int, float). For most cases (such as transient storage in memory or serialization for I/O and network), it suffices to know that the byte order in which the value is written is the same as the one in which it is read, and putFloat(int, float) is the preferable choice.
    
    Parameters:
    
    index - The position at which the value will be written.
    
    value - The long value to be written.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 8.
  - getDouble
```
public final double getDouble(int index)
```
    Reads a double-precision floating point value (64bit, 8 bytes) from the given position, in the system's native byte order. This method offers the best speed for double reading and should be used unless a specific byte order is required. In most cases, it suffices to know that the byte order in which the value is written is the same as the one in which it is read (such as transient storage in memory, or serialization for I/O and network), making this method the preferable choice.
    
    Parameters:
    
    index - The position from which the value will be read.
    
    Returns:
    
    The double value at the given position.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 8.
  - getDoubleLittleEndian
```
public final double getDoubleLittleEndian(int index)
```
    Reads a double-precision floating point value (64bit, 8 bytes) from the given position, in little endian byte order. This method's speed depends on the system's native byte order, and it is possibly slower than getDouble(int). For most cases (such as transient storage in memory or serialization for I/O and network), it suffices to know that the byte order in which the value is written is the same as the one in which it is read, and getDouble(int) is the preferable choice.
    
    Parameters:
    
    index - The position from which the value will be read.
    
    Returns:
    
    The long value at the given position.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 8.
  - getDoubleBigEndian
```
public final double getDoubleBigEndian(int index)
```
    Reads a double-precision floating point value (64bit, 8 bytes) from the given position, in big endian byte order. This method's speed depends on the system's native byte order, and it is possibly slower than getDouble(int). For most cases (such as transient storage in memory or serialization for I/O and network), it suffices to know that the byte order in which the value is written is the same as the one in which it is read, and getDouble(int) is the preferable choice.
    
    Parameters:
    
    index - The position from which the value will be read.
    
    Returns:
    
    The long value at the given position.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 8.
  - putDouble
```
public final void putDouble(int index,
                            double value)
```
    Writes the given double-precision floating-point value (64bit, 8 bytes) to the given position in the system's native byte order. This method offers the best speed for double writing and should be used unless a specific byte order is required. In most cases, it suffices to know that the byte order in which the value is written is the same as the one in which it is read (such as transient storage in memory, or serialization for I/O and network), making this method the preferable choice.
    
    Parameters:
    
    index - The position at which the memory will be written.
    
    value - The double value to be written.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 8.
  - putDoubleLittleEndian
```
public final void putDoubleLittleEndian(int index,
                                        double value)
```
    Writes the given double-precision floating-point value (64bit, 8 bytes) to the given position in little endian byte order. This method's speed depends on the system's native byte order, and it is possibly slower than putDouble(int, double). For most cases (such as transient storage in memory or serialization for I/O and network), it suffices to know that the byte order in which the value is written is the same as the one in which it is read, and putDouble(int, double) is the preferable choice.
    
    Parameters:
    
    index - The position at which the value will be written.
    
    value - The long value to be written.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 8.
  - putDoubleBigEndian
```
public final void putDoubleBigEndian(int index,
                                     double value)
```
    Writes the given double-precision floating-point value (64bit, 8 bytes) to the given position in big endian byte order. This method's speed depends on the system's native byte order, and it is possibly slower than putDouble(int, double). For most cases (such as transient storage in memory or serialization for I/O and network), it suffices to know that the byte order in which the value is written is the same as the one in which it is read, and putDouble(int, double) is the preferable choice.
    
    Parameters:
    
    index - The position at which the value will be written.
    
    value - The long value to be written.
    
    Throws:
    
    IndexOutOfBoundsException - Thrown, if the index is negative, or larger then the segment size minus 8.
  - get
```
public abstract void get(DataOutput out,
                         int offset,
                         int length)
                  throws IOException
```
    Throws:
    
    IOException
  - put
```
public abstract void put(DataInput in,
                         int offset,
                         int length)
                  throws IOException
```
    Bulk put method. Copies length memory from the given DataInput to the memory starting at position offset.
    
    Parameters:
    
    in - The DataInput to get the data from.
    
    offset - The position in the memory segment to copy the chunk to.
    
    length - The number of bytes to get.
    
    Throws:
    
    IOException - Thrown, if the DataInput encountered a problem upon reading, such as an End-Of-File.
  - get
```
public abstract void get(int offset,
                         ByteBuffer target,
                         int numBytes)
```
    Bulk get method. Copies numBytes bytes from this memory segment, starting at position offset to the target ByteBuffer. The bytes will be put into the target buffer starting at the buffer's current position. If this method attempts to write more bytes than the target byte buffer has remaining (with respect to Buffer.remaining()), this method will cause a BufferOverflowException.
    
    Parameters:
    
    offset - The position where the bytes are started to be read from in this memory segment.
    
    target - The ByteBuffer to copy the bytes to.
    
    numBytes - The number of bytes to copy.
    
    Throws:
    
    IndexOutOfBoundsException - If the offset is invalid, or this segment does not contain the given number of bytes (starting from offset), or the target byte buffer does not have enough space for the bytes.
  - put
```
public abstract void put(int offset,
                         ByteBuffer source,
                         int numBytes)
```
    Bulk put method. Copies numBytes bytes from the given ByteBuffer, into this memory segment. The bytes will be read from the target buffer starting at the buffer's current position, and will be written to this memory segment starting at offset. If this method attempts to read more bytes than the target byte buffer has remaining (with respect to Buffer.remaining()), this method will cause a BufferUnderflowException.
    
    Parameters:
    
    offset - The position where the bytes are started to be written to in this memory segment.
    
    source - The ByteBuffer to copy the bytes from.
    
    numBytes - The number of bytes to copy.
    
    Throws:
    
    IndexOutOfBoundsException - If the offset is invalid, or the source buffer does not contain the given number of bytes, or this segment does not have enough space for the bytes (counting from offset).
  - copyTo
```
public final void copyTo(int offset,
                         MemorySegment target,
                         int targetOffset,
                         int numBytes)
```
    Bulk copy method. Copies numBytes bytes from this memory segment, starting at position offset to the target memory segment. The bytes will be put into the target segment starting at position targetOffset.
    
    Parameters:
    
    offset - The position where the bytes are started to be read from in this memory segment.
    
    target - The memory segment to copy the bytes to.
    
    targetOffset - The position in the target memory segment to copy the chunk to.
    
    numBytes - The number of bytes to copy.
    
    Throws:
    
    IndexOutOfBoundsException - If either of the offsets is invalid, or the source segment does not contain the given number of bytes (starting from offset), or the target segment does not have enough space for the bytes (counting from targetOffset).
  - compare
```
public final int compare(MemorySegment seg2,
                         int offset1,
                         int offset2,
                         int len)
```
    Compares two memory segment regions.
    
    Parameters:
    
    seg2 - Segment to compare this segment with
    
    offset1 - Offset of this segment to start comparing
    
    offset2 - Offset of seg2 to start comparing
    
    len - Length of the compared memory region
    
    Returns:
    
    0 if equal, -1 if seg1 < seg2, 1 otherwise
  - swapBytes
```
public final void swapBytes(byte[] tempBuffer,
                            MemorySegment seg2,
                            int offset1,
                            int offset2,
                            int len)
```
    Swaps bytes between two memory segments, using the given auxiliary buffer.
    
    Parameters:
    
    tempBuffer - The auxiliary buffer in which to put data during triangle swap.
    
    seg2 - Segment to swap bytes with
    
    offset1 - Offset of this segment to start swapping
    
    offset2 - Offset of seg2 to start swapping
    
    len - Length of the swapped memory region

Back to Flink Website

Class MemorySegment

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

UNSAFE

BYTE_ARRAY_BASE_OFFSET

heapMemory

address

addressLimit

size

Method Detail

size

isFreed

free

isOffHeap

wrap

getOwner

get

put

get

put

get

put

getBoolean

putBoolean

getChar

getCharLittleEndian

getCharBigEndian

putChar

putCharLittleEndian

putCharBigEndian

getShort

getShortLittleEndian

getShortBigEndian

putShort

putShortLittleEndian

putShortBigEndian

getInt

getIntLittleEndian

getIntBigEndian

putInt

putIntLittleEndian

putIntBigEndian

getLong

getLongLittleEndian

getLongBigEndian

putLong

putLongLittleEndian

putLongBigEndian

getFloat

getFloatLittleEndian

getFloatBigEndian

putFloat

putFloatLittleEndian

putFloatBigEndian

getDouble

getDoubleLittleEndian

getDoubleBigEndian

putDouble

putDoubleLittleEndian

putDoubleBigEndian

get

put

get

put

copyTo

compare

swapBytes

Back to Flink Website