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 using atomic long count type

An AtomicHistogram guarantees lossless recording of values into the histogram even when the histogram is updated by multiple threads. It is important to note though that this lossless recording capability is the only thread-safe behavior provided by AtomicHistogram, and that it is not otherwise synchronized. Specifically, AtomicHistogram does not support auto-resizing, does not support value shift operations, and provides no implicit synchronization that would prevent the contents of the histogram from changing during iterations, copies, or addition operations on the histogram. Callers wishing to make potentially concurrent, multi-threaded updates that would safely work in the presence of queries, copies, or additions of histogram objects should either take care to externally synchronize and/or order their access, use the SynchronizedHistogram variant, or (recommended) use the Recorder class, which is intended for this purpose.

See package description for org.HdrHistogram for details.

 
 
 public class AtomicHistogram extends Histogram {
 
             AtomicLongFieldUpdater.newUpdater(AtomicHistogram.class"totalCount");
     volatile long totalCount;
     volatile AtomicLongArray counts;
 
     @Override
     long getCountAtIndex(final int index) {
         return .get(index);
     }
 
     @Override
     long getCountAtNormalizedIndex(final int index) {
         return .get(index);
     }
 
     @Override
     void incrementCountAtIndex(final int index) {
         .getAndIncrement(index);
     }
 
     @Override
     void addToCountAtIndex(final int indexfinal long value) {
         .getAndAdd(indexvalue);
     }
 
     @Override
     void setCountAtIndex(int indexlong value) {
         .lazySet(indexvalue);
     }
 
     @Override
     void setCountAtNormalizedIndex(int indexlong value) {
         .lazySet(indexvalue);
     }
 
     @Override
     int getNormalizingIndexOffset() {
         return 0;
     }
 
     @Override
     void setNormalizingIndexOffset(int normalizingIndexOffset) {
         if (normalizingIndexOffset != 0) {
             throw new IllegalStateException(
                     "AtomicHistogram does not support non-zero normalizing index settings." +
                             " Use ConcurrentHistogram Instead.");
         }
     }
 
     @Override
     void shiftNormalizingIndexByOffset(int offsetToAddboolean lowestHalfBucketPopulated) {
         throw new IllegalStateException(
                 "AtomicHistogram does not support Shifting operations." +
                         " Use ConcurrentHistogram Instead.");
     }
 
     @Override
     void resize(long newHighestTrackableValue) {
         throw new IllegalStateException(
                 "AtomicHistogram does not support resizing operations." +
                         " Use ConcurrentHistogram Instead.");
     }
 
     @Override
    public void setAutoResize(boolean autoResize) {
        throw new IllegalStateException(
                "AtomicHistogram does not support AutoResize operation." +
                        " Use ConcurrentHistogram Instead.");
    }
    @Override
    void clearCounts() {
        for (int i = 0; i < .length(); i++) {
            .lazySet(i, 0);
        }
        .set(this, 0);
    }
    @Override
    public AtomicHistogram copy() {
        AtomicHistogram copy = new AtomicHistogram(this);
        copy.add(this);
        return copy;
    }
    @Override
    public AtomicHistogram copyCorrectedForCoordinatedOmission(final long expectedIntervalBetweenValueSamples) {
        AtomicHistogram toHistogram = new AtomicHistogram(this);
        toHistogram.addWhileCorrectingForCoordinatedOmission(thisexpectedIntervalBetweenValueSamples);
        return toHistogram;
    }
    @Override
    public long getTotalCount() {
        return .get(this);
    }
    @Override
    void setTotalCount(final long totalCount) {
        .set(thistotalCount);
    }
    @Override
    void incrementTotalCount() {
        .incrementAndGet(this);
    }
    @Override
    void addToTotalCount(final long value) {
        .addAndGet(thisvalue);
    }
    @Override
        return (512 + (8 * .length()));
    }

    
Construct a AtomicHistogram 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 AtomicHistogram(final long highestTrackableValuefinal int numberOfSignificantValueDigits) {
        this(1, highestTrackableValuenumberOfSignificantValueDigits);
    }

    
Construct a AtomicHistogram 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 tracked (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 AtomicHistogram(final long lowestDiscernibleValuefinal long highestTrackableValuefinal int numberOfSignificantValueDigits) {
        super(lowestDiscernibleValuehighestTrackableValuenumberOfSignificantValueDigitsfalse);
         = new AtomicLongArray();
         = 8;
    }

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

Parameters:
source The source histogram to duplicate
    public AtomicHistogram(final AbstractHistogram source) {
        super(sourcefalse);
         = new AtomicLongArray();
         = 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 AtomicHistogram decodeFromByteBuffer(final ByteBuffer buffer,
                                                       final long minBarForHighestTrackableValue) {
        return (AtomicHistogramdecodeFromByteBuffer(bufferAtomicHistogram.class,
                minBarForHighestTrackableValue);
    }

    
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 AtomicHistogram decodeFromCompressedByteBuffer(final ByteBuffer buffer,
                                                                 final long minBarForHighestTrackableValuethrows DataFormatException {
        return decodeFromCompressedByteBuffer(bufferAtomicHistogram.classminBarForHighestTrackableValue);
    }
    private void readObject(final ObjectInputStream o)
            throws IOExceptionClassNotFoundException {
        o.defaultReadObject();
    }
    @Override
    synchronized void fillCountsArrayFromBuffer(final ByteBuffer bufferfinal int length) {
        LongBuffer logbuffer = buffer.asLongBuffer();
        for (int i = 0; i < lengthi++) {
            .lazySet(ilogbuffer.get());
        }
    }
New to GrepCode? Check out our FAQ X