Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Written by Gil Tene of Azul Systems, and released to the public domain, as explained at http://creativecommons.org/publicdomain/zero/1.0/

Author(s):
Gil Tene
  
  
  package org.HdrHistogram;
  

A High Dynamic Range (HDR) Histogram

Histogram supports the recording and analyzing sampled data value counts across a configurable integer value range with configurable value precision within the range. Value precision is expressed as the number of significant digits in the value recording, and provides control over value quantization behavior across the value range and the subsequent value resolution at any given level.

For example, a Histogram could be configured to track the counts of observed integer values between 0 and 3,600,000,000 while maintaining a value precision of 3 significant digits across that range. Value quantization within the range will thus be no larger than 1/1,000th (or 0.1%) of any value. This example Histogram could be used to track and analyze the counts of observed response times ranging between 1 microsecond and 1 hour in magnitude, while maintaining a value resolution of 1 microsecond up to 1 millisecond, a resolution of 1 millisecond (or better) up to one second, and a resolution of 1 second (or better) up to 1,000 seconds. At its maximum tracked value (1 hour), it would still maintain a resolution of 3.6 seconds (or better).

Histogram tracks value counts in long fields. Smaller field types are available in the IntCountsHistogram and ShortCountsHistogram implementations of AbstractHistogram.

Auto-resizing: When constructed with no specified value range range (or when auto-resize is turned on with AbstractHistogram.setAutoResize(boolean)) a Histogram will auto-resize its dynamic range to include recorded values as they are encountered. Note that recording calls that cause auto-resizing may take longer to execute, as resizing incurrs allocation and copying of internal data structures.

See package description for org.HdrHistogram for details.

 
 
 public class Histogram extends AbstractHistogram {
     long totalCount;
     long[] counts;
     int normalizingIndexOffset;
 
     @Override
     long getCountAtIndex(final int index) {
         return [normalizeIndex(index)];
     }
 
     @Override
     long getCountAtNormalizedIndex(final int index) {
         return [index];
     }
 
     @Override
     void incrementCountAtIndex(final int index) {
         [normalizeIndex(index)]++;
     }
 
     @Override
     void addToCountAtIndex(final int indexfinal long value) {
         [normalizeIndex(index)] += value;
     }
 
     @Override
     void setCountAtIndex(int indexlong value) {
         [normalizeIndex(index)] = value;
     }
 
     @Override
     void setCountAtNormalizedIndex(int indexlong value) {
         [index] = value;
     }
 
     @Override
     int getNormalizingIndexOffset() {
         return ;
     }
 
     @Override
     void setNormalizingIndexOffset(int normalizingIndexOffset) {
         this. = normalizingIndexOffset;
     }
 
     @Override
     void shiftNormalizingIndexByOffset(int offsetToAddboolean lowestHalfBucketPopulated) {
         nonConcurrentNormalizingIndexShift(offsetToAddlowestHalfBucketPopulated);
     }
 
     @Override
     void clearCounts() {
         java.util.Arrays.fill(, 0);
          = 0;
     }
    @Override
    public Histogram copy() {
        Histogram copy = new Histogram(this);
        copy.add(this);
        return copy;
    }
    @Override
    public Histogram copyCorrectedForCoordinatedOmission(final long expectedIntervalBetweenValueSamples) {
        Histogram copy = new Histogram(this);
        copy.addWhileCorrectingForCoordinatedOmission(thisexpectedIntervalBetweenValueSamples);
        return copy;
    }
    @Override
    public long getTotalCount() {
        return ;
    }
    @Override
    void setTotalCount(final long totalCount) {
        this. = totalCount;
    }
    @Override
    void incrementTotalCount() {
        ++;
    }
    @Override
    void addToTotalCount(final long value) {
         += value;
    }
    @Override
        return (512 + (8 * .));
    }
    @Override
    void resize(long newHighestTrackableValue) {
        int oldNormalizedZeroIndex = normalizeIndex(0, );
        establishSize(newHighestTrackableValue);
        int countsDelta =  - .;
         = Arrays.copyOf();
        if (oldNormalizedZeroIndex != 0) {
            // We need to shift the stuff from the zero index and up to the end of the array:
            int newNormalizedZeroIndex = oldNormalizedZeroIndex + countsDelta;
            int lengthToCopy = ( - countsDelta) - oldNormalizedZeroIndex;
            System.arraycopy(oldNormalizedZeroIndexnewNormalizedZeroIndexlengthToCopy);
        }
    }

    
Construct an auto-resizing histogram with a lowest discernible value of 1 and an auto-adjusting highestTrackableValue. Can auto-reize up to track values up to (Long.MAX_VALUE / 2).

Parameters:
numberOfSignificantValueDigits Specifies the precision to use. This is the number of significant decimal digits to which the histogram will maintain value resolution and separation. Must be a non-negative integer between 0 and 5.
    public Histogram(final int numberOfSignificantValueDigits) {
        this(1, 2, numberOfSignificantValueDigits);
        setAutoResize(true);
    }

    
Construct a Histogram given the Highest value to be tracked and a number of significant decimal digits. The histogram will be constructed to implicitly track (distinguish from 0) values as low as 1.

Parameters:
highestTrackableValue The highest value to be tracked by the histogram. Must be a positive integer that is >= 2.
numberOfSignificantValueDigits Specifies the precision to use. This is the number of significant decimal digits to which the histogram will maintain value resolution and separation. Must be a non-negative integer between 0 and 5.
    public Histogram(final long highestTrackableValuefinal int numberOfSignificantValueDigits) {
        this(1, highestTrackableValuenumberOfSignificantValueDigits);
    }

    
Construct a Histogram given the Lowest and Highest values to be tracked and a number of significant decimal digits. Providing a lowestDiscernibleValue is useful is situations where the units used for the histogram's values are much smaller that the minimal accuracy required. E.g. when tracking time values stated in nanosecond units, where the minimal accuracy required is a microsecond, the proper value for lowestDiscernibleValue would be 1000.

Parameters:
lowestDiscernibleValue The lowest value that can be discerned (distinguished from 0) by the histogram. Must be a positive integer that is >= 1. May be internally rounded down to nearest power of 2.
highestTrackableValue The highest value to be tracked by the histogram. Must be a positive integer that is >= (2 * lowestDiscernibleValue).
numberOfSignificantValueDigits Specifies the precision to use. This is the number of significant decimal digits to which the histogram will maintain value resolution and separation. Must be a non-negative integer between 0 and 5.
    public Histogram(final long lowestDiscernibleValuefinal long highestTrackableValue,
                     final int numberOfSignificantValueDigits) {
        this(lowestDiscernibleValuehighestTrackableValuenumberOfSignificantValueDigitstrue);
    }

    
Construct a histogram with the same range settings as a given source histogram, duplicating the source's start/end timestamps (but NOT its contents)

Parameters:
source The source histogram to duplicate
    public Histogram(final AbstractHistogram source) {
        this(sourcetrue);
    }
    Histogram(final AbstractHistogram sourceboolean allocateCountsArray) {
        super(source);
        if (allocateCountsArray) {
             = new long[];
        }
         = 8;
    }
    Histogram(final long lowestDiscernibleValuefinal long highestTrackableValue,
              final int numberOfSignificantValueDigitsboolean allocateCountsArray) {
        super(lowestDiscernibleValuehighestTrackableValuenumberOfSignificantValueDigits);
        if (allocateCountsArray) {
             = new long[];
        }
         = 8;
    }

    
Construct a new histogram by decoding it from a ByteBuffer.

Parameters:
buffer The buffer to decode from
minBarForHighestTrackableValue Force highestTrackableValue to be set at least this high
Returns:
The newly constructed histogram
    public static Histogram decodeFromByteBuffer(final ByteBuffer buffer,
                                                 final long minBarForHighestTrackableValue) {
        return (HistogramdecodeFromByteBuffer(bufferHistogram.classminBarForHighestTrackableValue);
    }

    
Construct a new histogram by decoding it from a compressed form in a ByteBuffer.

Parameters:
buffer The buffer to decode from
minBarForHighestTrackableValue Force highestTrackableValue to be set at least this high
Returns:
The newly constructed histogram
Throws:
java.util.zip.DataFormatException on error parsing/decompressing the buffer
    public static Histogram decodeFromCompressedByteBuffer(final ByteBuffer buffer,
                                                           final long minBarForHighestTrackableValuethrows DataFormatException {
        return (HistogramdecodeFromCompressedByteBuffer(bufferHistogram.class,
                minBarForHighestTrackableValue);
    }
    private void readObject(final ObjectInputStream o)
            throws IOExceptionClassNotFoundException {
        o.defaultReadObject();
    }
    @Override
    synchronized void fillCountsArrayFromBuffer(final ByteBuffer bufferfinal int length) {
        buffer.asLongBuffer().get(, 0, length);
    }
    // We try to cache the LongBuffer used in output cases, as repeated
    // output form the same histogram using the same buffer is likely:
    private LongBuffer cachedDstLongBuffer = null;
    private ByteBuffer cachedDstByteBuffer = null;
    private int cachedDstByteBufferPosition = 0;
    @Override
    synchronized void fillBufferFromCountsArray(final ByteBuffer bufferfinal int length) {
        if (( == null) ||
                (buffer != ) ||
                (buffer.position() != )) {
             = buffer;
             = buffer.position();
             = buffer.asLongBuffer();
        }
        .rewind();
        .put(, 0, length);
    }
New to GrepCode? Check out our FAQ X