You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@harmony.apache.org by nd...@apache.org on 2009/10/12 02:55:28 UTC
svn commit: r824209 [2/2] -
/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/platform/
Modified: harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/platform/OSFileSystem.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/platform/OSFileSystem.java?rev=824209&r1=824208&r2=824209&view=diff
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/platform/OSFileSystem.java (original)
+++ harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/platform/OSFileSystem.java Mon Oct 12 00:55:27 2009
@@ -35,124 +35,124 @@
}
private OSFileSystem() {
- super();
- }
+ super();
+ }
+
+ private final void validateLockArgs(int type, long start, long length) {
+ if ((type != IFileSystem.SHARED_LOCK_TYPE)
+ && (type != IFileSystem.EXCLUSIVE_LOCK_TYPE)) {
+ throw new IllegalArgumentException("Illegal lock type requested."); //$NON-NLS-1$
+ }
+
+ // Start position
+ if (start < 0) {
+ throw new IllegalArgumentException(
+ "Lock start position must be non-negative"); //$NON-NLS-1$
+ }
+
+ // Length of lock stretch
+ if (length < 0) {
+ throw new IllegalArgumentException(
+ "Lock length must be non-negative"); //$NON-NLS-1$
+ }
+ }
+
+ private native int lockImpl(long fileDescriptor, long start, long length,
+ int type, boolean wait);
+
+ /**
+ * Returns the granularity for virtual memory allocation.
+ * Note that this value for Windows differs from the one for the
+ * page size (64K and 4K respectively).
+ */
+ public native int getAllocGranularity() throws IOException;
+
+ public boolean lock(long fileDescriptor, long start, long length, int type,
+ boolean waitFlag) throws IOException {
+ // Validate arguments
+ validateLockArgs(type, start, length);
+ int result = lockImpl(fileDescriptor, start, length, type, waitFlag);
+ return result != -1;
+ }
+
+ private native int unlockImpl(long fileDescriptor, long start, long length);
+
+ public void unlock(long fileDescriptor, long start, long length)
+ throws IOException {
+ // Validate arguments
+ validateLockArgs(IFileSystem.SHARED_LOCK_TYPE, start, length);
+ int result = unlockImpl(fileDescriptor, start, length);
+ if (result == -1) {
+ throw new IOException();
+ }
+ }
+
+ private native int fflushImpl(long fd, boolean metadata);
+
+ public void fflush(long fileDescriptor, boolean metadata)
+ throws IOException {
+ int result = fflushImpl(fileDescriptor, metadata);
+ if (result == -1) {
+ throw new IOException();
+ }
+ }
- private final void validateLockArgs(int type, long start, long length) {
- if ((type != IFileSystem.SHARED_LOCK_TYPE)
- && (type != IFileSystem.EXCLUSIVE_LOCK_TYPE)) {
- throw new IllegalArgumentException("Illegal lock type requested."); //$NON-NLS-1$
- }
-
- // Start position
- if (start < 0) {
- throw new IllegalArgumentException(
- "Lock start position must be non-negative"); //$NON-NLS-1$
- }
-
- // Length of lock stretch
- if (length < 0) {
- throw new IllegalArgumentException(
- "Lock length must be non-negative"); //$NON-NLS-1$
- }
- }
-
- private native int lockImpl(long fileDescriptor, long start, long length,
- int type, boolean wait);
-
- /**
- * Returns the granularity for virtual memory allocation.
- * Note that this value for Windows differs from the one for the
- * page size (64K and 4K respectively).
- */
- public native int getAllocGranularity() throws IOException;
-
- public boolean lock(long fileDescriptor, long start, long length, int type,
- boolean waitFlag) throws IOException {
- // Validate arguments
- validateLockArgs(type, start, length);
- int result = lockImpl(fileDescriptor, start, length, type, waitFlag);
- return result != -1;
- }
-
- private native int unlockImpl(long fileDescriptor, long start, long length);
-
- public void unlock(long fileDescriptor, long start, long length)
- throws IOException {
- // Validate arguments
- validateLockArgs(IFileSystem.SHARED_LOCK_TYPE, start, length);
- int result = unlockImpl(fileDescriptor, start, length);
- if (result == -1) {
- throw new IOException();
- }
- }
-
- private native int fflushImpl(long fd, boolean metadata);
-
- public void fflush(long fileDescriptor, boolean metadata)
- throws IOException {
- int result = fflushImpl(fileDescriptor, metadata);
- if (result == -1) {
- throw new IOException();
- }
- }
-
- /*
- * File position seeking.
- */
-
- private native long seekImpl(long fd, long offset, int whence);
-
- public long seek(long fileDescriptor, long offset, int whence)
- throws IOException {
- long pos = seekImpl(fileDescriptor, offset, whence);
- if (pos == -1) {
- throw new IOException();
- }
- return pos;
- }
-
- /*
- * Direct read/write APIs work on addresses.
- */
- private native long readDirectImpl(long fileDescriptor, long address,
- int offset, int length);
-
- public long readDirect(long fileDescriptor, long address, int offset,
- int length) throws IOException {
- long bytesRead = readDirectImpl(fileDescriptor, address, offset, length);
- if (bytesRead < -1) {
- throw new IOException();
- }
- return bytesRead;
- }
-
- private native long writeDirectImpl(long fileDescriptor, long address,
- int offset, int length);
-
- public long writeDirect(long fileDescriptor, long address, int offset,
- int length) throws IOException {
- long bytesWritten = writeDirectImpl(fileDescriptor, address, offset,
- length);
- if (bytesWritten < 0) {
- throw new IOException();
- }
- return bytesWritten;
- }
-
- /*
- * Indirect read/writes work on byte[]'s
- */
- private native long readImpl(long fileDescriptor, byte[] bytes, int offset,
- int length);
-
- public long read(long fileDescriptor, byte[] bytes, int offset, int length)
- throws IOException {
- if (bytes == null) {
- throw new NullPointerException();
- }
- long bytesRead = readImpl(fileDescriptor, bytes, offset, length);
- if (bytesRead < -1) {
+ /*
+ * File position seeking.
+ */
+
+ private native long seekImpl(long fd, long offset, int whence);
+
+ public long seek(long fileDescriptor, long offset, int whence)
+ throws IOException {
+ long pos = seekImpl(fileDescriptor, offset, whence);
+ if (pos == -1) {
+ throw new IOException();
+ }
+ return pos;
+ }
+
+ /*
+ * Direct read/write APIs work on addresses.
+ */
+ private native long readDirectImpl(long fileDescriptor, long address,
+ int offset, int length);
+
+ public long readDirect(long fileDescriptor, long address, int offset,
+ int length) throws IOException {
+ long bytesRead = readDirectImpl(fileDescriptor, address, offset, length);
+ if (bytesRead < -1) {
+ throw new IOException();
+ }
+ return bytesRead;
+ }
+
+ private native long writeDirectImpl(long fileDescriptor, long address,
+ int offset, int length);
+
+ public long writeDirect(long fileDescriptor, long address, int offset,
+ int length) throws IOException {
+ long bytesWritten = writeDirectImpl(fileDescriptor, address, offset,
+ length);
+ if (bytesWritten < 0) {
+ throw new IOException();
+ }
+ return bytesWritten;
+ }
+
+ /*
+ * Indirect read/writes work on byte[]'s
+ */
+ private native long readImpl(long fileDescriptor, byte[] bytes, int offset,
+ int length);
+
+ public long read(long fileDescriptor, byte[] bytes, int offset, int length)
+ throws IOException {
+ if (bytes == null) {
+ throw new NullPointerException();
+ }
+ long bytesRead = readImpl(fileDescriptor, bytes, offset, length);
+ if (bytesRead < -1) {
/*
* TODO: bytesRead is never less than -1 so this code
* does nothing?
@@ -161,81 +161,81 @@
* any other cases. But the other cases have been
* ignored until now so fixing this could break things
*/
- throw new IOException();
- }
- return bytesRead;
- }
-
- private native long writeImpl(long fileDescriptor, byte[] bytes,
- int offset, int length);
-
- public long write(long fileDescriptor, byte[] bytes, int offset, int length)
- throws IOException {
- long bytesWritten = writeImpl(fileDescriptor, bytes, offset, length);
- if (bytesWritten < 0) {
- throw new IOException();
- }
- return bytesWritten;
- }
-
- /*
- * Scatter/gather calls.
- */
- public long readv(long fileDescriptor, long[] addresses, int[] offsets,
- int[] lengths, int size) throws IOException {
- long bytesRead = readvImpl(fileDescriptor, addresses, offsets, lengths,
- size);
- if (bytesRead < -1) {
- throw new IOException();
- }
- return bytesRead;
- }
-
- private native long readvImpl(long fileDescriptor, long[] addresses,
- int[] offsets, int[] lengths, int size);
-
- public long writev(long fileDescriptor, long[] addresses, int[] offsets,
- int[] lengths, int size) throws IOException {
- long bytesWritten = writevImpl(fileDescriptor, addresses, offsets,
- lengths, size);
- if (bytesWritten < 0) {
- throw new IOException();
- }
- return bytesWritten;
- }
-
- private native long writevImpl(long fileDescriptor, long[] addresses,
- int[] offsets, int[] lengths, int size);
-
- private native int closeImpl(long fileDescriptor);
-
- /*
- * (non-Javadoc)
- *
- * @see org.apache.harmony.luni.platform.IFileSystem#close(long)
- */
- public void close(long fileDescriptor) throws IOException {
- int rc = closeImpl(fileDescriptor);
- if (rc == -1) {
- throw new IOException();
- }
- }
-
- public void truncate(long fileDescriptor, long size) throws IOException {
- int rc = truncateImpl(fileDescriptor, size);
- if (rc < 0) {
- throw new IOException();
- }
- }
-
- private native int truncateImpl(long fileDescriptor, long size);
-
- public long open(byte[] fileName, int mode) throws FileNotFoundException {
- if (fileName == null) {
- throw new NullPointerException();
- }
- long handler = openImpl(fileName, mode);
- if (handler < 0) {
+ throw new IOException();
+ }
+ return bytesRead;
+ }
+
+ private native long writeImpl(long fileDescriptor, byte[] bytes,
+ int offset, int length);
+
+ public long write(long fileDescriptor, byte[] bytes, int offset, int length)
+ throws IOException {
+ long bytesWritten = writeImpl(fileDescriptor, bytes, offset, length);
+ if (bytesWritten < 0) {
+ throw new IOException();
+ }
+ return bytesWritten;
+ }
+
+ /*
+ * Scatter/gather calls.
+ */
+ public long readv(long fileDescriptor, long[] addresses, int[] offsets,
+ int[] lengths, int size) throws IOException {
+ long bytesRead = readvImpl(fileDescriptor, addresses, offsets, lengths,
+ size);
+ if (bytesRead < -1) {
+ throw new IOException();
+ }
+ return bytesRead;
+ }
+
+ private native long readvImpl(long fileDescriptor, long[] addresses,
+ int[] offsets, int[] lengths, int size);
+
+ public long writev(long fileDescriptor, long[] addresses, int[] offsets,
+ int[] lengths, int size) throws IOException {
+ long bytesWritten = writevImpl(fileDescriptor, addresses, offsets,
+ lengths, size);
+ if (bytesWritten < 0) {
+ throw new IOException();
+ }
+ return bytesWritten;
+ }
+
+ private native long writevImpl(long fileDescriptor, long[] addresses,
+ int[] offsets, int[] lengths, int size);
+
+ private native int closeImpl(long fileDescriptor);
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.apache.harmony.luni.platform.IFileSystem#close(long)
+ */
+ public void close(long fileDescriptor) throws IOException {
+ int rc = closeImpl(fileDescriptor);
+ if (rc == -1) {
+ throw new IOException();
+ }
+ }
+
+ public void truncate(long fileDescriptor, long size) throws IOException {
+ int rc = truncateImpl(fileDescriptor, size);
+ if (rc < 0) {
+ throw new IOException();
+ }
+ }
+
+ private native int truncateImpl(long fileDescriptor, long size);
+
+ public long open(byte[] fileName, int mode) throws FileNotFoundException {
+ if (fileName == null) {
+ throw new NullPointerException();
+ }
+ long handler = openImpl(fileName, mode);
+ if (handler < 0) {
try {
throw new FileNotFoundException(new String(fileName, "UTF-8"));
} catch (java.io.UnsupportedEncodingException e) {
@@ -244,40 +244,40 @@
e.initCause(fnfe);
throw new AssertionError(e);
}
- }
- return handler;
- }
-
- private native long openImpl(byte[] fileName, int mode);
-
- public long transfer(long fileHandler, FileDescriptor socketDescriptor,
- long offset, long count) throws IOException {
- long result = transferImpl(fileHandler, socketDescriptor, offset, count);
- if (result < 0)
- throw new IOException();
- return result;
- }
-
- private native long transferImpl(long fileHandler,
- FileDescriptor socketDescriptor, long offset, long count);
-
- public long ttyAvailable() throws IOException {
- long nChar = ttyAvailableImpl();
- if (nChar < 0) {
- throw new IOException();
- }
- return nChar;
- }
-
- private native long ttyAvailableImpl();
-
- public long ttyRead(byte[] bytes, int offset, int length) throws IOException {
- long nChar = ttyReadImpl(bytes, offset, length);
- if (nChar < 0) {
- throw new IOException();
- }
- return nChar;
- }
+ }
+ return handler;
+ }
+
+ private native long openImpl(byte[] fileName, int mode);
+
+ public long transfer(long fileHandler, FileDescriptor socketDescriptor,
+ long offset, long count) throws IOException {
+ long result = transferImpl(fileHandler, socketDescriptor, offset, count);
+ if (result < 0)
+ throw new IOException();
+ return result;
+ }
+
+ private native long transferImpl(long fileHandler,
+ FileDescriptor socketDescriptor, long offset, long count);
+
+ public long ttyAvailable() throws IOException {
+ long nChar = ttyAvailableImpl();
+ if (nChar < 0) {
+ throw new IOException();
+ }
+ return nChar;
+ }
+
+ private native long ttyAvailableImpl();
+
+ public long ttyRead(byte[] bytes, int offset, int length) throws IOException {
+ long nChar = ttyReadImpl(bytes, offset, length);
+ if (nChar < 0) {
+ throw new IOException();
+ }
+ return nChar;
+ }
- private native long ttyReadImpl(byte[] bytes, int offset, int length);
+ private native long ttyReadImpl(byte[] bytes, int offset, int length);
}
Modified: harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/platform/OSMemory.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/platform/OSMemory.java?rev=824209&r1=824208&r2=824209&view=diff
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/platform/OSMemory.java (original)
+++ harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/platform/OSMemory.java Mon Oct 12 00:55:27 2009
@@ -41,33 +41,33 @@
*/
final class OSMemory implements IMemorySystem {
- /**
- * Defines the size, in bytes, of a native pointer type for the underlying
- * platform. This will be 4 (for 32-bit machines) or 8 (for 64-bit
- * machines).
- */
- public static final int POINTER_SIZE;
-
- /**
- * Defines the natural byte order for this machine.
- */
- public static final Endianness NATIVE_ORDER;
-
- private static final OSMemory singleton = new OSMemory();
-
- static {
- POINTER_SIZE = getPointerSizeImpl();
-
- if (isLittleEndianImpl()) {
- NATIVE_ORDER = Endianness.LITTLE_ENDIAN;
- } else {
- NATIVE_ORDER = Endianness.BIG_ENDIAN;
- }
- }
-
- public static OSMemory getOSMemory() {
- return singleton;
- }
+ /**
+ * Defines the size, in bytes, of a native pointer type for the underlying
+ * platform. This will be 4 (for 32-bit machines) or 8 (for 64-bit
+ * machines).
+ */
+ public static final int POINTER_SIZE;
+
+ /**
+ * Defines the natural byte order for this machine.
+ */
+ public static final Endianness NATIVE_ORDER;
+
+ private static final OSMemory singleton = new OSMemory();
+
+ static {
+ POINTER_SIZE = getPointerSizeImpl();
+
+ if (isLittleEndianImpl()) {
+ NATIVE_ORDER = Endianness.LITTLE_ENDIAN;
+ } else {
+ NATIVE_ORDER = Endianness.BIG_ENDIAN;
+ }
+ }
+
+ public static OSMemory getOSMemory() {
+ return singleton;
+ }
/*
* Native method to determine whether the underlying platform is little
@@ -78,14 +78,14 @@
*/
private static native boolean isLittleEndianImpl();
- /**
- * This class is not designed to be publicly instantiated.
- *
- * @see #getOSMemory()
- */
- private OSMemory() {
- super();
- }
+ /**
+ * This class is not designed to be publicly instantiated.
+ *
+ * @see #getOSMemory()
+ */
+ private OSMemory() {
+ super();
+ }
/**
* Answers whether the byte order of this machine is little endian or not.
@@ -93,510 +93,510 @@
* @return <code>false</code> for Big Endian, and
* <code>true</code> for Little Endian.
*/
- public boolean isLittleEndian() {
- return NATIVE_ORDER == Endianness.LITTLE_ENDIAN;
- }
-
- /**
- * Answers the natural byte order for this machine.
- *
- * @return the native byte order for the current platform.
- */
- public Endianness getNativeOrder() {
- return NATIVE_ORDER;
- }
-
- /**
- * Answers the size of a native pointer type for the underlying platform.
- *
- * @return the size of a pointer, in bytes.
- */
- private static native int getPointerSizeImpl();
-
- public int getPointerSize() {
- return POINTER_SIZE;
- }
-
- /**
- * Allocates and returns a pointer to space for a memory block of
- * <code>length</code> bytes. The space is uninitialized and may be larger
- * than the number of bytes requested; however, the guaranteed usable memory
- * block is exactly <code>length</code> bytes long.
- *
- * @param length
- * number of bytes requested.
- * @return the address of the start of the memory block.
- * @throws OutOfMemoryError
- * if the request cannot be satisfied.
- */
- public native long malloc(long length) throws OutOfMemoryError;
-
- /**
- * Deallocates space for a memory block that was previously allocated by a
- * call to {@link #malloc(long) malloc(long)}. The number of bytes freed is
- * identical to the number of bytes acquired when the memory block was
- * allocated. If <code>address</code> is zero the method does nothing.
- * <p>
- * Freeing a pointer to a memory block that was not allocated by
- * <code>malloc()</code> has unspecified effect.
- * </p>
- *
- * @param address
- * the address of the memory block to deallocate.
- */
- public native void free(long address);
-
- /**
- * Places <code>value</code> into first <code>length</code> bytes of the
- * memory block starting at <code>address</code>.
- * <p>
- * The behavior is unspecified if
- * <code>(address ... address + length)</code> is not wholly within the
- * range that was previously allocated using <code>malloc()</code>.
- * </p>
- *
- * @param address
- * the address of the first memory location.
- * @param value
- * the byte value to set at each location.
- * @param length
- * the number of byte-length locations to set.
- */
- public native void memset(long address, byte value, long length);
-
- /**
- * Copies <code>length</code> bytes from <code>srcAddress</code> to
- * <code>destAddress</code>. Where any part of the source memory block
- * and the destination memory block overlap <code>memmove()</code> ensures
- * that the original source bytes in the overlapping region are copied
- * before being overwritten.
- * <p>
- * The behavior is unspecified if
- * <code>(srcAddress ... srcAddress + length)</code> and
- * <code>(destAddress ... destAddress + length)</code> are not both wholly
- * within the range that was previously allocated using
- * <code>malloc()</code>.
- * </p>
- *
- * @param destAddress
- * the address of the destination memory block.
- * @param srcAddress
- * the address of the source memory block.
- * @param length
- * the number of bytes to move.
- */
- public native void memmove(long destAddress, long srcAddress, long length);
-
- /**
- * Copies <code>length</code> bytes from the memory block at
- * <code>address</code> into the byte array <code>bytes</code> starting
- * at element <code>offset</code> within the byte array.
- * <p>
- * The behavior of this method is undefined if the range
- * <code>(address ... address + length)</code> is not within a memory
- * block that was allocated using {@link #malloc(long) malloc(long)}.
- * </p>
- *
- * @param address
- * the address of the OS memory block from which to copy bytes.
- * @param bytes
- * the byte array into which to copy the bytes.
- * @param offset
- * the index of the first element in <code>bytes</code> that
- * will be overwritten.
- * @param length
- * the total number of bytes to copy into the byte array.
- * @throws NullPointerException
- * if <code>bytes</code> is <code>null</code>.
- * @throws IndexOutOfBoundsException
- * if <code>offset + length > bytes.length</code>.
- */
- public native void getByteArray(long address, byte[] bytes, int offset,
- int length) throws NullPointerException, IndexOutOfBoundsException;
-
- /**
- * Copies <code>length</code> bytes from the byte array <code>bytes</code>
- * into the memory block at <code>address</code>, starting at element
- * <code>offset</code> within the byte array.
- * <p>
- * The behavior of this method is undefined if the range
- * <code>(address ... address + length)</code> is not within a memory
- * block that was allocated using {@link #malloc(long) malloc(long)}.
- * </p>
- *
- * @param address
- * the address of the OS memory block into which to copy the
- * bytes.
- * @param bytes
- * the byte array from which to copy the bytes.
- * @param offset
- * the index of the first element in <code>bytes</code> that
- * will be read.
- * @param length
- * the total number of bytes to copy from <code>bytes</code>
- * into the memory block.
- * @throws NullPointerException
- * if <code>bytes</code> is <code>null</code>.
- * @throws IndexOutOfBoundsException
- * if <code>offset + length > bytes.length</code>.
- */
- public native void setByteArray(long address, byte[] bytes, int offset,
- int length) throws NullPointerException, IndexOutOfBoundsException;
-
- // Primitive get & set methods
-
- /**
- * Gets the value of the single byte at the given address.
- * <p>
- * The behavior is unspecified if <code>address</code> is not in the range
- * that was previously allocated using <code>malloc()</code>.
- * </p>
- *
- * @param address
- * the platform address of the byte.
- * @return the byte value.
- */
- public native byte getByte(long address);
-
- /**
- * Sets the given single byte value at the given address.
- * <p>
- * The behavior is unspecified if <code>address</code> is not in the range
- * that was previously allocated using <code>malloc()</code>.
- * </p>
- *
- * @param address
- * the address at which to set the byte value.
- * @param value
- * the value to set.
- */
- public native void setByte(long address, byte value);
-
- /**
- * Gets the value of the signed two-byte integer stored in platform byte
- * order at the given address.
- * <p>
- * The behavior is unspecified if <code>(address ... address + 2)</code>
- * is not wholly within the range that was previously allocated using
- * <code>malloc()</code>.
- * </p>
- *
- * @param address
- * the platform address of the start of the two-byte value.
- * @return the value of the two-byte integer as a Java <code>short</code>.
- */
- public native short getShort(long address);
-
- public short getShort(long address, Endianness endianness) {
- return (endianness == NATIVE_ORDER) ? getShort(address)
- : swap(getShort(address));
- }
-
- /**
- * Sets the value of the signed two-byte integer at the given address in
- * platform byte order.
- * <p>
- * The behavior is unspecified if <code>(address ... address + 2)</code>
- * is not wholly within the range that was previously allocated using
- * <code>malloc()</code>.
- * </p>
- *
- * @param address
- * the platform address of the start of the two-byte value.
- * @param value
- * the value of the two-byte integer as a Java <code>short</code>.
- */
- public native void setShort(long address, short value);
-
- public void setShort(long address, short value, Endianness endianness) {
- if (endianness == NATIVE_ORDER) {
- setShort(address, value);
- } else {
- setShort(address, swap(value));
- }
- }
-
- /**
- * Gets the value of the signed four-byte integer stored in platform
- * byte-order at the given address.
- * <p>
- * The behavior is unspecified if <code>(address ... address + 4)</code>
- * is not wholly within the range that was previously allocated using
- * <code>malloc()</code>.
- * </p>
- *
- * @param address
- * the platform address of the start of the four-byte value.
- * @return the value of the four-byte integer as a Java <code>int</code>.
- */
- public native int getInt(long address);
-
- public int getInt(long address, Endianness endianness) {
- return (endianness == NATIVE_ORDER) ? getInt(address)
- : swap(getInt(address));
- }
-
- /**
- * Sets the value of the signed four-byte integer at the given address in
- * platform byte order.
- * <p>
- * The behavior is unspecified if <code>(address ... address + 4)</code>
- * is not wholly within the range that was previously allocated using
- * <code>malloc()</code>.
- * </p>
- *
- * @param address
- * the platform address of the start of the four-byte value.
- * @param value
- * the value of the four-byte integer as a Java <code>int</code>.
- */
- public native void setInt(long address, int value);
-
- public void setInt(long address, int value, Endianness endianness) {
- if (endianness == NATIVE_ORDER) {
- setInt(address, value);
- } else {
- setInt(address, swap(value));
- }
- }
-
- /**
- * Gets the value of the signed eight-byte integer stored in platform byte
- * order at the given address.
- * <p>
- * The behavior is unspecified if <code>(address ... address + 8)</code>
- * is not wholly within the range that was previously allocated using
- * <code>malloc()</code>.
- * </p>
- *
- * @param address
- * the platform address of the start of the eight-byte value.
- * @return the value of the eight-byte integer as a Java <code>long</code>.
- */
- public native long getLong(long address);
-
- public long getLong(long address, Endianness endianness) {
- return (endianness == NATIVE_ORDER) ? getLong(address)
- : swap(getLong(address));
- }
-
- /**
- * Sets the value of the signed eight-byte integer at the given address in
- * the platform byte order.
- * <p>
- * The behavior is unspecified if <code>(address ... address + 8)</code>
- * is not wholly within the range that was previously allocated using
- * <code>malloc()</code>.
- * </p>
- *
- * @param address
- * the platform address of the start of the eight-byte value.
- * @param value
- * the value of the eight-byte integer as a Java
- * <code>long</code>.
- */
- public native void setLong(long address, long value);
-
- public void setLong(long address, long value, Endianness endianness) {
- if (endianness == NATIVE_ORDER) {
- setLong(address, value);
- } else {
- setLong(address, swap(value));
- }
- }
-
- /**
- * Gets the value of the IEEE754-format four-byte float stored in platform
- * byte order at the given address.
- * <p>
- * The behavior is unspecified if <code>(address ... address + 4)</code>
- * is not wholly within the range that was previously allocated using
- * <code>malloc()</code>.
- * </p>
- *
- * @param address
- * the platform address of the start of the eight-byte value.
- * @return the value of the four-byte float as a Java <code>float</code>.
- */
- public native float getFloat(long address);
-
- public float getFloat(long address, Endianness endianness) {
- if (endianness == NATIVE_ORDER) {
- return getFloat(address);
- }
- int floatBits = swap(getInt(address));
- return Float.intBitsToFloat(floatBits);
- }
-
- /**
- * Sets the value of the IEEE754-format four-byte float stored in platform
- * byte order at the given address.
- * <p>
- * The behavior is unspecified if <code>(address ... address + 4)</code>
- * is not wholly within the range that was previously allocated using
- * <code>malloc()</code>.
- * </p>
- *
- * @param address
- * the platform address of the start of the eight-byte value.
- * @param value
- * the value of the four-byte float as a Java <code>float</code>.
- */
- public native void setFloat(long address, float value);
-
- public void setFloat(long address, float value, Endianness endianness) {
- if (endianness == NATIVE_ORDER) {
- setFloat(address, value);
- } else {
- int floatBits = Float.floatToIntBits(value);
- setInt(address, swap(floatBits));
- }
- }
-
- /**
- * Gets the value of the IEEE754-format eight-byte float stored in platform
- * byte order at the given address.
- * <p>
- * The behavior is unspecified if <code>(address ... address + 8)</code>
- * is not wholly within the range that was previously allocated using
- * <code>malloc()</code>.
- * </p>
- *
- * @param address
- * the platform address of the start of the eight-byte value.
- * @return the value of the eight-byte float as a Java <code>double</code>.
- */
- public native double getDouble(long address);
-
- public double getDouble(long address, Endianness endianness) {
- if (endianness == NATIVE_ORDER) {
- return getDouble(address);
- }
- long doubleBits = swap(getLong(address));
- return Double.longBitsToDouble(doubleBits);
- }
-
- /**
- * Sets the value of the IEEE754-format eight-byte float store in platform
- * byte order at the given address.
- * <p>
- * The behavior is unspecified if <code>(address ... address + 8)</code>
- * is not wholly within the range that was previously allocated using
- * <code>malloc()</code>.
- * </p>
- *
- * @param address
- * the platform address of the start of the eight-byte value.
- * @param value
- * the value of the eight-byte float as a Java
- * <code>double</code>.
- */
- public native void setDouble(long address, double value);
-
- public void setDouble(long address, double value, Endianness endianness) {
- if (endianness == NATIVE_ORDER) {
- setDouble(address, value);
- } else {
- long doubleBits = Double.doubleToLongBits(value);
- setLong(address, swap(doubleBits));
- }
- }
-
- /**
- * Gets the value of the platform pointer at the given address.
- * <p>
- * The length of the platform pointer is defined by
- * <code>POINTER_SIZE</code>.
- * </p>
- * The behavior is unspecified if
- * <code>(address ... address + POINTER_SIZE)</code> is not wholly within
- * the range that was previously allocated using <code>malloc()</code>.
- * </p>
- *
- * @param address
- * the platform address of the start of the platform pointer.
- * @return the value of the platform pointer as a Java <code>long</code>.
- */
- public native long getAddress(long address);
-
- /**
- * Sets the value of the platform pointer at the given address.
- * <p>
- * The length of the platform pointer is defined by
- * <code>POINTER_SIZE</code>. This method only sets
- * <code>POINTER_SIZE</code> bytes at the given address.
- * </p>
- * The behavior is unspecified if
- * <code>(address ... address + POINTER_SIZE)</code> is not wholly within
- * the range that was previously allocated using <code>malloc()</code>.
- * </p>
- *
- * @param address
- * the platform address of the start of the platform pointer.
- * @param value
- * the value of the platform pointer as a Java <code>long</code>.
- */
- public native void setAddress(long address, long value);
-
- /*
- * Memory mapped file
- */
- private native long mmapImpl(long fileDescriptor, long alignment,
- long size, int mapMode);
+ public boolean isLittleEndian() {
+ return NATIVE_ORDER == Endianness.LITTLE_ENDIAN;
+ }
+
+ /**
+ * Answers the natural byte order for this machine.
+ *
+ * @return the native byte order for the current platform.
+ */
+ public Endianness getNativeOrder() {
+ return NATIVE_ORDER;
+ }
+
+ /**
+ * Answers the size of a native pointer type for the underlying platform.
+ *
+ * @return the size of a pointer, in bytes.
+ */
+ private static native int getPointerSizeImpl();
+
+ public int getPointerSize() {
+ return POINTER_SIZE;
+ }
+
+ /**
+ * Allocates and returns a pointer to space for a memory block of
+ * <code>length</code> bytes. The space is uninitialized and may be larger
+ * than the number of bytes requested; however, the guaranteed usable memory
+ * block is exactly <code>length</code> bytes long.
+ *
+ * @param length
+ * number of bytes requested.
+ * @return the address of the start of the memory block.
+ * @throws OutOfMemoryError
+ * if the request cannot be satisfied.
+ */
+ public native long malloc(long length) throws OutOfMemoryError;
+
+ /**
+ * Deallocates space for a memory block that was previously allocated by a
+ * call to {@link #malloc(long) malloc(long)}. The number of bytes freed is
+ * identical to the number of bytes acquired when the memory block was
+ * allocated. If <code>address</code> is zero the method does nothing.
+ * <p>
+ * Freeing a pointer to a memory block that was not allocated by
+ * <code>malloc()</code> has unspecified effect.
+ * </p>
+ *
+ * @param address
+ * the address of the memory block to deallocate.
+ */
+ public native void free(long address);
+
+ /**
+ * Places <code>value</code> into first <code>length</code> bytes of the
+ * memory block starting at <code>address</code>.
+ * <p>
+ * The behavior is unspecified if
+ * <code>(address ... address + length)</code> is not wholly within the
+ * range that was previously allocated using <code>malloc()</code>.
+ * </p>
+ *
+ * @param address
+ * the address of the first memory location.
+ * @param value
+ * the byte value to set at each location.
+ * @param length
+ * the number of byte-length locations to set.
+ */
+ public native void memset(long address, byte value, long length);
+
+ /**
+ * Copies <code>length</code> bytes from <code>srcAddress</code> to
+ * <code>destAddress</code>. Where any part of the source memory block
+ * and the destination memory block overlap <code>memmove()</code> ensures
+ * that the original source bytes in the overlapping region are copied
+ * before being overwritten.
+ * <p>
+ * The behavior is unspecified if
+ * <code>(srcAddress ... srcAddress + length)</code> and
+ * <code>(destAddress ... destAddress + length)</code> are not both wholly
+ * within the range that was previously allocated using
+ * <code>malloc()</code>.
+ * </p>
+ *
+ * @param destAddress
+ * the address of the destination memory block.
+ * @param srcAddress
+ * the address of the source memory block.
+ * @param length
+ * the number of bytes to move.
+ */
+ public native void memmove(long destAddress, long srcAddress, long length);
+
+ /**
+ * Copies <code>length</code> bytes from the memory block at
+ * <code>address</code> into the byte array <code>bytes</code> starting
+ * at element <code>offset</code> within the byte array.
+ * <p>
+ * The behavior of this method is undefined if the range
+ * <code>(address ... address + length)</code> is not within a memory
+ * block that was allocated using {@link #malloc(long) malloc(long)}.
+ * </p>
+ *
+ * @param address
+ * the address of the OS memory block from which to copy bytes.
+ * @param bytes
+ * the byte array into which to copy the bytes.
+ * @param offset
+ * the index of the first element in <code>bytes</code> that
+ * will be overwritten.
+ * @param length
+ * the total number of bytes to copy into the byte array.
+ * @throws NullPointerException
+ * if <code>bytes</code> is <code>null</code>.
+ * @throws IndexOutOfBoundsException
+ * if <code>offset + length > bytes.length</code>.
+ */
+ public native void getByteArray(long address, byte[] bytes, int offset,
+ int length) throws NullPointerException, IndexOutOfBoundsException;
+
+ /**
+ * Copies <code>length</code> bytes from the byte array <code>bytes</code>
+ * into the memory block at <code>address</code>, starting at element
+ * <code>offset</code> within the byte array.
+ * <p>
+ * The behavior of this method is undefined if the range
+ * <code>(address ... address + length)</code> is not within a memory
+ * block that was allocated using {@link #malloc(long) malloc(long)}.
+ * </p>
+ *
+ * @param address
+ * the address of the OS memory block into which to copy the
+ * bytes.
+ * @param bytes
+ * the byte array from which to copy the bytes.
+ * @param offset
+ * the index of the first element in <code>bytes</code> that
+ * will be read.
+ * @param length
+ * the total number of bytes to copy from <code>bytes</code>
+ * into the memory block.
+ * @throws NullPointerException
+ * if <code>bytes</code> is <code>null</code>.
+ * @throws IndexOutOfBoundsException
+ * if <code>offset + length > bytes.length</code>.
+ */
+ public native void setByteArray(long address, byte[] bytes, int offset,
+ int length) throws NullPointerException, IndexOutOfBoundsException;
+
+ // Primitive get & set methods
+
+ /**
+ * Gets the value of the single byte at the given address.
+ * <p>
+ * The behavior is unspecified if <code>address</code> is not in the range
+ * that was previously allocated using <code>malloc()</code>.
+ * </p>
+ *
+ * @param address
+ * the platform address of the byte.
+ * @return the byte value.
+ */
+ public native byte getByte(long address);
+
+ /**
+ * Sets the given single byte value at the given address.
+ * <p>
+ * The behavior is unspecified if <code>address</code> is not in the range
+ * that was previously allocated using <code>malloc()</code>.
+ * </p>
+ *
+ * @param address
+ * the address at which to set the byte value.
+ * @param value
+ * the value to set.
+ */
+ public native void setByte(long address, byte value);
+
+ /**
+ * Gets the value of the signed two-byte integer stored in platform byte
+ * order at the given address.
+ * <p>
+ * The behavior is unspecified if <code>(address ... address + 2)</code>
+ * is not wholly within the range that was previously allocated using
+ * <code>malloc()</code>.
+ * </p>
+ *
+ * @param address
+ * the platform address of the start of the two-byte value.
+ * @return the value of the two-byte integer as a Java <code>short</code>.
+ */
+ public native short getShort(long address);
+
+ public short getShort(long address, Endianness endianness) {
+ return (endianness == NATIVE_ORDER) ? getShort(address)
+ : swap(getShort(address));
+ }
+
+ /**
+ * Sets the value of the signed two-byte integer at the given address in
+ * platform byte order.
+ * <p>
+ * The behavior is unspecified if <code>(address ... address + 2)</code>
+ * is not wholly within the range that was previously allocated using
+ * <code>malloc()</code>.
+ * </p>
+ *
+ * @param address
+ * the platform address of the start of the two-byte value.
+ * @param value
+ * the value of the two-byte integer as a Java <code>short</code>.
+ */
+ public native void setShort(long address, short value);
+
+ public void setShort(long address, short value, Endianness endianness) {
+ if (endianness == NATIVE_ORDER) {
+ setShort(address, value);
+ } else {
+ setShort(address, swap(value));
+ }
+ }
- public long mmap(long fileDescriptor, long alignment, long size,
- int mapMode) throws IOException {
+ /**
+ * Gets the value of the signed four-byte integer stored in platform
+ * byte-order at the given address.
+ * <p>
+ * The behavior is unspecified if <code>(address ... address + 4)</code>
+ * is not wholly within the range that was previously allocated using
+ * <code>malloc()</code>.
+ * </p>
+ *
+ * @param address
+ * the platform address of the start of the four-byte value.
+ * @return the value of the four-byte integer as a Java <code>int</code>.
+ */
+ public native int getInt(long address);
+
+ public int getInt(long address, Endianness endianness) {
+ return (endianness == NATIVE_ORDER) ? getInt(address)
+ : swap(getInt(address));
+ }
+
+ /**
+ * Sets the value of the signed four-byte integer at the given address in
+ * platform byte order.
+ * <p>
+ * The behavior is unspecified if <code>(address ... address + 4)</code>
+ * is not wholly within the range that was previously allocated using
+ * <code>malloc()</code>.
+ * </p>
+ *
+ * @param address
+ * the platform address of the start of the four-byte value.
+ * @param value
+ * the value of the four-byte integer as a Java <code>int</code>.
+ */
+ public native void setInt(long address, int value);
+
+ public void setInt(long address, int value, Endianness endianness) {
+ if (endianness == NATIVE_ORDER) {
+ setInt(address, value);
+ } else {
+ setInt(address, swap(value));
+ }
+ }
+
+ /**
+ * Gets the value of the signed eight-byte integer stored in platform byte
+ * order at the given address.
+ * <p>
+ * The behavior is unspecified if <code>(address ... address + 8)</code>
+ * is not wholly within the range that was previously allocated using
+ * <code>malloc()</code>.
+ * </p>
+ *
+ * @param address
+ * the platform address of the start of the eight-byte value.
+ * @return the value of the eight-byte integer as a Java <code>long</code>.
+ */
+ public native long getLong(long address);
+
+ public long getLong(long address, Endianness endianness) {
+ return (endianness == NATIVE_ORDER) ? getLong(address)
+ : swap(getLong(address));
+ }
+
+ /**
+ * Sets the value of the signed eight-byte integer at the given address in
+ * the platform byte order.
+ * <p>
+ * The behavior is unspecified if <code>(address ... address + 8)</code>
+ * is not wholly within the range that was previously allocated using
+ * <code>malloc()</code>.
+ * </p>
+ *
+ * @param address
+ * the platform address of the start of the eight-byte value.
+ * @param value
+ * the value of the eight-byte integer as a Java
+ * <code>long</code>.
+ */
+ public native void setLong(long address, long value);
+
+ public void setLong(long address, long value, Endianness endianness) {
+ if (endianness == NATIVE_ORDER) {
+ setLong(address, value);
+ } else {
+ setLong(address, swap(value));
+ }
+ }
+
+ /**
+ * Gets the value of the IEEE754-format four-byte float stored in platform
+ * byte order at the given address.
+ * <p>
+ * The behavior is unspecified if <code>(address ... address + 4)</code>
+ * is not wholly within the range that was previously allocated using
+ * <code>malloc()</code>.
+ * </p>
+ *
+ * @param address
+ * the platform address of the start of the eight-byte value.
+ * @return the value of the four-byte float as a Java <code>float</code>.
+ */
+ public native float getFloat(long address);
+
+ public float getFloat(long address, Endianness endianness) {
+ if (endianness == NATIVE_ORDER) {
+ return getFloat(address);
+ }
+ int floatBits = swap(getInt(address));
+ return Float.intBitsToFloat(floatBits);
+ }
+
+ /**
+ * Sets the value of the IEEE754-format four-byte float stored in platform
+ * byte order at the given address.
+ * <p>
+ * The behavior is unspecified if <code>(address ... address + 4)</code>
+ * is not wholly within the range that was previously allocated using
+ * <code>malloc()</code>.
+ * </p>
+ *
+ * @param address
+ * the platform address of the start of the eight-byte value.
+ * @param value
+ * the value of the four-byte float as a Java <code>float</code>.
+ */
+ public native void setFloat(long address, float value);
+
+ public void setFloat(long address, float value, Endianness endianness) {
+ if (endianness == NATIVE_ORDER) {
+ setFloat(address, value);
+ } else {
+ int floatBits = Float.floatToIntBits(value);
+ setInt(address, swap(floatBits));
+ }
+ }
+
+ /**
+ * Gets the value of the IEEE754-format eight-byte float stored in platform
+ * byte order at the given address.
+ * <p>
+ * The behavior is unspecified if <code>(address ... address + 8)</code>
+ * is not wholly within the range that was previously allocated using
+ * <code>malloc()</code>.
+ * </p>
+ *
+ * @param address
+ * the platform address of the start of the eight-byte value.
+ * @return the value of the eight-byte float as a Java <code>double</code>.
+ */
+ public native double getDouble(long address);
+
+ public double getDouble(long address, Endianness endianness) {
+ if (endianness == NATIVE_ORDER) {
+ return getDouble(address);
+ }
+ long doubleBits = swap(getLong(address));
+ return Double.longBitsToDouble(doubleBits);
+ }
+
+ /**
+ * Sets the value of the IEEE754-format eight-byte float store in platform
+ * byte order at the given address.
+ * <p>
+ * The behavior is unspecified if <code>(address ... address + 8)</code>
+ * is not wholly within the range that was previously allocated using
+ * <code>malloc()</code>.
+ * </p>
+ *
+ * @param address
+ * the platform address of the start of the eight-byte value.
+ * @param value
+ * the value of the eight-byte float as a Java
+ * <code>double</code>.
+ */
+ public native void setDouble(long address, double value);
+
+ public void setDouble(long address, double value, Endianness endianness) {
+ if (endianness == NATIVE_ORDER) {
+ setDouble(address, value);
+ } else {
+ long doubleBits = Double.doubleToLongBits(value);
+ setLong(address, swap(doubleBits));
+ }
+ }
+
+ /**
+ * Gets the value of the platform pointer at the given address.
+ * <p>
+ * The length of the platform pointer is defined by
+ * <code>POINTER_SIZE</code>.
+ * </p>
+ * The behavior is unspecified if
+ * <code>(address ... address + POINTER_SIZE)</code> is not wholly within
+ * the range that was previously allocated using <code>malloc()</code>.
+ * </p>
+ *
+ * @param address
+ * the platform address of the start of the platform pointer.
+ * @return the value of the platform pointer as a Java <code>long</code>.
+ */
+ public native long getAddress(long address);
+
+ /**
+ * Sets the value of the platform pointer at the given address.
+ * <p>
+ * The length of the platform pointer is defined by
+ * <code>POINTER_SIZE</code>. This method only sets
+ * <code>POINTER_SIZE</code> bytes at the given address.
+ * </p>
+ * The behavior is unspecified if
+ * <code>(address ... address + POINTER_SIZE)</code> is not wholly within
+ * the range that was previously allocated using <code>malloc()</code>.
+ * </p>
+ *
+ * @param address
+ * the platform address of the start of the platform pointer.
+ * @param value
+ * the value of the platform pointer as a Java <code>long</code>.
+ */
+ public native void setAddress(long address, long value);
+
+ /*
+ * Memory mapped file
+ */
+ private native long mmapImpl(long fileDescriptor, long alignment,
+ long size, int mapMode);
+
+ public long mmap(long fileDescriptor, long alignment, long size,
+ int mapMode) throws IOException {
// No need to check mmapImpl return as it throws IOException in error cases
- long address = mmapImpl(fileDescriptor, alignment, size, mapMode);
- return address;
- }
-
- private native void unmapImpl(long addr, long size);
-
- public void unmap(long addr, long size) {
- unmapImpl(addr, size);
- }
-
- public void load(long addr, long size) {
- loadImpl(addr, size);
- }
-
- private native int loadImpl(long l, long size);
-
- public boolean isLoaded(long addr, long size) {
- return size == 0 ? true : isLoadedImpl(addr, size);
- }
-
- private native boolean isLoadedImpl(long l, long size);
-
- public void flush(long addr, long size) {
- flushImpl(addr, size);
- }
-
- private native int flushImpl(long l, long size);
-
- /*
- * Helper methods to change byte order.
- */
- private short swap(short value) {
- int topEnd = value << 8;
- int btmEnd = (value >> 8) & 0xFF;
- return (short) (topEnd | btmEnd);
- }
-
- private int swap(int value) {
- short left = (short) (value >> 16);
- short right = (short) value;
- int topEnd = swap(right) << 16;
- int btmEnd = swap(left) & 0xFFFF;
- return topEnd | btmEnd;
- }
-
- private long swap(long value) {
- int left = (int) (value >> 32);
- int right = (int) value;
- long topEnd = ((long) swap(right)) << 32;
- long btmEnd = swap(left) & 0xFFFFFFFFL;
- return topEnd | btmEnd;
- }
+ long address = mmapImpl(fileDescriptor, alignment, size, mapMode);
+ return address;
+ }
+
+ private native void unmapImpl(long addr, long size);
+
+ public void unmap(long addr, long size) {
+ unmapImpl(addr, size);
+ }
+
+ public void load(long addr, long size) {
+ loadImpl(addr, size);
+ }
+
+ private native int loadImpl(long l, long size);
+
+ public boolean isLoaded(long addr, long size) {
+ return size == 0 ? true : isLoadedImpl(addr, size);
+ }
+
+ private native boolean isLoadedImpl(long l, long size);
+
+ public void flush(long addr, long size) {
+ flushImpl(addr, size);
+ }
+
+ private native int flushImpl(long l, long size);
+
+ /*
+ * Helper methods to change byte order.
+ */
+ private short swap(short value) {
+ int topEnd = value << 8;
+ int btmEnd = (value >> 8) & 0xFF;
+ return (short) (topEnd | btmEnd);
+ }
+
+ private int swap(int value) {
+ short left = (short) (value >> 16);
+ short right = (short) value;
+ int topEnd = swap(right) << 16;
+ int btmEnd = swap(left) & 0xFFFF;
+ return topEnd | btmEnd;
+ }
+
+ private long swap(long value) {
+ int left = (int) (value >> 32);
+ int right = (int) value;
+ long topEnd = ((long) swap(right)) << 32;
+ long btmEnd = swap(left) & 0xFFFFFFFFL;
+ return topEnd | btmEnd;
+ }
}
Modified: harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/platform/RuntimeMemorySpy.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/platform/RuntimeMemorySpy.java?rev=824209&r1=824208&r2=824209&view=diff
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/platform/RuntimeMemorySpy.java (original)
+++ harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/platform/RuntimeMemorySpy.java Mon Oct 12 00:55:27 2009
@@ -20,18 +20,18 @@
final class RuntimeMemorySpy extends AbstractMemorySpy {
- public RuntimeMemorySpy() {
- super();
- }
+ public RuntimeMemorySpy() {
+ super();
+ }
- public void alloc(PlatformAddress address) {
- // Pay a tax on the allocation to see if there are any frees pending.
- Reference ref = notifyQueue.poll(); // non-blocking check
- while (ref != null) {
- orphanedMemory(ref);
- ref = notifyQueue.poll();
- }
+ public void alloc(PlatformAddress address) {
+ // Pay a tax on the allocation to see if there are any frees pending.
+ Reference ref = notifyQueue.poll(); // non-blocking check
+ while (ref != null) {
+ orphanedMemory(ref);
+ ref = notifyQueue.poll();
+ }
super.alloc(address);
- }
+ }
}