eu.aschuetz.nativeutils.api

Interface NativeMemory

All Superinterfaces:

AutoCloseable

public interface NativeMemory
extends AutoCloseable

Interface for a pointer pointing to a memory region.

Method Summary

Modifier and Type	Method and Description
void	close() Closes the memory.
boolean	compareAndSet(long offset, byte[] data)
boolean	compareAndSet(long offset, byte expect, byte update) compares the value at offset with expect if equal sets the value at offset to update and returns true otherwise return false.
boolean	compareAndSet(long offset, int expect, int update) compares the value at offset with expect if equal sets the value at offset to update and returns true otherwise return false.
boolean	compareAndSet(long offset, long expect, long update) compares the value at offset with expect if equal sets the value at offset to update and returns true otherwise return false.
boolean	compareAndSet(long offset, short expect, short update) compares the value at offset with expect if equal sets the value at offset to update and returns true otherwise return false.
long	compareAndSet16ByteAlignment()
long	compareAndSet1ByteAlignment() Returns the amount of alignment needed for addresses to do 1 byte atomic operations on (if supported by cpu)
long	compareAndSet2ByteAlignment() Returns true if the cpu can do 2 byte atomic operations.
long	compareAndSet4ByteAlignment() Returns the amount of alignment needed for addresses to do 4 byte atomic operations on (if supported by cpu)
long	compareAndSet8ByteAlignment() Returns the amount of alignment needed for addresses to do 8 byte atomic operations on (if supported by cpu)
boolean	compareAndSetByte(long offset, byte expect, byte update)
boolean	compareAndSetInt(long offset, int expect, int update)
boolean	compareAndSetLong(long offset, long expect, long update)
boolean	compareAndSetShort(long offset, short expect, short update)
byte	getAndAdd(long offset, byte aByte) adds the parameter to the byte at offset. returns the previous value. this operation is atomic.
int	getAndAdd(long offset, int aInt) adds the parameter to the int at offset. returns the previous value. this operation is atomic.
long	getAndAdd(long offset, long aLong) adds the parameter to the long at offset. returns the previous value. this operation is atomic.
short	getAndAdd(long offset, short aShort) adds the parameter to the short at offset. returns the previous value. this operation is atomic.
byte	getAndAddByte(long offset, byte aByte)
int	getAndAddInt(long offset, int aInt)
long	getAndAddLong(long offset, long aLong)
short	getAndAddShort(long offset, short aShort)
byte	getAndSet(long offset, byte aByte) sets the value at offset to the given byte. returns the previous value. this operation is atomic.
int	getAndSet(long offset, int aInt) sets the value at offset to the given int. returns the previous value. this operation is atomic.
long	getAndSet(long offset, long aLong) sets the value at offset to the given long. returns the previous value. this operation is atomic.
short	getAndSet(long offset, short aShort) sets the value at offset to the given short. returns the previous value. this operation is atomic.
byte	getAndSetByte(long offset, byte aByte)
int	getAndSetInt(long offset, int aInt)
long	getAndSetLong(long offset, long aLong)
short	getAndSetShort(long offset, short aShort)
long	getNativePointer() returns the native pointer assosicated with this memory.
long	getNativePointer(long off) returns the native pointer to the given offset.
long	indexOf(long offset, byte value) Returns the next offset in the memory that has the given value.
boolean	isValid() Returns true if the close() method of this memory has not yet been called.
boolean	isValid(long off) Returns true if the close() method of this memory has not yet been called and the memory is valid for the given offset (at least 1 byte can be read/written at the given offset)
boolean	isValid(long off, long len) Returns true if the close() method of this memory has not yet been called and the memory is valid for the given offset and length
byte	read(long offset) read 1 byte from the offset address.
void	read(long offset, byte[] buffer) reads buffer.length bytes from the offset address and stores them into the buffer starting at offset 0.
void	read(long offset, byte[] buffer, int bufferOffset, int len) reads len bytes from the offset address and stores them into the buffer starting at bufferOffset.
void	read(long offset, byte[] bytes, int size, int off, int len)
void	read(long offset, ByteBuffer buffer, int len) reads len bytes from the offset address and stores them into the buffer.
void	read(long offset, char[] chars, int size, int off, int len)
void	read(long offset, double[] doubles, int off, int len)
void	read(long offset, float[] floats, int off, int len)
void	read(long offset, int[] ints, int size, int off, int len)
void	read(long offset, long[] longs, int size, int off, int len)
void	read(long off, NativeMemory dst, long dstOff, long len) reads len bytes from offset address and stores them into dst.
void	read(long offset, short[] shorts, int size, int off, int len)
double	readDouble(long offset) read 8 bytes from the offset address.
float	readFloat(long offset) read 4 bytes from the offset address.
int	readInt(long offset) read 4 bytes from the offset address.
long	readLong(long offset) read 8 bytes from the offset address.
long	readPointer(long offset) read a pointer from the given offset.
short	readShort(long offset) read 2 bytes from the offset address.
int	readUnsignedByte(long offset) read 1 byte from the offset address and read it as a unsigned byte.
long	readUnsignedInt(long offset) read 4 bytes from the offset address.
int	readUnsignedShort(long offset) reads 2 bytes from the offset address and treats them as a unsigned short.
int	readUntilByte(long offset, byte value, byte[] buffer, int off, int len) reads bytes into a buffer until a byte is encountered that is equal to the value parameter.
long	remaining(long off) returns the amount of bytes remaining to be read/written to until the end of the memory is reached.
void	set(long offset, byte value, long len)
void	set(long offset, int value, long len) Writes len bytes with the given value to the offset.
long	size() returns the size of this memory.
boolean	spin(long offset, byte expect, long aSpinTime, long aTimeout, TimeUnit aUnit) returns true if the value at offset becomes expected.
void	spin(long offset, byte expect, long aSpinTime, TimeUnit aUnit) returns true if the value at offset becomes expected.
boolean	spin(long offset, int expect, long aSpinTime, long aTimeout, TimeUnit aUnit) returns true if the value at offset becomes expected.
void	spin(long offset, int expect, long aSpinTime, TimeUnit aUnit) returns true if the value at offset becomes expected.
boolean	spin(long offset, long expect, long aSpinTime, long aTimeout, TimeUnit aUnit) returns true if the value at offset becomes expected.
void	spin(long offset, long expect, long aSpinTime, TimeUnit aUnit) returns true if the value at offset becomes expected.
boolean	spin(long offset, short expect, long aSpinTime, long aTimeout, TimeUnit aUnit) returns true if the value at offset becomes expected.
void	spin(long offset, short expect, long aSpinTime, TimeUnit aUnit) returns true if the value at offset becomes expected.
boolean	spinAndSet(long offset, byte expect, byte update, long aSpinTime, long aTimeout, TimeUnit aUnit) sets the value to update if it ever becomes expect before aTimeout elapses. returns true if the value was write false if the timeout expired.
void	spinAndSet(long offset, byte expect, byte update, long aSpinTime, TimeUnit aUnit) sets the value to update if it ever becomes expect before aTimeout elapses. returns true if the value was write false if the timeout expired.
boolean	spinAndSet(long offset, int expect, int update, long aSpinTime, long aTimeout, TimeUnit aUnit) sets the value to update if it ever becomes expect before aTimeout elapses. returns true if the value was written false if the timeout expired.
void	spinAndSet(long offset, int expect, int update, long aSpinTime, TimeUnit aUnit) sets the value to update if it ever becomes expect before aTimeout elapses. returns true if the value was write false if the timeout expired.
boolean	spinAndSet(long offset, long expect, long update, long aSpinTime, long aTimeout, TimeUnit aUnit) sets the value to update if it ever becomes expect before aTimeout elapses. returns true if the value was written false if the timeout expired.
void	spinAndSet(long offset, long expect, long update, long aSpinTime, TimeUnit aUnit) sets the value to update if it ever becomes expect before aTimeout elapses. returns true if the value was write false if the timeout expired.
boolean	spinAndSet(long offset, short expect, short update, long aSpinTime, long aTimeout, TimeUnit aUnit) sets the value to update if it ever becomes expect before aTimeout elapses. returns true if the value was written false if the timeout expired.
void	spinAndSet(long offset, short expect, short update, long aSpinTime, TimeUnit aUnit) sets the value to update if it ever becomes expect before aTimeout elapses. returns true if the value was write false if the timeout expired.
void	stopSpin() Stops/Cancels all java calls that are inside the spin(...) methods.
NativeBuffer	stream() Creates a new NativeBuffer instance that can be used to read this memory as one would read a InputStream Every instance of NativeBuffer is completely independent (other than all of them accessing this memory object) Note: the returned object must not be used by multiple threads at once.
NativeBuffer	stream(long offset)
boolean	supportsCompareAndSet16Byte()
boolean	supportsCompareAndSet1Byte() Returns true if the cpu can do 1 byte atomic operations.
boolean	supportsCompareAndSet2Byte() Returns the amount of alignment needed for addresses to do 2 byte atomic operations on (if supported by cpu)
boolean	supportsCompareAndSet4Byte() Returns true if the cpu can do 4 byte atomic operations.
boolean	supportsCompareAndSet8Byte() Returns true if the cpu can do 8 byte atomic operations.
void	sync(long offset, long length, boolean invalidate) Synchronize the changes made to the memory to the device/file backing the memory.
void	write(long offset, byte aByte) writes a single byte to the offset address.
void	write(long offset, byte[] buffer) writes all bytes from the buffer to the offset address in the shared memory.
void	write(long offset, byte[] buffer, int bufferOffset, int len) writes len bytes starting from the index bufferOffset from the buffer to the offset address in the shared memory.
void	write(long offset, byte[] bytes, int size, int off, int len) Writes the byte[] to the memory.
void	write(long offset, ByteBuffer buffer, int len) writes len bytes to the offset address from the buffer.
void	write(long offset, char[] chars, int size, int off, int len) Writes the char[] to the memory.
void	write(long offset, double aDouble) writes 8 bytes to the offset address.
void	write(long offset, double[] doubles, int off, int len) Writes the double[] to memory using 8 bytes per float.
void	write(long offset, float aFloat) writes 4 bytes to the offset address.
void	write(long offset, float[] floats, int off, int len) Writes the float[] to memory using 4 bytes per float.
void	write(long offset, int aInt) writes 4 bytes to the offset address.
void	write(long offset, int[] ints, int size, int off, int len) Writes the int[] to the memory.
void	write(long offset, long aLong) writes 8 bytes to the offset address.
void	write(long offset, long[] longs, int size, int off, int len) Writes the long[] to the memory.
void	write(long offset, short aShort) writes 2 bytes to the offset address.
void	write(long offset, short[] shorts, int size, int off, int len) Writes the short[] to the memory.
void	writeByte(long offset, byte aByte) writes a single byte to the offset address.
void	writeByte(long offset, int aInt)
void	writeDouble(long offset, double aDouble) writes 8 bytes to the offset address.
void	writeFloat(long offset, float aFloat) writes 4 bytes to the offset address.
void	writeInt(long offset, int aInt) writes 4 bytes to the offset address.
void	writeLong(long offset, long aLong) writes 8 bytes to the offset address.
void	writePointer(long offset, long ptr) writes a pointer value to the given offset.
void	writeShort(long offset, int aShort) writes 2 bytes to the offset address.
void	writeShort(long offset, short aShort) writes 2 bytes to the offset address.
void	zero() Sets the entire memory to 0.

Method Detail

close

void close()

Closes the memory. Calling this method when other threads are still using the memory will most likely cause use after free and may lead to the application accessing unexpected memory. This may crash the JVM.

Specified by:

close in interface AutoCloseable

isValid

boolean isValid()

Returns true if the close() method of this memory has not yet been called.

isValid

boolean isValid(long off)

Returns true if the close() method of this memory has not yet been called and the memory is valid for the given offset (at least 1 byte can be read/written at the given offset)

isValid

boolean isValid(long off,
                long len)

Returns true if the close() method of this memory has not yet been called and the memory is valid for the given offset and length

size

long size()

returns the size of this memory.

remaining

long remaining(long off)

returns the amount of bytes remaining to be read/written to until the end of the memory is reached. This is always greater or equal to 0.

Parameters:

off - must be greater or equal to zero

getNativePointer

long getNativePointer()

returns the native pointer assosicated with this memory. the returned value is 0 if the close method has been called. Warning: to ensure that the close() method is not called while the pointer is used it is recommended to acquire the readLock or writeLock of this memory while using the native pointer.

getNativePointer

long getNativePointer(long off)

returns the native pointer to the given offset. Warning: to ensure that the close() method is not called while the pointer is used it is recommended to acquire the readLock or writeLock of this memory while using the native pointer.

sync

void sync(long offset,
          long length,
          boolean invalidate)
   throws SyncFailedException

Synchronize the changes made to the memory to the device/file backing the memory. This is a noop for RAM. Depending on the type of mapping, offset and length may be changed internally to align with a size (such as LinuxNativeUtil.getpagesize()). This change is always guaranteed to contain the entirety of the requested area.

Parameters:

invalidate - if true invalidate other mappings of the same device/file so that they reflect the changes.

Throws:

SyncFailedException - if invalidate was true and another mapping has a memory lock on the region to be invalidated.

set

void set(long offset,
         byte value,
         long len)

set

void set(long offset,
         int value,
         long len)

Writes len bytes with the given value to the offset. Note: value is treated as if cast to a byte. This means the range of "value" is Byte.MIN_VALUE up to 0xff.

zero

void zero()

Sets the entire memory to 0.

write

void write(long offset,
           byte[] buffer,
           int bufferOffset,
           int len)

writes len bytes starting from the index bufferOffset from the buffer to the offset address in the shared memory.

write

void write(long offset,
           byte[] buffer)

writes all bytes from the buffer to the offset address in the shared memory.

write

void write(long offset,
           ByteBuffer buffer,
           int len)

writes len bytes to the offset address from the buffer. The buffers position is incremented by len as a result of this operation.

write

void write(long offset,
           byte[] bytes,
           int size,
           int off,
           int len)

Writes the byte[] to the memory.

Parameters:

size - parameter controls how many bytes are used per index of the array. size = 1 would just write the byte[] as is size = 2 would write a '0' byte followed by the byte size = 3 would write 2 '0' bytes followed by the char ...

read

void read(long offset,
          byte[] bytes,
          int size,
          int off,
          int len)

write

void write(long offset,
           char[] chars,
           int size,
           int off,
           int len)

Writes the char[] to the memory.

Parameters:

size - parameter controls how many bytes are used per index of the array. size = 1 would first cast each char to a byte. size = 3 would write a 0 byte followed by the char size = 4 would write 2 0 bytes followed by the char ...

read

void read(long offset,
          char[] chars,
          int size,
          int off,
          int len)

write

void write(long offset,
           short[] shorts,
           int size,
           int off,
           int len)

Writes the short[] to the memory.

Parameters:

size - parameter controls how many bytes are used per index of the array. size = 1 would first cast each short to a byte. size = 3 would write a 0 byte followed by the short size = 4 would write 2 0 bytes followed by the short ...

read

void read(long offset,
          short[] shorts,
          int size,
          int off,
          int len)

write

void write(long offset,
           int[] ints,
           int size,
           int off,
           int len)

Writes the int[] to the memory.

Parameters:

size - parameter controls how many bytes are used per index of the array. size = 1 would first cast each int to a byte. ... size = 3 would write the 24 least significant bits as 3 bytes. size = 4 would write the int[] as is ... size = 5 would prefix each int with a 0 byte * ...

read

void read(long offset,
          int[] ints,
          int size,
          int off,
          int len)

write

void write(long offset,
           long[] longs,
           int size,
           int off,
           int len)

Writes the long[] to the memory.

Parameters:

size - parameter controls how many bytes are used per index of the array. size = 1 would first cast each long to a byte. ... size = 3 would write the 24 least significant bits as 3 bytes. size = 4 would write each long to a int. ... size = 9 would prefix each long with a 0 byte * ...

read

void read(long offset,
          long[] longs,
          int size,
          int off,
          int len)

write

void write(long offset,
           float[] floats,
           int off,
           int len)

Writes the float[] to memory using 4 bytes per float.

read

void read(long offset,
          float[] floats,
          int off,
          int len)

write

void write(long offset,
           double[] doubles,
           int off,
           int len)

Writes the double[] to memory using 8 bytes per float.

read

void read(long offset,
          double[] doubles,
          int off,
          int len)

write

void write(long offset,
           byte aByte)

writes a single byte to the offset address.

writeByte

void writeByte(long offset,
               byte aByte)

writes a single byte to the offset address.

writeByte

void writeByte(long offset,
               int aInt)

writePointer

void writePointer(long offset,
                  long ptr)

writes a pointer value to the given offset. This may be a 64 bit or 32 bit write.

write

void write(long offset,
           int aInt)

writes 4 bytes to the offset address.

writeInt

void writeInt(long offset,
              int aInt)

writes 4 bytes to the offset address.

write

void write(long offset,
           long aLong)

writes 8 bytes to the offset address.

writeLong

void writeLong(long offset,
               long aLong)

writes 8 bytes to the offset address.

write

void write(long offset,
           float aFloat)

writes 4 bytes to the offset address.

writeFloat

void writeFloat(long offset,
                float aFloat)

writes 4 bytes to the offset address.

write

void write(long offset,
           double aDouble)

writes 8 bytes to the offset address.

writeDouble

void writeDouble(long offset,
                 double aDouble)

writes 8 bytes to the offset address.

write

void write(long offset,
           short aShort)

writes 2 bytes to the offset address.

writeShort

void writeShort(long offset,
                short aShort)

writes 2 bytes to the offset address.

writeShort

void writeShort(long offset,
                int aShort)

writes 2 bytes to the offset address. exists for convenience sake, will literally cast the int to short.

read

void read(long offset,
          byte[] buffer,
          int bufferOffset,
          int len)

reads len bytes from the offset address and stores them into the buffer starting at bufferOffset.

read

void read(long offset,
          byte[] buffer)

reads buffer.length bytes from the offset address and stores them into the buffer starting at offset 0.

read

void read(long off,
          NativeMemory dst,
          long dstOff,
          long len)

reads len bytes from offset address and stores them into dst. dst may be equal to this memory. This method handles overlap as if the bytes were first copied to temporary buffer before being copied to dst.

read

void read(long offset,
          ByteBuffer buffer,
          int len)

reads len bytes from the offset address and stores them into the buffer. The buffers position is incremented by len as a result of this operation.

readInt

int readInt(long offset)

read 4 bytes from the offset address.

readUnsignedInt

long readUnsignedInt(long offset)

read 4 bytes from the offset address. The return value x always satisfies: x >= 0 && x <= 0xFFFFFFFF Note: this is always equivalent to readInt(offset) & 0xFFFFFFFF

readLong

long readLong(long offset)

read 8 bytes from the offset address.

readPointer

long readPointer(long offset)

read a pointer from the given offset. Either a 32 bit or 64 bit read.

readFloat

float readFloat(long offset)

read 4 bytes from the offset address.

readDouble

double readDouble(long offset)

read 8 bytes from the offset address.

readShort

short readShort(long offset)

read 2 bytes from the offset address.

readUnsignedShort

int readUnsignedShort(long offset)

reads 2 bytes from the offset address and treats them as a unsigned short. Note this is always equivalent to readShort(offset) & 0xFFFF

read

byte read(long offset)

read 1 byte from the offset address.

readUnsignedByte

int readUnsignedByte(long offset)

read 1 byte from the offset address and read it as a unsigned byte. Note this is always equivalent to read(offset) & 0xFF

getAndAdd

long getAndAdd(long offset,
               long aLong)

adds the parameter to the long at offset. returns the previous value. this operation is atomic. This operations requires offset alignment(offset must be dividable by 8) on i386 (x86 - 32 bit) jvms otherwise an exceptions is thrown.

getAndAddLong

long getAndAddLong(long offset,
                   long aLong)

getAndAdd

int getAndAdd(long offset,
              int aInt)

adds the parameter to the int at offset. returns the previous value. this operation is atomic.

getAndAddInt

int getAndAddInt(long offset,
                 int aInt)

getAndAdd

short getAndAdd(long offset,
                short aShort)

adds the parameter to the short at offset. returns the previous value. this operation is atomic.

getAndAddShort

short getAndAddShort(long offset,
                     short aShort)

getAndAdd

byte getAndAdd(long offset,
               byte aByte)

adds the parameter to the byte at offset. returns the previous value. this operation is atomic.

getAndAddByte

byte getAndAddByte(long offset,
                   byte aByte)

getAndSet

long getAndSet(long offset,
               long aLong)

sets the value at offset to the given long. returns the previous value. this operation is atomic. This operations requires offset alignment(offset must be dividable by 8) on i386 (x86 - 32 bit) jvms otherwise an exceptions is thrown.

getAndSetLong

long getAndSetLong(long offset,
                   long aLong)

getAndSet

int getAndSet(long offset,
              int aInt)

sets the value at offset to the given int. returns the previous value. this operation is atomic.

getAndSetInt

int getAndSetInt(long offset,
                 int aInt)

getAndSet

short getAndSet(long offset,
                short aShort)

sets the value at offset to the given short. returns the previous value. this operation is atomic.

getAndSetShort

short getAndSetShort(long offset,
                     short aShort)

getAndSet

byte getAndSet(long offset,
               byte aByte)

sets the value at offset to the given byte. returns the previous value. this operation is atomic.

getAndSetByte

byte getAndSetByte(long offset,
                   byte aByte)

compareAndSet

boolean compareAndSet(long offset,
                      long expect,
                      long update)

compares the value at offset with expect if equal sets the value at offset to update and returns true otherwise return false. this operation is atomic. This operations requires offset alignment(offset must be dividable by 8) on i386 (x86 - 32 bit) jvms otherwise an exceptions is thrown.

compareAndSetLong

boolean compareAndSetLong(long offset,
                          long expect,
                          long update)

supportsCompareAndSet8Byte

boolean supportsCompareAndSet8Byte()

Returns true if the cpu can do 8 byte atomic operations.

compareAndSet8ByteAlignment

long compareAndSet8ByteAlignment()

Returns the amount of alignment needed for addresses to do 8 byte atomic operations on (if supported by cpu)

compareAndSet

boolean compareAndSet(long offset,
                      int expect,
                      int update)

compares the value at offset with expect if equal sets the value at offset to update and returns true otherwise return false. this operation is atomic.

compareAndSetInt

boolean compareAndSetInt(long offset,
                         int expect,
                         int update)

supportsCompareAndSet4Byte

boolean supportsCompareAndSet4Byte()

Returns true if the cpu can do 4 byte atomic operations.

compareAndSet4ByteAlignment

long compareAndSet4ByteAlignment()

Returns the amount of alignment needed for addresses to do 4 byte atomic operations on (if supported by cpu)

compareAndSet

boolean compareAndSet(long offset,
                      short expect,
                      short update)

compares the value at offset with expect if equal sets the value at offset to update and returns true otherwise return false. this operation is atomic.

compareAndSetShort

boolean compareAndSetShort(long offset,
                           short expect,
                           short update)

supportsCompareAndSet2Byte

boolean supportsCompareAndSet2Byte()

Returns the amount of alignment needed for addresses to do 2 byte atomic operations on (if supported by cpu)

compareAndSet2ByteAlignment

long compareAndSet2ByteAlignment()

Returns true if the cpu can do 2 byte atomic operations.

compareAndSet

boolean compareAndSet(long offset,
                      byte expect,
                      byte update)

compares the value at offset with expect if equal sets the value at offset to update and returns true otherwise return false. this operation is atomic.

compareAndSetByte

boolean compareAndSetByte(long offset,
                          byte expect,
                          byte update)

supportsCompareAndSet1Byte

boolean supportsCompareAndSet1Byte()

Returns true if the cpu can do 1 byte atomic operations.

compareAndSet1ByteAlignment

long compareAndSet1ByteAlignment()

Returns the amount of alignment needed for addresses to do 1 byte atomic operations on (if supported by cpu)

stopSpin

void stopSpin()

Stops/Cancels all java calls that are inside the spin(...) methods. They will all complete exceptionally. further calls to any spin method will always fail immediately. This call only guarantees that threads stuck in spin calls will return eventually. This method returns immediately and does not guarantee that all threads stuck have returned yet.

spinAndSet

boolean spinAndSet(long offset,
                   long expect,
                   long update,
                   long aSpinTime,
                   long aTimeout,
                   TimeUnit aUnit)

sets the value to update if it ever becomes expect before aTimeout elapses. returns true if the value was written false if the timeout expired. the parameter aSpinTime determines how long the thread should be put to sleep before trying again after a failed attempt. a negative value for aSpinTime indicates that the thread shouldn't be put to sleep. a negative value for aTimeout indicates the method should not timeout and thus never return false.

spinAndSet

boolean spinAndSet(long offset,
                   int expect,
                   int update,
                   long aSpinTime,
                   long aTimeout,
                   TimeUnit aUnit)

sets the value to update if it ever becomes expect before aTimeout elapses. returns true if the value was written false if the timeout expired. the parameter aSpinTime determines how long the thread should be put to sleep before trying again after a failed attempt. a negative value for aSpinTime indicates that the thread shouldn't be put to sleep. a negative value for aTimeout indicates the method should not timeout and thus never return false.

spinAndSet

boolean spinAndSet(long offset,
                   short expect,
                   short update,
                   long aSpinTime,
                   long aTimeout,
                   TimeUnit aUnit)

sets the value to update if it ever becomes expect before aTimeout elapses. returns true if the value was written false if the timeout expired. the parameter aSpinTime determines how long the thread should be put to sleep before trying again after a failed attempt. a negative value for aSpinTime indicates that the thread shouldn't be put to sleep. a negative value for aTimeout indicates the method should not timeout and thus never return false.

spinAndSet

boolean spinAndSet(long offset,
                   byte expect,
                   byte update,
                   long aSpinTime,
                   long aTimeout,
                   TimeUnit aUnit)

sets the value to update if it ever becomes expect before aTimeout elapses. returns true if the value was write false if the timeout expired. the parameter aSpinTime determines how long the thread should be put to sleep before trying again after a failed attempt. a negative value for aSpinTime indicates that the thread shouldn't be put to sleep. a negative value for aTimeout indicates the method should not timeout and thus never return false.

spinAndSet

void spinAndSet(long offset,
                long expect,
                long update,
                long aSpinTime,
                TimeUnit aUnit)

sets the value to update if it ever becomes expect before aTimeout elapses. returns true if the value was write false if the timeout expired. the parameter aSpinTime determines how long the thread should be put to sleep before trying again after a failed attempt. a negative value for aSpinTime indicates that the thread shouldn't be put to sleep.

spinAndSet

void spinAndSet(long offset,
                int expect,
                int update,
                long aSpinTime,
                TimeUnit aUnit)

sets the value to update if it ever becomes expect before aTimeout elapses. returns true if the value was write false if the timeout expired. the parameter aSpinTime determines how long the thread should be put to sleep before trying again after a failed attempt. a negative value for aSpinTime indicates that the thread shouldn't be put to sleep.

spinAndSet

void spinAndSet(long offset,
                short expect,
                short update,
                long aSpinTime,
                TimeUnit aUnit)

sets the value to update if it ever becomes expect before aTimeout elapses. returns true if the value was write false if the timeout expired. the parameter aSpinTime determines how long the thread should be put to sleep before trying again after a failed attempt. a negative value for aSpinTime indicates that the thread shouldn't be put to sleep.

spinAndSet

void spinAndSet(long offset,
                byte expect,
                byte update,
                long aSpinTime,
                TimeUnit aUnit)

sets the value to update if it ever becomes expect before aTimeout elapses. returns true if the value was write false if the timeout expired. the parameter aSpinTime determines how long the thread should be put to sleep before trying again after a failed attempt. a negative value for aSpinTime indicates that the thread shouldn't be put to sleep.

spin

boolean spin(long offset,
             long expect,
             long aSpinTime,
             long aTimeout,
             TimeUnit aUnit)

returns true if the value at offset becomes expected. After every read the Thread sleeps for aSpinTime. Returns if aTimeout elapsed before the value became expect. a negative value for aSpinTime indicates that the thread shouldn't be put to sleep. a negative value for aTimeout indicates the method should not timeout and thus never return false.

spin

boolean spin(long offset,
             int expect,
             long aSpinTime,
             long aTimeout,
             TimeUnit aUnit)

returns true if the value at offset becomes expected. After every read the Thread sleeps for aSpinTime. Returns if aTimeout elapsed before the value became expect. a negative value for aSpinTime indicates that the thread shouldn't be put to sleep. a negative value for aTimeout indicates the method should not timeout and thus never return false.

spin

boolean spin(long offset,
             short expect,
             long aSpinTime,
             long aTimeout,
             TimeUnit aUnit)

returns true if the value at offset becomes expected. After every read the Thread sleeps for aSpinTime. Returns if aTimeout elapsed before the value became expect. a negative value for aSpinTime indicates that the thread shouldn't be put to sleep. a negative value for aTimeout indicates the method should not timeout and thus never return false.

spin

boolean spin(long offset,
             byte expect,
             long aSpinTime,
             long aTimeout,
             TimeUnit aUnit)

returns true if the value at offset becomes expected. After every read the Thread sleeps for aSpinTime. Returns if aTimeout elapsed before the value became expect. a negative value for aSpinTime indicates that the thread shouldn't be put to sleep. a negative value for aTimeout indicates the method should not timeout and thus never return false.

spin

void spin(long offset,
          long expect,
          long aSpinTime,
          TimeUnit aUnit)

returns true if the value at offset becomes expected. After every read the Thread sleeps for aSpinTime. Returns if aTimeout elapsed before the value became expect. a negative value for aSpinTime indicates that the thread shouldn't be put to sleep.

spin

void spin(long offset,
          int expect,
          long aSpinTime,
          TimeUnit aUnit)

returns true if the value at offset becomes expected. After every read the Thread sleeps for aSpinTime. Returns if aTimeout elapsed before the value became expect. a negative value for aSpinTime indicates that the thread shouldn't be put to sleep.

spin

void spin(long offset,
          short expect,
          long aSpinTime,
          TimeUnit aUnit)

returns true if the value at offset becomes expected. After every read the Thread sleeps for aSpinTime. Returns if aTimeout elapsed before the value became expect. a negative value for aSpinTime indicates that the thread shouldn't be put to sleep.

spin

void spin(long offset,
          byte expect,
          long aSpinTime,
          TimeUnit aUnit)

returns true if the value at offset becomes expected. After every read the Thread sleeps for aSpinTime. Returns if aTimeout elapsed before the value became expect. a negative value for aSpinTime indicates that the thread shouldn't be put to sleep.

supportsCompareAndSet16Byte

boolean supportsCompareAndSet16Byte()

compareAndSet16ByteAlignment

long compareAndSet16ByteAlignment()

compareAndSet

boolean compareAndSet(long offset,
                      byte[] data)

indexOf

long indexOf(long offset,
             byte value)

Returns the next offset in the memory that has the given value. the return value is an absolute index meaning it ranges from the given offset up until the maximum valid offset of this memory. returns -1 in case the value is not found anywhere until the end of the memory.

readUntilByte

int readUntilByte(long offset,
                  byte value,
                  byte[] buffer,
                  int off,
                  int len)

reads bytes into a buffer until a byte is encountered that is equal to the value parameter. all bytes up until and including the byte equal to value are read into the given buffer. if the end of the memory or buffer is encountered then reading ceases. After reading has ceased the amount of bytes read is returned (this includes the value byte if it was found). Note: each byte is read individually. This ensures that the 'value' byte will never be encountered twice in the resulting buffer. There can however be no guarantees made in terms of integrity of the read data should the memory be modified concurrently. This method can be used to read zero terminated strings from memory.

Parameters:

len - for optimal performance a value <= 512 is recommended.

offset - this method permits offsets beyond the memory size. The method will just return 0 in those cases.

stream

NativeBuffer stream()

Creates a new NativeBuffer instance that can be used to read this memory as one would read a InputStream Every instance of NativeBuffer is completely independent (other than all of them accessing this memory object) Note: the returned object must not be used by multiple threads at once.

stream

NativeBuffer stream(long offset)