/** * Returns a new UnionBuilder * @return a new UnionBuilder */ public static DoublesUnionBuilder builder() { return new DoublesUnionBuilder(); }
@Override public DoublesUnion deserialise(final byte[] bytes) throws SerialisationException { final DoublesUnion union = DoublesUnion.builder().build(); union.update(WritableMemory.wrap(bytes)); return union; }
@Test public void checkBuilds() { UpdateDoublesSketch qs1 = DoublesSketch.builder().build(); for (int i=0; i<1000; i++) { qs1.update(i); } int bytes = qs1.getCompactStorageBytes(); WritableMemory dstMem = WritableMemory.wrap(new byte[bytes]); qs1.putMemory(dstMem); Memory srcMem = dstMem; DoublesUnionBuilder bldr = new DoublesUnionBuilder(); bldr.setMaxK(128); DoublesUnion union = bldr.build(); //virgin union union = DoublesUnion.heapify(srcMem); DoublesSketch qs2 = union.getResult(); assertEquals(qs1.getCompactStorageBytes(), qs2.getCompactStorageBytes()); union = DoublesUnion.heapify(qs2); DoublesSketch qs3 = union.getResult(); assertEquals(qs2.getCompactStorageBytes(), qs3.getCompactStorageBytes()); assertFalse(qs2 == qs3); }
@Test public void checkDirectInstance() { final int k = 128; final int n = 1000; final DoublesUnionBuilder bldr = DoublesUnion.builder(); bldr.setMaxK(k); Assert.assertEquals(bldr.getMaxK(), k); final int bytes = DoublesSketch.getUpdatableStorageBytes(k, n); final byte[] byteArr = new byte[bytes]; final WritableMemory mem = WritableMemory.wrap(byteArr); final DoublesUnion union = bldr.build(mem); assertTrue(union.isEmpty()); assertTrue(union.isDirect()); for (int i = 1; i <= n; i++) { union.update(i); } Assert.assertFalse(union.isEmpty()); final DoublesSketch res = union.getResult(); final double median = res.getQuantile(.5); Assert.assertEquals(median, 500, 10); println(union.toString()); }
public void rotateLatencyCollection() { // Swap current with replacement ThreadLocalAccessor local = current; current = replacement; replacement = local; final DoublesUnion aggregateSuccesss = new DoublesUnionBuilder().build(); final DoublesUnion aggregateFail = new DoublesUnionBuilder().build(); local.map.forEach((localData, b) -> { long stamp = localData.lock.writeLock(); try { aggregateSuccesss.update(localData.successSketch); localData.successSketch.reset(); aggregateFail.update(localData.failSketch); localData.failSketch.reset(); } finally { localData.lock.unlockWrite(stamp); } }); successResult = aggregateSuccesss.getResultAndReset(); failResult = aggregateFail.getResultAndReset(); }
@SuppressWarnings({ "deprecation", "unused" }) @Test public void checkDeprecatedRankError() { DoublesSketch ds = buildAndLoadQS(64, 64); double err = ds.getNormalizedRankError(); err = DoublesSketch.getNormalizedRankError(64); DoublesUnion du1 = DoublesUnionBuilder.heapify(ds); Memory mem = Memory.wrap(ds.toByteArray()); DoublesUnion du2 = DoublesUnionBuilder.heapify(mem); DoublesUnion du3 = DoublesUnionBuilder.wrap(mem); WritableMemory wmem = WritableMemory.wrap(ds.toByteArray()); DoublesUnion du4 = DoublesUnionBuilder.wrap(wmem); ItemsSketch<String> is = ItemsSketch.getInstance(64, Comparator.naturalOrder()); err = is.getNormalizedRankError(); err = ItemsSketch.getNormalizedRankError(64); }
@Override public synchronized void relocate(int oldPosition, int newPosition, ByteBuffer oldBuffer, ByteBuffer newBuffer) { DoublesUnion union = unions.get(oldBuffer).get(oldPosition); final WritableMemory oldMem = getMemory(oldBuffer).writableRegion(oldPosition, maxIntermediateSize); if (union.isSameResource(oldMem)) { // union was not relocated on heap final WritableMemory newMem = getMemory(newBuffer).writableRegion(newPosition, maxIntermediateSize); union = DoublesUnionBuilder.wrap(newMem); } putUnion(newBuffer, newPosition, union); Int2ObjectMap<DoublesUnion> map = unions.get(oldBuffer); map.remove(oldPosition); if (map.isEmpty()) { unions.remove(oldBuffer); memCache.remove(oldBuffer); } }
@Override protected DoublesUnion getEmptyExampleOutput() { return DoublesUnion.builder().build(); }
@Test public void checkDeprecated1() { UpdateDoublesSketch qs1 = DoublesSketch.builder().build(); for (int i=0; i<1000; i++) { qs1.update(i); } int bytes = qs1.getCompactStorageBytes(); WritableMemory dstMem = WritableMemory.wrap(new byte[bytes]); qs1.putMemory(dstMem); Memory srcMem = dstMem; DoublesUnionBuilder bldr = new DoublesUnionBuilder(); bldr.setMaxK(128); DoublesUnion union = bldr.build(); //virgin union union = DoublesUnion.heapify(srcMem); //heapify DoublesSketch qs2 = union.getResult(); assertEquals(qs1.getCompactStorageBytes(), qs2.getCompactStorageBytes()); assertEquals(qs1.getUpdatableStorageBytes(), qs2.getUpdatableStorageBytes()); union = DoublesUnion.heapify(qs2); //heapify again DoublesSketch qs3 = union.getResult(); assertEquals(qs2.getCompactStorageBytes(), qs3.getCompactStorageBytes()); assertEquals(qs2.getUpdatableStorageBytes(), qs3.getUpdatableStorageBytes()); assertFalse(qs2 == qs3); //different objects }
@Override protected DoublesUnion getExampleOutput() { final DoublesUnion union = DoublesUnion.builder().build(); union.update(1.0D); union.update(2.0D); union.update(3.0D); return union; }
private QuantileSketch(int k, Distribution.Type type) { updateSketch = new DoublesSketchBuilder().build(k); unionSketch = new DoublesUnionBuilder().setMaxK(k).build(); this.type = type; }
/** * Returns a new UnionBuilder * @return a new UnionBuilder */ public static DoublesUnionBuilder builder() { return new DoublesUnionBuilder(); }
@Override public synchronized void init(final ByteBuffer buffer, final int position) { final WritableMemory mem = getMemory(buffer); final WritableMemory region = mem.writableRegion(position, maxIntermediateSize); final DoublesUnion union = DoublesUnion.builder().setMaxK(k).build(region); putUnion(buffer, position, union); }
@Test public void isSameResourceHeap() { DoublesUnion union = DoublesUnion.builder().build(); Assert.assertFalse(union.isSameResource(null)); }
@Test public void isSameResourceDirect() { WritableMemory mem1 = WritableMemory.wrap(new byte[1000000]); DoublesUnion union = DoublesUnion.builder().build(mem1); Assert.assertTrue(union.isSameResource(mem1)); WritableMemory mem2 = WritableMemory.wrap(new byte[1000000]); Assert.assertFalse(union.isSameResource(mem2)); }