JDK 9 proposal: allocating ByteBuffers on heterogeneous memory

[Dohrmann, Steve]

This is a JDK 9 proposal to support allocation of direct java.nio.ByteBuffer instances backed by memory other than off-heap RAM.

The current allocateDirect() static method in java.nio.ByteBuffer is being used by some applications to meet special memory needs -- in particular, allocating large amounts of memory without contributing significantly to GC pause times.  Other kinds of memory could offer advantages to such applications.  For example, Intel's 3D XPoint memory offers large memory capacities that are more affordable than RAM and speeds that are much faster than NAND storage.  Currently, there is no well-defined interface that can be used to offer a Java developer access to these other kinds of memory.

Specifically, we propose adding a common memory interface that can be implemented by an open-ended set of memory classes.  The interface would provide one method that allocates a java.nio.ByteBuffer on the memory associated with the specific memory instance.

package java.nio;

interface Memory {
   public ByteBuffer allocateByteBuffer(int size);
}

These ByteBuffers will have the same behavior as those allocated by the allocateDirect method in java.nio.ByteBuffer: 1) the ByteBuffer instance is managed on the Java heap, 2) the buffer's backing memory resides on whatever space the memory instance represents, and 3) the backing memory is automatically freed when the ByteBuffer object is garbage collected.

Developers would obtain instances of these Memory objects by calling public constructors on specific memory classes.  We propose having developers call constructors directly because it is a simple way to accommodate varying initialization requirements (e.g. partitioning) that specific memory instances may have.

For uniformity, we propose mirroring the existing off-heap java.nio.ByteBuffer allocation through an off-heap RAM class that implements the Memory interface:

package java.nio;

public class OffHeapRAM implements Memory {
   @Override
   public ByteBuffer allocateByteBuffer(int size) {
       return ByteBuffer.allocateDirect(size);
   }
}

Uniform access could be extended to on-heap ByteBuffers with a class that wraps the non-direct allocation method in ByteBuffer:

package java.nio;

public class HeapRAM implements Memory {
   @Override
   public ByteBuffer allocateByteBuffer(int size) {
       return ByteBuffer.allocate(size);
   }
}

The 3 additions above are the only changes proposed.  Links to a bug report and to a JDK 9 patch containing these additions are shown below.  For sample code, we are also creating a class that implements the Memory interface for java.nio.ByteBuffers backed by Intel's 3D XPoint memory.

bug: https://bugs.openjdk.java.net/browse/JDK-8153111

patch: http://cr.openjdk.java.net/~vdeshpande/8153111/webrev.00/

While other useful capabilities in this space (e.g. persistent memory, process-shared memory) are being explored, they are specifically not addressed or proposed here.  We believe that supporting java.nio.ByteBuffer allocation on other memory spaces is sufficiently useful to propose it now for JDK 9.

Please let us know if there is interest in this proposal and if you would like to sponsor a patch.

Best regards,
Steve Dohrmann