Implement java.nio.ByteBuffers backed by unsafe.Ptr (scala-native#3532)

* Replace existing copy-pasted java.nio classes with code generated from templates
* Implement java.nio.PointerByteBuffer backed by unsafe.Ptr
* Add javalib-intf project used to provide extended  javalib API
* Add PointerByteBuffer tests
* Use common _offset for all types of Buffer implementation

Author: WojciechMazur

build.sbt

@@ -17,6 +17,7 @@ lazy val clib                     = Build.clib
 lazy val posixlib                 = Build.posixlib
 lazy val windowslib               = Build.windowslib
 lazy val javalib                  = Build.javalib
+lazy val javalibintf              = Build.javalibintf
 lazy val javalibExtDummies        = Build.javalibExtDummies
 lazy val auxlib                   = Build.auxlib
 lazy val scalalib                 = Build.scalalib

javalib-intf/src/main/java/scala/scalanative/javalibintf/PointerBuffer.java

@@ -0,0 +1,87 @@
+package scala.scalanative.javalibintf;
+
+import java.nio.ByteBuffer;
+import java.nio.Buffer;
+
+/**
+ * Utilities to interface {@link java.nio.Buffer}s and Scala Native Ptr[_].
+ *
+ * <p>{@link java.nio.Buffer}s can be <em>direct</em> buffers or
+ * <em>indirect</em> buffers. Indirect buffers use an underlying array (like
+ * {@code int[]} in Java or {@code Array[Int]} in Scala). Direct buffers are
+ * supposed to use off-heap memory.
+ *
+ * <p>In a Scala Native environment, the equivalent of off-heap memory for
+ * buffers of primitive numeric types can be access via pointers.
+ *
+ * <p>This class provides methods to wrap Ptr[_] as direct Buffers, and
+ * extract references to TypedArrays from direct Buffers.
+ */
+public final class PointerBuffer {
+  private PointerBuffer() {}
+
+  /**
+   * Wraps a ScalaNative {@code Ptr[Byte]} as a direct
+   * {@link java.nio.ByteBuffer}.
+   *
+   * <p>The provided {@code ptr} and ${@code size} parametesr must be a valid Scala Native
+   * {@code Ptr[Byte]} and size of referenced memory expressed in bytes, 
+   * otherwise the behavior of this method is not specified.
+   *
+   * <p>The returned {@link java.nio.ByteBuffer} has the following properties:
+   *
+   * <ul>
+   *   <li>It has a {@code capacity()} equal to the {@code size}.</li>
+   *   <li>Its initial {@code position()} is 0 and its {@code limit()} is its capacity.</li>
+   *   <li>It is a direct buffer backed by the provided {@code Ptr[Byte]}:
+   *     changes to one are reflected on the other.</li>
+   * </ul>
+   *
+   * @param ptr a ScalaNative {@code Ptr[_]}
+   * @param size size of memory chunk passed by @param ptr
+   * @return direct ByteBuffer backed by @param ptr and capacity/limit of @param size
+   */
+  public static final ByteBuffer wrapPointerByte(Object ptr, int size) {
+    throw new AssertionError("stub");
+  }
+
+  /**
+   * Tests whether the given {@link java.nio.Buffer} is backed by an accessible
+   * Scala Native {@code Ptr[_]}.
+   *
+   * <p>In particular, it is true for all {@link java.nio.Buffer}s created with
+   * any of the {@code wrapPointerX} methods of this class.
+   *
+   * <p>If this method returns {@code true}, then {@code pointer(buffer)}
+   * does not throw any {@link UnsupportedOperationException}.
+   *
+   * @param buffer Any valid {@link Buffer} instance
+   * @return
+   *   true if and only if the provided {@code buffer} is backed by an
+   *   accessible ScalaNative {@code Ptr[_]}
+   *
+   * @see PointerBuffer#pointer(Buffer)
+   */
+  public static final boolean hasPointer(Buffer buffer) {
+    throw new AssertionError("stub");
+  }
+
+   /**
+   * Returns a ScalaNative {@code Ptr[_]} view of the provided
+   * {@link java.nio.Buffer}.
+   *
+   * @param buffer Any valid {@link Buffer} instance
+   * @return
+   *   a ScalaNative {@code Ptr[_]} view of the provided {@code buffer}
+   *
+   * @throws UnsupportedOperationException
+   *   if the provided {@code buffer} is read-only or is not backed by a
+   *   ScalaNative {@code Ptr[_]}, i.e., if {@code hasPointer(buffer)}
+   *   returns {@code false}
+   *
+   * @see PointerBuffer#hasPointer(Buffer)
+   */
+   public static final Object pointer(Buffer buffer) {
+    throw new AssertionError("stub");
+  }
+}

javalib/src/main/scala/java/nio/Buffer.scala

@@ -1,6 +1,7 @@
 package java.nio
 
 // Ported from Scala.js
+import scala.scalanative.unsafe
 
 abstract class Buffer private[nio] (val _capacity: Int) {
   private[nio] type ElementType
@@ -98,15 +99,36 @@ abstract class Buffer private[nio] (val _capacity: Int) {
   override def toString(): String =
     s"${getClass.getName}[pos=${position()} lim=${limit()} cap=${capacity()}]"
 
+  // Extended API
+  final def hasPointer(): Boolean = _rawDataPointer != null && !isReadOnly()
+
+  final def pointer(): unsafe.Ptr[Byte] = {
+    val ptr = _rawDataPointer
+    if (ptr == null || isReadOnly())
+      throw new UnsupportedOperationException
+    ptr
+  }
+
   /* Generic access to methods declared in subclasses.
    * These methods allow to write generic algorithms on any kind of Buffer.
    * The optimizer will get rid of all the overhead.
    * We only declare the methods we need somewhere.
    */
 
-  private[nio] def _array: Array[ElementType]
-  private[nio] def _arrayOffset: Int
-  private[nio] def _mappedData: MappedByteBufferData // Added to ScalaNative
+  private[nio] def _array: Array[ElementType] = null
+  private[nio] def _offset: Int
+
+  // MappedByteBuffer specific
+  private[nio] def _mappedData: MappedByteBufferData = null
+
+  // PointerByteBuffer specific
+  private[nio] def _rawDataPointer: unsafe.Ptr[Byte] = null
+
+  // HeapByteBuffer specific
+  private[nio] def _byteArray: Array[Byte] =
+    throw new UnsupportedOperationException
+  private[nio] def isBigEndian: Boolean =
+    throw new UnsupportedOperationException
 
   /** Loads an element at the given absolute, unchecked index. */
   private[nio] def load(index: Int): ElementType
@@ -130,16 +152,6 @@ abstract class Buffer private[nio] (val _capacity: Int) {
       length: Int
   ): Unit
 
-  /* Only for HeapByteBufferViews -- but that's the only place we can put it.
-   * For all other types, it will be dce'ed.
-   */
-  private[nio] def _byteArray: Array[Byte] =
-    throw new UnsupportedOperationException
-  private[nio] def _byteArrayOffset: Int =
-    throw new UnsupportedOperationException
-  private[nio] def isBigEndian: Boolean =
-    throw new UnsupportedOperationException
-
   // Helpers
 
   @inline private[nio] def ensureNotReadOnly(): Unit = {

javalib/src/main/scala/java/nio/ByteBuffer.scala

@@ -1,7 +1,7 @@
 package java.nio
 
 // Ported from Scala.js
-
+import scala.scalanative.unsafe
 object ByteBuffer {
   private final val HashSeed = -547316498 // "java.nio.ByteBuffer".##
 
@@ -15,13 +15,17 @@ object ByteBuffer {
 
   def wrap(array: Array[Byte]): ByteBuffer =
     wrap(array, 0, array.length)
+
+    // Extended API
+
+  def wrapPointerByte(array: unsafe.Ptr[Byte], length: Int): ByteBuffer =
+    PointerByteBuffer.wrap(array, length)
 }
 
 abstract class ByteBuffer private[nio] (
     _capacity: Int,
-    private[nio] val _array: Array[Byte],
-    private[nio] val _mappedData: MappedByteBufferData,
-    private[nio] val _arrayOffset: Int
+    override private[nio] val _array: Array[Byte],
+    private[nio] val _offset: Int
 ) extends Buffer(_capacity)
     with Comparable[ByteBuffer] {
 
@@ -30,7 +34,7 @@ abstract class ByteBuffer private[nio] (
 
   private def genBuffer = GenBuffer[ByteBuffer](this)
 
-  def this(_capacity: Int) = this(_capacity, null, null, -1)
+  def this(_capacity: Int) = this(_capacity, null: Array[Byte], -1)
 
   private[nio] var _isBigEndian: Boolean = true
 
@@ -73,7 +77,7 @@ abstract class ByteBuffer private[nio] (
     genBuffer.generic_array()
 
   @inline final def arrayOffset(): Int =
-    genBuffer.generic_arrayOffset()
+    genBuffer.generic_offset()
 
   @inline override def position(newPosition: Int): ByteBuffer = {
     super.position(newPosition)

javalib/src/main/scala/java/nio/CharBuffer.scala

@@ -21,9 +21,8 @@ object CharBuffer {
 
 abstract class CharBuffer private[nio] (
     _capacity: Int,
-    private[nio] val _array: Array[Char],
-    private[nio] val _mappedData: MappedByteBufferData,
-    private[nio] val _arrayOffset: Int
+    override private[nio] val _array: Array[Char],
+    private[nio] val _offset: Int
 ) extends Buffer(_capacity)
     with Comparable[CharBuffer]
     with CharSequence
@@ -35,15 +34,15 @@ abstract class CharBuffer private[nio] (
 
   private def genBuffer = GenBuffer[CharBuffer](this)
 
-  def this(_capacity: Int) = this(_capacity, null, null, -1)
+  def this(_capacity: Int) = this(_capacity, null: Array[Char], -1)
 
   def read(target: CharBuffer): Int = {
     // Attention: this method must not change this buffer's position
     val n = remaining()
     if (n == 0) -1
     else if (_array != null) {
       // even if read-only
-      genBuffer.generic_put(_array, _arrayOffset, n)
+      genBuffer.generic_put(_array, _offset, n)
       n
     } else {
       val savedPos = position()
@@ -98,7 +97,7 @@ abstract class CharBuffer private[nio] (
     genBuffer.generic_array()
 
   @inline final def arrayOffset(): Int =
-    genBuffer.generic_arrayOffset()
+    genBuffer.generic_offset()
 
   @inline override def position(newPosition: Int): CharBuffer = {
     super.position(newPosition)
@@ -155,7 +154,7 @@ abstract class CharBuffer private[nio] (
   override def toString(): String = {
     if (_array != null) {
       // even if read-only
-      new String(_array, position() + _arrayOffset, remaining())
+      new String(_array, position() + _offset, remaining())
     } else {
       val chars = new Array[Char](remaining())
       val savedPos = position()

javalib/src/main/scala/java/nio/DoubleBuffer.scala

@@ -16,9 +16,8 @@ object DoubleBuffer {
 
 abstract class DoubleBuffer private[nio] (
     _capacity: Int,
-    private[nio] val _array: Array[Double],
-    private[nio] val _mappedData: MappedByteBufferData,
-    private[nio] val _arrayOffset: Int
+    override private[nio] val _array: Array[Double],
+    private[nio] val _offset: Int
 ) extends Buffer(_capacity)
     with Comparable[DoubleBuffer] {
 
@@ -27,7 +26,7 @@ abstract class DoubleBuffer private[nio] (
 
   private def genBuffer = GenBuffer[DoubleBuffer](this)
 
-  def this(_capacity: Int) = this(_capacity, null, null, -1)
+  def this(_capacity: Int) = this(_capacity, null, -1)
 
   def slice(): DoubleBuffer
 
@@ -68,7 +67,7 @@ abstract class DoubleBuffer private[nio] (
     genBuffer.generic_array()
 
   @inline final def arrayOffset(): Int =
-    genBuffer.generic_arrayOffset()
+    genBuffer.generic_offset()
 
   @inline override def position(newPosition: Int): DoubleBuffer = {
     super.position(newPosition)

javalib/src/main/scala/java/nio/FloatBuffer.scala

@@ -16,9 +16,8 @@ object FloatBuffer {
 
 abstract class FloatBuffer private[nio] (
     _capacity: Int,
-    private[nio] val _array: Array[Float],
-    private[nio] val _mappedData: MappedByteBufferData,
-    private[nio] val _arrayOffset: Int
+    override private[nio] val _array: Array[Float],
+    private[nio] val _offset: Int
 ) extends Buffer(_capacity)
     with Comparable[FloatBuffer] {
 
@@ -27,7 +26,7 @@ abstract class FloatBuffer private[nio] (
 
   private def genBuffer = GenBuffer[FloatBuffer](this)
 
-  def this(_capacity: Int) = this(_capacity, null, null, -1)
+  def this(_capacity: Int) = this(_capacity, null, -1)
 
   def slice(): FloatBuffer
 
@@ -68,7 +67,7 @@ abstract class FloatBuffer private[nio] (
     genBuffer.generic_array()
 
   @inline final def arrayOffset(): Int =
-    genBuffer.generic_arrayOffset()
+    genBuffer.generic_offset()
 
   @inline override def position(newPosition: Int): FloatBuffer = {
     super.position(newPosition)

javalib/src/main/scala/java/nio/GenBuffer.scala

@@ -56,7 +56,7 @@ private[nio] final class GenBuffer[B <: Buffer](val self: B) extends AnyVal {
 
     val srcArray = src._array // even if read-only
     if (srcArray != null) {
-      store(selfPos, srcArray, src._arrayOffset + srcPos, length)
+      store(selfPos, srcArray, src._offset + srcPos, length)
     } else {
       while (srcPos != srcLimit) {
         store(selfPos, src.load(srcPos))
@@ -95,8 +95,8 @@ private[nio] final class GenBuffer[B <: Buffer](val self: B) extends AnyVal {
   }
 
   @inline
-  def generic_arrayOffset(): Int = {
-    val o = _arrayOffset
+  def generic_offset(): Int = {
+    val o = _offset
     if (o == -1)
       throw new UnsupportedOperationException
     if (isReadOnly())