static void Main(string[] args)
{
ThreadPool.SetMaxThreads(maxThreads, maxThreads);
Console.WriteLine("Generating input distribution...");
samples = new int[sampleCount];
Zipf.Samples(samples, s, n);
int[] threadCount = Enumerable.Range(1, maxThreads).ToArray();
// Desired output:
// Class 1 2 3 4 5
// Classic 5 6 7 7 8
// Concurrent 5 6 7 7 8
DataTable resultTable = new DataTable();
resultTable.Clear();
resultTable.Columns.Add("Class");
foreach (var tc in threadCount)
{
resultTable.Columns.Add(tc.ToString());
}
DataRow concurrentLru = resultTable.NewRow();
DataRow classicLru = resultTable.NewRow();
concurrentLru["Class"] = "concurrentLru";
classicLru["Class"] = "classicLru";
foreach (int tc in threadCount)
{
const int warmup = 3;
const int runs = 6;
double[] results = new double[warmup + runs];
for (int i = 0; i < warmup + runs; i++)
{
results[i] = MeasureThroughput(new ConcurrentLru <int, int>(tc, capacity, EqualityComparer <int> .Default), tc);
}
double avg = AverageLast(results, runs) / 1000000;
Console.WriteLine($"ConcurrLru ({tc}) {avg} million ops/sec");
concurrentLru[tc.ToString()] = avg.ToString();
for (int i = 0; i < warmup + runs; i++)
{
results[i] = MeasureThroughput(new ClassicLru <int, int>(tc, capacity, EqualityComparer <int> .Default), tc);
}
avg = AverageLast(results, runs) / 1000000;
Console.WriteLine($"ClassicLru ({tc}) {avg} million ops/sec");
classicLru[tc.ToString()] = avg.ToString();
}
resultTable.Rows.Add(concurrentLru);
resultTable.Rows.Add(classicLru);
ExportCsv(resultTable);
Console.WriteLine("Done.");
}
public void Setup()
{
_newCache = new MassTransitCache <Guid, Item, CacheValue <Item> >(new UsageCachePolicy <Item>(), new CacheOptions {
Capacity = 1000
});
_samples = new int[SampleCount];
Zipf.Samples(_samples, S, N);
}
public void CanSampleSequence()
{
var d = new Zipf(0.7, 5);
var ied = d.Samples();
var e = ied.Take(1000).ToArray();
foreach (var i in e)
{
Assert.LessOrEqual(i, 5);
Assert.GreaterOrEqual(i, 0);
}
}
public void CanSampleSequence()
{
var d = new Zipf(0.7, 5);
var ied = d.Samples();
var e = ied.Take(1000).ToArray();
foreach (var i in e)
{
Assert.Between(i, 0, 5);
}
}
public void Setup()
{
_massTransitCache = new MassTransitCache <Guid, Item, ITimeToLiveCacheValue <Item> >(new TimeToLiveCachePolicy <Item>(TimeSpan.FromSeconds(30)),
new CacheOptions {
Capacity = 1000
});
_samples = new int[SampleCount];
Zipf.Samples(_samples, S, N);
}
public void CanSampleSequence()
{
var d = new Zipf(0.7, 5);
var ied = d.Samples();
var e = ied.Take(1000).ToArray();
foreach (var i in e)
{
Assert.LessOrEqual(i, 5);
Assert.GreaterOrEqual(i, 0);
}
}
public void GlobalSetup()
{
samples = new int[sampleCount];
Zipf.Samples(samples, s, n);
}
static void Main(string[] args)
{
double[] sValues = { 0.5, 0.86 };
// % of total number of items
double[] cacheSizes = { 0.0125, 0.025, 0.05, 0.075, 0.1, 0.125, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4 };
List <Analysis> analysis = new List <Analysis>();
foreach (var sValue in sValues)
{
foreach (var cacheSize in cacheSizes)
{
analysis.Add(new Analysis {
N = n,
s = sValue,
Samples = sampleCount,
CacheSizePercent = cacheSize
});
}
}
int[][] zipdfDistribution = new int[sValues.Length][];
for (int i = 0; i < sValues.Length; i++)
{
Console.WriteLine($"Generating Zipfan distribution with {sampleCount} samples, s = {sValues[i]}, N = {n}");
var sw = Stopwatch.StartNew();
zipdfDistribution[i] = new int[sampleCount];
Zipf.Samples(zipdfDistribution[i], sValues[i], n);
Console.WriteLine($"Took {sw.Elapsed}.");
}
List <AnalysisResult> results = new List <AnalysisResult>();
Func <int, int> func = x => x;
foreach (var a in analysis)
{
a.WriteSummaryToConsole();
int cacheSize = (int)(a.N * a.CacheSizePercent);
var concurrentLru = new ConcurrentLru <int, int>(1, cacheSize, EqualityComparer <int> .Default);
var classicLru = new ClassicLru <int, int>(1, cacheSize, EqualityComparer <int> .Default);
var concurrentLruScan = new ConcurrentLru <int, int>(1, cacheSize, EqualityComparer <int> .Default);
var classicLruScan = new ClassicLru <int, int>(1, cacheSize, EqualityComparer <int> .Default);
var d = a.s == 0.5 ? 0 : 1;
var lruSw = Stopwatch.StartNew();
for (int i = 0; i < sampleCount; i++)
{
concurrentLru.GetOrAdd(zipdfDistribution[d][i], func);
}
lruSw.Stop();
Console.WriteLine($"concurrentLru size={cacheSize} took {lruSw.Elapsed}.");
var clruSw = Stopwatch.StartNew();
for (int i = 0; i < sampleCount; i++)
{
classicLru.GetOrAdd(zipdfDistribution[d][i], func);
}
clruSw.Stop();
Console.WriteLine($"classic lru size={cacheSize} took {clruSw.Elapsed}.");
var lruSwScan = Stopwatch.StartNew();
for (int i = 0; i < sampleCount; i++)
{
concurrentLruScan.GetOrAdd(zipdfDistribution[d][i], func);
concurrentLruScan.GetOrAdd(i % n, func);
}
lruSwScan.Stop();
Console.WriteLine($"concurrentLruScan lru size={cacheSize} took {lruSwScan.Elapsed}.");
var clruSwScan = Stopwatch.StartNew();
for (int i = 0; i < sampleCount; i++)
{
classicLruScan.GetOrAdd(zipdfDistribution[d][i], func);
classicLruScan.GetOrAdd(i % n, func);
}
clruSwScan.Stop();
Console.WriteLine($"classicLruScan lru size={cacheSize} took {clruSwScan.Elapsed}.");
results.Add(new AnalysisResult
{
Cache = "ClassicLru",
N = a.N,
s = a.s,
CacheSizePercent = a.CacheSizePercent * 100.0,
Samples = a.Samples,
IsScan = false,
HitRatio = classicLru.HitRatio * 100.0,
Duration = clruSw.Elapsed,
});
results.Add(new AnalysisResult
{
Cache = "ConcurrentLru",
N = a.N,
s = a.s,
CacheSizePercent = a.CacheSizePercent * 100.0,
Samples = a.Samples,
IsScan = false,
HitRatio = concurrentLru.HitRatio * 100.0,
Duration = lruSw.Elapsed,
});
results.Add(new AnalysisResult
{
Cache = "ClassicLru",
N = a.N,
s = a.s,
CacheSizePercent = a.CacheSizePercent * 100.0,
Samples = a.Samples,
IsScan = true,
HitRatio = classicLruScan.HitRatio * 100.0,
Duration = clruSwScan.Elapsed,
});
results.Add(new AnalysisResult
{
Cache = "ConcurrentLru",
N = a.N,
s = a.s,
CacheSizePercent = a.CacheSizePercent * 100.0,
Samples = a.Samples,
IsScan = true,
HitRatio = concurrentLruScan.HitRatio * 100.0,
Duration = lruSwScan.Elapsed,
});
}
AnalysisResult.WriteToConsole(results);
AnalysisResult.WriteToFile("results.csv", results);
Console.ReadLine();
}
/// <summary>
/// Run example
/// </summary>
/// <a href="http://en.wikipedia.org/wiki/Zipf_distribution">Zipf distribution</a>
public void Run()
{
// 1. Initialize the new instance of the Zipf distribution class with parameters S = 5, N = 10
var zipf = new Zipf(5, 10);
Console.WriteLine(@"1. Initialize the new instance of the Zipf distribution class with parameters S = {0}, N = {1}", zipf.S, zipf.N);
Console.WriteLine();
// 2. Distributuion properties:
Console.WriteLine(@"2. {0} distributuion properties:", zipf);
// Cumulative distribution function
Console.WriteLine(@"{0} - Сumulative distribution at location '3'", zipf.CumulativeDistribution(3).ToString(" #0.00000;-#0.00000"));
// Probability density
Console.WriteLine(@"{0} - Probability mass at location '3'", zipf.Probability(3).ToString(" #0.00000;-#0.00000"));
// Log probability density
Console.WriteLine(@"{0} - Log probability mass at location '3'", zipf.ProbabilityLn(3).ToString(" #0.00000;-#0.00000"));
// Entropy
Console.WriteLine(@"{0} - Entropy", zipf.Entropy.ToString(" #0.00000;-#0.00000"));
// Largest element in the domain
Console.WriteLine(@"{0} - Largest element in the domain", zipf.Maximum.ToString(" #0.00000;-#0.00000"));
// Smallest element in the domain
Console.WriteLine(@"{0} - Smallest element in the domain", zipf.Minimum.ToString(" #0.00000;-#0.00000"));
// Mean
Console.WriteLine(@"{0} - Mean", zipf.Mean.ToString(" #0.00000;-#0.00000"));
// Mode
Console.WriteLine(@"{0} - Mode", zipf.Mode.ToString(" #0.00000;-#0.00000"));
// Variance
Console.WriteLine(@"{0} - Variance", zipf.Variance.ToString(" #0.00000;-#0.00000"));
// Standard deviation
Console.WriteLine(@"{0} - Standard deviation", zipf.StdDev.ToString(" #0.00000;-#0.00000"));
// Skewness
Console.WriteLine(@"{0} - Skewness", zipf.Skewness.ToString(" #0.00000;-#0.00000"));
Console.WriteLine();
// 3. Generate 10 samples of the Zipf distribution
Console.WriteLine(@"3. Generate 10 samples of the Zipf distribution");
for (var i = 0; i < 10; i++)
{
Console.Write(zipf.Sample().ToString("N05") + @" ");
}
Console.WriteLine();
Console.WriteLine();
// 4. Generate 100000 samples of the Zipf(5, 10) distribution and display histogram
Console.WriteLine(@"4. Generate 100000 samples of the Zipf(5, 10) distribution and display histogram");
var data = new int[100000];
Zipf.Samples(data, 5, 10);
ConsoleHelper.DisplayHistogram(data);
Console.WriteLine();
// 5. Generate 100000 samples of the Zipf(2, 10) distribution and display histogram
Console.WriteLine(@"5. Generate 100000 samples of the Zipf(2, 10) distribution and display histogram");
Zipf.Samples(data, 2, 10);
ConsoleHelper.DisplayHistogram(data);
Console.WriteLine();
// 6. Generate 100000 samples of the Zipf(5, 20) distribution and display histogram
Console.WriteLine(@"6. Generate 100000 samples of the Zipf(1, 20) distribution and display histogram");
Zipf.Samples(data, 1, 20);
ConsoleHelper.DisplayHistogram(data);
}
