internal void Init(LabelValues labelValues, SummaryConfiguration configuration, DateTime now)
{
base.Init(labelValues, configuration);
_sortedObjectives = new double[Configuration.Objectives.Count];
_buffer = new SampleBuffer(Configuration.BufCap);
_streamDuration = new TimeSpan(Configuration.MaxAge.Ticks / Configuration.AgeBuckets);
_headStreamExpTime = now.Add(_streamDuration);
_bufferExpTime = _headStreamExpTime;
_streams = new QuantileStream[Configuration.AgeBuckets];
for (int i = 0; i < Configuration.AgeBuckets; i++)
{
_streams[i] = QuantileStream.NewTargeted(Configuration.Objectives);
}
_headStream = _streams[0];
for (int i = 0; i < Configuration.Objectives.Count; i++)
{
_sortedObjectives[i] = Configuration.Objectives[i].Quantile;
}
Array.Sort(_sortedObjectives);
}
private void VerifyPercsWithAbsoluteEpsilon(double[] a, QuantileStream s)
{
Array.Sort(a);
foreach (var target in _targets)
{
double n = a.Length;
int k = (int)(target.Quantile * n);
int lower = (int)((target.Quantile - target.Epsilon) * n);
if (lower < 1)
{
lower = 1;
}
int upper = (int)Math.Ceiling((target.Quantile + target.Epsilon) * n);
if (upper > a.Length)
{
upper = a.Length;
}
double w = a[k - 1];
double min = a[lower - 1];
double max = a[upper - 1];
double g = s.Query(target.Quantile);
Assert.True(g >= min, $"q={target.Quantile}: want {w} [{min}, {max}], got {g}");
Assert.True(g <= max, $"q={target.Quantile}: want {w} [{min}, {max}], got {g}");
}
}
void VerifyPercsWithAbsoluteEpsilon(double[] a, QuantileStream s)
{
Array.Sort(a);
foreach (var target in _targets)
{
var n = (double)a.Length;
var k = (int)(target.Quantile * n);
var lower = (int)((target.Quantile - target.Epsilon) * n);
if (lower < 1)
{
lower = 1;
}
var upper = (int)Math.Ceiling((target.Quantile + target.Epsilon) * n);
if (upper > a.Length)
{
upper = a.Length;
}
var w = a[k - 1];
var min = a[lower - 1];
var max = a[upper - 1];
var g = s.Query(target.Quantile);
// Assert.That(g, Is.GreaterThanOrEqualTo(min), $"q={target.Quantile}: want {w} [{min}, {max}], got {g}");
Assert.True(g >= min, $"q={target.Quantile}: want {w} [{min}, {max}], got {g}");
// Assert.That(g, Is.LessThanOrEqualTo(max), $"q={target.Quantile}: want {w} [{min}, {max}], got {g}");
Assert.True(g <= max, $"q={target.Quantile}: want {w} [{min}, {max}], got {g}");
}
}
public void TestTargetedQuery()
{
var random = new Random(42);
var s = QuantileStream.NewTargeted(_targets);
var a = PopulateStream(s, random);
VerifyPercsWithAbsoluteEpsilon(a, s);
}
public void TestHighBiasedQuery()
{
var random = new Random(42);
var s = QuantileStream.NewHighBiased(RelativeEpsilon);
var a = PopulateStream(s, random);
VerifyHighPercsWithRelativeEpsilon(a, s);
}
public void TestDefaults()
{
var q = QuantileStream.NewTargeted(new List <QuantileEpsilonPair> {
new QuantileEpsilonPair(0.99d, 0.001d)
});
var g = q.Query(0.99);
Assert.Equal(0, g);
}
public void TestUncompressedOne()
{
var q = QuantileStream.NewTargeted(new List <QuantileEpsilonPair> {
new QuantileEpsilonPair(0.99d, 0.001d)
});
q.Insert(3.14);
var g = q.Query(0.90);
Assert.Equal(3.14, g);
}
public Summary(SummaryConfiguration configuration, IReadOnlyList <string> labels, Func <DateTimeOffset> currentTimeProvider = null)
: base(configuration, labels, currentTimeProvider)
{
var streamDuration = new TimeSpan(Configuration.MaxAge.Ticks / Configuration.AgeBuckets);
_quantileStream = new QuantileStream(
Configuration.BufCap,
streamDuration,
configuration.AgeBuckets,
Invariants.Targeted(Configuration.Objectives),
currentTimeProvider);
}
public void TestUncompressedSamples()
{
var q = QuantileStream.NewTargeted(new List <QuantileEpsilonPair> {
new QuantileEpsilonPair(0.99d, 0.001d)
});
for (var i = 1; i <= 100; i++)
{
q.Insert(i);
}
Assert.Equal(100, q.SamplesCount);
}
public Summary(SummaryConfiguration configuration, IReadOnlyList <string> labels, Func <DateTimeOffset> currentTimeProvider = null)
: base(configuration, labels, currentTimeProvider)
{
_buffer = new SampleBuffer(Configuration.BufCap);
_streamDuration = new TimeSpan(Configuration.MaxAge.Ticks / Configuration.AgeBuckets);
_headStreamExpTime = CurrentTimeProvider().Add(_streamDuration);
_bufferExpTime = _headStreamExpTime;
_streams = new QuantileStream[Configuration.AgeBuckets];
for (int i = 0; i < Configuration.AgeBuckets; i++)
{
_streams[i] = QuantileStream.NewTargeted(Configuration.Objectives);
}
_headStream = _streams[0];
}
// MaybeRotateStreams needs mtx AND bufMtx locked.
private void MaybeRotateStreams()
{
while (!_bufferExpTime.Equals(_headStreamExpTime))
{
_headStream.Reset();
_headStreamIdx++;
if (_headStreamIdx >= _streams.Length)
{
_headStreamIdx = 0;
}
_headStream = _streams[_headStreamIdx];
_headStreamExpTime = _headStreamExpTime.Add(_streamDuration);
}
}
internal void Init(ICollector parent, LabelValues labelValues, DateTime now)
{
base.Init(parent, labelValues);
_objectives = ((Summary)parent)._objectives;
_maxAge = ((Summary)parent)._maxAge;
_ageBuckets = ((Summary)parent)._ageBuckets;
_bufCap = ((Summary)parent)._bufCap;
_sortedObjectives = new double[_objectives.Count];
_hotBuf = new SampleBuffer(_bufCap);
_coldBuf = new SampleBuffer(_bufCap);
_streamDuration = new TimeSpan(_maxAge.Ticks / _ageBuckets);
_headStreamExpTime = now.Add(_streamDuration);
_hotBufExpTime = _headStreamExpTime;
_streams = new QuantileStream[_ageBuckets];
for (var i = 0; i < _ageBuckets; i++)
{
_streams[i] = QuantileStream.NewTargeted(_objectives);
}
_headStream = _streams[0];
for (var i = 0; i < _objectives.Count; i++)
{
_sortedObjectives[i] = _objectives[i].Quantile;
}
Array.Sort(_sortedObjectives);
_wireMetric = new CSummary {
Quantiles = new CQuantile[_objectives.Count]
};
for (int i = 0; i < _objectives.Count; i++)
{
_wireMetric.Quantiles[i] = new CQuantile
{
Quantile = _objectives[i].Quantile
}
}
;
}
public void TestUncompressed()
{
var q = QuantileStream.NewTargeted(_targets);
for (var i = 100; i > 0; i--)
{
q.Insert(i);
}
Assert.Equal(100, q.Count);
// Before compression, Query should have 100% accuracy
foreach (var quantile in _targets.Select(_ => _.Quantile))
{
var w = quantile * 100;
var g = q.Query(quantile);
Assert.Equal(g, w);
}
}
static double[] PopulateStream(QuantileStream stream, Random random)
{
var a = new double[100100];
for (int i = 0; i < a.Length; i++)
{
var v = random.NormDouble();
// Add 5% asymmetric outliers.
if (i % 20 == 0)
{
v = v * v + 1;
}
stream.Insert(v);
a[i] = v;
}
return(a);
}
internal Child(Summary parent, Labels labels, bool publish)
: base(parent, labels, publish)
{
_objectives = parent._objectives;
_maxAge = parent._maxAge;
_ageBuckets = parent._ageBuckets;
_bufCap = parent._bufCap;
_sortedObjectives = new double[_objectives.Count];
_hotBuf = new SampleBuffer(_bufCap);
_coldBuf = new SampleBuffer(_bufCap);
_streamDuration = new TimeSpan(_maxAge.Ticks / _ageBuckets);
_headStreamExpTime = DateTime.Now.Add(_streamDuration);
_hotBufExpTime = _headStreamExpTime;
_streams = new QuantileStream[_ageBuckets];
for (var i = 0; i < _ageBuckets; i++)
{
_streams[i] = QuantileStream.NewTargeted(_objectives);
}
_headStream = _streams[0];
for (var i = 0; i < _objectives.Count; i++)
{
_sortedObjectives[i] = _objectives[i].Quantile;
}
Array.Sort(_sortedObjectives);
_sumIdentifier = CreateIdentifier("sum");
_countIdentifier = CreateIdentifier("count");
_quantileIdentifiers = new byte[_objectives.Count][];
for (var i = 0; i < _objectives.Count; i++)
{
var value = double.IsPositiveInfinity(_objectives[i].Quantile) ? "+Inf" : _objectives[i].Quantile.ToString(CultureInfo.InvariantCulture);
_quantileIdentifiers[i] = CreateIdentifier(null, ("quantile", value));
}
}
private void VerifyHighPercsWithRelativeEpsilon(double[] a, QuantileStream s)
{
Array.Sort(a);
foreach (double qu in _highQuantiles)
{
double n = a.Length;
int k = (int)(qu * n);
int lowerRank = (int)((1 - ((1 + _relativeEpsilon) * (1 - qu))) * n);
int upperRank = (int)Math.Ceiling((1 - ((1 - _relativeEpsilon) * (1 - qu))) * n);
double w = a[k - 1];
double min = a[lowerRank - 1];
double max = a[upperRank - 1];
double g = s.Query(qu);
Assert.True(g >= min, $"q={qu}: want {w} [{min}, {max}], got {g}");
Assert.True(g <= max, $"q={qu}: want {w} [{min}, {max}], got {g}");
}
}
void VerifyHighPercsWithRelativeEpsilon(double[] a, QuantileStream s)
{
Array.Sort(a);
foreach (var qu in _highQuantiles)
{
var n = (double)a.Length;
var k = (int)(qu * n);
var lowerRank = (int)((1 - (1 + RelativeEpsilon) * (1 - qu)) * n);
var upperRank = (int)(Math.Ceiling((1 - (1 - RelativeEpsilon) * (1 - qu)) * n));
var w = a[k - 1];
var min = a[lowerRank - 1];
var max = a[upperRank - 1];
var g = s.Query(qu);
Assert.IsTrue(g >= min, $"q={qu}: want {w} [{min}, {max}], got {g}");
Assert.IsTrue(g <= max, $"q={qu}: want {w} [{min}, {max}], got {g}");
}
}
void VerifyLowPercsWithRelativeEpsilon(double[] a, QuantileStream s)
{
Array.Sort(a);
foreach (var qu in _lowQuantiles)
{
var n = (double)a.Length;
var k = (int)(qu * n);
var lowerRank = (int)((1 - RelativeEpsilon) * qu * n);
var upperRank = (int)(Math.Ceiling((1 + RelativeEpsilon) * qu * n));
var w = a[k - 1];
var min = a[lowerRank - 1];
var max = a[upperRank - 1];
var g = s.Query(qu);
Assert.That(g, Is.GreaterThanOrEqualTo(min), $"q={qu}: want {w} [{min}, {max}], got {g}");
Assert.That(g, Is.LessThanOrEqualTo(max), $"q={qu}: want {w} [{min}, {max}], got {g}");
}
}
