public AggregationResult(EntityMetadata metadata, AggregationConfig config, int keyIndex)
{
_metadata = metadata;
_config = config;
_keyIndex = keyIndex;
_aggregators = config.Aggregators.Select(c => c.CreateAggregator()).ToArray();
_groupResults = keyIndex < metadata.KeyCount ? new ConcurrentDictionary<int, AggregationResult>() : null;
}
private static void Dump(IAggregationResult result, EntityMetadata metadata, AggregationConfig config, string filepath)
{
using (var writer = new StreamWriter(File.Create(filepath))) {
writer.Write(String.Join("", Enumerable.Range(0, metadata.KeyCount).Select(i => "Key" + i + ",")));
writer.WriteLine(String.Join(",", config.Aggregators.Select(a => "\"" + a.Name + "\"")));
var keys = new int[metadata.KeyCount];
Dump(writer, result, config, keys, 0);
}
}
private static void Dump(EntitySet set, EntityMetadata metadata, string filepath)
{
using (var writer = new StreamWriter(File.Create(filepath))) {
writer.Write(String.Join("", Enumerable.Range(0, metadata.KeyCount).Select(i => "Key" + i + ",")));
writer.WriteLine(String.Join(",", metadata.Properties.Select(p => p.Name)));
foreach (var entity in set) {
// ReSharper disable AccessToForEachVariableInClosure
writer.Write(String.Join("", Enumerable.Range(0, metadata.KeyCount).Select(i => entity.GetKey(i) + ",")));
writer.WriteLine(String.Join(",", metadata.Properties.Select(p => entity.Get(p).ToString(""))));
// ReSharper restore AccessToForEachVariableInClosure
}
}
}
public AggregationConfigTest()
{
var metadata = new EntityMetadata(1, 3);
_property0 = metadata.Properties[0];
_property1 = metadata.Properties[1];
_property2 = metadata.Properties[2];
_aggregatorConfig0 = new WgtAvgPropertyAggregatorConfig(0, _property0, _property1);
_aggregatorConfig1 = new WgtAvgPropertyAggregatorConfig(1, _property1, _property2);
_aggregatorConfig2 = new WgtAvgPropertyAggregatorConfig(2, _property0, _property2);
_config = new AggregationConfig(metadata, new[] { _aggregatorConfig0, _aggregatorConfig1, _aggregatorConfig2 });
}
public AggregationResult(EntityMetadata metadata, AggregationConfig config, int keyIndex)
{
_metadata = metadata;
_config = config;
_keyIndex = keyIndex;
_aggregators = config.Aggregators.Select(c => c.CreateAggregator()).ToArray();
_groupResults = keyIndex < metadata.KeyCount ? new ConcurrentDictionary<int, AggregationResult>() : null;
_cts = new CancellationTokenSource();
var executionOptions = new ExecutionDataflowBlockOptions {
CancellationToken = _cts.Token,
SingleProducerConstrained = true
};
_changeBlock = new ActionBlock<AggregationChange>((Action<AggregationChange>)ProcessChange, executionOptions);
}
// ReSharper restore FunctionNeverReturns
private static AggregationConfig CreateAggregationConfig(EntityMetadata metadata)
{
var aggregators = new List<PropertyAggregatorConfig>();
foreach (var property in metadata.Properties) {
aggregators.Add(new SumPropertyAggregatorConfig(aggregators.Count, property));
aggregators.Add(new AvgPropertyAggregatorConfig(aggregators.Count, property));
}
foreach (var valueProperty in metadata.Properties) {
foreach (var weightProperty in metadata.Properties) {
if (valueProperty == weightProperty) continue;
aggregators.Add(new WgtAvgPropertyAggregatorConfig(aggregators.Count, valueProperty, weightProperty));
}
}
return new AggregationConfig(metadata, aggregators);
}
public AggregationConfig(EntityMetadata metadata, IEnumerable<PropertyAggregatorConfig> aggregators)
{
var aggregatorList = aggregators.ToList();
for (var i = 0; i < aggregatorList.Count; i++) {
Debug.Assert(aggregatorList[i].Index == i);
}
_aggregatorsUpdateWith = new ReadOnlyCollection<PropertyAggregatorConfig>[metadata.Properties.Count];
var aggregatorsGroupByProperty = aggregatorList
.SelectMany(a => a.Properties.Select(p => Tuple.Create(p, a)))
.GroupBy(t => t.Item1);
foreach (var g in aggregatorsGroupByProperty) {
var property = g.Key;
Debug.Assert(metadata.Properties.Contains(property));
_aggregatorsUpdateWith[property.Index] = new ReadOnlyCollection<PropertyAggregatorConfig>(g.Select(t => t.Item2).ToList());
}
_aggregators = new ReadOnlyCollection<PropertyAggregatorConfig>(aggregatorList);
}
public IAggregationRoot Aggregate(EntitySet set, AggregationConfig config, EntityMetadata metadata)
{
return new AggregationRoot(set, config, metadata);
}
static void Main(string[] args)
{
if (args.Length < 6) {
Console.WriteLine("Usage:\tBenchmark.exe <s or p> <key number> <key size> <property number> <entity number> <iteration> <seed>");
Console.WriteLine("Sample:\tBenchmark.exe s 5 3 10 100000 100 231347");
return;
}
var isParallel = args[0] == "p";
var keyCount = Int32.Parse(args[1]);
var keySize = Int32.Parse(args[2]);
var propertyCount = Int32.Parse(args[3]);
var entityCount = Int32.Parse(args[4]);
var iteration = Int32.Parse(args[5]);
var seed = args.Length < 7 ? DateTime.Now.Millisecond : Int32.Parse(args[6]);
Console.WriteLine("Parallel: " + isParallel);
Console.WriteLine("Key number: " + keyCount);
Console.WriteLine("Key size: " + keySize);
Console.WriteLine("Property number: " + propertyCount);
Console.WriteLine("Entity number: " + entityCount);
Console.WriteLine("Iteration: " + iteration);
Console.WriteLine("Seed: " + seed);
Console.WriteLine();
var random = new Random(seed);
var metadata = new EntityMetadata(keyCount, propertyCount);
var config = CreateAggregationConfig(metadata);
var set = new EntitySet();
foreach (var keys in InfiniteKeys(keyCount, keySize).Take(entityCount)) {
set.Add(metadata.CreateEntity(keys));
}
Console.Write("Preparing...");
var watch = new Stopwatch();
watch.Start();
var service = isParallel ? (IAggregationService)new ParallelAggregationService() : new SerialAggregationService();
var root = service.Aggregate(set, config, metadata);
root.Start();
Console.WriteLine("Done");
PrintMessage(iteration, 0);
for (var i = 0; i < iteration; i++) {
var num = 0;
foreach (var entity in set) {
foreach (var property in metadata.Properties) {
entity.Set(property, (decimal)(random.NextDouble() * 1000000));
}
if (++num % 1000 == 0) {
PrintMessage(iteration, i + num * 1.0 / entityCount);
}
}
PrintMessage(iteration, i + 1);
}
Console.WriteLine();
Console.WriteLine("Waiting for completion.");
while (root.Running) {
Thread.Sleep(100);
}
Console.WriteLine("Time: " + watch.Elapsed);
var postfix = DateTime.Now.ToString("yyyyMMdd-HHmmss");
Dump(set, metadata, "Source-" + postfix + ".csv");
Dump(root.Result, metadata, config, "Result-" + postfix + ".csv");
}
public AggregationRoot(EntitySet set, AggregationConfig config, EntityMetadata metadata)
: base(set, config)
{
_result = new AggregationResult(metadata, config, 0);
}
