import org.HdrHistogram.Recorder; //导入依赖的package包/类
public ResetByChunksAccumulator(Supplier<Recorder> recorderSupplier, int numberHistoryChunks, long intervalBetweenResettingMillis, Clock clock, Executor backgroundExecutor) {
    this.intervalBetweenResettingMillis = intervalBetweenResettingMillis;
    this.clock = clock;
    this.creationTimestamp = clock.currentTimeMillis();
    this.backgroundExecutor = backgroundExecutor;

    this.left = new Phase(recorderSupplier, creationTimestamp + intervalBetweenResettingMillis);
    this.right = new Phase(recorderSupplier, Long.MAX_VALUE);
    this.phases = new Phase[] {left, right};
    this.currentPhaseRef = new AtomicReference<>(left);


    this.historySupported = numberHistoryChunks > 0;
    if (historySupported) {
        this.archive = new ArchivedHistogram[numberHistoryChunks];
        for (int i = 0; i < numberHistoryChunks; i++) {
            Histogram archivedHistogram = HistogramUtil.createNonConcurrentCopy(left.intervalHistogram);
            this.archive[i] = new ArchivedHistogram(archivedHistogram, Long.MIN_VALUE);
        }
    } else {
        this.archive = null;
    }

    this.temporarySnapshotHistogram = HistogramUtil.createNonConcurrentCopy(left.intervalHistogram);
}
 

import org.HdrHistogram.Recorder; //导入依赖的package包/类
/**
 * Create a reservoir with a user-specified recorder.
 *
 * @param recorder Recorder to use
 */
public HdrHistogramReservoir(Recorder recorder) {
    this.recorder = recorder;

    /*
     * Start by flipping the recorder's interval histogram.
     * - it starts our counting at zero. Arguably this might be a bad thing if you wanted to feed in
     *   a recorder that already had some measurements? But that seems crazy.
     * - intervalHistogram can be nonnull.
     * - it lets us figure out the number of significant digits to use in runningTotals.
     */
    intervalHistogram = recorder.getIntervalHistogram();
    runningTotals = new Histogram(intervalHistogram.getNumberOfSignificantValueDigits());
}
 

import org.HdrHistogram.Recorder; //导入依赖的package包/类
/**
 * Create a reservoir with a user-specified recorder.
 *
 * @param recorder Recorder to use
 */
public HdrHistogramResetOnSnapshotReservoir(Recorder recorder) {
    this.recorder = recorder;

    /*
     * Start by flipping the recorder's interval histogram.
     * - it starts our counting at zero. Arguably this might be a bad thing if you wanted to feed in
     *   a recorder that already had some measurements? But that seems crazy.
     * - intervalHistogram can be nonnull.
     */
    intervalHistogram = recorder.getIntervalHistogram();
}
 

import org.HdrHistogram.Recorder; //导入依赖的package包/类
/**
 * Get reservoir implementation based on the reservoir type
 *
 * @return The {@link Reservoir} implementation
 */
private Reservoir getReservoir() {
    // The Reservoir implementation is selected using a switch statement.
    // The ReservoirType enum is a part of YAML configuration
    // and foreign imports are not supported by Carbon Configuration Maven Plugin.
    // Therefore, the Reservoir class cannot be imported and the Reservoir
    // creation logic cannot be written inside ReservoirType enum.
    switch (reservoirType) {
        case EXPONENTIALLY_DECAYING:
            return new ExponentiallyDecayingReservoir();
        case UNIFORM:
            return new UniformReservoir(reservoirParametersConfig.getSize());
        case SLIDING_WINDOW:
            return new SlidingWindowReservoir(reservoirParametersConfig.getSize());
        case SLIDING_TIME_WINDOW:
            return new SlidingTimeWindowReservoir(reservoirParametersConfig.getWindow(),
                    reservoirParametersConfig.getWindowUnit());
        case HDR_HISTOGRAM:
            Recorder recorder = new Recorder(reservoirParametersConfig.getNumberOfSignificantValueDigits());
            if (reservoirParametersConfig.isResetOnSnapshot()) {
                return new HdrHistogramResetOnSnapshotReservoir(recorder);
            } else {
                return new HdrHistogramReservoir(recorder);
            }
        default:
            throw new RuntimeException("Invalid Reservoir Type");

    }
}
 

import org.HdrHistogram.Recorder; //导入依赖的package包/类
/**
 * Create a reservoir with a user-specified recorder.
 *
 * @param recorder {@link Recorder} to use
 */
public HdrHistogramReservoir(Recorder recorder) {
    this.recorder = recorder;
    // Get Interval Histogram and keep the reference to reuse later when taking a snapshot
    intervalHistogram = recorder.getIntervalHistogram();
    histogram = new Histogram(intervalHistogram.getNumberOfSignificantValueDigits());
}
 

import org.HdrHistogram.Recorder; //导入依赖的package包/类
private Recorder buildRecorder() {
    if (lowestDiscernibleValue.isPresent()) {
        return new Recorder(lowestDiscernibleValue.get(), highestTrackableValue.get(), numberOfSignificantValueDigits);
    }
    if (highestTrackableValue.isPresent()) {
        return new Recorder(highestTrackableValue.get(), numberOfSignificantValueDigits);
    }
    return new Recorder(numberOfSignificantValueDigits);
}
 

import org.HdrHistogram.Recorder; //导入依赖的package包/类
/**
 * Create a reservoir with a default recorder.
 */
public HdrHistogramResetOnSnapshotReservoir() {
    this(new Recorder(2));
}
 

import org.HdrHistogram.Recorder; //导入依赖的package包/类
public ResetOnSnapshotAccumulator(Recorder recorder) {
    this.recorder = recorder;
    this.intervalHistogram = recorder.getIntervalHistogram();
}
 

import org.HdrHistogram.Recorder; //导入依赖的package包/类
Phase(Supplier<Recorder> recorderSupplier, long proposedInvalidationTimestamp) {
    this.recorder = recorderSupplier.get();
    this.intervalHistogram = recorder.getIntervalHistogram();
    this.totalsHistogram = intervalHistogram.copy();
    this.proposedInvalidationTimestamp = proposedInvalidationTimestamp;
}
 

import org.HdrHistogram.Recorder; //导入依赖的package包/类
public UniformAccumulator(Recorder recorder) {
    this.recorder = recorder;
    this.intervalHistogram = recorder.getIntervalHistogram();
    this.uniformHistogram = HistogramUtil.createNonConcurrentCopy(intervalHistogram);
}
 

import org.HdrHistogram.Recorder; //导入依赖的package包/类
public Recorder getRecorder() {
    return recorder;
}
 

import org.HdrHistogram.Recorder; //导入依赖的package包/类
private static long getProbeTotalCount(String probeName, TestContainer container) {
    Map<String, Probe> probeMap = container.getProbeMap();
    HdrProbe probe = (HdrProbe) probeMap.get(probeName);
    Recorder recorder = probe.getRecorder();
    return recorder.getIntervalHistogram().getTotalCount();
}
 

import org.HdrHistogram.Recorder; //导入依赖的package包/类
Accumulator createAccumulator(Supplier<Recorder> recorderSupplier, com.github.rollingmetrics.util.Clock clock);