com.goldencode.p2j.util

Class MemoryManager

java.lang.Object

com.goldencode.p2j.util.MemoryManager

public class MemoryManager
extends java.lang.Object

Provides access to buffers implemented by platform-specific memory buffers instead of the Java heap. The backing functions for this class are implemented via JNI. No real error handling or checking is implemented in these functions. It is expected that the caller will handle all such boundary checking and safety code.

Constructor Summary

Constructors

Constructor and Description
MemoryManager()

Method Summary

Modifier and Type	Method and Description
static long	allocate(long len) Allocate the given number of bytes as a new memory block and return the 64-bit address.
static int	compiledWordSize() Returns the word size (the size of a pointer) for the native code as compiled.
static void	copy(long source, long dest, long offset, long len) Copy the specified range of contents from the source memory block to the destination memory block.
static void	deallocate(long addr) De-allocate the memory block at the given 64-bit address.
static long	findNextNull(long addr, long idx, long size) Returns the next index position into the array which is the null byte, starting at the given index position.
static boolean	isLittleEndian() Reports on the native byte-ordering of the platform on which this library is running.
static byte[]	read(long addr, long offset, long len) Read the specified range of contents from the memory block at the given 64-bit address.
static void	write(long addr, long offset, byte[] data) Write the specified contents to the memory block at the given 64-bit address plus offset.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

MemoryManager

public MemoryManager()

Method Detail

isLittleEndian

public static boolean isLittleEndian()

Reports on the native byte-ordering of the platform on which this library is running.

Returns:

true if the platform uses little-endian byte-ordering, false if the platform is big-endian.

compiledWordSize

public static int compiledWordSize()

Returns the word size (the size of a pointer) for the native code as compiled. This may be different than the word size of the operating system in the case where 32-bit code is run on a 64-bit system.

Returns:

This value will be either 32 or 64 depending on how the native library was compiled.

allocate

public static long allocate(long len)

Allocate the given number of bytes as a new memory block and return the 64-bit address. All bytes in the memory region will be initialized to 0x00.

To duplicate the permissiveness of the 4GL memptr allocation (where certain operations often can read or write past the end of the allocated buffer without an access violation), the buffer allocated by this function will always be 16 bytes larger than the requested size.

Parameters:

len - The size in bytes of the memory region to allocate.

Returns:

The address of the allocated memory region or 0 if memory could not be allocated.

deallocate

public static void deallocate(long addr)

De-allocate the memory block at the given 64-bit address. Memory in this region MUST NOT be accessed after this call.

Parameters:

addr - The 64-bit pointer to a memory region previously allocated using this module. DO NOT pass in an invalid pointer. DO NOT deallocate the same pointer more than once.

findNextNull

public static long findNextNull(long addr,
                                long idx,
                                long size)

Returns the next index position into the array which is the null byte, starting at the given index position.

Parameters:

addr - The 64-bit pointer to a memory region previously allocated using this module. DO NOT pass in an invalid pointer.

idx - The index position at which to start the search.

size - The length of the buffer. If the search reaches this byte without finding a null byte, then this value will be returned. If this is given as -1, then the caller has no size information and we operate in unsafe mode. In this mode the code will read until it finds a null or gets an access violation. This is how the 4GL does it too.

Returns:

The index of the next byte position which contains the null byte or the length of the array if no null byte is contained.

read

public static byte[] read(long addr,
                          long offset,
                          long len)

Read the specified range of contents from the memory block at the given 64-bit address.

Parameters:

addr - The 64-bit pointer to a memory region previously allocated using this module. DO NOT pass in an invalid pointer.

offset - The 0-based index position from the beginning of the buffer, from which to start reading.

len - The number of bytes to read. Must be greater than 0 and must NOT extend past the end of the buffer.

Returns:

The range of bytes read or null if there is any problem allocating the array.

write

public static void write(long addr,
                         long offset,
                         byte[] data)

Write the specified contents to the memory block at the given 64-bit address plus offset.

Parameters:

addr - The 64-bit pointer to a memory region previously allocated using this module. DO NOT pass in an invalid pointer.

offset - The 0-based index position from the beginning of the buffer, at which to start writing.

data - The bytes to write. The entire contents of the array will be written. The length of the array must not be bigger than the number of bytes between the offset and the end of the buffer.

copy

public static void copy(long source,
                        long dest,
                        long offset,
                        long len)

Copy the specified range of contents from the source memory block to the destination memory block.

Parameters:

source - The 64-bit pointer to a memory region previously allocated using this module. DO NOT pass in an invalid pointer.

dest - The 64-bit pointer to a memory region previously allocated using this module. DO NOT pass in an invalid pointer.

offset - The 0-based index position from the beginning of the buffer, at which to start writing.

len - The number of bytes to write. Must be greater than 0 and must NOT extend past the end of the destination buffer.