This is an automated email from the ASF dual-hosted git repository.
leerho pushed a commit to branch frank_grimes_java-21-ffm
in repository https://gitbox.apache.org/repos/asf/datasketches-memory.git
The following commit(s) were added to refs/heads/frank_grimes_java-21-ffm by
this push:
new ff0fbe3 Updating the frank grimes java21 contribution.
ff0fbe3 is described below
commit ff0fbe3e24fce763aa59fd394b55b61439f8f74e
Author: Lee Rhodes <[email protected]>
AuthorDate: Wed Dec 4 16:26:21 2024 -0800
Updating the frank grimes java21 contribution.
---
pom.xml | 36 +++-
.../org/apache/datasketches/memory/Resource.java | 23 ++-
.../apache/datasketches/memory/WritableMemory.java | 33 +++-
.../memory/internal/NativeWritableBufferImpl.java | 155 ++++++++---------
.../memory/internal/NativeWritableMemoryImpl.java | 156 +++++++++++------
.../internal/NonNativeWritableBufferImpl.java | 133 ++++-----------
.../internal/NonNativeWritableMemoryImpl.java | 187 +++++++++++----------
.../datasketches/memory/internal/ResourceImpl.java | 76 +++++++--
.../apache/datasketches/memory/internal/Util.java | 15 +-
.../memory/internal/WritableBufferImpl.java | 10 +-
.../memory/internal/WritableMemoryImpl.java | 18 +-
.../memory/internal/CommonBufferTest.java | 1 +
.../memory/internal/CommonMemoryTest.java | 67 +++++---
.../datasketches/memory/internal/ResourceTest.java | 71 +++++++-
14 files changed, 585 insertions(+), 396 deletions(-)
diff --git a/pom.xml b/pom.xml
index 52252a5..9e33d2b 100644
--- a/pom.xml
+++ b/pom.xml
@@ -25,7 +25,7 @@ under the License.
<modelVersion>4.0.0</modelVersion>
-<!--
+ <!--
<parent>
<groupId>org.apache</groupId>
<artifactId>apache</artifactId>
@@ -108,11 +108,12 @@ under the License.
<maven-gpg-plugin.version>3.2.7</maven-gpg-plugin.version>
<maven-install-plugin.version>3.1.2</maven-install-plugin.version>
<maven-jar-plugin.version>3.4.2</maven-jar-plugin.version>
- <maven-javadoc-plugin.version>3.10.1</maven-javadoc-plugin.version>
+ <maven-javadoc-plugin.version>3.11.1</maven-javadoc-plugin.version>
<maven-release-plugin.version>3.1.1</maven-release-plugin.version>
<maven-remote-resources-plugin.version>3.2.0</maven-remote-resources-plugin.version>
<maven-source-plugin.version>3.3.1</maven-source-plugin.version>
-
<maven-surefire-failsafe-plugins.version>3.5.0</maven-surefire-failsafe-plugins.version>
<!-- for surefire, failsafe and surefire-report -->
+
<maven-surefire-failsafe-plugins.version>3.5.2</maven-surefire-failsafe-plugins.version>
<!-- for surefire, failsafe and surefire-report -->
+ <maven-toolchains-plugin.version>3.2.0</maven-toolchains-plugin.version>
<!-- com.github plugins -->
<git-commit-id-plugin.version>4.9.10</git-commit-id-plugin.version>
<!-- org.apache.creadur plugins -->
@@ -161,8 +162,7 @@ under the License.
<artifactId>maven-compiler-plugin</artifactId>
<version>${maven-compiler-plugin.version}</version>
<configuration>
- <release>21</release>
- <compilerArgs>
+ <compilerArgs>
<arg>${enable.preview}</arg>
</compilerArgs>
</configuration>
@@ -189,7 +189,7 @@ under the License.
<configuration>
<rules>
<requireJavaVersion>
- <version>21</version>
+ <version>${java.version}</version>
</requireJavaVersion>
<requireMavenVersion>
<version>[${maven.version},4.0.0)</version>
@@ -291,6 +291,26 @@ under the License.
</configuration>
</plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-toolchains-plugin</artifactId>
+ <version>${maven-toolchains-plugin.version}</version>
+ <executions>
+ <execution>
+ <goals>
+ <goal>toolchain</goal>
+ </goals>
+ </execution>
+ </executions>
+ <configuration>
+ <toolchains>
+ <jdk>
+ <version>${java.version}</version>
+ </jdk>
+ </toolchains>
+ </configuration>
+ </plugin>
+
<plugin>
<groupId>org.apache.rat</groupId>
<artifactId>apache-rat-plugin</artifactId>
@@ -394,6 +414,10 @@ under the License.
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
</plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-toolchains-plugin</artifactId>
+ </plugin>
<plugin>
<groupId>org.apache.rat</groupId>
<artifactId>apache-rat-plugin</artifactId>
diff --git a/src/main/java/org/apache/datasketches/memory/Resource.java
b/src/main/java/org/apache/datasketches/memory/Resource.java
index 21ab8dd..34baf70 100644
--- a/src/main/java/org/apache/datasketches/memory/Resource.java
+++ b/src/main/java/org/apache/datasketches/memory/Resource.java
@@ -270,7 +270,8 @@ public interface Resource extends AutoCloseable {
/**
* Loads the contents of this mapped segment into physical memory. Please
refer to
- * <a
href="https://docs.oracle.com/en/java/javase/17/docs/api/jdk.incubator.foreign/jdk/incubator/foreign/MemorySegment.html#load()">load()</a>
+ * <a
href="https://docs.oracle.com/en/java/javase/17/docs/api/jdk.incubator.foreign/jdk/incubator/foreign/MemorySegment.html
+#load()">load()</a>
*/
void load();
@@ -286,13 +287,28 @@ public interface Resource extends AutoCloseable {
long nativeOverlap(Resource that);
/**
- * See <a
href="https://docs.oracle.com/en/java/javase/17/docs/api/jdk.incubator.foreign/jdk/incubator/foreign/MemorySegment.html#mismatch(jdk.incubator.foreign.MemorySegment)">mismatch(...)</a>
+ * See <a
href="https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/foreign/MemorySegment.html
+#mismatch(java.lang.foreign.MemorySegment)">mismatch(MemorySegment)</a>
* @param that the other Resource
* @return the relative offset, in bytes, of the first mismatch between this
and the given other Resource object,
* otherwise -1 if no mismatch
*/
long mismatch(Resource that);
+ /**
+ * See <a
href="https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/foreign/MemorySegment.html
+#mismatch(java.lang.foreign.MemorySegment,long,long,java.lang.foreign.MemorySegment,long,long)">
+mismatch(MemorySegment, long, long, MemorySegment, long, long)</a>
+ * @param src the given source Resource
+ * @param srcFromOffset the given start offset of the source region,
inclusive.
+ * @param srcToOffset the given end offset of the source region, exclusive.
+ * @param dst the given destination Resource
+ * @param dstFromOffset the given start of the destination destination
region, inclusive.
+ * @param dstToOffset the given end offset of the destination destination
region, exclusive.
+ * @return the byte offset of the first mismatch relative to the start of
each of the above two regions.
+ */
+ long mismatch(Resource src, long srcFromOffset, long srcToOffset, Resource
dst, long dstFromOffset, long dstToOffset);
+
/**
* Returns the resource scope associated with this memory segment.
* @return the resource scope associated with this memory segment.
@@ -332,8 +348,7 @@ public interface Resource extends AutoCloseable {
/**
* Returns a copy of the underlying MemorySegment.
- * The size is limited to <i>Integer.MAX_VALUE</i>.
- * @return a copy of the underlying MemorySegment
+ * @return a copy of the underlying MemorySegment.
*/
MemorySegment toMemorySegment();
diff --git a/src/main/java/org/apache/datasketches/memory/WritableMemory.java
b/src/main/java/org/apache/datasketches/memory/WritableMemory.java
index 2a764d0..7395ec6 100644
--- a/src/main/java/org/apache/datasketches/memory/WritableMemory.java
+++ b/src/main/java/org/apache/datasketches/memory/WritableMemory.java
@@ -71,7 +71,7 @@ public interface WritableMemory extends Memory {
//MAP
/**
- * Maps the entire given file into native-ordered WritableMemory for write
operations
+ * Maps the entire given file into native-ordered WritableMemory for write
operations with Arena.ofConfined().
* Calling this method is equivalent to calling
* {@link #writableMap(File, long, long, ByteOrder) writableMap(file, 0,
file.length(), ByteOrder.nativeOrder())}.
* @param file the given file to map. It must be non-null and writable.
@@ -82,15 +82,18 @@ public interface WritableMemory extends Memory {
* required by the implementation.
*/
static WritableMemory writableMap(File file) throws IOException {
- return writableMap(file, 0, file.length(), ByteOrder.nativeOrder(),
Arena.ofConfined());
+ return WritableMemoryImpl.wrapMap(file, 0, file.length(),
ByteOrder.nativeOrder(), false, Arena.ofConfined());
}
/**
* Maps the specified portion of the given file into Memory for write
operations with Arena.ofConfined().
+ * Calling this method is equivalent to calling
+ * {@link #writableMap(File, long, long, ByteOrder, Arena)
+ * writableMap(file, fileOffsetBytes, capacityBytes, ByteOrder,
Arena.ofConfined())}.
* @param file the given file to map. It must be non-null with a
non-negative length and writable.
* @param fileOffsetBytes the position in the given file in bytes. It must
not be negative.
* @param capacityBytes the size of the mapped Memory. It must be ≥ 0.
- * @param byteOrder the byte order to be used. It must be non-null.
+ * @param byteOrder the byte order to be used. It must be non-null.
* @return mapped WritableMemory.
* @throws IllegalArgumentException -- if file is not readable or writable.
* @throws IllegalArgumentException -- if file is not writable.
@@ -133,14 +136,34 @@ public interface WritableMemory extends Memory {
/**
* Allocates and provides access to capacityBytes directly in native
(off-heap) memory.
+ * The allocated memory will be 8-byte aligned.
* Native byte order is assumed.
+ * A new DefaultMemoryRequestServer() is created.
+ * A new Arena.ofConfined() is created.
+ *
+ * <p><b>NOTE:</b> Native/Direct memory acquired may have garbage in it.
+ * It is the responsibility of the using application to clear this memory,
if required,
+ * and to call <i>close()</i> when done.</p>
+ * @param capacityBytes the size of the desired memory in bytes.
+ * Warning: This class is not thread-safe.
+ *
+ * @return WritableMemory for this off-heap, native resource.
+ */
+ static WritableMemory allocateDirect(long capacityBytes) {
+ return allocateDirect(capacityBytes, 8, ByteOrder.nativeOrder(), new
DefaultMemoryRequestServer(), Arena.ofConfined());
+ }
+
+ /**
+ * Allocates and provides access to capacityBytes directly in native
(off-heap) memory.
* The allocated memory will be 8-byte aligned.
+ * Native byte order is assumed.
+ * A new DefaultMemoryRequestServer() is created.
*
* <p><b>NOTE:</b> Native/Direct memory acquired may have garbage in it.
* It is the responsibility of the using application to clear this memory,
if required,
* and to call <i>close()</i> when done.</p>
* @param capacityBytes the size of the desired memory in bytes.
- * @param arena the given arena to map. It must be non-null.
+ * @param arena the given arena to use. It must be non-null.
* Warning: This class is not thread-safe. Specifying an Arena that allows
multiple threads is not recommended.
*
* @return WritableMemory for this off-heap, native resource.
@@ -161,7 +184,7 @@ public interface WritableMemory extends Memory {
* @param byteOrder the given <i>ByteOrder</i>. It must be non-null.
* @param memReqSvr A user-specified MemoryRequestServer, which may be null.
* This is a callback mechanism for a user client of direct memory to
request more memory.
- * @param arena the given arena to map. It must be non-null.
+ * @param arena the given arena to use. It must be non-null.
* Warning: This class is not thread-safe. Specifying an Arena that allows
multiple threads is not recommended.
*
* @return a WritableMemory for this off-heap resource.
diff --git
a/src/main/java/org/apache/datasketches/memory/internal/NativeWritableBufferImpl.java
b/src/main/java/org/apache/datasketches/memory/internal/NativeWritableBufferImpl.java
index b254398..588f0d6 100644
---
a/src/main/java/org/apache/datasketches/memory/internal/NativeWritableBufferImpl.java
+++
b/src/main/java/org/apache/datasketches/memory/internal/NativeWritableBufferImpl.java
@@ -19,9 +19,27 @@
package org.apache.datasketches.memory.internal;
+import static java.lang.foreign.ValueLayout.JAVA_CHAR_UNALIGNED;
+import static java.lang.foreign.ValueLayout.JAVA_DOUBLE_UNALIGNED;
+import static java.lang.foreign.ValueLayout.JAVA_FLOAT_UNALIGNED;
+import static java.lang.foreign.ValueLayout.JAVA_INT_UNALIGNED;
+import static java.lang.foreign.ValueLayout.JAVA_LONG_UNALIGNED;
+import static java.lang.foreign.ValueLayout.JAVA_SHORT_UNALIGNED;
+import static
org.apache.datasketches.memory.internal.NativeWritableMemoryImpl.getCharArr;
+import static
org.apache.datasketches.memory.internal.NativeWritableMemoryImpl.getDoubleArr;
+import static
org.apache.datasketches.memory.internal.NativeWritableMemoryImpl.getFloatArr;
+import static
org.apache.datasketches.memory.internal.NativeWritableMemoryImpl.getIntArr;
+import static
org.apache.datasketches.memory.internal.NativeWritableMemoryImpl.getLongArr;
+import static
org.apache.datasketches.memory.internal.NativeWritableMemoryImpl.getShortArr;
+import static
org.apache.datasketches.memory.internal.NativeWritableMemoryImpl.putCharArr;
+import static
org.apache.datasketches.memory.internal.NativeWritableMemoryImpl.putDoubleArr;
+import static
org.apache.datasketches.memory.internal.NativeWritableMemoryImpl.putFloatArr;
+import static
org.apache.datasketches.memory.internal.NativeWritableMemoryImpl.putIntArr;
+import static
org.apache.datasketches.memory.internal.NativeWritableMemoryImpl.putLongArr;
+import static
org.apache.datasketches.memory.internal.NativeWritableMemoryImpl.putShortArr;
+
import java.lang.foreign.Arena;
import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
import org.apache.datasketches.memory.MemoryRequestServer;
import org.apache.datasketches.memory.WritableBuffer;
@@ -59,132 +77,114 @@ final class NativeWritableBufferImpl extends
WritableBufferImpl {
public char getChar() {
final long pos = getPosition();
setPosition(pos + Character.BYTES);
- return seg.get(ValueLayout.JAVA_CHAR_UNALIGNED, pos);
+ return seg.get(JAVA_CHAR_UNALIGNED, pos);
}
@Override
public char getChar(final long offsetBytes) {
- return seg.get(ValueLayout.JAVA_CHAR_UNALIGNED, offsetBytes);
+ return seg.get(JAVA_CHAR_UNALIGNED, offsetBytes);
}
@Override
public void getCharArray(final char[] dstArray, final int dstOffsetChars,
final int lengthChars) {
final long pos = getPosition();
- final long copyBytes = ((long) lengthChars) << CHAR_SHIFT;
- final MemorySegment srcSlice = seg.asSlice(pos, copyBytes);
- final MemorySegment dstSlice =
MemorySegment.ofArray(dstArray).asSlice(dstOffsetChars << CHAR_SHIFT,
copyBytes);
- dstSlice.copyFrom(srcSlice);
- setPosition(pos + copyBytes);
+ getCharArr(seg, pos, dstArray, dstOffsetChars, lengthChars);
+ setPosition(pos + (lengthChars) << CHAR_SHIFT);
}
@Override
public double getDouble() {
final long pos = getPosition();
setPosition(pos + Double.BYTES);
- return seg.get(ValueLayout.JAVA_DOUBLE_UNALIGNED, pos);
+ return seg.get(JAVA_DOUBLE_UNALIGNED, pos);
}
@Override
public double getDouble(final long offsetBytes) {
- return seg.get(ValueLayout.JAVA_DOUBLE_UNALIGNED, offsetBytes);
+ return seg.get(JAVA_DOUBLE_UNALIGNED, offsetBytes);
}
@Override
public void getDoubleArray(final double[] dstArray, final int
dstOffsetDoubles, final int lengthDoubles) {
final long pos = getPosition();
- final long copyBytes = ((long) lengthDoubles) << DOUBLE_SHIFT;
- final MemorySegment srcSlice = seg.asSlice(pos, copyBytes);
- final MemorySegment dstSlice =
MemorySegment.ofArray(dstArray).asSlice(dstOffsetDoubles << DOUBLE_SHIFT,
copyBytes);
- dstSlice.copyFrom(srcSlice);
- setPosition(pos + copyBytes);
+ getDoubleArr(seg, pos, dstArray, dstOffsetDoubles, lengthDoubles);
+ setPosition(pos + (lengthDoubles) << DOUBLE_SHIFT);
}
@Override
public float getFloat() {
final long pos = getPosition();
setPosition(pos + Float.BYTES);
- return seg.get(ValueLayout.JAVA_FLOAT_UNALIGNED, pos);
+ return seg.get(JAVA_FLOAT_UNALIGNED, pos);
}
@Override
public float getFloat(final long offsetBytes) {
- return seg.get(ValueLayout.JAVA_FLOAT_UNALIGNED, offsetBytes);
+ return seg.get(JAVA_FLOAT_UNALIGNED, offsetBytes);
}
@Override
public void getFloatArray(final float[] dstArray, final int dstOffsetFloats,
final int lengthFloats) {
final long pos = getPosition();
- final long copyBytes = ((long) lengthFloats) << FLOAT_SHIFT;
- final MemorySegment srcSlice = seg.asSlice(pos, copyBytes);
- final MemorySegment dstSlice =
MemorySegment.ofArray(dstArray).asSlice(dstOffsetFloats << FLOAT_SHIFT,
copyBytes);
- dstSlice.copyFrom(srcSlice);
- setPosition(pos + copyBytes);
+ getFloatArr(seg, pos, dstArray, dstOffsetFloats, lengthFloats);
+ setPosition(pos + (lengthFloats) << FLOAT_SHIFT);
}
@Override
public int getInt() {
final long pos = getPosition();
setPosition(pos + Integer.BYTES);
- return seg.get(ValueLayout.JAVA_INT_UNALIGNED, pos);
+ return seg.get(JAVA_INT_UNALIGNED, pos);
}
@Override
public int getInt(final long offsetBytes) {
- return seg.get(ValueLayout.JAVA_INT_UNALIGNED, offsetBytes);
+ return seg.get(JAVA_INT_UNALIGNED, offsetBytes);
}
@Override
public void getIntArray(final int[] dstArray, final int dstOffsetInts, final
int lengthInts) {
final long pos = getPosition();
- final long copyBytes = ((long) lengthInts) << INT_SHIFT;
- final MemorySegment srcSlice = seg.asSlice(pos, copyBytes);
- final MemorySegment dstSlice =
MemorySegment.ofArray(dstArray).asSlice(dstOffsetInts << INT_SHIFT, copyBytes);
- dstSlice.copyFrom(srcSlice);
- setPosition(pos + copyBytes);
+ getIntArr(seg, pos, dstArray, dstOffsetInts, lengthInts);
+ setPosition(pos + (lengthInts) << INT_SHIFT);
}
@Override
public long getLong() {
final long pos = getPosition();
setPosition(pos + Long.BYTES);
- return seg.get(ValueLayout.JAVA_LONG_UNALIGNED, pos);
+ return seg.get(JAVA_LONG_UNALIGNED, pos);
}
@Override
public long getLong(final long offsetBytes) {
- return seg.get(ValueLayout.JAVA_LONG_UNALIGNED, offsetBytes);
+ return seg.get(JAVA_LONG_UNALIGNED, offsetBytes);
}
@Override
public void getLongArray(final long[] dstArray, final int dstOffsetLongs,
final int lengthLongs) {
final long pos = getPosition();
- final long copyBytes = ((long) lengthLongs) << LONG_SHIFT;
- final MemorySegment srcSlice = seg.asSlice(pos, copyBytes);
- final MemorySegment dstSlice =
MemorySegment.ofArray(dstArray).asSlice(dstOffsetLongs << LONG_SHIFT,
copyBytes);
- dstSlice.copyFrom(srcSlice);
- setPosition(pos + copyBytes);
+ getLongArr(seg, pos, dstArray, dstOffsetLongs, lengthLongs);
+ setPosition(pos + (lengthLongs) << LONG_SHIFT);
}
@Override
public short getShort() {
final long pos = getPosition();
setPosition(pos + Short.BYTES);
- return seg.get(ValueLayout.JAVA_SHORT_UNALIGNED, pos);
+ return seg.get(JAVA_SHORT_UNALIGNED, pos);
}
@Override
public short getShort(final long offsetBytes) {
- return seg.get(ValueLayout.JAVA_SHORT_UNALIGNED, offsetBytes);
+ return seg.get(JAVA_SHORT_UNALIGNED, offsetBytes);
}
@Override
public void getShortArray(final short[] dstArray, final int dstOffsetShorts,
final int lengthShorts) {
final long pos = getPosition();
- final long copyBytes = ((long) lengthShorts) << SHORT_SHIFT;
- final MemorySegment srcSlice = seg.asSlice(pos, copyBytes);
- final MemorySegment dstSlice =
MemorySegment.ofArray(dstArray).asSlice(dstOffsetShorts << SHORT_SHIFT,
copyBytes);
- dstSlice.copyFrom(srcSlice);
- setPosition(pos + copyBytes);
+ getShortArr(seg, pos, dstArray, dstOffsetShorts, lengthShorts);
+ setPosition(pos + (lengthShorts) << SHORT_SHIFT);
}
//PRIMITIVE putX() and putXArray()
@@ -192,132 +192,113 @@ final class NativeWritableBufferImpl extends
WritableBufferImpl {
public void putChar(final char value) {
final long pos = getPosition();
setPosition(pos + Character.BYTES);
- seg.set(ValueLayout.JAVA_CHAR_UNALIGNED, pos, value);
+ seg.set(JAVA_CHAR_UNALIGNED, pos, value);
}
@Override
public void putChar(final long offsetBytes, final char value) {
- seg.set(ValueLayout.JAVA_CHAR_UNALIGNED, offsetBytes, value);
+ seg.set(JAVA_CHAR_UNALIGNED, offsetBytes, value);
}
@Override
public void putCharArray(final char[] srcArray, final int srcOffsetChars,
final int lengthChars) {
final long pos = getPosition();
- final long copyBytes = ((long) lengthChars) << CHAR_SHIFT;
- final MemorySegment srcSlice =
MemorySegment.ofArray(srcArray).asSlice(srcOffsetChars << CHAR_SHIFT,
copyBytes);
- final MemorySegment dstSlice = seg.asSlice(pos, copyBytes);
- dstSlice.copyFrom(srcSlice);
- setPosition(pos + copyBytes);
+ putCharArr(seg, pos, srcArray, srcOffsetChars, lengthChars);
+ setPosition(pos + (lengthChars) << CHAR_SHIFT);
}
@Override
public void putDouble(final double value) {
final long pos = getPosition();
setPosition(pos + Double.BYTES);
- seg.set(ValueLayout.JAVA_DOUBLE_UNALIGNED, pos, value);
+ seg.set(JAVA_DOUBLE_UNALIGNED, pos, value);
}
@Override
public void putDouble(final long offsetBytes, final double value) {
- seg.set(ValueLayout.JAVA_DOUBLE_UNALIGNED, offsetBytes, value);
+ seg.set(JAVA_DOUBLE_UNALIGNED, offsetBytes, value);
}
@Override
public void putDoubleArray(final double[] srcArray, final int
srcOffsetDoubles, final int lengthDoubles) {
final long pos = getPosition();
- final long copyBytes = ((long) lengthDoubles) << DOUBLE_SHIFT;
- final MemorySegment srcSlice =
MemorySegment.ofArray(srcArray).asSlice(srcOffsetDoubles << DOUBLE_SHIFT,
copyBytes);
- final MemorySegment dstSlice = seg.asSlice(pos, copyBytes);
- dstSlice.copyFrom(srcSlice);
- setPosition(pos + copyBytes);
+ putDoubleArr(seg, pos, srcArray, srcOffsetDoubles, lengthDoubles);
+ setPosition(pos + (lengthDoubles) << DOUBLE_SHIFT);
}
@Override
public void putFloat(final float value) {
final long pos = getPosition();
setPosition(pos + Float.BYTES);
- seg.set(ValueLayout.JAVA_FLOAT_UNALIGNED, pos, value);
+ seg.set(JAVA_FLOAT_UNALIGNED, pos, value);
}
@Override
public void putFloat(final long offsetBytes, final float value) {
- seg.set(ValueLayout.JAVA_FLOAT_UNALIGNED, offsetBytes, value);
+ seg.set(JAVA_FLOAT_UNALIGNED, offsetBytes, value);
}
@Override
public void putFloatArray(final float[] srcArray, final int srcOffsetFloats,
final int lengthFloats) {
final long pos = getPosition();
- final long copyBytes = ((long) lengthFloats) << FLOAT_SHIFT;
- final MemorySegment srcSlice =
MemorySegment.ofArray(srcArray).asSlice(srcOffsetFloats << FLOAT_SHIFT,
copyBytes);
- final MemorySegment dstSlice = seg.asSlice(pos, copyBytes);
- dstSlice.copyFrom(srcSlice);
- setPosition(pos + copyBytes);
+ putFloatArr(seg, pos, srcArray, srcOffsetFloats, lengthFloats);
+ setPosition(pos + (lengthFloats) << FLOAT_SHIFT);
}
@Override
public void putInt(final int value) {
final long pos = getPosition();
setPosition(pos + Integer.BYTES);
- seg.set(ValueLayout.JAVA_INT_UNALIGNED, pos, value);
+ seg.set(JAVA_INT_UNALIGNED, pos, value);
}
@Override
public void putInt(final long offsetBytes, final int value) {
- seg.set(ValueLayout.JAVA_INT_UNALIGNED, offsetBytes, value);
+ seg.set(JAVA_INT_UNALIGNED, offsetBytes, value);
}
@Override
public void putIntArray(final int[] srcArray, final int srcOffsetInts, final
int lengthInts) {
final long pos = getPosition();
- final long copyBytes = ((long) lengthInts) << INT_SHIFT;
- final MemorySegment srcSlice =
MemorySegment.ofArray(srcArray).asSlice(srcOffsetInts << INT_SHIFT, copyBytes);
- final MemorySegment dstSlice = seg.asSlice(pos, copyBytes);
- dstSlice.copyFrom(srcSlice);
- setPosition(pos + copyBytes);
+ putIntArr(seg, pos, srcArray, srcOffsetInts, lengthInts);
+ setPosition(pos + (lengthInts) << INT_SHIFT);
}
@Override
public void putLong(final long value) {
final long pos = getPosition();
setPosition(pos + Long.BYTES);
- seg.set(ValueLayout.JAVA_LONG_UNALIGNED, pos, value);
+ seg.set(JAVA_LONG_UNALIGNED, pos, value);
}
@Override
public void putLong(final long offsetBytes, final long value) {
- seg.set(ValueLayout.JAVA_LONG_UNALIGNED, offsetBytes, value);
+ seg.set(JAVA_LONG_UNALIGNED, offsetBytes, value);
}
@Override
public void putLongArray(final long[] srcArray, final int srcOffsetLongs,
final int lengthLongs) {
final long pos = getPosition();
- final long copyBytes = ((long) lengthLongs) << LONG_SHIFT;
- final MemorySegment srcSlice =
MemorySegment.ofArray(srcArray).asSlice(srcOffsetLongs << LONG_SHIFT,
copyBytes);
- final MemorySegment dstSlice = seg.asSlice(pos, copyBytes);
- dstSlice.copyFrom(srcSlice);
- setPosition(pos + copyBytes);
+ putLongArr(seg, pos, srcArray, srcOffsetLongs, lengthLongs);
+ setPosition(pos + (lengthLongs) << LONG_SHIFT);
}
@Override
public void putShort(final short value) {
final long pos = getPosition();
setPosition(pos + Short.BYTES);
- seg.set(ValueLayout.JAVA_SHORT_UNALIGNED, pos, value);
+ seg.set(JAVA_SHORT_UNALIGNED, pos, value);
}
@Override
public void putShort(final long offsetBytes, final short value) {
- seg.set(ValueLayout.JAVA_SHORT_UNALIGNED, offsetBytes, value);
+ seg.set(JAVA_SHORT_UNALIGNED, offsetBytes, value);
}
@Override
- public void putShortArray(final short[] srcArray, final int srcOffsetShorts,
- final int lengthShorts) {
+ public void putShortArray(final short[] srcArray, final int srcOffsetShorts,
final int lengthShorts) {
final long pos = getPosition();
- final long copyBytes = ((long) lengthShorts) << SHORT_SHIFT;
- final MemorySegment srcSlice =
MemorySegment.ofArray(srcArray).asSlice(srcOffsetShorts << SHORT_SHIFT,
copyBytes);
- final MemorySegment dstSlice = seg.asSlice(pos, copyBytes);
- dstSlice.copyFrom(srcSlice);
- setPosition(pos + copyBytes);
+ putShortArr(seg, pos, srcArray, srcOffsetShorts, lengthShorts);
+ setPosition(pos + (lengthShorts) << SHORT_SHIFT);
}
}
diff --git
a/src/main/java/org/apache/datasketches/memory/internal/NativeWritableMemoryImpl.java
b/src/main/java/org/apache/datasketches/memory/internal/NativeWritableMemoryImpl.java
index 6025ed5..4c5222a 100644
---
a/src/main/java/org/apache/datasketches/memory/internal/NativeWritableMemoryImpl.java
+++
b/src/main/java/org/apache/datasketches/memory/internal/NativeWritableMemoryImpl.java
@@ -19,6 +19,19 @@
package org.apache.datasketches.memory.internal;
+import static java.lang.foreign.ValueLayout.JAVA_CHAR;
+import static java.lang.foreign.ValueLayout.JAVA_CHAR_UNALIGNED;
+import static java.lang.foreign.ValueLayout.JAVA_DOUBLE;
+import static java.lang.foreign.ValueLayout.JAVA_DOUBLE_UNALIGNED;
+import static java.lang.foreign.ValueLayout.JAVA_FLOAT;
+import static java.lang.foreign.ValueLayout.JAVA_FLOAT_UNALIGNED;
+import static java.lang.foreign.ValueLayout.JAVA_INT;
+import static java.lang.foreign.ValueLayout.JAVA_INT_UNALIGNED;
+import static java.lang.foreign.ValueLayout.JAVA_LONG;
+import static java.lang.foreign.ValueLayout.JAVA_LONG_UNALIGNED;
+import static java.lang.foreign.ValueLayout.JAVA_SHORT;
+import static java.lang.foreign.ValueLayout.JAVA_SHORT_UNALIGNED;
+
import java.lang.foreign.Arena;
import java.lang.foreign.MemorySegment;
import java.lang.foreign.ValueLayout;
@@ -50,10 +63,14 @@ final class NativeWritableMemoryImpl extends
WritableMemoryImpl {
@Override
public void getCharArray(final long offsetBytes, final char[] dstArray,
final int dstOffsetChars, final int lengthChars) {
- final long copyBytes = ((long) lengthChars) << CHAR_SHIFT;
- final MemorySegment srcSlice = seg.asSlice(offsetBytes, copyBytes);
- final MemorySegment dstSlice =
MemorySegment.ofArray(dstArray).asSlice(dstOffsetChars << CHAR_SHIFT,
copyBytes);
- dstSlice.copyFrom(srcSlice);
+ getCharArr(seg, offsetBytes, dstArray, dstOffsetChars, lengthChars);
+ }
+
+ static void getCharArr(
+ final MemorySegment seg, final long offsetBytes, final char[] dstArray,
final int dstOffsetChars, final int lengthChars) {
+ final MemorySegment dstSeg = MemorySegment.ofArray(dstArray);
+ final long dstOffsetBytes = ((long) dstOffsetChars) << CHAR_SHIFT;
+ MemorySegment.copy(seg, JAVA_CHAR_UNALIGNED, offsetBytes, dstSeg,
JAVA_CHAR, dstOffsetBytes, lengthChars);
}
@Override
@@ -63,10 +80,14 @@ final class NativeWritableMemoryImpl extends
WritableMemoryImpl {
@Override
public void getDoubleArray(final long offsetBytes, final double[] dstArray,
final int dstOffsetDoubles, final int lengthDoubles) {
- final long copyBytes = ((long) lengthDoubles) << DOUBLE_SHIFT;
- final MemorySegment srcSlice = seg.asSlice(offsetBytes, copyBytes);
- final MemorySegment dstSlice =
MemorySegment.ofArray(dstArray).asSlice(dstOffsetDoubles << DOUBLE_SHIFT,
copyBytes);
- dstSlice.copyFrom(srcSlice);
+ getDoubleArr(seg, offsetBytes, dstArray, dstOffsetDoubles, lengthDoubles);
+ }
+
+ static void getDoubleArr(
+ final MemorySegment seg, final long offsetBytes, final double[]
dstArray, final int dstOffsetDoubles, final int lengthDoubles) {
+ final MemorySegment dstSeg = MemorySegment.ofArray(dstArray);
+ final long dstOffsetBytes = ((long) dstOffsetDoubles) << DOUBLE_SHIFT;
+ MemorySegment.copy(seg, JAVA_DOUBLE_UNALIGNED, offsetBytes, dstSeg,
JAVA_DOUBLE, dstOffsetBytes, lengthDoubles);
}
@Override
@@ -76,10 +97,14 @@ final class NativeWritableMemoryImpl extends
WritableMemoryImpl {
@Override
public void getFloatArray(final long offsetBytes, final float[] dstArray,
final int dstOffsetFloats, final int lengthFloats) {
- final long copyBytes = ((long) lengthFloats) << FLOAT_SHIFT;
- final MemorySegment srcSlice = seg.asSlice(offsetBytes, copyBytes);
- final MemorySegment dstSlice =
MemorySegment.ofArray(dstArray).asSlice(dstOffsetFloats << FLOAT_SHIFT,
copyBytes);
- dstSlice.copyFrom(srcSlice);
+ getFloatArr(seg, offsetBytes, dstArray, dstOffsetFloats, lengthFloats);
+ }
+
+ static void getFloatArr(
+ final MemorySegment seg, final long offsetBytes, final float[] dstArray,
final int dstOffsetFloats, final int lengthFloats) {
+ final MemorySegment dstSeg = MemorySegment.ofArray(dstArray);
+ final long dstOffsetBytes = ((long) dstOffsetFloats) << FLOAT_SHIFT;
+ MemorySegment.copy(seg, JAVA_FLOAT_UNALIGNED, offsetBytes, dstSeg,
JAVA_FLOAT, dstOffsetBytes, lengthFloats);
}
@Override
@@ -89,10 +114,14 @@ final class NativeWritableMemoryImpl extends
WritableMemoryImpl {
@Override
public void getIntArray(final long offsetBytes, final int[] dstArray, final
int dstOffsetInts, final int lengthInts) {
- final long copyBytes = ((long) lengthInts) << INT_SHIFT;
- final MemorySegment srcSlice = seg.asSlice(offsetBytes, copyBytes);
- final MemorySegment dstSlice =
MemorySegment.ofArray(dstArray).asSlice(dstOffsetInts << INT_SHIFT, copyBytes);
- dstSlice.copyFrom(srcSlice);
+ getIntArr(seg, offsetBytes, dstArray, dstOffsetInts, lengthInts);
+ }
+
+ static void getIntArr(
+ final MemorySegment seg, final long offsetBytes, final int[] dstArray,
final int dstOffsetInts, final int lengthInts) {
+ final MemorySegment dstSeg = MemorySegment.ofArray(dstArray);
+ final long dstOffsetBytes = ((long) dstOffsetInts) << INT_SHIFT;
+ MemorySegment.copy(seg, JAVA_INT_UNALIGNED, offsetBytes, dstSeg, JAVA_INT,
dstOffsetBytes, lengthInts);
}
@Override
@@ -102,10 +131,14 @@ final class NativeWritableMemoryImpl extends
WritableMemoryImpl {
@Override
public void getLongArray(final long offsetBytes, final long[] dstArray,
final int dstOffsetLongs, final int lengthLongs) {
- final long copyBytes = ((long) lengthLongs) << LONG_SHIFT;
- final MemorySegment srcSlice = seg.asSlice(offsetBytes, copyBytes);
- final MemorySegment dstSlice =
MemorySegment.ofArray(dstArray).asSlice(dstOffsetLongs << LONG_SHIFT,
copyBytes);
- dstSlice.copyFrom(srcSlice);
+ getLongArr(seg, offsetBytes, dstArray, dstOffsetLongs, lengthLongs);
+ }
+
+ static void getLongArr(
+ final MemorySegment seg, final long offsetBytes, final long[] dstArray,
final int dstOffsetLongs, final int lengthLongs) {
+ final MemorySegment dstSeg = MemorySegment.ofArray(dstArray);
+ final long dstOffsetBytes = ((long) dstOffsetLongs) << LONG_SHIFT;
+ MemorySegment.copy(seg, JAVA_LONG_UNALIGNED, offsetBytes, dstSeg,
JAVA_LONG, dstOffsetBytes, lengthLongs);
}
@Override
@@ -115,10 +148,14 @@ final class NativeWritableMemoryImpl extends
WritableMemoryImpl {
@Override
public void getShortArray(final long offsetBytes, final short[] dstArray,
final int dstOffsetShorts, final int lengthShorts) {
- final long copyBytes = ((long) lengthShorts) << SHORT_SHIFT;
- final MemorySegment srcSlice = seg.asSlice(offsetBytes, copyBytes);
- final MemorySegment dstSlice =
MemorySegment.ofArray(dstArray).asSlice(dstOffsetShorts << SHORT_SHIFT,
copyBytes);
- dstSlice.copyFrom(srcSlice);
+ getShortArr(seg, offsetBytes, dstArray, dstOffsetShorts, lengthShorts);
+ }
+
+ static void getShortArr(
+ final MemorySegment seg, final long offsetBytes, final short[] dstArray,
final int dstOffsetShorts, final int lengthShorts) {
+ final MemorySegment dstSeg = MemorySegment.ofArray(dstArray);
+ final long dstOffsetBytes = ((long) dstOffsetShorts) << SHORT_SHIFT;
+ MemorySegment.copy(seg, JAVA_SHORT_UNALIGNED, offsetBytes, dstSeg,
JAVA_SHORT, dstOffsetBytes, lengthShorts);
}
//PRIMITIVE putX() and putXArray() implementations
@@ -129,10 +166,14 @@ final class NativeWritableMemoryImpl extends
WritableMemoryImpl {
@Override
public void putCharArray(final long offsetBytes, final char[] srcArray,
final int srcOffsetChars, final int lengthChars) {
- final long copyBytes = ((long) lengthChars) << CHAR_SHIFT;
- final MemorySegment srcSlice =
MemorySegment.ofArray(srcArray).asSlice(srcOffsetChars << CHAR_SHIFT,
copyBytes);
- final MemorySegment dstSlice = seg.asSlice(offsetBytes, copyBytes);
- dstSlice.copyFrom(srcSlice);
+ putCharArr(seg, offsetBytes, srcArray, srcOffsetChars, lengthChars);
+ }
+
+ static void putCharArr(
+ final MemorySegment seg, final long offsetBytes, final char[] srcArray,
final int srcOffsetChars, final int lengthChars) {
+ final MemorySegment srcSeg = MemorySegment.ofArray(srcArray);
+ final long srcOffsetBytes = ((long) srcOffsetChars) << CHAR_SHIFT;
+ MemorySegment.copy(srcSeg, JAVA_CHAR, srcOffsetBytes, seg,
JAVA_CHAR_UNALIGNED, offsetBytes, lengthChars);
}
@Override
@@ -142,10 +183,14 @@ final class NativeWritableMemoryImpl extends
WritableMemoryImpl {
@Override
public void putDoubleArray(final long offsetBytes, final double[] srcArray,
final int srcOffsetDoubles, final int lengthDoubles) {
- final long copyBytes = ((long) lengthDoubles) << DOUBLE_SHIFT;
- final MemorySegment srcSlice =
MemorySegment.ofArray(srcArray).asSlice(srcOffsetDoubles << DOUBLE_SHIFT,
copyBytes);
- final MemorySegment dstSlice = seg.asSlice(offsetBytes, copyBytes);
- dstSlice.copyFrom(srcSlice);
+ putDoubleArr(seg, offsetBytes, srcArray, srcOffsetDoubles, lengthDoubles);
+ }
+
+ static void putDoubleArr(
+ final MemorySegment seg, final long offsetBytes, final double[]
srcArray, final int srcOffsetDoubles, final int lengthDoubles) {
+ final MemorySegment srcSeg = MemorySegment.ofArray(srcArray);
+ final long srcOffsetBytes = ((long) srcOffsetDoubles) << DOUBLE_SHIFT;
+ MemorySegment.copy(srcSeg, JAVA_DOUBLE, srcOffsetBytes, seg,
JAVA_DOUBLE_UNALIGNED, offsetBytes, lengthDoubles);
}
@Override
@@ -155,10 +200,14 @@ final class NativeWritableMemoryImpl extends
WritableMemoryImpl {
@Override
public void putFloatArray(final long offsetBytes, final float[] srcArray,
final int srcOffsetFloats, final int lengthFloats) {
- final long copyBytes = ((long) lengthFloats) << FLOAT_SHIFT;
- final MemorySegment srcSlice =
MemorySegment.ofArray(srcArray).asSlice(srcOffsetFloats << FLOAT_SHIFT,
copyBytes);
- final MemorySegment dstSlice = seg.asSlice(offsetBytes, copyBytes);
- dstSlice.copyFrom(srcSlice);
+ putFloatArr(seg, offsetBytes, srcArray, srcOffsetFloats, lengthFloats);
+ }
+
+ static void putFloatArr(
+ final MemorySegment seg, final long offsetBytes, final float[] srcArray,
final int srcOffsetFloats, final int lengthFloats) {
+ final MemorySegment srcSeg = MemorySegment.ofArray(srcArray);
+ final long srcOffsetBytes = ((long) srcOffsetFloats) << FLOAT_SHIFT;
+ MemorySegment.copy(srcSeg, JAVA_FLOAT, srcOffsetBytes, seg,
JAVA_FLOAT_UNALIGNED, offsetBytes, lengthFloats);
}
@Override
@@ -168,10 +217,14 @@ final class NativeWritableMemoryImpl extends
WritableMemoryImpl {
@Override
public void putIntArray(final long offsetBytes, final int[] srcArray, final
int srcOffsetInts, final int lengthInts) {
- final long copyBytes = ((long) lengthInts) << INT_SHIFT;
- final MemorySegment srcSlice =
MemorySegment.ofArray(srcArray).asSlice(srcOffsetInts << INT_SHIFT, copyBytes);
- final MemorySegment dstSlice = seg.asSlice(offsetBytes, copyBytes);
- dstSlice.copyFrom(srcSlice);
+ putIntArr(seg, offsetBytes, srcArray, srcOffsetInts, lengthInts);
+ }
+
+ static void putIntArr(
+ final MemorySegment seg, final long offsetBytes, final int[] srcArray,
final int srcOffsetInts, final int lengthInts) {
+ final MemorySegment srcSeg = MemorySegment.ofArray(srcArray);
+ final long srcOffsetBytes = ((long) srcOffsetInts) << INT_SHIFT;
+ MemorySegment.copy(srcSeg, JAVA_INT, srcOffsetBytes, seg,
JAVA_INT_UNALIGNED, offsetBytes, lengthInts);
}
@Override
@@ -181,10 +234,14 @@ final class NativeWritableMemoryImpl extends
WritableMemoryImpl {
@Override
public void putLongArray(final long offsetBytes, final long[] srcArray,
final int srcOffsetLongs, final int lengthLongs) {
- final long copyBytes = ((long) lengthLongs) << LONG_SHIFT;
- final MemorySegment srcSlice =
MemorySegment.ofArray(srcArray).asSlice(srcOffsetLongs << LONG_SHIFT,
copyBytes);
- final MemorySegment dstSlice = seg.asSlice(offsetBytes, copyBytes);
- dstSlice.copyFrom(srcSlice);
+ putLongArr(seg, offsetBytes, srcArray, srcOffsetLongs, lengthLongs);
+ }
+
+ static void putLongArr(
+ final MemorySegment seg, final long offsetBytes, final long[] srcArray,
final int srcOffsetLongs, final int lengthLongs) {
+ final MemorySegment srcSeg = MemorySegment.ofArray(srcArray);
+ final long srcOffsetBytes = ((long) srcOffsetLongs) << LONG_SHIFT;
+ MemorySegment.copy(srcSeg, JAVA_LONG, srcOffsetBytes, seg,
JAVA_LONG_UNALIGNED, offsetBytes, lengthLongs);
}
@Override
@@ -194,10 +251,13 @@ final class NativeWritableMemoryImpl extends
WritableMemoryImpl {
@Override
public void putShortArray(final long offsetBytes, final short[] srcArray,
final int srcOffsetShorts, final int lengthShorts) {
- final long copyBytes = ((long) lengthShorts) << SHORT_SHIFT;
- final MemorySegment srcSlice =
MemorySegment.ofArray(srcArray).asSlice(srcOffsetShorts << SHORT_SHIFT,
copyBytes);
- final MemorySegment dstSlice = seg.asSlice(offsetBytes, copyBytes);
- dstSlice.copyFrom(srcSlice);
+ putShortArr(seg, offsetBytes, srcArray, srcOffsetShorts, lengthShorts);
}
+ static void putShortArr(
+ final MemorySegment seg, final long offsetBytes, final short[] srcArray,
final int srcOffsetShorts, final int lengthShorts) {
+ final MemorySegment srcSeg = MemorySegment.ofArray(srcArray);
+ final long srcOffsetBytes = ((long) srcOffsetShorts) << SHORT_SHIFT;
+ MemorySegment.copy(srcSeg, JAVA_SHORT, srcOffsetBytes, seg,
JAVA_SHORT_UNALIGNED, offsetBytes, lengthShorts);
+ }
}
diff --git
a/src/main/java/org/apache/datasketches/memory/internal/NonNativeWritableBufferImpl.java
b/src/main/java/org/apache/datasketches/memory/internal/NonNativeWritableBufferImpl.java
index b9ab430..84cf349 100644
---
a/src/main/java/org/apache/datasketches/memory/internal/NonNativeWritableBufferImpl.java
+++
b/src/main/java/org/apache/datasketches/memory/internal/NonNativeWritableBufferImpl.java
@@ -25,10 +25,21 @@ import static
org.apache.datasketches.memory.internal.NonNativeValueLayouts.JAVA
import static
org.apache.datasketches.memory.internal.NonNativeValueLayouts.JAVA_INT_UNALIGNED_NON_NATIVE;
import static
org.apache.datasketches.memory.internal.NonNativeValueLayouts.JAVA_LONG_UNALIGNED_NON_NATIVE;
import static
org.apache.datasketches.memory.internal.NonNativeValueLayouts.JAVA_SHORT_UNALIGNED_NON_NATIVE;
+import static
org.apache.datasketches.memory.internal.NonNativeWritableMemoryImpl.getCharArr;
+import static
org.apache.datasketches.memory.internal.NonNativeWritableMemoryImpl.getDoubleArr;
+import static
org.apache.datasketches.memory.internal.NonNativeWritableMemoryImpl.getFloatArr;
+import static
org.apache.datasketches.memory.internal.NonNativeWritableMemoryImpl.getIntArr;
+import static
org.apache.datasketches.memory.internal.NonNativeWritableMemoryImpl.getLongArr;
+import static
org.apache.datasketches.memory.internal.NonNativeWritableMemoryImpl.getShortArr;
+import static
org.apache.datasketches.memory.internal.NonNativeWritableMemoryImpl.putCharArr;
+import static
org.apache.datasketches.memory.internal.NonNativeWritableMemoryImpl.putDoubleArr;
+import static
org.apache.datasketches.memory.internal.NonNativeWritableMemoryImpl.putFloatArr;
+import static
org.apache.datasketches.memory.internal.NonNativeWritableMemoryImpl.putIntArr;
+import static
org.apache.datasketches.memory.internal.NonNativeWritableMemoryImpl.putLongArr;
+import static
org.apache.datasketches.memory.internal.NonNativeWritableMemoryImpl.putShortArr;
import java.lang.foreign.Arena;
import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
import org.apache.datasketches.memory.MemoryRequestServer;
import org.apache.datasketches.memory.WritableBuffer;
@@ -78,14 +89,8 @@ final class NonNativeWritableBufferImpl extends
WritableBufferImpl {
@Override
public void getCharArray(final char[] dstArray, final int dstOffsetChars,
final int lengthChars) {
final long pos = getPosition();
- final long copyBytes = ((long) lengthChars) << CHAR_SHIFT;
- final MemorySegment srcSlice = seg.asSlice(pos, copyBytes);
- final MemorySegment dstSlice =
MemorySegment.ofArray(dstArray).asSlice(dstOffsetChars << CHAR_SHIFT,
copyBytes);
- for (int index = 0; index < lengthChars; index++) {
- final char aChar = srcSlice.getAtIndex(JAVA_CHAR_UNALIGNED_NON_NATIVE,
index);
- dstSlice.setAtIndex(ValueLayout.JAVA_CHAR_UNALIGNED, index, aChar);
- }
- setPosition(pos + copyBytes);
+ getCharArr(seg, pos, dstArray, dstOffsetChars, lengthChars);
+ setPosition(pos + (lengthChars) << CHAR_SHIFT);
}
@Override
@@ -103,14 +108,8 @@ final class NonNativeWritableBufferImpl extends
WritableBufferImpl {
@Override
public void getDoubleArray(final double[] dstArray, final int
dstOffsetDoubles, final int lengthDoubles) {
final long pos = getPosition();
- final long copyBytes = ((long) lengthDoubles) << DOUBLE_SHIFT;
- final MemorySegment srcSlice = seg.asSlice(pos, copyBytes);
- final MemorySegment dstSlice =
MemorySegment.ofArray(dstArray).asSlice(dstOffsetDoubles << DOUBLE_SHIFT,
copyBytes);
- for (int index = 0; index < lengthDoubles; index++) {
- final double dbl = srcSlice.getAtIndex(JAVA_DOUBLE_UNALIGNED_NON_NATIVE,
index);
- dstSlice.setAtIndex(ValueLayout.JAVA_DOUBLE_UNALIGNED, index, dbl);
- }
- setPosition(pos + copyBytes);
+ getDoubleArr(seg, pos, dstArray, dstOffsetDoubles, lengthDoubles);
+ setPosition(pos + (lengthDoubles) << DOUBLE_SHIFT);
}
@Override
@@ -128,14 +127,8 @@ final class NonNativeWritableBufferImpl extends
WritableBufferImpl {
@Override
public void getFloatArray(final float[] dstArray, final int dstOffsetFloats,
final int lengthFloats) {
final long pos = getPosition();
- final long copyBytes = ((long) lengthFloats) << FLOAT_SHIFT;
- final MemorySegment srcSlice = seg.asSlice(pos, copyBytes);
- final MemorySegment dstSlice =
MemorySegment.ofArray(dstArray).asSlice(dstOffsetFloats << FLOAT_SHIFT,
copyBytes);
- for (int index = 0; index < lengthFloats; index++) {
- final float flt = srcSlice.getAtIndex(JAVA_FLOAT_UNALIGNED_NON_NATIVE,
index);
- dstSlice.setAtIndex(ValueLayout.JAVA_FLOAT_UNALIGNED, index, flt);
- }
- setPosition(pos + copyBytes);
+ getFloatArr(seg, pos, dstArray, dstOffsetFloats, lengthFloats);
+ setPosition(pos + (lengthFloats) << FLOAT_SHIFT);
}
@Override
@@ -153,14 +146,8 @@ final class NonNativeWritableBufferImpl extends
WritableBufferImpl {
@Override
public void getIntArray(final int[] dstArray, final int dstOffsetInts, final
int lengthInts) {
final long pos = getPosition();
- final long copyBytes = ((long) lengthInts) << INT_SHIFT;
- final MemorySegment srcSlice = seg.asSlice(pos, copyBytes);
- final MemorySegment dstSlice =
MemorySegment.ofArray(dstArray).asSlice(dstOffsetInts << INT_SHIFT, copyBytes);
- for (int index = 0; index < lengthInts; index++) {
- final int anInt = srcSlice.getAtIndex(JAVA_INT_UNALIGNED_NON_NATIVE,
index);
- dstSlice.setAtIndex(ValueLayout.JAVA_INT_UNALIGNED, index, anInt);
- }
- setPosition(pos + copyBytes);
+ getIntArr(seg, pos, dstArray, dstOffsetInts, lengthInts);
+ setPosition(pos + (lengthInts) << INT_SHIFT);
}
@Override
@@ -178,14 +165,8 @@ final class NonNativeWritableBufferImpl extends
WritableBufferImpl {
@Override
public void getLongArray(final long[] dstArray, final int dstOffsetLongs,
final int lengthLongs) {
final long pos = getPosition();
- final long copyBytes = ((long) lengthLongs) << LONG_SHIFT;
- final MemorySegment srcSlice = seg.asSlice(pos, copyBytes);
- final MemorySegment dstSlice =
MemorySegment.ofArray(dstArray).asSlice(dstOffsetLongs << LONG_SHIFT,
copyBytes);
- for (int index = 0; index < lengthLongs; index++) {
- final long aLong = srcSlice.getAtIndex(JAVA_LONG_UNALIGNED_NON_NATIVE,
index);
- dstSlice.setAtIndex(ValueLayout.JAVA_LONG_UNALIGNED, index, aLong);
- }
- setPosition(pos + copyBytes);
+ getLongArr(seg, pos, dstArray, dstOffsetLongs, lengthLongs);
+ setPosition(pos + (lengthLongs) << LONG_SHIFT);
}
@Override
@@ -203,14 +184,8 @@ final class NonNativeWritableBufferImpl extends
WritableBufferImpl {
@Override
public void getShortArray(final short[] dstArray, final int dstOffsetShorts,
final int lengthShorts) {
final long pos = getPosition();
- final long copyBytes = ((long) lengthShorts) << SHORT_SHIFT;
- final MemorySegment srcSlice = seg.asSlice(pos, copyBytes);
- final MemorySegment dstSlice =
MemorySegment.ofArray(dstArray).asSlice(dstOffsetShorts << SHORT_SHIFT,
copyBytes);
- for (int index = 0; index < lengthShorts; index++) {
- final short aShort =
srcSlice.getAtIndex(JAVA_SHORT_UNALIGNED_NON_NATIVE, index);
- dstSlice.setAtIndex(ValueLayout.JAVA_SHORT_UNALIGNED, index, aShort);
- }
- setPosition(pos + copyBytes);
+ getShortArr(seg, pos, dstArray, dstOffsetShorts, lengthShorts);
+ setPosition(pos + (lengthShorts) << SHORT_SHIFT);
}
//PRIMITIVE putX() and putXArray()
@@ -229,14 +204,8 @@ final class NonNativeWritableBufferImpl extends
WritableBufferImpl {
@Override
public void putCharArray(final char[] srcArray, final int srcOffsetChars,
final int lengthChars) {
final long pos = getPosition();
- final long copyBytes = ((long) lengthChars) << CHAR_SHIFT;
- final MemorySegment srcSlice =
MemorySegment.ofArray(srcArray).asSlice(srcOffsetChars << CHAR_SHIFT,
copyBytes);
- final MemorySegment dstSlice = seg.asSlice(pos, copyBytes);
- for (int index = 0; index < lengthChars; index++) {
- final char aChar = srcSlice.getAtIndex(ValueLayout.JAVA_CHAR_UNALIGNED,
index);
- dstSlice.setAtIndex(JAVA_CHAR_UNALIGNED_NON_NATIVE, index, aChar);
- }
- setPosition(pos + copyBytes);
+ putCharArr(seg, pos, srcArray, srcOffsetChars, lengthChars);
+ setPosition(pos + (lengthChars) << CHAR_SHIFT);
}
@Override
@@ -254,14 +223,8 @@ final class NonNativeWritableBufferImpl extends
WritableBufferImpl {
@Override
public void putDoubleArray(final double[] srcArray, final int
srcOffsetDoubles, final int lengthDoubles) {
final long pos = getPosition();
- final long copyBytes = ((long) lengthDoubles) << DOUBLE_SHIFT;
- final MemorySegment srcSlice =
MemorySegment.ofArray(srcArray).asSlice(srcOffsetDoubles << DOUBLE_SHIFT,
copyBytes);
- final MemorySegment dstSlice = seg.asSlice(pos, copyBytes);
- for (int index = 0; index < lengthDoubles; index++) {
- final double dbl =
srcSlice.getAtIndex(ValueLayout.JAVA_DOUBLE_UNALIGNED, index);
- dstSlice.setAtIndex(JAVA_DOUBLE_UNALIGNED_NON_NATIVE, index, dbl);
- }
- setPosition(pos + copyBytes);
+ putDoubleArr(seg, pos, srcArray, srcOffsetDoubles, lengthDoubles);
+ setPosition(pos + (lengthDoubles) << DOUBLE_SHIFT);
}
@Override
@@ -279,14 +242,8 @@ final class NonNativeWritableBufferImpl extends
WritableBufferImpl {
@Override
public void putFloatArray(final float[] srcArray, final int srcOffsetFloats,
final int lengthFloats) {
final long pos = getPosition();
- final long copyBytes = ((long) lengthFloats) << FLOAT_SHIFT;
- final MemorySegment srcSlice =
MemorySegment.ofArray(srcArray).asSlice(srcOffsetFloats << FLOAT_SHIFT,
copyBytes);
- final MemorySegment dstSlice = seg.asSlice(pos, copyBytes);
- for (int index = 0; index < lengthFloats; index++) {
- final float flt = srcSlice.getAtIndex(ValueLayout.JAVA_FLOAT_UNALIGNED,
index);
- dstSlice.setAtIndex(JAVA_FLOAT_UNALIGNED_NON_NATIVE, index, flt);
- }
- setPosition(pos + copyBytes);
+ putFloatArr(seg, pos, srcArray, srcOffsetFloats, lengthFloats);
+ setPosition(pos + (lengthFloats) << FLOAT_SHIFT);
}
@Override
@@ -304,14 +261,8 @@ final class NonNativeWritableBufferImpl extends
WritableBufferImpl {
@Override
public void putIntArray(final int[] srcArray, final int srcOffsetInts, final
int lengthInts) {
final long pos = getPosition();
- final long copyBytes = ((long) lengthInts) << INT_SHIFT;
- final MemorySegment srcSlice =
MemorySegment.ofArray(srcArray).asSlice(srcOffsetInts << INT_SHIFT, copyBytes);
- final MemorySegment dstSlice = seg.asSlice(pos, copyBytes);
- for (int index = 0; index < lengthInts; index++) {
- final int anInt = srcSlice.getAtIndex(ValueLayout.JAVA_INT_UNALIGNED,
index);
- dstSlice.setAtIndex(JAVA_INT_UNALIGNED_NON_NATIVE, index, anInt);
- }
- setPosition(pos + copyBytes);
+ putIntArr(seg, pos, srcArray, srcOffsetInts, lengthInts);
+ setPosition(pos + (lengthInts) << INT_SHIFT);
}
@Override
@@ -329,14 +280,8 @@ final class NonNativeWritableBufferImpl extends
WritableBufferImpl {
@Override
public void putLongArray(final long[] srcArray, final int srcOffsetLongs,
final int lengthLongs) {
final long pos = getPosition();
- final long copyBytes = ((long) lengthLongs) << LONG_SHIFT;
- final MemorySegment srcSlice =
MemorySegment.ofArray(srcArray).asSlice(srcOffsetLongs << LONG_SHIFT,
copyBytes);
- final MemorySegment dstSlice = seg.asSlice(pos, copyBytes);
- for (int index = 0; index < lengthLongs; index++) {
- final long aLong = srcSlice.getAtIndex(ValueLayout.JAVA_LONG_UNALIGNED,
index);
- dstSlice.setAtIndex(JAVA_LONG_UNALIGNED_NON_NATIVE, index, aLong);
- }
- setPosition(pos + copyBytes);
+ putLongArr(seg, pos, srcArray, srcOffsetLongs, lengthLongs);
+ setPosition(pos + (lengthLongs) << LONG_SHIFT);
}
@Override
@@ -354,14 +299,8 @@ final class NonNativeWritableBufferImpl extends
WritableBufferImpl {
@Override
public void putShortArray(final short[] srcArray, final int srcOffsetShorts,
final int lengthShorts) {
final long pos = getPosition();
- final long copyBytes = ((long) lengthShorts) << SHORT_SHIFT;
- final MemorySegment srcSlice =
MemorySegment.ofArray(srcArray).asSlice(srcOffsetShorts << SHORT_SHIFT,
copyBytes);
- final MemorySegment dstSlice = seg.asSlice(pos, copyBytes);
- for (int index = 0; index < lengthShorts; index++) {
- final short aShort =
srcSlice.getAtIndex(ValueLayout.JAVA_SHORT_UNALIGNED, index);
- dstSlice.setAtIndex(JAVA_SHORT_UNALIGNED_NON_NATIVE, index, aShort);
- }
- setPosition(pos + copyBytes);
+ putShortArr(seg, pos, srcArray, srcOffsetShorts, lengthShorts);
+ setPosition(pos + (lengthShorts) << SHORT_SHIFT);
}
}
diff --git
a/src/main/java/org/apache/datasketches/memory/internal/NonNativeWritableMemoryImpl.java
b/src/main/java/org/apache/datasketches/memory/internal/NonNativeWritableMemoryImpl.java
index bcd3287..5744ffd 100644
---
a/src/main/java/org/apache/datasketches/memory/internal/NonNativeWritableMemoryImpl.java
+++
b/src/main/java/org/apache/datasketches/memory/internal/NonNativeWritableMemoryImpl.java
@@ -19,6 +19,12 @@
package org.apache.datasketches.memory.internal;
+import static java.lang.foreign.ValueLayout.JAVA_CHAR;
+import static java.lang.foreign.ValueLayout.JAVA_DOUBLE;
+import static java.lang.foreign.ValueLayout.JAVA_FLOAT;
+import static java.lang.foreign.ValueLayout.JAVA_INT;
+import static java.lang.foreign.ValueLayout.JAVA_LONG;
+import static java.lang.foreign.ValueLayout.JAVA_SHORT;
import static
org.apache.datasketches.memory.internal.NonNativeValueLayouts.JAVA_CHAR_UNALIGNED_NON_NATIVE;
import static
org.apache.datasketches.memory.internal.NonNativeValueLayouts.JAVA_DOUBLE_UNALIGNED_NON_NATIVE;
import static
org.apache.datasketches.memory.internal.NonNativeValueLayouts.JAVA_FLOAT_UNALIGNED_NON_NATIVE;
@@ -28,7 +34,6 @@ import static
org.apache.datasketches.memory.internal.NonNativeValueLayouts.JAVA
import java.lang.foreign.Arena;
import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
import org.apache.datasketches.memory.MemoryRequestServer;
import org.apache.datasketches.memory.WritableMemory;
@@ -57,13 +62,14 @@ final class NonNativeWritableMemoryImpl extends
WritableMemoryImpl {
@Override
public void getCharArray(final long offsetBytes, final char[] dstArray,
final int dstOffsetChars, final int lengthChars) {
- final long copyBytes = ((long) lengthChars) << CHAR_SHIFT;
- final MemorySegment srcSlice = seg.asSlice(offsetBytes, copyBytes);
- final MemorySegment dstSlice =
MemorySegment.ofArray(dstArray).asSlice(dstOffsetChars << CHAR_SHIFT,
copyBytes);
- for (int index = 0; index < lengthChars; index++) {
- final char aChar = srcSlice.getAtIndex(JAVA_CHAR_UNALIGNED_NON_NATIVE,
index);
- dstSlice.setAtIndex(ValueLayout.JAVA_CHAR_UNALIGNED, index, aChar);
- }
+ getCharArr(seg, offsetBytes, dstArray, dstOffsetChars, lengthChars);
+ }
+
+ static void getCharArr(
+ final MemorySegment seg, final long offsetBytes, final char[] dstArray,
final int dstOffsetChars, final int lengthChars) {
+ final MemorySegment dstSeg = MemorySegment.ofArray(dstArray);
+ final long dstOffsetBytes = ((long) dstOffsetChars) << CHAR_SHIFT;
+ MemorySegment.copy(seg, JAVA_CHAR_UNALIGNED_NON_NATIVE, offsetBytes,
dstSeg, JAVA_CHAR, dstOffsetBytes, lengthChars);
}
@Override
@@ -73,13 +79,14 @@ final class NonNativeWritableMemoryImpl extends
WritableMemoryImpl {
@Override
public void getDoubleArray(final long offsetBytes, final double[] dstArray,
final int dstOffsetDoubles, final int lengthDoubles) {
- final long copyBytes = ((long) lengthDoubles) << DOUBLE_SHIFT;
- final MemorySegment srcSlice = seg.asSlice(offsetBytes, copyBytes);
- final MemorySegment dstSlice =
MemorySegment.ofArray(dstArray).asSlice(dstOffsetDoubles << DOUBLE_SHIFT,
copyBytes);
- for (int index = 0; index < lengthDoubles; index++) {
- final double dbl = srcSlice.getAtIndex(JAVA_DOUBLE_UNALIGNED_NON_NATIVE,
index);
- dstSlice.setAtIndex(ValueLayout.JAVA_DOUBLE_UNALIGNED, index, dbl);
- }
+ getDoubleArr(seg, offsetBytes, dstArray, dstOffsetDoubles, lengthDoubles);
+ }
+
+ static void getDoubleArr(
+ final MemorySegment seg, final long offsetBytes, final double[]
dstArray, final int dstOffsetDoubles, final int lengthDoubles) {
+ final MemorySegment dstSeg = MemorySegment.ofArray(dstArray);
+ final long dstOffsetBytes = ((long) dstOffsetDoubles) << DOUBLE_SHIFT;
+ MemorySegment.copy(seg, JAVA_DOUBLE_UNALIGNED_NON_NATIVE, offsetBytes,
dstSeg, JAVA_DOUBLE, dstOffsetBytes, lengthDoubles);
}
@Override
@@ -89,13 +96,14 @@ final class NonNativeWritableMemoryImpl extends
WritableMemoryImpl {
@Override
public void getFloatArray(final long offsetBytes, final float[] dstArray,
final int dstOffsetFloats, final int lengthFloats) {
- final long copyBytes = ((long) lengthFloats) << FLOAT_SHIFT;
- final MemorySegment srcSlice = seg.asSlice(offsetBytes, copyBytes);
- final MemorySegment dstSlice =
MemorySegment.ofArray(dstArray).asSlice(dstOffsetFloats << FLOAT_SHIFT,
copyBytes);
- for (int index = 0; index < lengthFloats; index++) {
- final float flt = srcSlice.getAtIndex(JAVA_FLOAT_UNALIGNED_NON_NATIVE,
index);
- dstSlice.setAtIndex(ValueLayout.JAVA_FLOAT_UNALIGNED, index, flt);
- }
+ getFloatArr(seg, offsetBytes, dstArray, dstOffsetFloats, lengthFloats);
+ }
+
+ static void getFloatArr(
+ final MemorySegment seg, final long offsetBytes, final float[] dstArray,
final int dstOffsetFloats, final int lengthFloats) {
+ final MemorySegment dstSeg = MemorySegment.ofArray(dstArray);
+ final long dstOffsetBytes = ((long) dstOffsetFloats) << FLOAT_SHIFT;
+ MemorySegment.copy(seg, JAVA_FLOAT_UNALIGNED_NON_NATIVE, offsetBytes,
dstSeg, JAVA_FLOAT, dstOffsetBytes, lengthFloats);
}
@Override
@@ -105,13 +113,14 @@ final class NonNativeWritableMemoryImpl extends
WritableMemoryImpl {
@Override
public void getIntArray(final long offsetBytes, final int[] dstArray, final
int dstOffsetInts, final int lengthInts) {
- final long copyBytes = ((long) lengthInts) << INT_SHIFT;
- final MemorySegment srcSlice = seg.asSlice(offsetBytes, copyBytes);
- final MemorySegment dstSlice =
MemorySegment.ofArray(dstArray).asSlice(dstOffsetInts << INT_SHIFT, copyBytes);
- for (int index = 0; index < lengthInts; index++) {
- final int anInt = srcSlice.getAtIndex(JAVA_INT_UNALIGNED_NON_NATIVE,
index);
- dstSlice.setAtIndex(ValueLayout.JAVA_INT_UNALIGNED, index, anInt);
- }
+ getIntArr(seg, offsetBytes, dstArray, dstOffsetInts, lengthInts);
+ }
+
+ static void getIntArr(
+ final MemorySegment seg, final long offsetBytes, final int[] dstArray,
final int dstOffsetInts, final int lengthInts) {
+ final MemorySegment dstSeg = MemorySegment.ofArray(dstArray);
+ final long dstOffsetBytes = ((long) dstOffsetInts) << INT_SHIFT;
+ MemorySegment.copy(seg, JAVA_INT_UNALIGNED_NON_NATIVE, offsetBytes,
dstSeg, JAVA_INT, dstOffsetBytes, lengthInts);
}
@Override
@@ -121,13 +130,14 @@ final class NonNativeWritableMemoryImpl extends
WritableMemoryImpl {
@Override
public void getLongArray(final long offsetBytes, final long[] dstArray,
final int dstOffsetLongs, final int lengthLongs) {
- final long copyBytes = ((long) lengthLongs) << LONG_SHIFT;
- final MemorySegment srcSlice = seg.asSlice(offsetBytes, copyBytes);
- final MemorySegment dstSlice =
MemorySegment.ofArray(dstArray).asSlice(dstOffsetLongs << LONG_SHIFT,
copyBytes);
- for (int index = 0; index < lengthLongs; index++) {
- final long aLong = srcSlice.getAtIndex(JAVA_LONG_UNALIGNED_NON_NATIVE,
index);
- dstSlice.setAtIndex(ValueLayout.JAVA_LONG_UNALIGNED, index, aLong);
- }
+ getLongArr(seg, offsetBytes, dstArray, dstOffsetLongs, lengthLongs);
+ }
+
+ static void getLongArr(
+ final MemorySegment seg, final long offsetBytes, final long[] dstArray,
final int dstOffsetLongs, final int lengthLongs) {
+ final MemorySegment dstSeg = MemorySegment.ofArray(dstArray);
+ final long dstOffsetBytes = ((long) dstOffsetLongs) << LONG_SHIFT;
+ MemorySegment.copy(seg, JAVA_LONG_UNALIGNED_NON_NATIVE, offsetBytes,
dstSeg, JAVA_LONG, dstOffsetBytes, lengthLongs);
}
@Override
@@ -137,13 +147,14 @@ final class NonNativeWritableMemoryImpl extends
WritableMemoryImpl {
@Override
public void getShortArray(final long offsetBytes, final short[] dstArray,
final int dstOffsetShorts, final int lengthShorts) {
- final long copyBytes = ((long) lengthShorts) << SHORT_SHIFT;
- final MemorySegment srcSlice = seg.asSlice(offsetBytes, copyBytes);
- final MemorySegment dstSlice =
MemorySegment.ofArray(dstArray).asSlice(dstOffsetShorts << SHORT_SHIFT,
copyBytes);
- for (int index = 0; index < lengthShorts; index++) {
- final short aShort =
srcSlice.getAtIndex(JAVA_SHORT_UNALIGNED_NON_NATIVE, index);
- dstSlice.setAtIndex(ValueLayout.JAVA_SHORT_UNALIGNED, index, aShort);
- }
+ getShortArr(seg, offsetBytes, dstArray, dstOffsetShorts, lengthShorts);
+ }
+
+ static void getShortArr(
+ final MemorySegment seg, final long offsetBytes, final short[] dstArray,
final int dstOffsetShorts, final int lengthShorts) {
+ final MemorySegment dstSeg = MemorySegment.ofArray(dstArray);
+ final long dstOffsetBytes = ((long) dstOffsetShorts) << SHORT_SHIFT;
+ MemorySegment.copy(seg, JAVA_SHORT_UNALIGNED_NON_NATIVE, offsetBytes,
dstSeg, JAVA_SHORT, dstOffsetBytes, lengthShorts);
}
//PRIMITIVE putX() and putXArray() implementations
@@ -154,13 +165,14 @@ final class NonNativeWritableMemoryImpl extends
WritableMemoryImpl {
@Override
public void putCharArray(final long offsetBytes, final char[] srcArray,
final int srcOffsetChars, final int lengthChars) {
- final long copyBytes = ((long) lengthChars) << CHAR_SHIFT;
- final MemorySegment srcSlice =
MemorySegment.ofArray(srcArray).asSlice(srcOffsetChars << CHAR_SHIFT,
copyBytes);
- final MemorySegment dstSlice = seg.asSlice(offsetBytes, copyBytes);
- for (int index = 0; index < lengthChars; index++) {
- final char aChar = srcSlice.getAtIndex(ValueLayout.JAVA_CHAR_UNALIGNED,
index);
- dstSlice.setAtIndex(JAVA_CHAR_UNALIGNED_NON_NATIVE, index, aChar);
- }
+ putCharArr(seg, offsetBytes, srcArray, srcOffsetChars, lengthChars);
+ }
+
+ static void putCharArr(
+ final MemorySegment seg, final long offsetBytes, final char[] srcArray,
final int srcOffsetChars, final int lengthChars) {
+ final MemorySegment srcSeg = MemorySegment.ofArray(srcArray);
+ final long srcOffsetBytes = ((long) srcOffsetChars) << CHAR_SHIFT;
+ MemorySegment.copy(srcSeg, JAVA_CHAR, srcOffsetBytes, seg,
JAVA_CHAR_UNALIGNED_NON_NATIVE, offsetBytes, lengthChars);
}
@Override
@@ -170,13 +182,14 @@ final class NonNativeWritableMemoryImpl extends
WritableMemoryImpl {
@Override
public void putDoubleArray(final long offsetBytes, final double[] srcArray,
final int srcOffsetDoubles, final int lengthDoubles) {
- final long copyBytes = ((long) lengthDoubles) << DOUBLE_SHIFT;
- final MemorySegment srcSlice =
MemorySegment.ofArray(srcArray).asSlice(srcOffsetDoubles << DOUBLE_SHIFT,
copyBytes);
- final MemorySegment dstSlice = seg.asSlice(offsetBytes, copyBytes);
- for (int index = 0; index < lengthDoubles; index++) {
- final double dbl =
srcSlice.getAtIndex(ValueLayout.JAVA_DOUBLE_UNALIGNED, index);
- dstSlice.setAtIndex(JAVA_DOUBLE_UNALIGNED_NON_NATIVE, index, dbl);
- }
+ putDoubleArr(seg, offsetBytes, srcArray, srcOffsetDoubles, lengthDoubles);
+ }
+
+ static void putDoubleArr(
+ final MemorySegment seg, final long offsetBytes, final double[]
srcArray, final int srcOffsetDoubles, final int lengthDoubles) {
+ final MemorySegment srcSeg = MemorySegment.ofArray(srcArray);
+ final long srcOffsetBytes = ((long) srcOffsetDoubles) << DOUBLE_SHIFT;
+ MemorySegment.copy(srcSeg, JAVA_DOUBLE, srcOffsetBytes, seg,
JAVA_DOUBLE_UNALIGNED_NON_NATIVE, offsetBytes, lengthDoubles);
}
@Override
@@ -186,13 +199,14 @@ final class NonNativeWritableMemoryImpl extends
WritableMemoryImpl {
@Override
public void putFloatArray(final long offsetBytes, final float[] srcArray,
final int srcOffsetFloats, final int lengthFloats) {
- final long copyBytes = ((long) lengthFloats) << FLOAT_SHIFT;
- final MemorySegment srcSlice =
MemorySegment.ofArray(srcArray).asSlice(srcOffsetFloats << FLOAT_SHIFT,
copyBytes);
- final MemorySegment dstSlice = seg.asSlice(offsetBytes, copyBytes);
- for (int index = 0; index < lengthFloats; index++) {
- final float flt = srcSlice.getAtIndex(ValueLayout.JAVA_FLOAT_UNALIGNED,
index);
- dstSlice.setAtIndex(JAVA_FLOAT_UNALIGNED_NON_NATIVE, index, flt);
- }
+ putFloatArr(seg, offsetBytes, srcArray, srcOffsetFloats, lengthFloats);
+ }
+
+ static void putFloatArr(
+ final MemorySegment seg, final long offsetBytes, final float[] srcArray,
final int srcOffsetFloats, final int lengthFloats) {
+ final MemorySegment srcSeg = MemorySegment.ofArray(srcArray);
+ final long srcOffsetBytes = ((long) srcOffsetFloats) << FLOAT_SHIFT;
+ MemorySegment.copy(srcSeg, JAVA_FLOAT, srcOffsetBytes, seg,
JAVA_FLOAT_UNALIGNED_NON_NATIVE, offsetBytes, lengthFloats);
}
@Override
@@ -202,13 +216,14 @@ final class NonNativeWritableMemoryImpl extends
WritableMemoryImpl {
@Override
public void putIntArray(final long offsetBytes, final int[] srcArray, final
int srcOffsetInts, final int lengthInts) {
- final long copyBytes = ((long) lengthInts) << INT_SHIFT;
- final MemorySegment srcSlice =
MemorySegment.ofArray(srcArray).asSlice(srcOffsetInts << INT_SHIFT, copyBytes);
- final MemorySegment dstSlice = seg.asSlice(offsetBytes, copyBytes);
- for (int index = 0; index < lengthInts; index++) {
- final int anInt = srcSlice.getAtIndex(ValueLayout.JAVA_INT_UNALIGNED,
index);
- dstSlice.setAtIndex(JAVA_INT_UNALIGNED_NON_NATIVE, index, anInt);
- }
+ putIntArr(seg, offsetBytes, srcArray, srcOffsetInts, lengthInts);
+ }
+
+ static void putIntArr(
+ final MemorySegment seg, final long offsetBytes, final int[] srcArray,
final int srcOffsetInts, final int lengthInts) {
+ final MemorySegment srcSeg = MemorySegment.ofArray(srcArray);
+ final long srcOffsetBytes = ((long) srcOffsetInts) << INT_SHIFT;
+ MemorySegment.copy(srcSeg, JAVA_INT, srcOffsetBytes, seg,
JAVA_INT_UNALIGNED_NON_NATIVE, offsetBytes, lengthInts);
}
@Override
@@ -218,13 +233,14 @@ final class NonNativeWritableMemoryImpl extends
WritableMemoryImpl {
@Override
public void putLongArray(final long offsetBytes, final long[] srcArray,
final int srcOffsetLongs, final int lengthLongs) {
- final long copyBytes = ((long) lengthLongs) << LONG_SHIFT;
- final MemorySegment srcSlice =
MemorySegment.ofArray(srcArray).asSlice(srcOffsetLongs << LONG_SHIFT,
copyBytes);
- final MemorySegment dstSlice = seg.asSlice(offsetBytes, copyBytes);
- for (int index = 0; index < lengthLongs; index++) {
- final long aLong = srcSlice.getAtIndex(ValueLayout.JAVA_LONG_UNALIGNED,
index);
- dstSlice.setAtIndex(JAVA_LONG_UNALIGNED_NON_NATIVE, index, aLong);
- }
+ putLongArr(seg, offsetBytes, srcArray, srcOffsetLongs, lengthLongs);
+ }
+
+ static void putLongArr(
+ final MemorySegment seg, final long offsetBytes, final long[] srcArray,
final int srcOffsetLongs, final int lengthLongs) {
+ final MemorySegment srcSeg = MemorySegment.ofArray(srcArray);
+ final long srcOffsetBytes = ((long) srcOffsetLongs) << LONG_SHIFT;
+ MemorySegment.copy(srcSeg, JAVA_LONG, srcOffsetBytes, seg,
JAVA_LONG_UNALIGNED_NON_NATIVE, offsetBytes, lengthLongs);
}
@Override
@@ -234,13 +250,14 @@ final class NonNativeWritableMemoryImpl extends
WritableMemoryImpl {
@Override
public void putShortArray(final long offsetBytes, final short[] srcArray,
final int srcOffsetShorts, final int lengthShorts) {
- final long copyBytes = ((long) lengthShorts) << SHORT_SHIFT;
- final MemorySegment srcSlice =
MemorySegment.ofArray(srcArray).asSlice(srcOffsetShorts << SHORT_SHIFT,
copyBytes);
- final MemorySegment dstSlice = seg.asSlice(offsetBytes, copyBytes);
- for (int index = 0; index < lengthShorts; index++) {
- final short aShort =
srcSlice.getAtIndex(ValueLayout.JAVA_SHORT_UNALIGNED, index);
- dstSlice.setAtIndex(JAVA_SHORT_UNALIGNED_NON_NATIVE, index, aShort);
- }
+ putShortArr(seg, offsetBytes, srcArray, srcOffsetShorts, lengthShorts);
+ }
+
+ static void putShortArr(
+ final MemorySegment seg, final long offsetBytes, final short[] srcArray,
final int srcOffsetShorts, final int lengthShorts) {
+ final MemorySegment srcSeg = MemorySegment.ofArray(srcArray);
+ final long srcOffsetBytes = ((long) srcOffsetShorts) << SHORT_SHIFT;
+ MemorySegment.copy(srcSeg, JAVA_SHORT, srcOffsetBytes, seg,
JAVA_SHORT_UNALIGNED_NON_NATIVE, offsetBytes, lengthShorts);
}
}
diff --git
a/src/main/java/org/apache/datasketches/memory/internal/ResourceImpl.java
b/src/main/java/org/apache/datasketches/memory/internal/ResourceImpl.java
index 796f0d4..f8f7346 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/ResourceImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/ResourceImpl.java
@@ -40,8 +40,8 @@ import org.apache.datasketches.memory.WritableMemory;
* @author Lee Rhodes
*/
abstract class ResourceImpl implements Resource {
- static final String JDK; //must be at least "17"
- static final int JDK_MAJOR; //8, 11, 17, etc
+ static final String JDK; //the first two numbers of the java version string:
1.8, 11.0, 17.0, 21.0, etc
+ static final int JDK_MAJOR; //either 1.8 or just the first number of the
java version string: 11, 17, 21, etc
//Used to convert "type" to bytes: bytes = longs << LONG_SHIFT
static final int BOOLEAN_SHIFT = 0;
@@ -93,6 +93,11 @@ abstract class ResourceImpl implements Resource {
static final ByteOrder NON_NATIVE_BYTE_ORDER =
(ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN) ?
ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN;
+ /**
+ * The alignment of the starting address of new MemorySegments
+ */
+ static final long SEGMENT_ALIGHMENT = 8;
+
static {
final String jdkVer = System.getProperty("java.version");
final int[] p = parseJavaVersion(jdkVer);
@@ -100,9 +105,9 @@ abstract class ResourceImpl implements Resource {
JDK_MAJOR = (p[0] == 1) ? p[1] : p[0];
}
- final Arena arena;
final MemorySegment seg;
final int typeId;
+ final Arena arena;
/**
* Root constructor.
@@ -163,9 +168,9 @@ abstract class ResourceImpl implements Resource {
}
static void checkJavaVersion(final String jdkVer, final int p0) {
- if ( p0 != 21 ) {
+ if ( p0 < 21 ) {
throw new IllegalArgumentException(
- "Unsupported JDK Major Version, must be 21; " + jdkVer);
+ "Unsupported JDK Major Version, must be >= 21; " + jdkVer);
}
}
@@ -341,7 +346,7 @@ abstract class ResourceImpl implements Resource {
arena.close();
}
catch (final UnsupportedOperationException uoe) {
- // ignored as it seems there's no way to determine if the Arena is
closeable or not
+ // ignored as it seems there's no reliable way to determine if the
Arena is closeable or not
}
} //not idempotent
}
@@ -440,8 +445,10 @@ abstract class ResourceImpl implements Resource {
@Override
public final boolean isSameResource(final Resource that) {
+ Objects.requireNonNull(that);
final ResourceImpl that2 = (ResourceImpl) that;
- return this.seg.address() == that2.seg.address();
+ return this.seg.address() == that2.seg.address()
+ && this.seg.byteSize() == that2.seg.byteSize();
}
@Override
@@ -451,17 +458,33 @@ abstract class ResourceImpl implements Resource {
public long mismatch(final Resource that) {
Objects.requireNonNull(that);
if (!that.isAlive()) { throw new IllegalArgumentException("Given argument
is not alive."); }
- final ResourceImpl thatBSI = (ResourceImpl) that;
- return seg.mismatch(thatBSI.seg);
+ final ResourceImpl that2 = (ResourceImpl) that;
+ return seg.mismatch(that2.seg);
+ }
+
+ @Override
+ public long mismatch(final Resource src,
+ final long srcFromOffset,
+ final long srcToOffset,
+ final Resource dst,
+ final long dstFromOffset,
+ final long dstToOffset ) {
+ return MemorySegment.mismatch(
+ ((ResourceImpl)src).seg,
+ srcFromOffset,
+ srcToOffset,
+ ((ResourceImpl)dst).seg,
+ dstFromOffset,
+ dstToOffset);
}
@Override
public final long nativeOverlap(final Resource that) {
if (that == null) { return 0; }
if (!that.isAlive()) { return 0; }
- final ResourceImpl thatBSI = (ResourceImpl) that;
- if (this == thatBSI) { return seg.byteSize(); }
- return nativeOverlap(seg, thatBSI.seg);
+ final ResourceImpl that2 = (ResourceImpl) that;
+ if (this == that2) { return seg.byteSize(); }
+ return nativeOverlap(seg, that2.seg);
}
static final long nativeOverlap(final MemorySegment segA, final
MemorySegment segB) { //used in test
@@ -525,9 +548,32 @@ abstract class ResourceImpl implements Resource {
@Override
public MemorySegment toMemorySegment() {
- final MemorySegment arrSeg = MemorySegment.ofArray(new
byte[(int)seg.byteSize()]);
- arrSeg.copyFrom(seg);
- return arrSeg;
+ final long len = seg.byteSize();
+ final MemorySegment out;
+ if (seg.isNative()) { //off-heap
+ if (len == 0) {
+ out = MemorySegment.NULL;
+ return out;
+ }
+ out = arena.allocate(seg.byteSize(), SEGMENT_ALIGHMENT);
+ }
+ else { //on-heap
+ if (len == 0) {
+ out = MemorySegment.ofArray(new byte[0]);
+ return out;
+ }
+ if (len % Long.BYTES == 0) {
+ out = MemorySegment.ofArray(new long[(int)(len >>> LONG_SHIFT)]);
+ } else if (len % Integer.BYTES == 0) {
+ out = MemorySegment.ofArray(new int[(int)(len >>> INT_SHIFT)]);
+ } else if (len % Short.BYTES == 0) {
+ out = MemorySegment.ofArray(new short[(int)(len >>> SHORT_SHIFT)]);
+ } else {
+ out = MemorySegment.ofArray(new byte[(int)len]);
+ }
+ }
+ out.copyFrom(seg);
+ return out;
}
@Override
diff --git a/src/main/java/org/apache/datasketches/memory/internal/Util.java
b/src/main/java/org/apache/datasketches/memory/internal/Util.java
index 96c606e..949c2c4 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/Util.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/Util.java
@@ -29,6 +29,8 @@ import java.net.URL;
import java.nio.file.Paths;
import java.util.Objects;
+import org.apache.datasketches.memory.Memory;
+
/**
* @author Lee Rhodes
*/
@@ -68,6 +70,17 @@ final class Util {
return s;
}
+ public static String toHexSeparated(final Memory mem, final int offset,
final int lengthBytes) {
+ final int len = (int)Math.min(mem.getCapacity(), lengthBytes);
+ final StringBuilder sb = new StringBuilder();
+ for (int i = 0; i < len; i++) {
+ final int b = mem.getByte(offset + i);
+ sb.append(zeroPad(Integer.toString(b), 2));
+ sb.append(" ");
+ }
+ return sb.toString();
+ }
+
/**
* Return true if all the masked bits of value are zero
* @param value the value to be tested
@@ -108,7 +121,7 @@ final class Util {
return (value & bitMask) != 0;
}
- //Resources mention: these 3 methods are duplicated in Java/
datasketches/Util
+ //Resources mention: these 2 methods are duplicated in Java/
datasketches/Util
/**
* Gets the absolute path of the given resource file's shortName.
diff --git
a/src/main/java/org/apache/datasketches/memory/internal/WritableBufferImpl.java
b/src/main/java/org/apache/datasketches/memory/internal/WritableBufferImpl.java
index 7b448c3..a7afc4a 100644
---
a/src/main/java/org/apache/datasketches/memory/internal/WritableBufferImpl.java
+++
b/src/main/java/org/apache/datasketches/memory/internal/WritableBufferImpl.java
@@ -272,10 +272,9 @@ public abstract class WritableBufferImpl extends
PositionalImpl implements Writa
@Override
public final void getByteArray(final byte[] dstArray, final int
dstOffsetBytes, final int lengthBytes) {
- final MemorySegment dstSlice =
MemorySegment.ofArray(dstArray).asSlice(dstOffsetBytes, lengthBytes);
final long pos = getPosition();
- final MemorySegment srcSlice = seg.asSlice(pos, lengthBytes);
- dstSlice.copyFrom(srcSlice);
+ final MemorySegment dstSeg = MemorySegment.ofArray(dstArray);
+ MemorySegment.copy(seg, pos, dstSeg, dstOffsetBytes, lengthBytes);
setPosition(pos + lengthBytes);
}
@@ -319,10 +318,9 @@ public abstract class WritableBufferImpl extends
PositionalImpl implements Writa
@Override
public final void putByteArray(final byte[] srcArray, final int
srcOffsetBytes, final int lengthBytes) {
- final MemorySegment srcSlice =
MemorySegment.ofArray(srcArray).asSlice(srcOffsetBytes, lengthBytes);
final long pos = getPosition();
- final MemorySegment dstSlice = seg.asSlice(pos, lengthBytes);
- dstSlice.copyFrom(srcSlice);
+ final MemorySegment srcSeg = MemorySegment.ofArray(srcArray);
+ MemorySegment.copy(srcSeg, srcOffsetBytes, seg, pos, lengthBytes);
setPosition(pos + lengthBytes);
}
diff --git
a/src/main/java/org/apache/datasketches/memory/internal/WritableMemoryImpl.java
b/src/main/java/org/apache/datasketches/memory/internal/WritableMemoryImpl.java
index 6c008db..1d7cf3f 100644
---
a/src/main/java/org/apache/datasketches/memory/internal/WritableMemoryImpl.java
+++
b/src/main/java/org/apache/datasketches/memory/internal/WritableMemoryImpl.java
@@ -319,10 +319,8 @@ public abstract class WritableMemoryImpl extends
ResourceImpl implements Writabl
@Override
public final void getByteArray(final long offsetBytes, final byte[]
dstArray, final int dstOffsetBytes, final int lengthBytes) {
- checkBounds(dstOffsetBytes, lengthBytes, dstArray.length);
- final MemorySegment srcSlice = seg.asSlice(offsetBytes, lengthBytes);
- final MemorySegment dstSlice =
MemorySegment.ofArray(dstArray).asSlice(dstOffsetBytes, lengthBytes);
- dstSlice.copyFrom(srcSlice);
+ final MemorySegment dstSeg = MemorySegment.ofArray(dstArray);
+ MemorySegment.copy(seg, offsetBytes, dstSeg, dstOffsetBytes, lengthBytes);
}
//OTHER PRIMITIVE READ METHODS: compareTo, copyTo, writeTo
@@ -342,8 +340,8 @@ public abstract class WritableMemoryImpl extends
ResourceImpl implements Writabl
}
@Override
- public final void writeToByteStream(final long offsetBytes, final int
lengthBytes,
- final ByteArrayOutputStream out) throws IOException {
+ public final void writeToByteStream(final long offsetBytes, final int
lengthBytes, final ByteArrayOutputStream out)
+ throws IOException {
checkBounds(offsetBytes, lengthBytes, seg.byteSize());
final byte[] bArr = new byte[lengthBytes];
getByteArray(offsetBytes,bArr, 0, lengthBytes); //fundamental limitation
of MemorySegment
@@ -363,11 +361,9 @@ public abstract class WritableMemoryImpl extends
ResourceImpl implements Writabl
}
@Override
- public final void putByteArray(final long offsetBytes, final byte[] srcArray,
- final int srcOffsetBytes, final int lengthBytes) {
- final MemorySegment srcSlice =
MemorySegment.ofArray(srcArray).asSlice(srcOffsetBytes, lengthBytes);
- final MemorySegment dstSlice = seg.asSlice(offsetBytes, lengthBytes);
- dstSlice.copyFrom(srcSlice);
+ public final void putByteArray(final long offsetBytes, final byte[]
srcArray, final int srcOffsetBytes, final int lengthBytes) {
+ final MemorySegment srcSeg = MemorySegment.ofArray(srcArray);
+ MemorySegment.copy(srcSeg, srcOffsetBytes, seg, offsetBytes, lengthBytes);
}
// OTHER WRITE METHODS
diff --git
a/src/test/java/org/apache/datasketches/memory/internal/CommonBufferTest.java
b/src/test/java/org/apache/datasketches/memory/internal/CommonBufferTest.java
index 02fbf50..59aa659 100644
---
a/src/test/java/org/apache/datasketches/memory/internal/CommonBufferTest.java
+++
b/src/test/java/org/apache/datasketches/memory/internal/CommonBufferTest.java
@@ -32,6 +32,7 @@ import org.testng.annotations.Test;
public class CommonBufferTest {
private final MemoryRequestServer memReqSvr = Resource.defaultMemReqSvr;
+
@Test
public void checkSetGet() throws Exception {
int memCapacity = 60; //must be at least 60
diff --git
a/src/test/java/org/apache/datasketches/memory/internal/CommonMemoryTest.java
b/src/test/java/org/apache/datasketches/memory/internal/CommonMemoryTest.java
index 07a696f..f32e5c7 100644
---
a/src/test/java/org/apache/datasketches/memory/internal/CommonMemoryTest.java
+++
b/src/test/java/org/apache/datasketches/memory/internal/CommonMemoryTest.java
@@ -19,10 +19,12 @@
package org.apache.datasketches.memory.internal;
+import static
org.apache.datasketches.memory.internal.ResourceImpl.NON_NATIVE_BYTE_ORDER;
import static org.apache.datasketches.memory.internal.Util.isAllBitsClear;
import static org.apache.datasketches.memory.internal.Util.isAllBitsSet;
import static org.apache.datasketches.memory.internal.Util.isAnyBitsClear;
import static org.apache.datasketches.memory.internal.Util.isAnyBitsSet;
+import static org.apache.datasketches.memory.internal.Util.*;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertTrue;
@@ -30,13 +32,15 @@ import static org.testng.Assert.assertTrue;
import java.lang.foreign.Arena;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.Resource;
+import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.MemoryRequestServer;
+import org.apache.datasketches.memory.Resource;
import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
public class CommonMemoryTest {
private final MemoryRequestServer memReqSvr = Resource.defaultMemReqSvr;
+
@Test
public void checkSetGet() throws Exception {
int memCapacity = 16; //must be at least 8
@@ -159,14 +163,19 @@ public class CommonMemoryTest {
}
}
- @Test
+ @Test //Also checks putting and getting from the segment can be unaligned
public void checkSetGetPartialArraysWithOffset() throws Exception {
- int memCapacity = 32;
+ int memCapacity = 64;
try (Arena arena = Arena.ofConfined()) {
WritableMemory mem = WritableMemory.allocateDirect(memCapacity, 1,
ByteOrder.nativeOrder(), memReqSvr, arena);
assertEquals(memCapacity, mem.getCapacity());
setGetPartialArraysWithOffsetTests(mem);
}
+ try (Arena arena = Arena.ofConfined()) {
+ WritableMemory mem = WritableMemory.allocateDirect(memCapacity, 1,
NON_NATIVE_BYTE_ORDER, memReqSvr, arena);
+ assertEquals(memCapacity, mem.getCapacity());
+ setGetPartialArraysWithOffsetTests(mem);
+ }
}
public static void setGetPartialArraysWithOffsetTests(WritableMemory mem) {
@@ -182,48 +191,50 @@ public class CommonMemoryTest {
char[] srcArray3 = { 'A', 'B', 'C', 'D' };
char[] dstArray3 = new char[items];
- mem.putCharArray(0, srcArray3, 2, items/2);
- mem.getCharArray(0, dstArray3, 2, items/2);
+ mem.clear();
+ mem.putCharArray(1, srcArray3, 2, items/2);
+ mem.getCharArray(1, dstArray3, 2, items/2);
for (int i = 2; i < items; i++) {
assertEquals(dstArray3[i], srcArray3[i]);
}
+ //println(""); println(toHexSeparated(mem, 1, 8));
double[] srcArray4 = { 1.0, -2.0, 3.0, -4.0 };
double[] dstArray4 = new double[items];
- mem.putDoubleArray(0, srcArray4, 2, items/2);
- mem.getDoubleArray(0, dstArray4, 2, items/2);
+ mem.putDoubleArray(1, srcArray4, 2, items/2);
+ mem.getDoubleArray(1, dstArray4, 2, items/2);
for (int i = 2; i < items; i++) {
assertEquals(dstArray4[i], srcArray4[i], 0.0);
}
float[] srcArray5 = { (float)1.0, (float)-2.0, (float)3.0, (float)-4.0 };
float[] dstArray5 = new float[items];
- mem.putFloatArray(0, srcArray5, 2, items/2);
- mem.getFloatArray(0, dstArray5, 2, items/2);
+ mem.putFloatArray(1, srcArray5, 2, items/2);
+ mem.getFloatArray(1, dstArray5, 2, items/2);
for (int i = 2; i < items; i++) {
assertEquals(dstArray5[i], srcArray5[i], 0.0);
}
int[] srcArray6 = { 1, -2, 3, -4 };
int[] dstArray6 = new int[items];
- mem.putIntArray(0, srcArray6, 2, items/2);
- mem.getIntArray(0, dstArray6, 2, items/2);
+ mem.putIntArray(1, srcArray6, 2, items/2);
+ mem.getIntArray(1, dstArray6, 2, items/2);
for (int i = 2; i < items; i++) {
assertEquals(dstArray6[i], srcArray6[i]);
}
long[] srcArray7 = { 1, -2, 3, -4 };
long[] dstArray7 = new long[items];
- mem.putLongArray(0, srcArray7, 2, items/2);
- mem.getLongArray(0, dstArray7, 2, items/2);
+ mem.putLongArray(1, srcArray7, 2, items/2);
+ mem.getLongArray(1, dstArray7, 2, items/2);
for (int i = 2; i < items; i++) {
assertEquals(dstArray7[i], srcArray7[i]);
}
short[] srcArray8 = { 1, -2, 3, -4 };
short[] dstArray8 = new short[items];
- mem.putShortArray(0, srcArray8, 2, items/2);
- mem.getShortArray(0, dstArray8, 2, items/2);
+ mem.putShortArray(1, srcArray8, 2, items/2);
+ mem.getShortArray(1, dstArray8, 2, items/2);
for (int i = 2; i < items; i++) {
assertEquals(dstArray8[i], srcArray8[i]);
}
@@ -283,7 +294,7 @@ public class CommonMemoryTest {
}
}
- //enable println stmts to visually check
+ //enable println statements to visually check
public static void setClearMemoryRegionsTests(WritableMemory mem) {
int accessCapacity = (int)mem.getCapacity();
@@ -299,7 +310,7 @@ public class CommonMemoryTest {
for (int i = reg1Start; i < (reg1Len+reg1Start); i++) {
assertEquals(mem.getByte(i), b1);
}
- //println(mem.toHexString("Region1 to 5", reg1Start, reg1Len));
+ //println(ResourceImpl.toHex((ResourceImpl)mem, "Region1 to 5", reg1Start,
reg1Len, true));
//set region 2
byte b2 = 7;
@@ -308,7 +319,7 @@ public class CommonMemoryTest {
for (int i = reg2Start; i < (reg2Len+reg2Start); i++) {
assertEquals(mem.getByte(i), b2);
}
- //println(mem.toHexString("Region2 to 7", reg2Start, reg2Len));
+ //println(ResourceImpl.toHex((ResourceImpl)mem, "Region2 to 7", reg2Start,
reg2Len, true));
//clear region 1
byte zeroByte = 0;
@@ -316,14 +327,14 @@ public class CommonMemoryTest {
for (int i = reg1Start; i < (reg1Len+reg1Start); i++) {
assertEquals(mem.getByte(i), zeroByte);
}
- //println(mem.toHexString("Region1 cleared", reg1Start, reg1Len));
+ //println(ResourceImpl.toHex((ResourceImpl)mem, "Region1 cleared",
reg1Start, reg1Len, true));
//clear region 2
mem.clear(reg2Start, reg2Len);
for (int i = reg2Start; i < (reg2Len+reg2Start); i++) {
assertEquals(mem.getByte(i), zeroByte);
}
- //println(mem.toHexString("Region2 cleared", reg2Start, reg2Len));
+ //println(ResourceImpl.toHex((ResourceImpl)mem, "Region2 cleared",
reg2Start, reg2Len, true));
//set all to ones
byte b4 = 127;
@@ -331,14 +342,14 @@ public class CommonMemoryTest {
for (int i=0; i<accessCapacity; i++) {
assertEquals(mem.getByte(i), b4);
}
- //println(mem.toHexString("Region1 + Region2 all ones", 0,
accessCapacity));
+ //println(ResourceImpl.toHex((ResourceImpl)mem, "Region1 + Region2 all
ones", 0, accessCapacity, true));
//clear all
mem.clear();
for (int i = 0; i < accessCapacity; i++) {
assertEquals(mem.getByte(i), zeroByte);
}
- //println(mem.toHexString("Region1 + Region2 cleared", 0, accessCapacity));
+ //println(ResourceImpl.toHex((ResourceImpl)mem, "Region1 + Region2
cleared", 0, accessCapacity, true));
}
@Test
@@ -358,8 +369,8 @@ public class CommonMemoryTest {
mem.putByte(i, (byte)i);
}
- //println(mem.toHexString("Check toHexString(0, 48) to integers", 0,
memCapacity));
- //println(mem.toHexString("Check toHexString(8, 40)", 8, 40));
+ //println(ResourceImpl.toHex((ResourceImpl)mem, "Check toHexString(0, 48)
to integers", 0, memCapacity, true));
+ //println(ResourceImpl.toHex((ResourceImpl)mem, "Check toHexString(8,
40)", 8, 40, true));
}
@Test
@@ -370,7 +381,11 @@ public class CommonMemoryTest {
/**
* @param s value to print
*/
- static void println(String s) {
- //System.out.println(s); //disable here
+ static void println(Object o) {
+ System.out.println(o); //disable here
+ }
+
+ static void print(Object o) {
+ System.out.print(o); //disable here
}
}
diff --git
a/src/test/java/org/apache/datasketches/memory/internal/ResourceTest.java
b/src/test/java/org/apache/datasketches/memory/internal/ResourceTest.java
index cb6181c..0a3d411 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/ResourceTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/ResourceTest.java
@@ -23,12 +23,17 @@ import java.lang.foreign.Arena;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertTrue;
+import static org.testng.Assert.fail;
+import static java.lang.foreign.ValueLayout.JAVA_BYTE;
import java.lang.foreign.MemorySegment;
+import java.lang.foreign.ValueLayout;
+import java.lang.foreign.ValueLayout.OfByte;
import java.nio.ByteOrder;
import org.apache.datasketches.memory.Buffer;
import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.Resource;
import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@@ -118,9 +123,65 @@ public class ResourceTest {
@Test
public void checkToMemorySegment() {
- WritableMemory mem = WritableMemory.allocate(8);
- mem.toMemorySegment();
- mem.asByteBufferView(ByteOrder.nativeOrder());
+ {
+ int len = 0;
+ WritableMemory mem = WritableMemory.allocate(len);
+ MemorySegment seg = mem.toMemorySegment();
+ assertEquals(seg.byteSize(), len);
+ }
+ {
+ int len = 13 * 8;
+ WritableMemory mem = WritableMemory.allocate(len);
+ MemorySegment seg = mem.toMemorySegment();
+ assertEquals(seg.byteSize(), len);
+ }
+ {
+ int len = 13 * 4;
+ WritableMemory mem = WritableMemory.allocate(len);
+ MemorySegment seg = mem.toMemorySegment();
+ assertEquals(seg.byteSize(), len);
+ }
+ {
+ int len = 13 * 2;
+ WritableMemory mem = WritableMemory.allocate(len);
+ MemorySegment seg = mem.toMemorySegment();
+ assertEquals(seg.byteSize(), len);
+ }
+ {
+ int len = 13;
+ WritableMemory mem = WritableMemory.allocate(len);
+ MemorySegment seg = mem.toMemorySegment();
+ assertEquals(seg.byteSize(), len);
+ }
+ }
+
+ @Test
+ public void checkParseJavaVersion() {
+ try {
+ ResourceImpl.parseJavaVersion("15_1");
+ fail();
+ } catch (IllegalArgumentException e) { }
+ try {
+ ResourceImpl.parseJavaVersion("20");
+ fail();
+ } catch (IllegalArgumentException e) { }
+ ResourceImpl.parseJavaVersion("21");
+ ResourceImpl.parseJavaVersion("22");
+ }
+
+ @Test
+ public void checkGetRelativeOffset() {
+ WritableMemory wmem = WritableMemory.allocateDirect(1024);
+ WritableMemory reg = wmem.writableRegion(512, 256);
+ long off = wmem.getRelativeOffset(reg);
+ assertEquals(off, 512);
+ }
+
+ @Test
+ public void checkIsSameResource() {
+ WritableMemory wmem = WritableMemory.allocateDirect(1024);
+ WritableMemory reg = wmem.writableRegion(0, 1024);
+ assertTrue(wmem.isSameResource(reg));
}
/********************/
@@ -132,8 +193,8 @@ public class ResourceTest {
/**
* @param s value to print
*/
- static void println(String s) {
- //System.out.println(s); //disable here
+ static void println(Object o) {
+ //System.out.println(o); //disable here
}
}
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
