This is an automated email from the ASF dual-hosted git repository.
leerho pushed a commit to branch ffm_phase3
in repository https://gitbox.apache.org/repos/asf/datasketches-java.git
The following commit(s) were added to refs/heads/ffm_phase3 by this push:
new f5e19314e Finished converting CPC
f5e19314e is described below
commit f5e19314efaab3f15f2eca8dd5186bc3a6de955a
Author: Lee Rhodes <[email protected]>
AuthorDate: Mon Jul 7 14:57:45 2025 -0700
Finished converting CPC
---
.../apache/datasketches/cpc/CompressedState.java | 122 +++----
.../cpc/CompressionCharacterization.java | 41 ++-
.../org/apache/datasketches/cpc/CpcSketch.java | 54 +--
.../org/apache/datasketches/cpc/CpcWrapper.java | 41 +--
.../org/apache/datasketches/cpc/PreambleUtil.java | 382 +++++++++++----------
.../datasketches/cpc/CompressedStateTest.java | 17 +-
.../cpc/CpcSketchCrossLanguageTest.java | 22 +-
.../org/apache/datasketches/cpc/CpcSketchTest.java | 28 +-
.../apache/datasketches/cpc/CpcWrapperTest.java | 66 ++--
.../apache/datasketches/cpc/PreambleUtilTest.java | 195 +++++------
10 files changed, 487 insertions(+), 481 deletions(-)
diff --git a/src/main/java/org/apache/datasketches/cpc/CompressedState.java
b/src/main/java/org/apache/datasketches/cpc/CompressedState.java
index b88a71812..20322cf7d 100644
--- a/src/main/java/org/apache/datasketches/cpc/CompressedState.java
+++ b/src/main/java/org/apache/datasketches/cpc/CompressedState.java
@@ -47,9 +47,9 @@ import static
org.apache.datasketches.cpc.PreambleUtil.putSparseHybridHip;
import static org.apache.datasketches.cpc.PreambleUtil.putSparseHybridMerged;
import static org.apache.datasketches.cpc.RuntimeAsserts.rtAssert;
+import java.lang.foreign.MemorySegment;
+
import org.apache.datasketches.common.Util;
-import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.WritableMemory;
/**
* @author Lee Rhodes
@@ -118,121 +118,121 @@ final class CompressedState {
return 4L * (preInts + csvLengthInts + cwLengthInts);
}
- static CompressedState importFromMemory(final Memory mem) {
- checkLoPreamble(mem);
- rtAssert(isCompressed(mem));
- final int lgK = getLgK(mem);
- final short seedHash = getSeedHash(mem);
+ static CompressedState importFromSegment(final MemorySegment seg) {
+ checkLoPreamble(seg);
+ rtAssert(isCompressed(seg));
+ final int lgK = getLgK(seg);
+ final short seedHash = getSeedHash(seg);
final CompressedState state = new CompressedState(lgK, seedHash);
- final int fmtOrd = getFormatOrdinal(mem);
+ final int fmtOrd = getFormatOrdinal(seg);
final Format format = Format.ordinalToFormat(fmtOrd);
- state.mergeFlag = !((fmtOrd & 1) > 0); //merge flag is complement of HIP
+ state.mergeFlag = ((fmtOrd & 1) <= 0); //merge flag is complement of HIP
state.csvIsValid = (fmtOrd & 2) > 0;
state.windowIsValid = (fmtOrd & 4) > 0;
switch (format) {
case EMPTY_MERGED :
case EMPTY_HIP : {
- checkCapacity(mem.getCapacity(), 8L);
+ checkCapacity(seg.byteSize(), 8L);
break;
}
case SPARSE_HYBRID_MERGED : {
//state.fiCol = getFiCol(mem);
- state.numCoupons = getNumCoupons(mem);
+ state.numCoupons = getNumCoupons(seg);
state.numCsv = (int) state.numCoupons; //only true for sparse_hybrid
- state.csvLengthInts = getSvLengthInts(mem);
+ state.csvLengthInts = getSvLengthInts(seg);
//state.cwLength = getCwLength(mem);
//state.kxp = getKxP(mem);
//state.hipEstAccum = getHipAccum(mem);
- checkCapacity(mem.getCapacity(), state.getRequiredSerializedBytes());
+ checkCapacity(seg.byteSize(), state.getRequiredSerializedBytes());
//state.cwStream = getCwStream(mem);
- state.csvStream = getSvStream(mem);
+ state.csvStream = getSvStream(seg);
break;
}
case SPARSE_HYBRID_HIP : {
//state.fiCol = getFiCol(mem);
- state.numCoupons = getNumCoupons(mem);
+ state.numCoupons = getNumCoupons(seg);
state.numCsv = (int) state.numCoupons; //only true for sparse_hybrid
- state.csvLengthInts = getSvLengthInts(mem);
+ state.csvLengthInts = getSvLengthInts(seg);
//state.cwLength = getCwLength(mem);
- state.kxp = getKxP(mem);
- state.hipEstAccum = getHipAccum(mem);
- checkCapacity(mem.getCapacity(), state.getRequiredSerializedBytes());
+ state.kxp = getKxP(seg);
+ state.hipEstAccum = getHipAccum(seg);
+ checkCapacity(seg.byteSize(), state.getRequiredSerializedBytes());
//state.cwStream = getCwStream(mem);
- state.csvStream = getSvStream(mem);
+ state.csvStream = getSvStream(seg);
break;
}
case PINNED_SLIDING_MERGED_NOSV : {
- state.fiCol = getFiCol(mem);
- state.numCoupons = getNumCoupons(mem);
+ state.fiCol = getFiCol(seg);
+ state.numCoupons = getNumCoupons(seg);
//state.numCsv = getNumCsv(mem);
//state.csvLength = getCsvLength(mem);
- state.cwLengthInts = getWLengthInts(mem);
+ state.cwLengthInts = getWLengthInts(seg);
//state.kxp = getKxP(mem);
//state.hipEstAccum = getHipAccum(mem);
- checkCapacity(mem.getCapacity(), state.getRequiredSerializedBytes());
- state.cwStream = getWStream(mem);
+ checkCapacity(seg.byteSize(), state.getRequiredSerializedBytes());
+ state.cwStream = getWStream(seg);
//state.csvStream = getCsvStream(mem);
break;
}
case PINNED_SLIDING_HIP_NOSV : {
- state.fiCol = getFiCol(mem);
- state.numCoupons = getNumCoupons(mem);
+ state.fiCol = getFiCol(seg);
+ state.numCoupons = getNumCoupons(seg);
//state.numCsv = getNumCsv(mem);
//state.csvLength = getCsvLength(mem);
- state.cwLengthInts = getWLengthInts(mem);
- state.kxp = getKxP(mem);
- state.hipEstAccum = getHipAccum(mem);
- checkCapacity(mem.getCapacity(), state.getRequiredSerializedBytes());
- state.cwStream = getWStream(mem);
+ state.cwLengthInts = getWLengthInts(seg);
+ state.kxp = getKxP(seg);
+ state.hipEstAccum = getHipAccum(seg);
+ checkCapacity(seg.byteSize(), state.getRequiredSerializedBytes());
+ state.cwStream = getWStream(seg);
//state.csvStream = getCsvStream(mem);
break;
}
case PINNED_SLIDING_MERGED : {
- state.fiCol = getFiCol(mem);
- state.numCoupons = getNumCoupons(mem);
- state.numCsv = getNumSv(mem);
- state.csvLengthInts = getSvLengthInts(mem);
- state.cwLengthInts = getWLengthInts(mem);
+ state.fiCol = getFiCol(seg);
+ state.numCoupons = getNumCoupons(seg);
+ state.numCsv = getNumSv(seg);
+ state.csvLengthInts = getSvLengthInts(seg);
+ state.cwLengthInts = getWLengthInts(seg);
//state.kxp = getKxP(mem);
//state.hipEstAccum = getHipAccum(mem);
- checkCapacity(mem.getCapacity(), state.getRequiredSerializedBytes());
- state.cwStream = getWStream(mem);
- state.csvStream = getSvStream(mem);
+ checkCapacity(seg.byteSize(), state.getRequiredSerializedBytes());
+ state.cwStream = getWStream(seg);
+ state.csvStream = getSvStream(seg);
break;
}
case PINNED_SLIDING_HIP : {
- state.fiCol = getFiCol(mem);
- state.numCoupons = getNumCoupons(mem);
- state.numCsv = getNumSv(mem);
- state.csvLengthInts = getSvLengthInts(mem);
- state.cwLengthInts = getWLengthInts(mem);
- state.kxp = getKxP(mem);
- state.hipEstAccum = getHipAccum(mem);
- checkCapacity(mem.getCapacity(), state.getRequiredSerializedBytes());
- state.cwStream = getWStream(mem);
- state.csvStream = getSvStream(mem);
+ state.fiCol = getFiCol(seg);
+ state.numCoupons = getNumCoupons(seg);
+ state.numCsv = getNumSv(seg);
+ state.csvLengthInts = getSvLengthInts(seg);
+ state.cwLengthInts = getWLengthInts(seg);
+ state.kxp = getKxP(seg);
+ state.hipEstAccum = getHipAccum(seg);
+ checkCapacity(seg.byteSize(), state.getRequiredSerializedBytes());
+ state.cwStream = getWStream(seg);
+ state.csvStream = getSvStream(seg);
break;
}
}
- checkCapacity(mem.getCapacity(),
- 4L * (getPreInts(mem) + state.csvLengthInts + state.cwLengthInts));
+ checkCapacity(seg.byteSize(),
+ 4L * (getPreInts(seg) + state.csvLengthInts + state.cwLengthInts));
return state;
}
- void exportToMemory(final WritableMemory wmem) {
+ void exportToSegment(final MemorySegment wseg) {
final Format format = getFormat();
switch (format) {
case EMPTY_MERGED : {
- putEmptyMerged(wmem, lgK, seedHash);
+ putEmptyMerged(wseg, lgK, seedHash);
break;
}
case EMPTY_HIP : {
- putEmptyHip(wmem, lgK, seedHash);
+ putEmptyHip(wseg, lgK, seedHash);
break;
}
case SPARSE_HYBRID_MERGED : {
- putSparseHybridMerged(wmem,
+ putSparseHybridMerged(wseg,
lgK,
(int) numCoupons, //unsigned
csvLengthInts,
@@ -241,7 +241,7 @@ final class CompressedState {
break;
}
case SPARSE_HYBRID_HIP : {
- putSparseHybridHip(wmem,
+ putSparseHybridHip(wseg,
lgK,
(int) numCoupons, //unsigned
csvLengthInts,
@@ -252,7 +252,7 @@ final class CompressedState {
break;
}
case PINNED_SLIDING_MERGED_NOSV : {
- putPinnedSlidingMergedNoSv(wmem,
+ putPinnedSlidingMergedNoSv(wseg,
lgK,
fiCol,
(int) numCoupons, //unsigned
@@ -262,7 +262,7 @@ final class CompressedState {
break;
}
case PINNED_SLIDING_HIP_NOSV : {
- putPinnedSlidingHipNoSv(wmem,
+ putPinnedSlidingHipNoSv(wseg,
lgK,
fiCol,
(int) numCoupons, //unsigned
@@ -274,7 +274,7 @@ final class CompressedState {
break;
}
case PINNED_SLIDING_MERGED : {
- putPinnedSlidingMerged(wmem,
+ putPinnedSlidingMerged(wseg,
lgK,
fiCol,
(int) numCoupons, //unsigned
@@ -287,7 +287,7 @@ final class CompressedState {
break;
}
case PINNED_SLIDING_HIP : {
- putPinnedSlidingHip(wmem,
+ putPinnedSlidingHip(wseg,
lgK,
fiCol,
(int) numCoupons, //unsigned
diff --git
a/src/main/java/org/apache/datasketches/cpc/CompressionCharacterization.java
b/src/main/java/org/apache/datasketches/cpc/CompressionCharacterization.java
index f34054d48..32c52ef28 100644
--- a/src/main/java/org/apache/datasketches/cpc/CompressionCharacterization.java
+++ b/src/main/java/org/apache/datasketches/cpc/CompressionCharacterization.java
@@ -24,16 +24,15 @@ import static org.apache.datasketches.common.Util.LS;
import static org.apache.datasketches.common.Util.ceilingPowerOf2;
import static org.apache.datasketches.common.Util.log2;
import static org.apache.datasketches.common.Util.powerSeriesNextDouble;
-import static org.apache.datasketches.cpc.CompressedState.importFromMemory;
+import static org.apache.datasketches.cpc.CompressedState.importFromSegment;
import static org.apache.datasketches.cpc.RuntimeAsserts.rtAssert;
+import java.lang.foreign.MemorySegment;
import java.io.PrintStream;
import java.io.PrintWriter;
import org.apache.datasketches.common.SuppressFBWarnings;
import org.apache.datasketches.common.Util;
-import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.WritableMemory;
/**
* This code is used both by unit tests, for short running tests,
@@ -51,20 +50,20 @@ public class CompressionCharacterization {
private long vIn = 0;
//inputs
- private int lgMinK;
- private int lgMaxK; //inclusive
- private int lgMinT; //Trials at end
- private int lgMaxT; //Trials at start
- private int lgMulK; //multiplier of K to produce maxU
- private int uPPO;
- private int incLgK; //increment of lgK
- private PrintStream ps;
- private PrintWriter pw;
+ private final int lgMinK;
+ private final int lgMaxK; //inclusive
+ private final int lgMinT; //Trials at end
+ private final int lgMaxT; //Trials at start
+ private final int lgMulK; //multiplier of K to produce maxU
+ private final int uPPO;
+ private final int incLgK; //increment of lgK
+ private final PrintStream ps;
+ private final PrintWriter pw;
//intermediates
private CpcSketch[] streamSketches;
private CompressedState[] compressedStates1;
- private WritableMemory[] memoryArr;
+ private MemorySegment[] segArr;
private CompressedState[] compressedStates2;
private CpcSketch[] unCompressedSketches;
@@ -141,7 +140,7 @@ public class CompressionCharacterization {
//printf("%d %d %d %d\n", totalTrials, lgTotTrials, 1 << lgWaves,
trialsPerWave);
streamSketches = new CpcSketch[trialsPerWave];
compressedStates1 = new CompressedState[trialsPerWave];
- memoryArr = new WritableMemory[trialsPerWave];
+ segArr = new MemorySegment[trialsPerWave];
compressedStates2 = new CompressedState[trialsPerWave];
unCompressedSketches = new CpcSketch[trialsPerWave];
@@ -194,23 +193,23 @@ public class CompressionCharacterization {
sumCom_nS += nanoEnd - nanoStart;
nanoStart = nanoEnd;
- //State to Memory loop
+ //State to MemorySegment loop
for (int trial = 0; trial < trialsPerWave; trial++) {
final CompressedState state = compressedStates1[trial];
final long cap = state.getRequiredSerializedBytes();
- final WritableMemory wmem = WritableMemory.allocate((int) cap);
- state.exportToMemory(wmem);
- memoryArr[trial] = wmem;
+ final MemorySegment wseg = MemorySegment.ofArray(new byte[(int) cap]);
+ state.exportToSegment(wseg);
+ segArr[trial] = wseg;
}
nanoEnd = System.nanoTime();
sumSer_nS += nanoEnd - nanoStart;
nanoStart = nanoEnd;
- //Memory to State loop
+ //MemorySegment to State loop
for (int trial = 0; trial < trialsPerWave; trial++) {
- final Memory mem = memoryArr[trial];
- final CompressedState state = importFromMemory(mem);
+ final MemorySegment seg = segArr[trial];
+ final CompressedState state = importFromSegment(seg);
compressedStates2[trial] = state;
}
diff --git a/src/main/java/org/apache/datasketches/cpc/CpcSketch.java
b/src/main/java/org/apache/datasketches/cpc/CpcSketch.java
index a87fd1448..672e90348 100644
--- a/src/main/java/org/apache/datasketches/cpc/CpcSketch.java
+++ b/src/main/java/org/apache/datasketches/cpc/CpcSketch.java
@@ -19,6 +19,7 @@
package org.apache.datasketches.cpc;
+import static java.lang.foreign.ValueLayout.JAVA_BYTE;
import static java.lang.Math.log;
import static java.lang.Math.sqrt;
import static java.nio.charset.StandardCharsets.UTF_8;
@@ -30,13 +31,12 @@ import static org.apache.datasketches.cpc.CpcUtil.checkLgK;
import static org.apache.datasketches.cpc.CpcUtil.countBitsSetInMatrix;
import static org.apache.datasketches.hash.MurmurHash3.hash;
+import java.lang.foreign.MemorySegment;
import java.nio.ByteBuffer;
import java.util.Arrays;
import org.apache.datasketches.common.Family;
import org.apache.datasketches.common.Util;
-import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.WritableMemory;
/**
* This is a unique-counting sketch that implements the
@@ -228,12 +228,12 @@ public final class CpcSketch {
}
/**
- * Return the given Memory as a CpcSketch on the Java heap using the
DEFAULT_UPDATE_SEED.
- * @param mem the given Memory
- * @return the given Memory as a CpcSketch on the Java heap.
+ * Return the given MemorySegment as a CpcSketch on the Java heap using the
DEFAULT_UPDATE_SEED.
+ * @param seg the given MemorySegment
+ * @return the given MemorySegment as a CpcSketch on the Java heap.
*/
- public static CpcSketch heapify(final Memory mem) {
- return heapify(mem, Util.DEFAULT_UPDATE_SEED);
+ public static CpcSketch heapify(final MemorySegment seg) {
+ return heapify(seg, Util.DEFAULT_UPDATE_SEED);
}
/**
@@ -246,13 +246,13 @@ public final class CpcSketch {
}
/**
- * Return the given Memory as a CpcSketch on the Java heap.
- * @param mem the given Memory
- * @param seed the seed used to create the original sketch from which the
Memory was derived.
- * @return the given Memory as a CpcSketch on the Java heap.
+ * Return the given MemorySegment as a CpcSketch on the Java heap.
+ * @param seg the given MemorySegment
+ * @param seed the seed used to create the original sketch from which the
MemorySegment was derived.
+ * @return the given MemorySegment as a CpcSketch on the Java heap.
*/
- public static CpcSketch heapify(final Memory mem, final long seed) {
- final CompressedState state = CompressedState.importFromMemory(mem);
+ public static CpcSketch heapify(final MemorySegment seg, final long seed) {
+ final CompressedState state = CompressedState.importFromSegment(seg);
return uncompress(state, seed);
}
@@ -263,8 +263,8 @@ public final class CpcSketch {
* @return the given byte array as a CpcSketch on the Java heap.
*/
public static CpcSketch heapify(final byte[] byteArray, final long seed) {
- final Memory mem = Memory.wrap(byteArray);
- return heapify(mem, seed);
+ final MemorySegment seg = MemorySegment.ofArray(byteArray);
+ return heapify(seg, seed);
}
/**
@@ -278,7 +278,7 @@ public final class CpcSketch {
/**
* Resets this sketch to empty but retains the original LgK and Seed.
*/
- public final void reset() {
+ public void reset() {
numCoupons = 0;
mergeFlag = false;
fiCol = 0;
@@ -298,9 +298,9 @@ public final class CpcSketch {
public byte[] toByteArray() {
final CompressedState state = CompressedState.compress(this);
final long cap = state.getRequiredSerializedBytes();
- final WritableMemory wmem = WritableMemory.allocate((int) cap);
- state.exportToMemory(wmem);
- return wmem.getArray();
+ final MemorySegment wseg = MemorySegment.ofArray(new byte[(int) cap]);
+ state.exportToSegment(wseg);
+ return wseg.toArray(JAVA_BYTE);
}
/**
@@ -370,7 +370,7 @@ public final class CpcSketch {
* @param data The given ByteBuffer
*/
public void update(final ByteBuffer data) {
- if ((data == null) || data.hasRemaining() == false) { return; }
+ if ((data == null) || !data.hasRemaining()) { return; }
final long[] arr = hash(data, seed);
hashUpdate(arr[0], arr[1]);
}
@@ -489,7 +489,7 @@ public final class CpcSketch {
else {
// cannot use Table.mustInsert(), because it doesn't provide for
growth
final boolean isNovel = PairTable.maybeInsert(newTable, rowCol);
- assert (isNovel == true);
+ assert isNovel;
}
}
}
@@ -575,7 +575,7 @@ public final class CpcSketch {
pattern = pattern ^ (1L << col); // erase the 1.
final int rowCol = (i << 6) | col;
final boolean isNovel = PairTable.maybeInsert(table, rowCol);
- assert isNovel == true;
+ assert isNovel;
}
}
sketch.windowOffset = newOffset;
@@ -774,14 +774,14 @@ public final class CpcSketch {
}
/**
- * Returns a human readable string of the preamble of a Memory image of a
CpcSketch.
- * @param mem the given Memory
+ * Returns a human readable string of the preamble of a MemorySegment image
of a CpcSketch.
+ * @param seg the given MemorySegment
* @param detail if true, a dump of the compressed window and surprising
value streams will be
* included.
- * @return a human readable string of the preamble of a Memory image of a
CpcSketch.
+ * @return a human readable string of the preamble of a MemorySegment image
of a CpcSketch.
*/
- public static String toString(final Memory mem, final boolean detail) {
- return PreambleUtil.toString(mem, detail);
+ public static String toString(final MemorySegment seg, final boolean detail)
{
+ return PreambleUtil.toString(seg, detail);
}
private static void fillKxpByteLookup() { //called from static initializer
diff --git a/src/main/java/org/apache/datasketches/cpc/CpcWrapper.java
b/src/main/java/org/apache/datasketches/cpc/CpcWrapper.java
index fe7f0e5d4..083eeadf7 100644
--- a/src/main/java/org/apache/datasketches/cpc/CpcWrapper.java
+++ b/src/main/java/org/apache/datasketches/cpc/CpcWrapper.java
@@ -31,28 +31,29 @@ import static
org.apache.datasketches.cpc.PreambleUtil.hasHip;
import static org.apache.datasketches.cpc.PreambleUtil.isCompressed;
import static org.apache.datasketches.cpc.RuntimeAsserts.rtAssert;
+import java.lang.foreign.MemorySegment;
+
import org.apache.datasketches.common.Family;
import org.apache.datasketches.common.SuppressFBWarnings;
-import org.apache.datasketches.memory.Memory;
/**
* This provides a read-only view of a serialized image of a CpcSketch, which
can be
- * on-heap or off-heap represented as a Memory object, or on-heap represented
as a byte array.
+ * on-heap or off-heap represented as a MemorySegment object, or on-heap
represented as a byte array.
* @author Lee Rhodes
* @author Kevin Lang
*/
public final class CpcWrapper {
- Memory mem;
+ MemorySegment seg;
/**
- * Construct a read-only view of the given Memory that contains a CpcSketch
- * @param mem the given Memory
+ * Construct a read-only view of the given MemorySegment that contains a
CpcSketch
+ * @param seg the given MemorySegment
*/
@SuppressFBWarnings(value = "EI_EXPOSE_REP2", justification = "This is OK
here")
- public CpcWrapper(final Memory mem) {
- this.mem = mem;
- checkLoPreamble(mem);
- rtAssert(isCompressed(mem));
+ public CpcWrapper(final MemorySegment seg) {
+ this.seg = seg;
+ checkLoPreamble(seg);
+ rtAssert(isCompressed(seg));
}
@@ -61,7 +62,7 @@ public final class CpcWrapper {
* @param byteArray the given byte array
*/
public CpcWrapper(final byte[] byteArray) {
- this(Memory.wrap(byteArray));
+ this(MemorySegment.ofArray(byteArray));
}
/**
@@ -69,10 +70,10 @@ public final class CpcWrapper {
* @return the best estimate of the cardinality of the sketch.
*/
public double getEstimate() {
- if (!hasHip(mem)) {
- return getIconEstimate(PreambleUtil.getLgK(mem), getNumCoupons(mem));
+ if (!hasHip(seg)) {
+ return getIconEstimate(PreambleUtil.getLgK(seg), getNumCoupons(seg));
}
- return getHipAccum(mem);
+ return getHipAccum(seg);
}
/**
@@ -88,7 +89,7 @@ public final class CpcWrapper {
* @return the configured Log_base2 of K of this sketch.
*/
public int getLgK() {
- return PreambleUtil.getLgK(mem);
+ return PreambleUtil.getLgK(seg);
}
/**
@@ -98,10 +99,10 @@ public final class CpcWrapper {
* @return the best estimate of the lower bound of the confidence interval
given <i>kappa</i>.
*/
public double getLowerBound(final int kappa) {
- if (!hasHip(mem)) {
- return getIconConfidenceLB(PreambleUtil.getLgK(mem), getNumCoupons(mem),
kappa);
+ if (!hasHip(seg)) {
+ return getIconConfidenceLB(PreambleUtil.getLgK(seg), getNumCoupons(seg),
kappa);
}
- return getHipConfidenceLB(PreambleUtil.getLgK(mem), getNumCoupons(mem),
getHipAccum(mem), kappa);
+ return getHipConfidenceLB(PreambleUtil.getLgK(seg), getNumCoupons(seg),
getHipAccum(seg), kappa);
}
/**
@@ -111,10 +112,10 @@ public final class CpcWrapper {
* @return the best estimate of the upper bound of the confidence interval
given <i>kappa</i>.
*/
public double getUpperBound(final int kappa) {
- if (!hasHip(mem)) {
- return getIconConfidenceUB(PreambleUtil.getLgK(mem), getNumCoupons(mem),
kappa);
+ if (!hasHip(seg)) {
+ return getIconConfidenceUB(PreambleUtil.getLgK(seg), getNumCoupons(seg),
kappa);
}
- return getHipConfidenceUB(PreambleUtil.getLgK(mem), getNumCoupons(mem),
getHipAccum(mem), kappa);
+ return getHipConfidenceUB(PreambleUtil.getLgK(seg), getNumCoupons(seg),
getHipAccum(seg), kappa);
}
}
diff --git a/src/main/java/org/apache/datasketches/cpc/PreambleUtil.java
b/src/main/java/org/apache/datasketches/cpc/PreambleUtil.java
index 3d2f350c9..713e72ded 100644
--- a/src/main/java/org/apache/datasketches/cpc/PreambleUtil.java
+++ b/src/main/java/org/apache/datasketches/cpc/PreambleUtil.java
@@ -19,20 +19,24 @@
package org.apache.datasketches.cpc;
+import static java.lang.foreign.ValueLayout.JAVA_BYTE;
+import static java.lang.foreign.ValueLayout.JAVA_DOUBLE_UNALIGNED;
+import static java.lang.foreign.ValueLayout.JAVA_INT_UNALIGNED;
+import static java.lang.foreign.ValueLayout.JAVA_SHORT_UNALIGNED;
import static org.apache.datasketches.common.Util.LS;
import static org.apache.datasketches.common.Util.checkBounds;
+import static org.apache.datasketches.common.Util.clear;
import static org.apache.datasketches.common.Util.zeroPad;
import static org.apache.datasketches.cpc.RuntimeAsserts.rtAssert;
import static org.apache.datasketches.cpc.RuntimeAsserts.rtAssertEquals;
+import java.lang.foreign.MemorySegment;
import java.nio.ByteOrder;
import java.util.Objects;
import org.apache.datasketches.common.Family;
import org.apache.datasketches.common.SketchesArgumentException;
import org.apache.datasketches.common.SketchesStateException;
-import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.WritableMemory;
//@formatter:off
/**
@@ -194,59 +198,59 @@ final class PreambleUtil {
return loField.ordinal();
}
- static int getPreInts(final Memory mem) {
- return mem.getByte(getLoFieldOffset(LoField.PRE_INTS)) & 0XFF;
+ static int getPreInts(final MemorySegment seg) {
+ return seg.get(JAVA_BYTE, getLoFieldOffset(LoField.PRE_INTS)) & 0XFF;
}
- static int getSerVer(final Memory mem) {
- return mem.getByte(getLoFieldOffset(LoField.SER_VERSION)) & 0XFF;
+ static int getSerVer(final MemorySegment seg) {
+ return seg.get(JAVA_BYTE, getLoFieldOffset(LoField.SER_VERSION)) & 0XFF;
}
- static Family getFamily(final Memory mem) {
- final int fam = mem.getByte(getLoFieldOffset(LoField.FAMILY)) & 0XFF;
+ static Family getFamily(final MemorySegment seg) {
+ final int fam = seg.get(JAVA_BYTE, getLoFieldOffset(LoField.FAMILY)) &
0XFF;
return Family.idToFamily(fam);
}
- static int getLgK(final Memory mem) {
- return mem.getByte(getLoFieldOffset(LoField.LG_K)) & 0XFF;
+ static int getLgK(final MemorySegment seg) {
+ return seg.get(JAVA_BYTE, getLoFieldOffset(LoField.LG_K)) & 0XFF;
}
- static int getFiCol(final Memory mem) {
- return mem.getByte(getLoFieldOffset(LoField.FI_COL)) & 0XFF;
+ static int getFiCol(final MemorySegment seg) {
+ return seg.get(JAVA_BYTE, getLoFieldOffset(LoField.FI_COL)) & 0XFF;
}
- static int getFlags(final Memory mem) {
- return mem.getByte(getLoFieldOffset(LoField.FLAGS)) & 0XFF;
+ static int getFlags(final MemorySegment seg) {
+ return seg.get(JAVA_BYTE, getLoFieldOffset(LoField.FLAGS)) & 0XFF;
}
- static short getSeedHash(final Memory mem) {
- return mem.getShort(getLoFieldOffset(LoField.SEED_HASH));
+ static short getSeedHash(final MemorySegment seg) {
+ return seg.get(JAVA_SHORT_UNALIGNED, getLoFieldOffset(LoField.SEED_HASH));
}
- static int getFormatOrdinal(final Memory mem) {
- final int flags = getFlags(mem);
+ static int getFormatOrdinal(final MemorySegment seg) {
+ final int flags = getFlags(seg);
return (flags >>> 2) & 0x7;
}
- static Format getFormat(final Memory mem) {
- final int ordinal = getFormatOrdinal(mem);
+ static Format getFormat(final MemorySegment seg) {
+ final int ordinal = getFormatOrdinal(seg);
return Format.ordinalToFormat(ordinal);
}
- static boolean hasHip(final Memory mem) {
- return (getFlags(mem) & HIP_FLAG_MASK) > 0;
+ static boolean hasHip(final MemorySegment seg) {
+ return (getFlags(seg) & HIP_FLAG_MASK) > 0;
}
- static final boolean hasSv(final Memory mem) {
- return (getFlags(mem) & SUP_VAL_FLAG_MASK) > 0;
+ static boolean hasSv(final MemorySegment seg) {
+ return (getFlags(seg) & SUP_VAL_FLAG_MASK) > 0;
}
- static final boolean hasWindow(final Memory mem) {
- return (getFlags(mem) & WINDOW_FLAG_MASK) > 0;
+ static boolean hasWindow(final MemorySegment seg) {
+ return (getFlags(seg) & WINDOW_FLAG_MASK) > 0;
}
- static final boolean isCompressed(final Memory mem) {
- return (getFlags(mem) & COMPRESSED_FLAG_MASK) > 0;
+ static boolean isCompressed(final MemorySegment seg) {
+ return (getFlags(seg) & COMPRESSED_FLAG_MASK) > 0;
}
//PREAMBLE HI_FIELD DEFINITIONS
@@ -301,121 +305,121 @@ final class PreambleUtil {
//PREAMBLE HI_FIELD GETS
- static int getNumCoupons(final Memory mem) {
- final Format format = getFormat(mem);
+ static int getNumCoupons(final MemorySegment seg) {
+ final Format format = getFormat(seg);
final HiField hiField = HiField.NUM_COUPONS;
final long offset = getHiFieldOffset(format, hiField);
- return mem.getInt(offset);
+ return seg.get(JAVA_INT_UNALIGNED, offset);
}
- static int getNumSv(final Memory mem) {
- final Format format = getFormat(mem);
+ static int getNumSv(final MemorySegment seg) {
+ final Format format = getFormat(seg);
final HiField hiField = HiField.NUM_SV;
final long offset = getHiFieldOffset(format, hiField);
- return mem.getInt(offset);
+ return seg.get(JAVA_INT_UNALIGNED, offset);
}
- static int getSvLengthInts(final Memory mem) {
- final Format format = getFormat(mem);
+ static int getSvLengthInts(final MemorySegment seg) {
+ final Format format = getFormat(seg);
final HiField hiField = HiField.SV_LENGTH_INTS;
final long offset = getHiFieldOffset(format, hiField);
- return mem.getInt(offset);
+ return seg.get(JAVA_INT_UNALIGNED, offset);
}
- static int getWLengthInts(final Memory mem) {
- final Format format = getFormat(mem);
+ static int getWLengthInts(final MemorySegment seg) {
+ final Format format = getFormat(seg);
final HiField hiField = HiField.W_LENGTH_INTS;
final long offset = getHiFieldOffset(format, hiField);
- return mem.getInt(offset);
+ return seg.get(JAVA_INT_UNALIGNED, offset);
}
- static double getKxP(final Memory mem) {
- final Format format = getFormat(mem);
+ static double getKxP(final MemorySegment seg) {
+ final Format format = getFormat(seg);
final HiField hiField = HiField.KXP;
final long offset = getHiFieldOffset(format, hiField);
- return mem.getDouble(offset);
+ return seg.get(JAVA_DOUBLE_UNALIGNED, offset);
}
- static double getHipAccum(final Memory mem) {
- final Format format = getFormat(mem);
+ static double getHipAccum(final MemorySegment seg) {
+ final Format format = getFormat(seg);
final HiField hiField = HiField.HIP_ACCUM;
final long offset = getHiFieldOffset(format, hiField);
- return mem.getDouble(offset);
+ return seg.get(JAVA_DOUBLE_UNALIGNED, offset);
}
- static long getSvStreamOffset(final Memory mem) {
- final Format format = getFormat(mem);
+ static long getSvStreamOffset(final MemorySegment seg) {
+ final Format format = getFormat(seg);
final HiField svLenField = HiField.SV_LENGTH_INTS;
- if (!hasSv(mem)) {
+ if (!hasSv(seg)) {
fieldError(format, svLenField);
} else {
- final long svLengthInts = mem.getInt(getHiFieldOffset(format,
HiField.SV_LENGTH_INTS)) & 0XFFFF_FFFFL;
+ final long svLengthInts = seg.get(JAVA_INT_UNALIGNED,
getHiFieldOffset(format, HiField.SV_LENGTH_INTS)) & 0XFFFF_FFFFL;
if (svLengthInts == 0) {
throw new SketchesStateException("svLengthInts cannot be zero");
}
}
long wLengthInts = 0;
- if (hasWindow(mem)) {
- wLengthInts = mem.getInt(getHiFieldOffset(format,
HiField.W_LENGTH_INTS)) & 0XFFFF_FFFFL;
+ if (hasWindow(seg)) {
+ wLengthInts = seg.get(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.W_LENGTH_INTS)) & 0XFFFF_FFFFL;
if (wLengthInts == 0) {
throw new SketchesStateException("wLengthInts cannot be zero");
}
}
- return (getPreInts(mem) + wLengthInts) << 2;
+ return (getPreInts(seg) + wLengthInts) << 2;
}
- static long getWStreamOffset(final Memory mem) {
- final Format format = getFormat(mem);
+ static long getWStreamOffset(final MemorySegment seg) {
+ final Format format = getFormat(seg);
final HiField wLenField = HiField.W_LENGTH_INTS;
- if (!hasWindow(mem)) { fieldError(format, wLenField); }
- final long wLengthInts = mem.getInt(getHiFieldOffset(format,
HiField.W_LENGTH_INTS)) & 0XFFFF_FFFFL;
+ if (!hasWindow(seg)) { fieldError(format, wLenField); }
+ final long wLengthInts = seg.get(JAVA_INT_UNALIGNED,
getHiFieldOffset(format, HiField.W_LENGTH_INTS)) & 0XFFFF_FFFFL;
if (wLengthInts == 0) {
throw new SketchesStateException("wLengthInts cannot be zero");
}
- return getPreInts(mem) << 2;
+ return getPreInts(seg) << 2;
}
- static int[] getSvStream(final Memory mem) {
- final long offset = getSvStreamOffset(mem);
- final int svLengthInts = getSvLengthInts(mem);
+ static int[] getSvStream(final MemorySegment seg) {
+ final long offset = getSvStreamOffset(seg);
+ final int svLengthInts = getSvLengthInts(seg);
final int[] svStream = new int[svLengthInts];
- mem.getIntArray(offset, svStream, 0, svLengthInts);
+ MemorySegment.copy(seg, JAVA_INT_UNALIGNED, offset, svStream, 0,
svLengthInts);
return svStream;
}
- static int[] getWStream(final Memory mem) {
- final long offset = getWStreamOffset(mem);
- final int wLength = getWLengthInts(mem);
+ static int[] getWStream(final MemorySegment seg) {
+ final long offset = getWStreamOffset(seg);
+ final int wLength = getWLengthInts(seg);
final int[] wStream = new int[wLength];
- mem.getIntArray(offset, wStream, 0, wLength);
+ MemorySegment.copy(seg, JAVA_INT_UNALIGNED, offset, wStream, 0, wLength);
return wStream;
}
// PUT INTO MEMORY
- static void putEmptyMerged(final WritableMemory wmem,
+ static void putEmptyMerged(final MemorySegment wseg,
final int lgK,
final short seedHash) {
final Format format = Format.EMPTY_MERGED;
final byte preInts = getDefinedPreInts(format);
final byte fiCol = (byte) 0;
final byte flags = (byte) ((format.ordinal() << 2) | COMPRESSED_FLAG_MASK);
- checkCapacity(wmem.getCapacity(), 8);
- putFirst8(wmem, preInts, (byte) lgK, fiCol, flags, seedHash);
+ checkCapacity(wseg.byteSize(), 8);
+ putFirst8(wseg, preInts, (byte) lgK, fiCol, flags, seedHash);
}
- static void putEmptyHip(final WritableMemory wmem,
+ static void putEmptyHip(final MemorySegment wseg,
final int lgK,
final short seedHash) {
final Format format = Format.EMPTY_HIP;
final byte preInts = getDefinedPreInts(format);
final byte fiCol = (byte) 0;
final byte flags = (byte) ((format.ordinal() << 2) | COMPRESSED_FLAG_MASK);
- checkCapacity(wmem.getCapacity(), 8);
- putFirst8(wmem, preInts, (byte) lgK, fiCol, flags, seedHash);
+ checkCapacity(wseg.byteSize(), 8);
+ putFirst8(wseg, preInts, (byte) lgK, fiCol, flags, seedHash);
}
- static void putSparseHybridMerged(final WritableMemory wmem,
+ static void putSparseHybridMerged(final MemorySegment wseg,
final int lgK,
final int numCoupons, //unsigned
final int svLengthInts,
@@ -425,15 +429,15 @@ final class PreambleUtil {
final byte preInts = getDefinedPreInts(format);
final byte fiCol = (byte) 0;
final byte flags = (byte) ((format.ordinal() << 2) | COMPRESSED_FLAG_MASK);
- checkCapacity(wmem.getCapacity(), 4L * (preInts + svLengthInts));
- putFirst8(wmem, preInts, (byte) lgK, fiCol, flags, seedHash);
+ checkCapacity(wseg.byteSize(), 4L * (preInts + svLengthInts));
+ putFirst8(wseg, preInts, (byte) lgK, fiCol, flags, seedHash);
- wmem.putInt(getHiFieldOffset(format, HiField.NUM_COUPONS), numCoupons);
- wmem.putInt(getHiFieldOffset(format, HiField.SV_LENGTH_INTS),
svLengthInts);
- wmem.putIntArray(getSvStreamOffset(wmem), svStream, 0, svLengthInts);
+ wseg.set(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.NUM_COUPONS), numCoupons);
+ wseg.set(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.SV_LENGTH_INTS), svLengthInts);
+ MemorySegment.copy(svStream, 0, wseg, JAVA_INT_UNALIGNED,
getSvStreamOffset(wseg), svLengthInts);
}
- static void putSparseHybridHip(final WritableMemory wmem,
+ static void putSparseHybridHip(final MemorySegment wseg,
final int lgK,
final int numCoupons, //unsigned
final int svLengthInts,
@@ -445,17 +449,17 @@ final class PreambleUtil {
final byte preInts = getDefinedPreInts(format);
final byte fiCol = (byte) 0;
final byte flags = (byte) ((format.ordinal() << 2) | COMPRESSED_FLAG_MASK);
- checkCapacity(wmem.getCapacity(), 4L * (preInts + svLengthInts));
- putFirst8(wmem, preInts, (byte) lgK, fiCol, flags, seedHash);
+ checkCapacity(wseg.byteSize(), 4L * (preInts + svLengthInts));
+ putFirst8(wseg, preInts, (byte) lgK, fiCol, flags, seedHash);
- wmem.putInt(getHiFieldOffset(format, HiField.NUM_COUPONS), numCoupons);
- wmem.putInt(getHiFieldOffset(format, HiField.SV_LENGTH_INTS),
svLengthInts);
- wmem.putDouble(getHiFieldOffset(format, HiField.KXP), kxp);
- wmem.putDouble(getHiFieldOffset(format, HiField.HIP_ACCUM), hipAccum);
- wmem.putIntArray(getSvStreamOffset(wmem), svStream, 0, svLengthInts);
+ wseg.set(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.NUM_COUPONS), numCoupons);
+ wseg.set(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.SV_LENGTH_INTS), svLengthInts);
+ wseg.set(JAVA_DOUBLE_UNALIGNED, getHiFieldOffset(format, HiField.KXP),
kxp);
+ wseg.set(JAVA_DOUBLE_UNALIGNED, getHiFieldOffset(format,
HiField.HIP_ACCUM), hipAccum);
+ MemorySegment.copy(svStream, 0, wseg, JAVA_INT_UNALIGNED,
getSvStreamOffset(wseg), svLengthInts);
}
- static void putPinnedSlidingMergedNoSv(final WritableMemory wmem,
+ static void putPinnedSlidingMergedNoSv(final MemorySegment wseg,
final int lgK,
final int fiCol,
final int numCoupons, //unsigned
@@ -465,15 +469,15 @@ final class PreambleUtil {
final Format format = Format.PINNED_SLIDING_MERGED_NOSV;
final byte preInts = getDefinedPreInts(format);
final byte flags = (byte) ((format.ordinal() << 2) | COMPRESSED_FLAG_MASK);
- checkCapacity(wmem.getCapacity(), 4L * (preInts + wLengthInts));
- putFirst8(wmem, preInts, (byte) lgK, (byte) fiCol, flags, seedHash);
+ checkCapacity(wseg.byteSize(), 4L * (preInts + wLengthInts));
+ putFirst8(wseg, preInts, (byte) lgK, (byte) fiCol, flags, seedHash);
- wmem.putInt(getHiFieldOffset(format, HiField.NUM_COUPONS), numCoupons);
- wmem.putInt(getHiFieldOffset(format, HiField.W_LENGTH_INTS), wLengthInts);
- wmem.putIntArray(getWStreamOffset(wmem), wStream, 0, wLengthInts);
+ wseg.set(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.NUM_COUPONS), numCoupons);
+ wseg.set(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.W_LENGTH_INTS), wLengthInts);
+ MemorySegment.copy(wStream, 0, wseg, JAVA_INT_UNALIGNED,
getWStreamOffset(wseg), wLengthInts);
}
- static void putPinnedSlidingHipNoSv(final WritableMemory wmem,
+ static void putPinnedSlidingHipNoSv(final MemorySegment wseg,
final int lgK,
final int fiCol,
final int numCoupons, //unsigned
@@ -485,17 +489,17 @@ final class PreambleUtil {
final Format format = Format.PINNED_SLIDING_HIP_NOSV;
final byte preInts = getDefinedPreInts(format);
final byte flags = (byte) ((format.ordinal() << 2) | COMPRESSED_FLAG_MASK);
- checkCapacity(wmem.getCapacity(), 4L * (preInts + wLengthInts));
- putFirst8(wmem, preInts, (byte) lgK, (byte) fiCol, flags, seedHash);
+ checkCapacity(wseg.byteSize(), 4L * (preInts + wLengthInts));
+ putFirst8(wseg, preInts, (byte) lgK, (byte) fiCol, flags, seedHash);
- wmem.putInt(getHiFieldOffset(format, HiField.NUM_COUPONS), numCoupons);
- wmem.putInt(getHiFieldOffset(format, HiField.W_LENGTH_INTS), wLengthInts);
- wmem.putDouble(getHiFieldOffset(format, HiField.KXP), kxp);
- wmem.putDouble(getHiFieldOffset(format, HiField.HIP_ACCUM), hipAccum);
- wmem.putIntArray(getWStreamOffset(wmem), wStream, 0, wLengthInts);
+ wseg.set(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.NUM_COUPONS), numCoupons);
+ wseg.set(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.W_LENGTH_INTS), wLengthInts);
+ wseg.set(JAVA_DOUBLE_UNALIGNED, getHiFieldOffset(format, HiField.KXP),
kxp);
+ wseg.set(JAVA_DOUBLE_UNALIGNED, getHiFieldOffset(format,
HiField.HIP_ACCUM), hipAccum);
+ MemorySegment.copy(wStream, 0, wseg, JAVA_INT_UNALIGNED,
getWStreamOffset(wseg), wLengthInts);
}
- static void putPinnedSlidingMerged(final WritableMemory wmem,
+ static void putPinnedSlidingMerged(final MemorySegment wseg,
final int lgK,
final int fiCol,
final int numCoupons, //unsigned
@@ -508,18 +512,18 @@ final class PreambleUtil {
final Format format = Format.PINNED_SLIDING_MERGED;
final byte preInts = getDefinedPreInts(format);
final byte flags = (byte) ((format.ordinal() << 2) | COMPRESSED_FLAG_MASK);
- checkCapacity(wmem.getCapacity(), 4L * (preInts + svLengthInts +
wLengthInts));
- putFirst8(wmem, preInts, (byte) lgK, (byte) fiCol, flags, seedHash);
+ checkCapacity(wseg.byteSize(), 4L * (preInts + svLengthInts +
wLengthInts));
+ putFirst8(wseg, preInts, (byte) lgK, (byte) fiCol, flags, seedHash);
- wmem.putInt(getHiFieldOffset(format, HiField.NUM_COUPONS), numCoupons);
- wmem.putInt(getHiFieldOffset(format, HiField.NUM_SV), numSv);
- wmem.putInt(getHiFieldOffset(format, HiField.SV_LENGTH_INTS),
svLengthInts);
- wmem.putInt(getHiFieldOffset(format, HiField.W_LENGTH_INTS), wLengthInts);
- wmem.putIntArray(getSvStreamOffset(wmem), svStream, 0, svLengthInts);
- wmem.putIntArray(getWStreamOffset(wmem), wStream, 0, wLengthInts);
+ wseg.set(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.NUM_COUPONS), numCoupons);
+ wseg.set(JAVA_INT_UNALIGNED, getHiFieldOffset(format, HiField.NUM_SV),
numSv);
+ wseg.set(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.SV_LENGTH_INTS), svLengthInts);
+ wseg.set(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.W_LENGTH_INTS), wLengthInts);
+ MemorySegment.copy(svStream, 0, wseg, JAVA_INT_UNALIGNED,
getSvStreamOffset(wseg), svLengthInts);
+ MemorySegment.copy(wStream, 0, wseg, JAVA_INT_UNALIGNED,
getWStreamOffset(wseg), wLengthInts);
}
- static void putPinnedSlidingHip(final WritableMemory wmem,
+ static void putPinnedSlidingHip(final MemorySegment wseg,
final int lgK,
final int fiCol,
final int numCoupons, //unsigned
@@ -534,48 +538,48 @@ final class PreambleUtil {
final Format format = Format.PINNED_SLIDING_HIP;
final byte preInts = getDefinedPreInts(format);
final byte flags = (byte) ((format.ordinal() << 2) | COMPRESSED_FLAG_MASK);
- checkCapacity(wmem.getCapacity(), 4L * (preInts + svLengthInts +
wLengthInts));
- putFirst8(wmem, preInts, (byte) lgK, (byte) fiCol, flags, seedHash);
+ checkCapacity(wseg.byteSize(), 4L * (preInts + svLengthInts +
wLengthInts));
+ putFirst8(wseg, preInts, (byte) lgK, (byte) fiCol, flags, seedHash);
- wmem.putInt(getHiFieldOffset(format, HiField.NUM_COUPONS), numCoupons);
- wmem.putInt(getHiFieldOffset(format, HiField.NUM_SV), numSv);
- wmem.putDouble(getHiFieldOffset(format, HiField.KXP), kxp);
- wmem.putDouble(getHiFieldOffset(format, HiField.HIP_ACCUM), hipAccum);
- wmem.putInt(getHiFieldOffset(format, HiField.SV_LENGTH_INTS),
svLengthInts);
- wmem.putInt(getHiFieldOffset(format, HiField.W_LENGTH_INTS), wLengthInts);
- wmem.putIntArray(getSvStreamOffset(wmem), svStream, 0, svLengthInts);
- wmem.putIntArray(getWStreamOffset(wmem), wStream, 0, wLengthInts);
+ wseg.set(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.NUM_COUPONS), numCoupons);
+ wseg.set(JAVA_INT_UNALIGNED, getHiFieldOffset(format, HiField.NUM_SV),
numSv);
+ wseg.set(JAVA_DOUBLE_UNALIGNED, getHiFieldOffset(format, HiField.KXP),
kxp);
+ wseg.set(JAVA_DOUBLE_UNALIGNED, getHiFieldOffset(format,
HiField.HIP_ACCUM), hipAccum);
+ wseg.set(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.SV_LENGTH_INTS), svLengthInts);
+ wseg.set(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.W_LENGTH_INTS), wLengthInts);
+ MemorySegment.copy(svStream, 0, wseg, JAVA_INT_UNALIGNED,
getSvStreamOffset(wseg), svLengthInts);
+ MemorySegment.copy(wStream, 0, wseg, JAVA_INT_UNALIGNED,
getWStreamOffset(wseg), wLengthInts);
}
- private static void putFirst8(final WritableMemory wmem, final byte preInts,
final byte lgK,
+ private static void putFirst8(final MemorySegment wseg, final byte preInts,
final byte lgK,
final byte fiCol, final byte flags, final short seedHash) {
- wmem.clear(0L, 4L * preInts);
- wmem.putByte(getLoFieldOffset(LoField.PRE_INTS), preInts);
- wmem.putByte(getLoFieldOffset(LoField.SER_VERSION), SER_VER);
- wmem.putByte(getLoFieldOffset(LoField.FAMILY), (byte) Family.CPC.getID());
- wmem.putByte(getLoFieldOffset(LoField.LG_K), lgK);
- wmem.putByte(getLoFieldOffset(LoField.FI_COL), fiCol);
- wmem.putByte(getLoFieldOffset(LoField.FLAGS), flags);
- wmem.putShort(getLoFieldOffset(LoField.SEED_HASH), seedHash);
+ clear(wseg, 0L, 4L * preInts);
+ wseg.set(JAVA_BYTE, getLoFieldOffset(LoField.PRE_INTS), preInts);
+ wseg.set(JAVA_BYTE, getLoFieldOffset(LoField.SER_VERSION), SER_VER);
+ wseg.set(JAVA_BYTE, getLoFieldOffset(LoField.FAMILY), (byte)
Family.CPC.getID());
+ wseg.set(JAVA_BYTE, getLoFieldOffset(LoField.LG_K), lgK);
+ wseg.set(JAVA_BYTE, getLoFieldOffset(LoField.FI_COL), fiCol);
+ wseg.set(JAVA_BYTE, getLoFieldOffset(LoField.FLAGS), flags);
+ wseg.set(JAVA_SHORT_UNALIGNED, getLoFieldOffset(LoField.SEED_HASH),
seedHash);
}
//TO STRING
static String toString(final byte[] byteArr, final boolean detail) {
- final Memory mem = Memory.wrap(byteArr);
- return toString(mem, detail);
+ final MemorySegment seg = MemorySegment.ofArray(byteArr);
+ return toString(seg, detail);
}
- static String toString(final Memory mem, final boolean detail) {
- final long capBytes = mem.getCapacity();
+ static String toString(final MemorySegment seg, final boolean detail) {
+ final long capBytes = seg.byteSize();
//Lo Fields Preamble, first 7 fields, first 8 bytes
- final int preInts = mem.getByte(getLoFieldOffset(LoField.PRE_INTS)) & 0xFF;
- final int serVer = mem.getByte(getLoFieldOffset(LoField.SER_VERSION)) &
0xFF;
- final Family family =
Family.idToFamily(mem.getByte(getLoFieldOffset(LoField.FAMILY)) & 0xFF);
- final int lgK = mem.getByte(getLoFieldOffset(LoField.LG_K)) & 0xFF;
- final int fiCol = mem.getByte(getLoFieldOffset(LoField.FI_COL)) & 0xFF;
- final int flags = mem.getByte(getLoFieldOffset(LoField.FLAGS)) & 0XFF;
- final int seedHash = mem.getShort(getLoFieldOffset(LoField.SEED_HASH)) &
0XFFFF;
+ final int preInts = seg.get(JAVA_BYTE, getLoFieldOffset(LoField.PRE_INTS))
& 0xFF;
+ final int serVer = seg.get(JAVA_BYTE,
getLoFieldOffset(LoField.SER_VERSION)) & 0xFF;
+ final Family family = Family.idToFamily(seg.get(JAVA_BYTE,
getLoFieldOffset(LoField.FAMILY)) & 0xFF);
+ final int lgK = seg.get(JAVA_BYTE, getLoFieldOffset(LoField.LG_K)) & 0xFF;
+ final int fiCol = seg.get(JAVA_BYTE, getLoFieldOffset(LoField.FI_COL)) &
0xFF;
+ final int flags = seg.get(JAVA_BYTE, getLoFieldOffset(LoField.FLAGS)) &
0XFF;
+ final int seedHash = seg.get(JAVA_SHORT_UNALIGNED,
getLoFieldOffset(LoField.SEED_HASH)) & 0XFFFF;
final String seedHashStr = Integer.toHexString(seedHash);
//Flags of the Flags byte
@@ -630,11 +634,11 @@ final class PreambleUtil {
break;
}
case SPARSE_HYBRID_MERGED : {
- numCoupons = mem.getInt(getHiFieldOffset(format, HiField.NUM_COUPONS))
& 0xFFFF_FFFFL;
+ numCoupons = seg.get(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.NUM_COUPONS)) & 0xFFFF_FFFFL;
numSv = numCoupons;
- svLengthInts = mem.getInt(getHiFieldOffset(format,
HiField.SV_LENGTH_INTS)) & 0xFFFF_FFFFL;
- svStreamStart = getSvStreamOffset(mem);
+ svLengthInts = seg.get(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.SV_LENGTH_INTS)) & 0xFFFF_FFFFL;
+ svStreamStart = getSvStreamOffset(seg);
reqBytes = svStreamStart + (svLengthInts << 2);
flavor = CpcUtil.determineFlavor(lgK, numCoupons);
sb.append("Flavor :
").append(flavor).append(LS);
@@ -646,14 +650,14 @@ final class PreambleUtil {
break;
}
case SPARSE_HYBRID_HIP : {
- numCoupons = mem.getInt(getHiFieldOffset(format, HiField.NUM_COUPONS))
& 0xFFFF_FFFFL;
+ numCoupons = seg.get(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.NUM_COUPONS)) & 0xFFFF_FFFFL;
numSv = numCoupons;
- svLengthInts = mem.getInt(getHiFieldOffset(format,
HiField.SV_LENGTH_INTS)) & 0xFFFF_FFFFL;
- svStreamStart = getSvStreamOffset(mem);
+ svLengthInts = seg.get(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.SV_LENGTH_INTS)) & 0xFFFF_FFFFL;
+ svStreamStart = getSvStreamOffset(seg);
- kxp = mem.getDouble(getHiFieldOffset(format, HiField.KXP));
- hipAccum = mem.getDouble(getHiFieldOffset(format, HiField.HIP_ACCUM));
+ kxp = seg.get(JAVA_DOUBLE_UNALIGNED, getHiFieldOffset(format,
HiField.KXP));
+ hipAccum = seg.get(JAVA_DOUBLE_UNALIGNED, getHiFieldOffset(format,
HiField.HIP_ACCUM));
reqBytes = svStreamStart + (svLengthInts << 2);
flavor = CpcUtil.determineFlavor(lgK, numCoupons);
@@ -669,11 +673,11 @@ final class PreambleUtil {
break;
}
case PINNED_SLIDING_MERGED_NOSV : {
- numCoupons = mem.getInt(getHiFieldOffset(format, HiField.NUM_COUPONS))
& 0xFFFF_FFFFL;
+ numCoupons = seg.get(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.NUM_COUPONS)) & 0xFFFF_FFFFL;
winOffset = CpcUtil.determineCorrectOffset(lgK, numCoupons);
- wLengthInts = mem.getInt(getHiFieldOffset(format,
HiField.W_LENGTH_INTS)) & 0xFFFF_FFFFL;
- wStreamStart = getWStreamOffset(mem);
+ wLengthInts = seg.get(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.W_LENGTH_INTS)) & 0xFFFF_FFFFL;
+ wStreamStart = getWStreamOffset(seg);
reqBytes = wStreamStart + (wLengthInts << 2);
flavor = CpcUtil.determineFlavor(lgK, numCoupons);
@@ -686,14 +690,14 @@ final class PreambleUtil {
break;
}
case PINNED_SLIDING_HIP_NOSV : {
- numCoupons = mem.getInt(getHiFieldOffset(format, HiField.NUM_COUPONS))
& 0xFFFF_FFFFL;
+ numCoupons = seg.get(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.NUM_COUPONS)) & 0xFFFF_FFFFL;
winOffset = CpcUtil.determineCorrectOffset(lgK, numCoupons);
- wLengthInts = mem.getInt(getHiFieldOffset(format,
HiField.W_LENGTH_INTS)) & 0xFFFF_FFFFL;
- wStreamStart = getWStreamOffset(mem);
+ wLengthInts = seg.get(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.W_LENGTH_INTS)) & 0xFFFF_FFFFL;
+ wStreamStart = getWStreamOffset(seg);
- kxp = mem.getDouble(getHiFieldOffset(format, HiField.KXP));
- hipAccum = mem.getDouble(getHiFieldOffset(format, HiField.HIP_ACCUM));
+ kxp = seg.get(JAVA_DOUBLE_UNALIGNED, getHiFieldOffset(format,
HiField.KXP));
+ hipAccum = seg.get(JAVA_DOUBLE_UNALIGNED, getHiFieldOffset(format,
HiField.HIP_ACCUM));
reqBytes = wStreamStart + (wLengthInts << 2);
flavor = CpcUtil.determineFlavor(lgK, numCoupons);
@@ -709,16 +713,16 @@ final class PreambleUtil {
break;
}
case PINNED_SLIDING_MERGED : {
- numCoupons = mem.getInt(getHiFieldOffset(format, HiField.NUM_COUPONS)
& 0xFFFF_FFFFL);
+ numCoupons = seg.get(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.NUM_COUPONS) & 0xFFFF_FFFFL);
winOffset = CpcUtil.determineCorrectOffset(lgK, numCoupons);
- wLengthInts = mem.getInt(getHiFieldOffset(format,
HiField.W_LENGTH_INTS)) & 0xFFFF_FFFFL;
+ wLengthInts = seg.get(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.W_LENGTH_INTS)) & 0xFFFF_FFFFL;
- numSv = mem.getInt(getHiFieldOffset(format, HiField.NUM_SV)) &
0xFFFF_FFFFL;
- svLengthInts = mem.getInt(getHiFieldOffset(format,
HiField.SV_LENGTH_INTS)) & 0xFFFF_FFFFL;
+ numSv = seg.get(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.NUM_SV)) & 0xFFFF_FFFFL;
+ svLengthInts = seg.get(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.SV_LENGTH_INTS)) & 0xFFFF_FFFFL;
- wStreamStart = getWStreamOffset(mem);
- svStreamStart = getSvStreamOffset(mem);
+ wStreamStart = getWStreamOffset(seg);
+ svStreamStart = getSvStreamOffset(seg);
reqBytes = svStreamStart + (svLengthInts << 2);
flavor = CpcUtil.determineFlavor(lgK, numCoupons);
@@ -735,18 +739,18 @@ final class PreambleUtil {
break;
}
case PINNED_SLIDING_HIP : {
- numCoupons = mem.getInt(getHiFieldOffset(format, HiField.NUM_COUPONS)
& 0xFFFF_FFFFL);
+ numCoupons = seg.get(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.NUM_COUPONS) & 0xFFFF_FFFFL);
winOffset = CpcUtil.determineCorrectOffset(lgK, numCoupons);
- wLengthInts = mem.getInt(getHiFieldOffset(format,
HiField.W_LENGTH_INTS)) & 0xFFFF_FFFFL;
+ wLengthInts = seg.get(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.W_LENGTH_INTS)) & 0xFFFF_FFFFL;
- numSv = mem.getInt(getHiFieldOffset(format, HiField.NUM_SV)) &
0xFFFF_FFFFL;
- svLengthInts = mem.getInt(getHiFieldOffset(format,
HiField.SV_LENGTH_INTS)) & 0xFFFF_FFFFL;
- wStreamStart = getWStreamOffset(mem);
- svStreamStart = getSvStreamOffset(mem);
+ numSv = seg.get(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.NUM_SV)) & 0xFFFF_FFFFL;
+ svLengthInts = seg.get(JAVA_INT_UNALIGNED, getHiFieldOffset(format,
HiField.SV_LENGTH_INTS)) & 0xFFFF_FFFFL;
+ wStreamStart = getWStreamOffset(seg);
+ svStreamStart = getSvStreamOffset(seg);
- kxp = mem.getDouble(getHiFieldOffset(format, HiField.KXP));
- hipAccum = mem.getDouble(getHiFieldOffset(format, HiField.HIP_ACCUM));
+ kxp = seg.get(JAVA_DOUBLE_UNALIGNED, getHiFieldOffset(format,
HiField.KXP));
+ hipAccum = seg.get(JAVA_DOUBLE_UNALIGNED, getHiFieldOffset(format,
HiField.HIP_ACCUM));
reqBytes = svStreamStart + (svLengthInts << 2);
flavor = CpcUtil.determineFlavor(lgK, numCoupons);
@@ -774,24 +778,24 @@ final class PreambleUtil {
sb.append(LS).append("### CPC SKETCH IMAGE - DATA").append(LS);
if (wLengthInts > 0) {
sb.append(LS).append("Window Stream:").append(LS);
- listData(mem, wStreamStart, wLengthInts, sb);
+ listData(seg, wStreamStart, wLengthInts, sb);
}
if (svLengthInts > 0) {
sb.append(LS).append("SV Stream:").append(LS);
- listData(mem, svStreamStart, svLengthInts, sb);
+ listData(seg, svStreamStart, svLengthInts, sb);
}
}
sb.append("### END CPC SKETCH IMAGE").append(LS);
return sb.toString();
- } //end toString(mem)
+ } //end toString(seg)
- private static void listData(final Memory mem, final long offsetBytes, final
long lengthInts,
+ private static void listData(final MemorySegment seg, final long
offsetBytes, final long lengthInts,
final StringBuilder sb) {
- final long memCap = mem.getCapacity();
+ final long segCap = seg.byteSize();
final long expectedCap = offsetBytes + (4L * lengthInts);
- checkCapacity(memCap, expectedCap);
+ checkCapacity(segCap, expectedCap);
for (long i = 0; i < lengthInts; i++) {
- sb.append(String.format(fmt, i, mem.getInt(offsetBytes + (4L *
i)))).append(LS);
+ sb.append(String.format(fmt, i, seg.get(JAVA_INT_UNALIGNED, offsetBytes
+ (4L * i)))).append(LS);
}
}
@@ -800,26 +804,26 @@ final class PreambleUtil {
"Operation is illegal: Format = " + format.name() + ", HiField = " +
hiField);
}
- static void checkCapacity(final long memCap, final long expectedCap) {
- if (memCap < expectedCap) {
+ static void checkCapacity(final long segCap, final long expectedCap) {
+ if (segCap < expectedCap) {
throw new SketchesArgumentException(
- "Insufficient Image Bytes = " + memCap + ", Expected = " +
expectedCap);
+ "Insufficient Image Bytes = " + segCap + ", Expected = " +
expectedCap);
}
}
//basic checks of SerVer, Format, preInts, Family, fiCol, lgK.
- static void checkLoPreamble(final Memory mem) {
- Objects.requireNonNull(mem, "Source Memory must not be null");
- checkBounds(0, 8, mem.getCapacity()); //need min 8 bytes
- rtAssertEquals(getSerVer(mem), SER_VER & 0XFF);
- final Format fmat = getFormat(mem);
+ static void checkLoPreamble(final MemorySegment seg) {
+ Objects.requireNonNull(seg, "Source MemorySegment must not be null");
+ checkBounds(0, 8, seg.byteSize()); //need min 8 bytes
+ rtAssertEquals(getSerVer(seg), SER_VER & 0XFF);
+ final Format fmat = getFormat(seg);
final int preIntsDef = getDefinedPreInts(fmat) & 0XFF;
- rtAssertEquals(getPreInts(mem), preIntsDef);
- final Family fam = getFamily(mem);
+ rtAssertEquals(getPreInts(seg), preIntsDef);
+ final Family fam = getFamily(seg);
rtAssert(fam == Family.CPC);
- final int lgK = getLgK(mem);
+ final int lgK = getLgK(seg);
rtAssert((lgK >= 4) && (lgK <= 26));
- final int fiCol = getFiCol(mem);
+ final int fiCol = getFiCol(seg);
rtAssert((fiCol <= 63) && (fiCol >= 0));
}
diff --git a/src/test/java/org/apache/datasketches/cpc/CompressedStateTest.java
b/src/test/java/org/apache/datasketches/cpc/CompressedStateTest.java
index 58359968f..4fdc5da73 100644
--- a/src/test/java/org/apache/datasketches/cpc/CompressedStateTest.java
+++ b/src/test/java/org/apache/datasketches/cpc/CompressedStateTest.java
@@ -22,10 +22,9 @@ package org.apache.datasketches.cpc;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.fail;
+import java.lang.foreign.MemorySegment;
import java.io.PrintStream;
-import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
/**
@@ -43,10 +42,10 @@ public class CompressedStateTest {
Format fmt = state.getFormat();
assertEquals(fmt, skFmt);
long c = state.numCoupons;
- WritableMemory wmem =
WritableMemory.allocate((int)state.getRequiredSerializedBytes());
- state.exportToMemory(wmem);
+ MemorySegment wseg = MemorySegment.ofArray(new
byte[(int)state.getRequiredSerializedBytes()]);
+ state.exportToSegment(wseg);
printf("%8d %8d %10s %35s\n", vIn, c, f.toString(), fmt.toString());
- CompressedState state2 = CompressedState.importFromMemory(wmem);
+ CompressedState state2 = CompressedState.importFromSegment(wseg);
final CpcUnion union = new CpcUnion(lgK);
union.update(sk);
@@ -57,10 +56,10 @@ public class CompressedStateTest {
fmt = state.getFormat();
assertEquals(fmt, skFmt);
c = state.numCoupons;
- wmem = WritableMemory.allocate((int)state.getRequiredSerializedBytes());
- state.exportToMemory(wmem);
+ wseg = MemorySegment.ofArray(new
byte[(int)state.getRequiredSerializedBytes()]);
+ state.exportToSegment(wseg);
printf("%8d %8d %10s %35s\n", vIn, c, f.toString(), fmt.toString());
- state2 = CompressedState.importFromMemory(wmem);
+ state2 = CompressedState.importFromSegment(wseg);
fmt = state2.getFormat();
assertEquals(fmt, skFmt);
}
@@ -111,7 +110,7 @@ public class CompressedStateTest {
final byte[] byteArr = sk.toByteArray();
byteArr[5] &= (byte) -3;
try {
- CompressedState.importFromMemory(Memory.wrap(byteArr));
+ CompressedState.importFromSegment(MemorySegment.ofArray(byteArr));
fail();
} catch (final AssertionError e) { }
}
diff --git
a/src/test/java/org/apache/datasketches/cpc/CpcSketchCrossLanguageTest.java
b/src/test/java/org/apache/datasketches/cpc/CpcSketchCrossLanguageTest.java
index 19d167f8c..d2add683b 100644
--- a/src/test/java/org/apache/datasketches/cpc/CpcSketchCrossLanguageTest.java
+++ b/src/test/java/org/apache/datasketches/cpc/CpcSketchCrossLanguageTest.java
@@ -25,10 +25,10 @@ import static
org.apache.datasketches.common.TestUtil.cppPath;
import static org.apache.datasketches.common.TestUtil.javaPath;
import static org.testng.Assert.assertEquals;
+import java.lang.foreign.MemorySegment;
import java.io.IOException;
import java.nio.file.Files;
-import org.apache.datasketches.memory.Memory;
import org.testng.annotations.Test;
/**
@@ -42,9 +42,11 @@ public class CpcSketchCrossLanguageTest {
final int[] nArr = {0, 100, 200, 2000, 20_000};
final Flavor[] flavorArr = {Flavor.EMPTY, Flavor.SPARSE, Flavor.HYBRID,
Flavor.PINNED, Flavor.SLIDING};
int flavorIdx = 0;
- for (int n: nArr) {
+ for (final int n: nArr) {
final CpcSketch sk = new CpcSketch(11);
- for (int i = 0; i < n; i++) sk.update(i);
+ for (int i = 0; i < n; i++) {
+ sk.update(i);
+ }
assertEquals(sk.getFlavor(), flavorArr[flavorIdx++]);
Files.newOutputStream(javaPath.resolve("cpc_n" + n +
"_java.sk")).write(sk.toByteArray());
}
@@ -52,14 +54,14 @@ public class CpcSketchCrossLanguageTest {
@Test(groups = {GENERATE_JAVA_FILES})
void negativeIntEquivalence() throws Exception {
- CpcSketch sk = new CpcSketch();
- byte v1 = (byte) -1;
+ final CpcSketch sk = new CpcSketch();
+ final byte v1 = (byte) -1;
sk.update(v1);
- short v2 = -1;
+ final short v2 = -1;
sk.update(v2);
- int v3 = -1;
+ final int v3 = -1;
sk.update(v3);
- long v4 = -1;
+ final long v4 = -1;
sk.update(v4);
assertEquals(sk.getEstimate(), 1, 0.01);
Files.newOutputStream(javaPath.resolve("cpc_negative_one_java.sk")).write(sk.toByteArray());
@@ -70,9 +72,9 @@ public class CpcSketchCrossLanguageTest {
final int[] nArr = {0, 100, 200, 2000, 20000};
final Flavor[] flavorArr = {Flavor.EMPTY, Flavor.SPARSE, Flavor.HYBRID,
Flavor.PINNED, Flavor.SLIDING};
int flavorIdx = 0;
- for (int n: nArr) {
+ for (final int n: nArr) {
final byte[] bytes = Files.readAllBytes(cppPath.resolve("cpc_n" + n +
"_cpp.sk"));
- final CpcSketch sketch = CpcSketch.heapify(Memory.wrap(bytes));
+ final CpcSketch sketch = CpcSketch.heapify(MemorySegment.ofArray(bytes));
assertEquals(sketch.getFlavor(), flavorArr[flavorIdx++]);
assertEquals(sketch.getEstimate(), n, n * 0.02);
}
diff --git a/src/test/java/org/apache/datasketches/cpc/CpcSketchTest.java
b/src/test/java/org/apache/datasketches/cpc/CpcSketchTest.java
index 3782bdc34..1f8ae715f 100644
--- a/src/test/java/org/apache/datasketches/cpc/CpcSketchTest.java
+++ b/src/test/java/org/apache/datasketches/cpc/CpcSketchTest.java
@@ -24,13 +24,13 @@ import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertTrue;
import static org.testng.Assert.fail;
+import java.lang.foreign.MemorySegment;
import java.io.PrintStream;
import java.nio.ByteBuffer;
import org.apache.datasketches.common.Family;
import org.apache.datasketches.common.SketchesArgumentException;
import org.apache.datasketches.common.Util;
-import org.apache.datasketches.memory.Memory;
import org.testng.annotations.Test;
/**
@@ -47,7 +47,7 @@ public class CpcSketchTest {
sk.update(1L);
sk.update(2.0);
sk.update("3");
- byte[] bytes = new byte[] { 4, 4 };
+ final byte[] bytes = { 4, 4 };
sk.update(bytes);
sk.update(ByteBuffer.wrap(bytes)); // same as previous
sk.update(ByteBuffer.wrap(bytes, 0, 1));
@@ -188,29 +188,29 @@ public class CpcSketchTest {
@Test
public void checkHeapify() {
- int lgK = 10;
- CpcSketch sk = new CpcSketch(lgK, Util.DEFAULT_UPDATE_SEED);
+ final int lgK = 10;
+ final CpcSketch sk = new CpcSketch(lgK, Util.DEFAULT_UPDATE_SEED);
assertTrue(sk.isEmpty());
- byte[] byteArray = sk.toByteArray();
- CpcSketch sk2 = CpcSketch.heapify(byteArray, Util.DEFAULT_UPDATE_SEED);
+ final byte[] byteArray = sk.toByteArray();
+ final CpcSketch sk2 = CpcSketch.heapify(byteArray,
Util.DEFAULT_UPDATE_SEED);
assertTrue(specialEquals(sk2, sk, false, false));
}
@Test
public void checkHeapify2() {
- int lgK = 10;
- CpcSketch sk = new CpcSketch(lgK);
+ final int lgK = 10;
+ final CpcSketch sk = new CpcSketch(lgK);
assertTrue(sk.isEmpty());
- byte[] byteArray = sk.toByteArray();
- Memory mem = Memory.wrap(byteArray);
- CpcSketch sk2 = CpcSketch.heapify(mem);
+ final byte[] byteArray = sk.toByteArray();
+ final MemorySegment seg = MemorySegment.ofArray(byteArray);
+ final CpcSketch sk2 = CpcSketch.heapify(seg);
assertTrue(specialEquals(sk2, sk, false, false));
}
@Test
public void checkRowColUpdate() {
- int lgK = 10;
- CpcSketch sk = new CpcSketch(lgK, Util.DEFAULT_UPDATE_SEED);
+ final int lgK = 10;
+ final CpcSketch sk = new CpcSketch(lgK, Util.DEFAULT_UPDATE_SEED);
sk.rowColUpdate(0);
assertEquals(sk.getFlavor(), Flavor.SPARSE);
}
@@ -226,7 +226,7 @@ public class CpcSketchTest {
/**
* @param s the string to print
*/
- private static void println(String s) {
+ private static void println(final String s) {
//ps.println(s); //disable here
}
diff --git a/src/test/java/org/apache/datasketches/cpc/CpcWrapperTest.java
b/src/test/java/org/apache/datasketches/cpc/CpcWrapperTest.java
index 1635b477d..81f35f63c 100644
--- a/src/test/java/org/apache/datasketches/cpc/CpcWrapperTest.java
+++ b/src/test/java/org/apache/datasketches/cpc/CpcWrapperTest.java
@@ -22,11 +22,11 @@ package org.apache.datasketches.cpc;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.fail;
+import java.lang.foreign.MemorySegment;
import java.io.PrintStream;
import org.testng.annotations.Test;
import org.apache.datasketches.common.Family;
-import org.apache.datasketches.memory.Memory;
/**
* @author Lee Rhodes
@@ -37,48 +37,48 @@ public class CpcWrapperTest {
@SuppressWarnings("unused")
@Test
public void check() {
- int lgK = 10;
- CpcSketch sk1 = new CpcSketch(lgK);
- CpcSketch sk2 = new CpcSketch(lgK);
- CpcSketch skD = new CpcSketch(lgK);
- double dEst = skD.getEstimate();
- double dlb = skD.getLowerBound(2);
- double dub = skD.getUpperBound(2);
+ final int lgK = 10;
+ final CpcSketch sk1 = new CpcSketch(lgK);
+ final CpcSketch sk2 = new CpcSketch(lgK);
+ final CpcSketch skD = new CpcSketch(lgK);
+ final double dEst = skD.getEstimate();
+ final double dlb = skD.getLowerBound(2);
+ final double dub = skD.getUpperBound(2);
- int n = 100000;
+ final int n = 100000;
for (int i = 0; i < n; i++) {
sk1.update(i);
sk2.update(i + n);
skD.update(i);
skD.update(i + n);
}
- byte[] concatArr = skD.toByteArray();
+ final byte[] concatArr = skD.toByteArray();
- CpcUnion union = new CpcUnion(lgK);
- CpcSketch result = union.getResult();
- double uEst = result.getEstimate();
- double ulb = result.getLowerBound(2);
- double uub = result.getUpperBound(2);
+ final CpcUnion union = new CpcUnion(lgK);
+ final CpcSketch result = union.getResult();
+ final double uEst = result.getEstimate();
+ final double ulb = result.getLowerBound(2);
+ final double uub = result.getUpperBound(2);
union.update(sk1);
union.update(sk2);
- CpcSketch merged = union.getResult();
- byte[] mergedArr = merged.toByteArray();
+ final CpcSketch merged = union.getResult();
+ final byte[] mergedArr = merged.toByteArray();
- Memory concatMem = Memory.wrap(concatArr);
- CpcWrapper concatSk = new CpcWrapper(concatMem);
+ final MemorySegment concatSeg = MemorySegment.ofArray(concatArr);
+ final CpcWrapper concatSk = new CpcWrapper(concatSeg);
assertEquals(concatSk.getLgK(), lgK);
printf(" %12s %12s %12s\n", "Lb", "Est", "Ub");
- double ccEst = concatSk.getEstimate();
- double ccLb = concatSk.getLowerBound(2);
- double ccUb = concatSk.getUpperBound(2);
+ final double ccEst = concatSk.getEstimate();
+ final double ccLb = concatSk.getLowerBound(2);
+ final double ccUb = concatSk.getUpperBound(2);
printf("Concatenated: %12.0f %12.0f %12.0f\n", ccLb, ccEst, ccUb);
- //Memory mergedMem = Memory.wrap(mergedArr);
- CpcWrapper mergedSk = new CpcWrapper(mergedArr);
- double mEst = mergedSk.getEstimate();
- double mLb = mergedSk.getLowerBound(2);
- double mUb = mergedSk.getUpperBound(2);
+ //MemorySegment mergedSeg = MemorySegment.ofArray(mergedArr);
+ final CpcWrapper mergedSk = new CpcWrapper(mergedArr);
+ final double mEst = mergedSk.getEstimate();
+ final double mLb = mergedSk.getLowerBound(2);
+ final double mUb = mergedSk.getUpperBound(2);
printf("Merged: %12.0f %12.0f %12.0f\n", mLb, mEst, mUb);
assertEquals(Family.CPC, CpcWrapper.getFamily());
}
@@ -86,27 +86,27 @@ public class CpcWrapperTest {
@SuppressWarnings("unused")
@Test
public void checkIsCompressed() {
- CpcSketch sk = new CpcSketch(10);
- byte[] byteArr = sk.toByteArray();
+ final CpcSketch sk = new CpcSketch(10);
+ final byte[] byteArr = sk.toByteArray();
byteArr[5] &= (byte) -3;
try {
- CpcWrapper wrapper = new CpcWrapper(Memory.wrap(byteArr));
+ final CpcWrapper wrapper = new
CpcWrapper(MemorySegment.ofArray(byteArr));
fail();
- } catch (AssertionError e) {}
+ } catch (final AssertionError e) {}
}
/**
* @param format the string to print
* @param args the arguments
*/
- static void printf(String format, Object... args) {
+ static void printf(final String format, final Object... args) {
//ps.printf(format, args); //disable here
}
/**
* @param s the string to print
*/
- static void println(String s) {
+ static void println(final String s) {
//ps.println(s); //disable here
}
diff --git a/src/test/java/org/apache/datasketches/cpc/PreambleUtilTest.java
b/src/test/java/org/apache/datasketches/cpc/PreambleUtilTest.java
index 8577b8a3d..c8891d2ca 100644
--- a/src/test/java/org/apache/datasketches/cpc/PreambleUtilTest.java
+++ b/src/test/java/org/apache/datasketches/cpc/PreambleUtilTest.java
@@ -19,6 +19,7 @@
package org.apache.datasketches.cpc;
+import static java.lang.foreign.ValueLayout.JAVA_BYTE;
import static org.apache.datasketches.cpc.PreambleUtil.COMPRESSED_FLAG_MASK;
import static org.apache.datasketches.cpc.PreambleUtil.SER_VER;
import static org.apache.datasketches.cpc.PreambleUtil.getDefinedPreInts;
@@ -51,9 +52,9 @@ import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertTrue;
import static org.testng.Assert.fail;
+import java.lang.foreign.MemorySegment;
import org.testng.annotations.Test;
-import org.apache.datasketches.memory.WritableMemory;
import org.apache.datasketches.common.Family;
import org.apache.datasketches.common.SketchesArgumentException;
import org.apache.datasketches.common.SketchesStateException;
@@ -66,135 +67,135 @@ import org.apache.datasketches.cpc.PreambleUtil.HiField;
public class PreambleUtilTest {
static final short defaultSeedHash =
Util.computeSeedHash(Util.DEFAULT_UPDATE_SEED) ;
- private static void checkFirst8(WritableMemory wmem, Format format, int lgK,
int fiCol) {
- assertEquals(getFormat(wmem), format);
- assertEquals(getPreInts(wmem), getDefinedPreInts(format));
- assertEquals(getSerVer(wmem), SER_VER);
- assertEquals(getFamily(wmem), Family.CPC);
- assertEquals(getLgK(wmem), lgK);
- assertEquals(getFiCol(wmem), fiCol);
- assertEquals(getFlags(wmem), (format.ordinal() << 2) |
COMPRESSED_FLAG_MASK);
- assertEquals(getSeedHash(wmem), defaultSeedHash);
+ private static void checkFirst8(final MemorySegment wseg, final Format
format, final int lgK, final int fiCol) {
+ assertEquals(getFormat(wseg), format);
+ assertEquals(getPreInts(wseg), getDefinedPreInts(format));
+ assertEquals(getSerVer(wseg), SER_VER);
+ assertEquals(getFamily(wseg), Family.CPC);
+ assertEquals(getLgK(wseg), lgK);
+ assertEquals(getFiCol(wseg), fiCol);
+ assertEquals(getFlags(wseg), (format.ordinal() << 2) |
COMPRESSED_FLAG_MASK);
+ assertEquals(getSeedHash(wseg), defaultSeedHash);
}
@Test
- public void checkNormalPutMemory() {
- int lgK = 12;
- double kxp = lgK;
- double hipAccum = 1005;
- int fiCol = 1;
- int[] csvStream = new int[] {1, 2, 3};
- int numCoupons = csvStream.length;
- int csvLength = csvStream.length;
- short seedHash = defaultSeedHash;
- int[] cwStream = new int[] {4, 5, 6};
- int cwLength = cwStream.length;
- int numSv = cwStream.length;
- int maxInts = 10 + csvLength + cwLength;
- WritableMemory wmem = WritableMemory.allocate(4 * maxInts);
+ public void checkNormalPutSegment() {
+ final int lgK = 12;
+ final double kxp = lgK;
+ final double hipAccum = 1005;
+ final int fiCol = 1;
+ final int[] csvStream = {1, 2, 3};
+ final int numCoupons = csvStream.length;
+ final int csvLength = csvStream.length;
+ final short seedHash = defaultSeedHash;
+ final int[] cwStream = {4, 5, 6};
+ final int cwLength = cwStream.length;
+ final int numSv = cwStream.length;
+ final int maxInts = 10 + csvLength + cwLength;
+ final MemorySegment wseg = MemorySegment.ofArray(new byte[4 * maxInts]);
Format format;
format = Format.EMPTY_MERGED;
- putEmptyMerged(wmem, lgK, seedHash);
- println(CpcSketch.toString((byte[])wmem.getArray(), true));
- checkFirst8(wmem, format, lgK, (byte) 0);
- assertFalse(hasHip(wmem));
+ putEmptyMerged(wseg, lgK, seedHash);
+ println(CpcSketch.toString((byte[])wseg.toArray(JAVA_BYTE), true));
+ checkFirst8(wseg, format, lgK, (byte) 0);
+ assertFalse(hasHip(wseg));
format = Format.SPARSE_HYBRID_MERGED;
- putSparseHybridMerged(wmem, lgK, numCoupons, csvLength, seedHash,
csvStream);
- println(CpcSketch.toString(wmem, true));
- println(CpcSketch.toString(wmem, false));
- checkFirst8(wmem, format, lgK, (byte) 0);
- assertEquals(getNumCoupons(wmem), numCoupons);
- assertEquals(getSvLengthInts(wmem), csvLength);
+ putSparseHybridMerged(wseg, lgK, numCoupons, csvLength, seedHash,
csvStream);
+ println(CpcSketch.toString(wseg, true));
+ println(CpcSketch.toString(wseg, false));
+ checkFirst8(wseg, format, lgK, (byte) 0);
+ assertEquals(getNumCoupons(wseg), numCoupons);
+ assertEquals(getSvLengthInts(wseg), csvLength);
format = Format.SPARSE_HYBRID_HIP;
- putSparseHybridHip(wmem, lgK, numCoupons, csvLength, kxp, hipAccum,
seedHash, csvStream);
- println(CpcSketch.toString(wmem, true));
- println(CpcSketch.toString(wmem, false));
- checkFirst8(wmem, format, lgK, (byte) 0);
- assertEquals(getNumCoupons(wmem), numCoupons);
- assertEquals(getSvLengthInts(wmem), csvLength);
- assertEquals(getKxP(wmem), kxp);
- assertEquals(getHipAccum(wmem), hipAccum);
- assertTrue(hasHip(wmem));
+ putSparseHybridHip(wseg, lgK, numCoupons, csvLength, kxp, hipAccum,
seedHash, csvStream);
+ println(CpcSketch.toString(wseg, true));
+ println(CpcSketch.toString(wseg, false));
+ checkFirst8(wseg, format, lgK, (byte) 0);
+ assertEquals(getNumCoupons(wseg), numCoupons);
+ assertEquals(getSvLengthInts(wseg), csvLength);
+ assertEquals(getKxP(wseg), kxp);
+ assertEquals(getHipAccum(wseg), hipAccum);
+ assertTrue(hasHip(wseg));
format = Format.PINNED_SLIDING_MERGED_NOSV;
- putPinnedSlidingMergedNoSv(wmem, lgK, fiCol, numCoupons, cwLength,
seedHash, cwStream);
- println(CpcSketch.toString(wmem, true));
- println(CpcSketch.toString(wmem, false));
- checkFirst8(wmem, format, lgK, fiCol);
- assertEquals(getNumCoupons(wmem), numCoupons);
- assertEquals(getWLengthInts(wmem), cwLength);
+ putPinnedSlidingMergedNoSv(wseg, lgK, fiCol, numCoupons, cwLength,
seedHash, cwStream);
+ println(CpcSketch.toString(wseg, true));
+ println(CpcSketch.toString(wseg, false));
+ checkFirst8(wseg, format, lgK, fiCol);
+ assertEquals(getNumCoupons(wseg), numCoupons);
+ assertEquals(getWLengthInts(wseg), cwLength);
format = Format.PINNED_SLIDING_HIP_NOSV;
- putPinnedSlidingHipNoSv(wmem, lgK, fiCol, numCoupons, cwLength, kxp,
hipAccum, seedHash,
+ putPinnedSlidingHipNoSv(wseg, lgK, fiCol, numCoupons, cwLength, kxp,
hipAccum, seedHash,
cwStream);
- println(CpcSketch.toString(wmem, true));
- println(CpcSketch.toString(wmem, false));
- checkFirst8(wmem, format, lgK, fiCol);
- assertEquals(getNumCoupons(wmem), numCoupons);
- assertEquals(getWLengthInts(wmem), cwLength);
- assertEquals(getKxP(wmem), kxp);
- assertEquals(getHipAccum(wmem), hipAccum);
+ println(CpcSketch.toString(wseg, true));
+ println(CpcSketch.toString(wseg, false));
+ checkFirst8(wseg, format, lgK, fiCol);
+ assertEquals(getNumCoupons(wseg), numCoupons);
+ assertEquals(getWLengthInts(wseg), cwLength);
+ assertEquals(getKxP(wseg), kxp);
+ assertEquals(getHipAccum(wseg), hipAccum);
format = Format.PINNED_SLIDING_MERGED;
- putPinnedSlidingMerged(wmem, lgK, fiCol, numCoupons, numSv, csvLength,
cwLength, seedHash,
+ putPinnedSlidingMerged(wseg, lgK, fiCol, numCoupons, numSv, csvLength,
cwLength, seedHash,
csvStream, cwStream);
- println(CpcSketch.toString(wmem, true));
- println(CpcSketch.toString(wmem, false));
- checkFirst8(wmem, format, lgK, fiCol);
- assertEquals(getNumCoupons(wmem), numCoupons);
- assertEquals(getNumSv(wmem), numSv);
- assertEquals(getSvLengthInts(wmem), csvLength);
- assertEquals(getWLengthInts(wmem), cwLength);
+ println(CpcSketch.toString(wseg, true));
+ println(CpcSketch.toString(wseg, false));
+ checkFirst8(wseg, format, lgK, fiCol);
+ assertEquals(getNumCoupons(wseg), numCoupons);
+ assertEquals(getNumSv(wseg), numSv);
+ assertEquals(getSvLengthInts(wseg), csvLength);
+ assertEquals(getWLengthInts(wseg), cwLength);
format = Format.PINNED_SLIDING_HIP;
- putPinnedSlidingHip(wmem, lgK, fiCol, numCoupons, numSv, kxp, hipAccum,
csvLength, cwLength,
+ putPinnedSlidingHip(wseg, lgK, fiCol, numCoupons, numSv, kxp, hipAccum,
csvLength, cwLength,
seedHash, csvStream, cwStream);
- println(CpcSketch.toString(wmem, true));
- println(CpcSketch.toString(wmem, false));
- checkFirst8(wmem, format, lgK, fiCol);
- assertEquals(getNumCoupons(wmem), numCoupons);
- assertEquals(getNumSv(wmem), numSv);
- assertEquals(getSvLengthInts(wmem), csvLength);
- assertEquals(getWLengthInts(wmem), cwLength);
- assertEquals(getKxP(wmem), kxp);
- assertEquals(getHipAccum(wmem), hipAccum);
+ println(CpcSketch.toString(wseg, true));
+ println(CpcSketch.toString(wseg, false));
+ checkFirst8(wseg, format, lgK, fiCol);
+ assertEquals(getNumCoupons(wseg), numCoupons);
+ assertEquals(getNumSv(wseg), numSv);
+ assertEquals(getSvLengthInts(wseg), csvLength);
+ assertEquals(getWLengthInts(wseg), cwLength);
+ assertEquals(getKxP(wseg), kxp);
+ assertEquals(getHipAccum(wseg), hipAccum);
}
@Test
public void checkStreamErrors() {
- WritableMemory wmem = WritableMemory.allocate(4 * 10);
- putEmptyMerged(wmem, (byte) 12, defaultSeedHash);
- try { getSvStreamOffset(wmem); fail(); } catch (SketchesArgumentException
e) { }
- wmem.putByte(5, (byte) (7 << 2));
- try { getSvStreamOffset(wmem); fail(); } catch (SketchesStateException e)
{ }
- wmem.putByte(5, (byte) 0);
- try { getWStreamOffset(wmem); fail(); } catch (SketchesArgumentException
e) { }
- wmem.putByte(5, (byte) (7 << 2));
- try { getWStreamOffset(wmem); fail(); } catch (SketchesStateException e) {
}
+ final MemorySegment wseg = MemorySegment.ofArray(new byte[4 * 10]);
+ putEmptyMerged(wseg, (byte) 12, defaultSeedHash);
+ try { getSvStreamOffset(wseg); fail(); } catch (final
SketchesArgumentException e) { }
+ wseg.set(JAVA_BYTE, 5, (byte) (7 << 2));
+ try { getSvStreamOffset(wseg); fail(); } catch (final
SketchesStateException e) { }
+ wseg.set(JAVA_BYTE, 5, (byte) 0);
+ try { getWStreamOffset(wseg); fail(); } catch (final
SketchesArgumentException e) { }
+ wseg.set(JAVA_BYTE, 5, (byte) (7 << 2));
+ try { getWStreamOffset(wseg); fail(); } catch (final
SketchesStateException e) { }
}
@Test
public void checkStreamErrors2() {
- WritableMemory wmem = WritableMemory.allocate(4 * 10);
- int[] svStream = { 1 };
- int[] wStream = { 2 };
+ final MemorySegment wseg = MemorySegment.ofArray(new byte[4 * 10]);
+ final int[] svStream = { 1 };
+ final int[] wStream = { 2 };
try {
- putPinnedSlidingMerged(wmem, 4, 0, 1, 1, 1, 0, (short) 0, svStream,
wStream);
+ putPinnedSlidingMerged(wseg, 4, 0, 1, 1, 1, 0, (short) 0, svStream,
wStream);
fail();
- } catch (SketchesStateException e) { }
- assertTrue(PreambleUtil.isCompressed(wmem));
+ } catch (final SketchesStateException e) { }
+ assertTrue(PreambleUtil.isCompressed(wseg));
}
@Test
- public void checkEmptyMemory() {
- WritableMemory wmem = WritableMemory.allocate(4 * 10);
- wmem.putByte(2, (byte) 16); //legal Family
- wmem.putByte(5, (byte) (1 << 2)); //select NONE
- println(CpcSketch.toString(wmem, false));
+ public void checkEmptySegment() {
+ final MemorySegment wseg = MemorySegment.ofArray(new byte[4 * 10]);
+ wseg.set(JAVA_BYTE, 2, (byte) 16); //legal Family
+ wseg.set(JAVA_BYTE, 5, (byte) (1 << 2)); //select NONE
+ println(CpcSketch.toString(wseg, false));
}
@Test(expectedExceptions = SketchesArgumentException.class)
@@ -214,7 +215,7 @@ public class PreambleUtilTest {
@Test
public void checkWindowOffset() {
- long offset = CpcUtil.determineCorrectOffset(4, 54);
+ final long offset = CpcUtil.determineCorrectOffset(4, 54);
assertEquals(offset, 1L);
}
@@ -247,7 +248,7 @@ public class PreambleUtilTest {
/**
* @param s value to print
*/
- static void println(String s) {
+ static void println(final String s) {
//System.out.println(s); //disable here
}
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
