Skip to content

Commit f5e1931

Browse files
leerholeerho
committed
Finished converting CPC
1 parent daf0b14 commit f5e1931

10 files changed

Lines changed: 487 additions & 481 deletions

File tree

‎src/main/java/org/apache/datasketches/cpc/CompressedState.java‎

Lines changed: 61 additions & 61 deletions
Original file line numberDiff line numberDiff line change
@@ -47,9 +47,9 @@
4747
import static org.apache.datasketches.cpc.PreambleUtil.putSparseHybridMerged;
4848
import static org.apache.datasketches.cpc.RuntimeAsserts.rtAssert;
4949

50+
import java.lang.foreign.MemorySegment;
51+
5052
import org.apache.datasketches.common.Util;
51-
import org.apache.datasketches.memory.Memory;
52-
import org.apache.datasketches.memory.WritableMemory;
5353

5454
/**
5555
* @author Lee Rhodes
@@ -118,121 +118,121 @@ long getRequiredSerializedBytes() {
118118
return 4L * (preInts + csvLengthInts + cwLengthInts);
119119
}
120120

121-
static CompressedState importFromMemory(final Memory mem) {
122-
checkLoPreamble(mem);
123-
rtAssert(isCompressed(mem));
124-
final int lgK = getLgK(mem);
125-
final short seedHash = getSeedHash(mem);
121+
static CompressedState importFromSegment(final MemorySegment seg) {
122+
checkLoPreamble(seg);
123+
rtAssert(isCompressed(seg));
124+
final int lgK = getLgK(seg);
125+
final short seedHash = getSeedHash(seg);
126126
final CompressedState state = new CompressedState(lgK, seedHash);
127-
final int fmtOrd = getFormatOrdinal(mem);
127+
final int fmtOrd = getFormatOrdinal(seg);
128128
final Format format = Format.ordinalToFormat(fmtOrd);
129-
state.mergeFlag = !((fmtOrd & 1) > 0); //merge flag is complement of HIP
129+
state.mergeFlag = ((fmtOrd & 1) <= 0); //merge flag is complement of HIP
130130
state.csvIsValid = (fmtOrd & 2) > 0;
131131
state.windowIsValid = (fmtOrd & 4) > 0;
132132

133133
switch (format) {
134134
case EMPTY_MERGED :
135135
case EMPTY_HIP : {
136-
checkCapacity(mem.getCapacity(), 8L);
136+
checkCapacity(seg.byteSize(), 8L);
137137
break;
138138
}
139139
case SPARSE_HYBRID_MERGED : {
140140
//state.fiCol = getFiCol(mem);
141-
state.numCoupons = getNumCoupons(mem);
141+
state.numCoupons = getNumCoupons(seg);
142142
state.numCsv = (int) state.numCoupons; //only true for sparse_hybrid
143-
state.csvLengthInts = getSvLengthInts(mem);
143+
state.csvLengthInts = getSvLengthInts(seg);
144144
//state.cwLength = getCwLength(mem);
145145
//state.kxp = getKxP(mem);
146146
//state.hipEstAccum = getHipAccum(mem);
147-
checkCapacity(mem.getCapacity(), state.getRequiredSerializedBytes());
147+
checkCapacity(seg.byteSize(), state.getRequiredSerializedBytes());
148148
//state.cwStream = getCwStream(mem);
149-
state.csvStream = getSvStream(mem);
149+
state.csvStream = getSvStream(seg);
150150
break;
151151
}
152152
case SPARSE_HYBRID_HIP : {
153153
//state.fiCol = getFiCol(mem);
154-
state.numCoupons = getNumCoupons(mem);
154+
state.numCoupons = getNumCoupons(seg);
155155
state.numCsv = (int) state.numCoupons; //only true for sparse_hybrid
156-
state.csvLengthInts = getSvLengthInts(mem);
156+
state.csvLengthInts = getSvLengthInts(seg);
157157
//state.cwLength = getCwLength(mem);
158-
state.kxp = getKxP(mem);
159-
state.hipEstAccum = getHipAccum(mem);
160-
checkCapacity(mem.getCapacity(), state.getRequiredSerializedBytes());
158+
state.kxp = getKxP(seg);
159+
state.hipEstAccum = getHipAccum(seg);
160+
checkCapacity(seg.byteSize(), state.getRequiredSerializedBytes());
161161
//state.cwStream = getCwStream(mem);
162-
state.csvStream = getSvStream(mem);
162+
state.csvStream = getSvStream(seg);
163163
break;
164164
}
165165
case PINNED_SLIDING_MERGED_NOSV : {
166-
state.fiCol = getFiCol(mem);
167-
state.numCoupons = getNumCoupons(mem);
166+
state.fiCol = getFiCol(seg);
167+
state.numCoupons = getNumCoupons(seg);
168168
//state.numCsv = getNumCsv(mem);
169169
//state.csvLength = getCsvLength(mem);
170-
state.cwLengthInts = getWLengthInts(mem);
170+
state.cwLengthInts = getWLengthInts(seg);
171171
//state.kxp = getKxP(mem);
172172
//state.hipEstAccum = getHipAccum(mem);
173-
checkCapacity(mem.getCapacity(), state.getRequiredSerializedBytes());
174-
state.cwStream = getWStream(mem);
173+
checkCapacity(seg.byteSize(), state.getRequiredSerializedBytes());
174+
state.cwStream = getWStream(seg);
175175
//state.csvStream = getCsvStream(mem);
176176
break;
177177
}
178178
case PINNED_SLIDING_HIP_NOSV : {
179-
state.fiCol = getFiCol(mem);
180-
state.numCoupons = getNumCoupons(mem);
179+
state.fiCol = getFiCol(seg);
180+
state.numCoupons = getNumCoupons(seg);
181181
//state.numCsv = getNumCsv(mem);
182182
//state.csvLength = getCsvLength(mem);
183-
state.cwLengthInts = getWLengthInts(mem);
184-
state.kxp = getKxP(mem);
185-
state.hipEstAccum = getHipAccum(mem);
186-
checkCapacity(mem.getCapacity(), state.getRequiredSerializedBytes());
187-
state.cwStream = getWStream(mem);
183+
state.cwLengthInts = getWLengthInts(seg);
184+
state.kxp = getKxP(seg);
185+
state.hipEstAccum = getHipAccum(seg);
186+
checkCapacity(seg.byteSize(), state.getRequiredSerializedBytes());
187+
state.cwStream = getWStream(seg);
188188
//state.csvStream = getCsvStream(mem);
189189
break;
190190
}
191191
case PINNED_SLIDING_MERGED : {
192-
state.fiCol = getFiCol(mem);
193-
state.numCoupons = getNumCoupons(mem);
194-
state.numCsv = getNumSv(mem);
195-
state.csvLengthInts = getSvLengthInts(mem);
196-
state.cwLengthInts = getWLengthInts(mem);
192+
state.fiCol = getFiCol(seg);
193+
state.numCoupons = getNumCoupons(seg);
194+
state.numCsv = getNumSv(seg);
195+
state.csvLengthInts = getSvLengthInts(seg);
196+
state.cwLengthInts = getWLengthInts(seg);
197197
//state.kxp = getKxP(mem);
198198
//state.hipEstAccum = getHipAccum(mem);
199-
checkCapacity(mem.getCapacity(), state.getRequiredSerializedBytes());
200-
state.cwStream = getWStream(mem);
201-
state.csvStream = getSvStream(mem);
199+
checkCapacity(seg.byteSize(), state.getRequiredSerializedBytes());
200+
state.cwStream = getWStream(seg);
201+
state.csvStream = getSvStream(seg);
202202
break;
203203
}
204204
case PINNED_SLIDING_HIP : {
205-
state.fiCol = getFiCol(mem);
206-
state.numCoupons = getNumCoupons(mem);
207-
state.numCsv = getNumSv(mem);
208-
state.csvLengthInts = getSvLengthInts(mem);
209-
state.cwLengthInts = getWLengthInts(mem);
210-
state.kxp = getKxP(mem);
211-
state.hipEstAccum = getHipAccum(mem);
212-
checkCapacity(mem.getCapacity(), state.getRequiredSerializedBytes());
213-
state.cwStream = getWStream(mem);
214-
state.csvStream = getSvStream(mem);
205+
state.fiCol = getFiCol(seg);
206+
state.numCoupons = getNumCoupons(seg);
207+
state.numCsv = getNumSv(seg);
208+
state.csvLengthInts = getSvLengthInts(seg);
209+
state.cwLengthInts = getWLengthInts(seg);
210+
state.kxp = getKxP(seg);
211+
state.hipEstAccum = getHipAccum(seg);
212+
checkCapacity(seg.byteSize(), state.getRequiredSerializedBytes());
213+
state.cwStream = getWStream(seg);
214+
state.csvStream = getSvStream(seg);
215215
break;
216216
}
217217
}
218-
checkCapacity(mem.getCapacity(),
219-
4L * (getPreInts(mem) + state.csvLengthInts + state.cwLengthInts));
218+
checkCapacity(seg.byteSize(),
219+
4L * (getPreInts(seg) + state.csvLengthInts + state.cwLengthInts));
220220
return state;
221221
}
222222

223-
void exportToMemory(final WritableMemory wmem) {
223+
void exportToSegment(final MemorySegment wseg) {
224224
final Format format = getFormat();
225225
switch (format) {
226226
case EMPTY_MERGED : {
227-
putEmptyMerged(wmem, lgK, seedHash);
227+
putEmptyMerged(wseg, lgK, seedHash);
228228
break;
229229
}
230230
case EMPTY_HIP : {
231-
putEmptyHip(wmem, lgK, seedHash);
231+
putEmptyHip(wseg, lgK, seedHash);
232232
break;
233233
}
234234
case SPARSE_HYBRID_MERGED : {
235-
putSparseHybridMerged(wmem,
235+
putSparseHybridMerged(wseg,
236236
lgK,
237237
(int) numCoupons, //unsigned
238238
csvLengthInts,
@@ -241,7 +241,7 @@ void exportToMemory(final WritableMemory wmem) {
241241
break;
242242
}
243243
case SPARSE_HYBRID_HIP : {
244-
putSparseHybridHip(wmem,
244+
putSparseHybridHip(wseg,
245245
lgK,
246246
(int) numCoupons, //unsigned
247247
csvLengthInts,
@@ -252,7 +252,7 @@ void exportToMemory(final WritableMemory wmem) {
252252
break;
253253
}
254254
case PINNED_SLIDING_MERGED_NOSV : {
255-
putPinnedSlidingMergedNoSv(wmem,
255+
putPinnedSlidingMergedNoSv(wseg,
256256
lgK,
257257
fiCol,
258258
(int) numCoupons, //unsigned
@@ -262,7 +262,7 @@ void exportToMemory(final WritableMemory wmem) {
262262
break;
263263
}
264264
case PINNED_SLIDING_HIP_NOSV : {
265-
putPinnedSlidingHipNoSv(wmem,
265+
putPinnedSlidingHipNoSv(wseg,
266266
lgK,
267267
fiCol,
268268
(int) numCoupons, //unsigned
@@ -274,7 +274,7 @@ void exportToMemory(final WritableMemory wmem) {
274274
break;
275275
}
276276
case PINNED_SLIDING_MERGED : {
277-
putPinnedSlidingMerged(wmem,
277+
putPinnedSlidingMerged(wseg,
278278
lgK,
279279
fiCol,
280280
(int) numCoupons, //unsigned
@@ -287,7 +287,7 @@ void exportToMemory(final WritableMemory wmem) {
287287
break;
288288
}
289289
case PINNED_SLIDING_HIP : {
290-
putPinnedSlidingHip(wmem,
290+
putPinnedSlidingHip(wseg,
291291
lgK,
292292
fiCol,
293293
(int) numCoupons, //unsigned

‎src/main/java/org/apache/datasketches/cpc/CompressionCharacterization.java‎

Lines changed: 20 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -24,16 +24,15 @@
2424
import static org.apache.datasketches.common.Util.ceilingPowerOf2;
2525
import static org.apache.datasketches.common.Util.log2;
2626
import static org.apache.datasketches.common.Util.powerSeriesNextDouble;
27-
import static org.apache.datasketches.cpc.CompressedState.importFromMemory;
27+
import static org.apache.datasketches.cpc.CompressedState.importFromSegment;
2828
import static org.apache.datasketches.cpc.RuntimeAsserts.rtAssert;
2929

30+
import java.lang.foreign.MemorySegment;
3031
import java.io.PrintStream;
3132
import java.io.PrintWriter;
3233

3334
import org.apache.datasketches.common.SuppressFBWarnings;
3435
import org.apache.datasketches.common.Util;
35-
import org.apache.datasketches.memory.Memory;
36-
import org.apache.datasketches.memory.WritableMemory;
3736

3837
/**
3938
* This code is used both by unit tests, for short running tests,
@@ -51,20 +50,20 @@ public class CompressionCharacterization {
5150
private long vIn = 0;
5251

5352
//inputs
54-
private int lgMinK;
55-
private int lgMaxK; //inclusive
56-
private int lgMinT; //Trials at end
57-
private int lgMaxT; //Trials at start
58-
private int lgMulK; //multiplier of K to produce maxU
59-
private int uPPO;
60-
private int incLgK; //increment of lgK
61-
private PrintStream ps;
62-
private PrintWriter pw;
53+
private final int lgMinK;
54+
private final int lgMaxK; //inclusive
55+
private final int lgMinT; //Trials at end
56+
private final int lgMaxT; //Trials at start
57+
private final int lgMulK; //multiplier of K to produce maxU
58+
private final int uPPO;
59+
private final int incLgK; //increment of lgK
60+
private final PrintStream ps;
61+
private final PrintWriter pw;
6362

6463
//intermediates
6564
private CpcSketch[] streamSketches;
6665
private CompressedState[] compressedStates1;
67-
private WritableMemory[] memoryArr;
66+
private MemorySegment[] segArr;
6867
private CompressedState[] compressedStates2;
6968
private CpcSketch[] unCompressedSketches;
7069

@@ -141,7 +140,7 @@ private void doTrialsAtLgKAtN(final int lgK, final long n, final int totalTrials
141140
//printf("%d %d %d %d\n", totalTrials, lgTotTrials, 1 << lgWaves, trialsPerWave);
142141
streamSketches = new CpcSketch[trialsPerWave];
143142
compressedStates1 = new CompressedState[trialsPerWave];
144-
memoryArr = new WritableMemory[trialsPerWave];
143+
segArr = new MemorySegment[trialsPerWave];
145144
compressedStates2 = new CompressedState[trialsPerWave];
146145
unCompressedSketches = new CpcSketch[trialsPerWave];
147146

@@ -194,23 +193,23 @@ private void doTrialsAtLgKAtN(final int lgK, final long n, final int totalTrials
194193
sumCom_nS += nanoEnd - nanoStart;
195194
nanoStart = nanoEnd;
196195

197-
//State to Memory loop
196+
//State to MemorySegment loop
198197
for (int trial = 0; trial < trialsPerWave; trial++) {
199198
final CompressedState state = compressedStates1[trial];
200199
final long cap = state.getRequiredSerializedBytes();
201-
final WritableMemory wmem = WritableMemory.allocate((int) cap);
202-
state.exportToMemory(wmem);
203-
memoryArr[trial] = wmem;
200+
final MemorySegment wseg = MemorySegment.ofArray(new byte[(int) cap]);
201+
state.exportToSegment(wseg);
202+
segArr[trial] = wseg;
204203
}
205204

206205
nanoEnd = System.nanoTime();
207206
sumSer_nS += nanoEnd - nanoStart;
208207
nanoStart = nanoEnd;
209208

210-
//Memory to State loop
209+
//MemorySegment to State loop
211210
for (int trial = 0; trial < trialsPerWave; trial++) {
212-
final Memory mem = memoryArr[trial];
213-
final CompressedState state = importFromMemory(mem);
211+
final MemorySegment seg = segArr[trial];
212+
final CompressedState state = importFromSegment(seg);
214213
compressedStates2[trial] = state;
215214
}
216215

0 commit comments

Comments
 (0)