/*
Copyright (c) 2012 LinkedIn Corp.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
/**
* $Id: LongTracking.java 151859 2010-11-19 21:43:47Z slim $
*/
package com.linkedin.common.stats;
import java.util.Arrays;
import com.linkedin.common.util.ConfigHelper;
/**
* @author Swee Lim
* @version $Rev: 151859 $
*/
/**
* Maintain a collection of values and provide the count, average, standard deviation,
* minimum, maximum, percentile values for the collection.
*
* This class implementation is not synchronized. If concurrent access is required, it
* must be synchronized externally.
*/
public class LongTracking
{
private static final int DEFAULT_INITIAL_CAPACITY = 1000;
private static final double DEFAULT_GROWTH_FACTOR = 2.0;
private static final int DEFAULT_MAX_CAPACITY = 4000;
private long[] _buffer;
private int _bufferSize;
private final int _initialCapacity;
private final double _growthFactor;
private final int _maxCapacity;
private int _count;
private long _min;
private long _max;
private long _sum;
private long _sumOfSquares; // Running sum of squares
// for call times, used for
// std deviation.
private int _sortedEnd;
private int _nextIndex;
private int _keepRatio;
public LongTracking()
{
this(DEFAULT_MAX_CAPACITY, DEFAULT_INITIAL_CAPACITY, DEFAULT_GROWTH_FACTOR);
}
public LongTracking(final Config config)
{
this(config.getMaxCapacity(), config.getInitialCapacity(), config.getGrowthFactor());
}
public LongTracking(final int maxCapacity, int initialCapacity, double growthFactor)
{
if (initialCapacity > maxCapacity || initialCapacity <= 0)
{
initialCapacity = maxCapacity;
}
if (growthFactor <= 1.0)
{
growthFactor = DEFAULT_GROWTH_FACTOR;
}
_buffer = new long[initialCapacity];
_bufferSize = initialCapacity;
_initialCapacity = initialCapacity;
_growthFactor = growthFactor;
_maxCapacity = maxCapacity;
reset();
}
public void reset()
{
_count = 0;
_min = 0;
_max = 0;
_sum = 0;
_sumOfSquares = 0;
_sortedEnd = 0;
_nextIndex = 0;
_keepRatio = 1;
}
public void addValue(long value)
{
if (_count == 0)
{
_min = _max = value;
}
else if (value < _min)
{
_min = value;
}
else if (value > _max)
{
_max = value;
}
_sum += value;
_sumOfSquares += value * value;
_count++;
if (_keepRatio > 1 && (_count % _keepRatio) != 0)
{
return;
}
if (_nextIndex >= _bufferSize)
{
if (_bufferSize < _maxCapacity)
{
grow();
}
else
{
dropHalf();
}
}
_buffer[_nextIndex] = value;
_nextIndex++;
}
public int getBufferSize()
{
return _bufferSize;
}
public int getInitialCapacity()
{
return _initialCapacity;
}
public double getGrowthFactor()
{
return _growthFactor;
}
public int getMaxCapacity()
{
return _maxCapacity;
}
public LongStats getStats()
{
return new LongStats(getCount(), getAverage(), getStandardDeviation(),
getMinimum(), getMaximum(),
get50Pct(), get90Pct(), get95Pct(), get99Pct());
}
private int getCount()
{
return _count;
}
private double getAverage()
{
return safeDivide(_sum, _count);
}
private double getStandardDeviation()
{
double variation;
variation = safeDivide(_sumOfSquares - _sum * getAverage(), getCount());
return Math.sqrt(variation);
}
private long getMinimum()
{
return _min;
}
private long getMaximum()
{
return _max;
}
private long get50Pct()
{
return getPercentile(0.50);
}
private long get90Pct()
{
return getPercentile(0.90);
}
private long get95Pct()
{
return getPercentile(0.95);
}
private long get99Pct()
{
return getPercentile(0.99);
}
private long getPercentile(double pct)
{
if (_count == 0)
{
return 0;
}
if (_sortedEnd < _nextIndex)
{
Arrays.sort(_buffer, 0, _nextIndex);
_sortedEnd = _nextIndex;
}
if (pct < 0.0)
{
pct = 0;
}
else if (pct > 1.0)
{
pct = 1.0;
}
int index = (int) Math.round(pct * (_sortedEnd - 1));
return _buffer[index];
}
private void dropHalf()
{
_nextIndex = (_nextIndex + 1) / 2;
_sortedEnd = (_sortedEnd + 1) / 2;
_keepRatio += _keepRatio;
int destIndex = 1;
int lastSrcIndex = 0;
// copy half the sorted values by skipping alternate
while (destIndex < _nextIndex)
{
_buffer[destIndex++] = _buffer[lastSrcIndex += 2];
}
}
private void grow()
{
int newBufferSize = (int) (_bufferSize * _growthFactor);
if (newBufferSize == _bufferSize)
{
newBufferSize += DEFAULT_INITIAL_CAPACITY;
}
if (newBufferSize > _maxCapacity)
{
newBufferSize = _maxCapacity;
}
long[] newBuffer = new long[newBufferSize];
System.arraycopy(_buffer, 0, newBuffer, 0, _nextIndex);
_buffer = newBuffer;
_bufferSize = newBufferSize;
}
private static double safeDivide(final double numerator, final double denominator)
{
return denominator != 0 ? numerator / denominator : 0;
}
public static class Config
{
private Integer _maxCapacity = DEFAULT_MAX_CAPACITY;
private Integer _initialCapacity = DEFAULT_INITIAL_CAPACITY;
private Double _growthFactor = DEFAULT_GROWTH_FACTOR;
Config()
{
}
public int getMaxCapacity()
{
return ConfigHelper.getRequired(_maxCapacity);
}
public void setMaxCapacity(final int maxCapacity)
{
_maxCapacity = maxCapacity;
}
public int getInitialCapacity()
{
return ConfigHelper.getRequired(_initialCapacity);
}
public void setInitialCapacity(final int initialCapacity)
{
_initialCapacity = initialCapacity;
}
public double getGrowthFactor()
{
return ConfigHelper.getRequired(_growthFactor);
}
public void setGrowthFactor(final double growthFactor)
{
_growthFactor = growthFactor;
}
}
}