protected override void Init()
{
base.Init();
_taskScheduler = new Thread(AutoCheck)
{
IsBackground = true
};
_taskScheduler.Start();
_scaleOutTask = () =>
{
try
{
TryAddNewEntry(Config.ScaleFactor - 1);
_logger.Info("scaleOut success");
}
catch (Exception ex)
{
_logger.Error(ex, "scaleOut failed");
}
finally
{
Interlocked.CompareExchange(ref _scalingOut, 1, 0);
}
};
ThreadPool.IBuilder builder = ThreadPools.NewThreadPoolConfigBuilder();
builder.SetMinSize(1).SetMaxSize(1);
_taskExecutor = ThreadPools.NewThreadPool(builder.Build());
}
protected virtual IThreadPool NewThreadPool(int queueCapacity)
{
IBuilder Builder = ThreadPools.NewThreadPoolConfigBuilder();
Builder.SetMinSize(_minSize).SetMaxSize(_maxSize).SetQueueCapacity(queueCapacity);
return(ThreadPools.NewThreadPool(Builder.Build()));
}
protected override void Test(IQuantileEstimator <int> quantileEstimator, List <Double> quantiles, int count, int upperBound,
double errorRate, Func <int, int, List <int> > dataProvider)
{
int maxError = (int)(upperBound * errorRate);
List <int> items = dataProvider(count, upperBound);
int concurrency = 20;
IBuilder builder = ThreadPools.NewThreadPoolConfigBuilder();
using (IThreadPool threadPool = ThreadPools.NewThreadPool(builder.SetMaxSize(concurrency).SetMinSize(concurrency).Build()))
{
object @lock = new object();
CountdownEvent latch = new CountdownEvent(concurrency);
for (int i = 0; i < concurrency; i++)
{
threadPool.Submit(() =>
{
lock (@lock)
{
Monitor.Wait(@lock);
}
items.ForEach(item => quantileEstimator.Add(item));
quantileEstimator.Get(quantiles);
latch.Signal();
});
}
Thread.Sleep(1 * 1000);
lock (@lock)
{
Monitor.PulseAll(@lock);
}
latch.Wait();
}
Console.WriteLine("data: " + items);
Console.WriteLine();
items.Sort();
Console.WriteLine("sorted: " + items);
Console.WriteLine();
Dictionary <Double, int> quantileResults = new Dictionary <Double, int>();
foreach (Double quantile in quantiles)
{
int pos = (int)(count * quantile) - 1;
if (pos < 0)
{
pos = 0;
}
int item = items[pos];
quantileEstimator.Add(item);
quantileResults[quantile] = item;
}
Dictionary <Double, int> results = quantileEstimator.Get(quantiles);
for (int i = 0; i < quantiles.Count; i++)
{
Double quantile = quantiles[i];
int expected = quantileResults[quantile];
int actual = results[quantile];
int actualError = Math.Abs(actual - expected);
Console.WriteLine("quantile " + quantile + ", expected: " + expected + ", actual: " + actual + ", error: "
+ actualError);
Console.WriteLine();
Assert.True(actualError <= maxError);
}
}
