@Override public int getStorageBytesEstimate() { return current().getBytesEstimate(); }
@Override public int peekLength(ByteBuffer in) { return current().peekLength(in); }
@Override public void aggregate(PercentileCounter value) { if (sum == null) sum = new PercentileCounter(value); else sum.merge(value); }
@Override public PercentileCounter deserialize(ByteBuffer in) { PercentileCounter counter = new PercentileCounter(compression); counter.readRegisters(in); return counter; } }
private void testPercentileSize(int sumNums, Integer sqrtNum, Integer compresion) throws Exception { compresion = compresion == null ? DEFAULT_COMPRESSION : compresion; PercentileAggregator aggregator = createPercentileAggreator(sumNums, sqrtNum, compresion); double actual = getActualSize(aggregator); double estimate = getEstimateSize((int) aggregator.getState().getRegisters().size(), 1, compresion); assertTrue(Math.abs(actual - estimate) / actual < 0.3); aggregator.reset(); }
private double getEstimateSize(int numBefore, int numAfter, int compression) { return new PercentileCounter(compression == 0 ? DEFAULT_COMPRESSION : compression) .getBytesEstimate(numBefore * 1.0 / numAfter); }
public static double result(PercentileCounter counter) { return counter == null ? 0L : counter.getResultEstimate(); }
private PercentileCounter current() { if (current == null) { current = new ThreadLocal<>(); } PercentileCounter counter = current.get(); if (counter == null) { counter = new PercentileCounter(compression); current.set(counter); } return counter; }
private double getActualSize(PercentileAggregator aggregator) { ByteBuffer buffer = ByteBuffer.allocate(10 * 1024 * 1024); aggregator.getState().writeRegisters(buffer); double actual = buffer.position(); buffer.clear(); return actual; }
public PercentileCounter(PercentileCounter another) { this(another.compression, another.quantileRatio); merge(another); }
@Override public void serialize(PercentileCounter value, ByteBuffer out) { value.writeRegisters(out); }
public PercentileCounter(double compression, double quantileRatio) { this.compression = compression; this.quantileRatio = quantileRatio; reInitRegisters(); }
@Override public MeasureType<PercentileCounter> createMeasureType(String funcName, DataType dataType) { return new PercentileMeasureType(dataType); }
public int getBytesEstimate() { return maxLength(); }
private double getEstimateSize(int numBefore, int numAfter) { return getEstimateSize(numBefore, numAfter, 0); }
@Override public PercentileCounter aggregate(PercentileCounter value1, PercentileCounter value2) { if (value1 == null) { return new PercentileCounter(value2); } else if (value2 == null) { return new PercentileCounter(value1); } PercentileCounter merged = new PercentileCounter(value1); merged.merge(value2); return merged; }
@Override protected double getStorageBytesEstimate(double count) { return current().getBytesEstimate(count); }
public static PercentileCounter merge(PercentileCounter counter0, PercentileCounter counter1) { counter0.merge(counter1); return counter0; }
public void clear() { reInitRegisters(); }