private async Task <List <Task> > ResolvePending(List <Task> pending, IndexingReport report, bool all = false)
{
try
{
await(all ? Task.WhenAll(pending) : Task.WhenAny(pending));
}
catch (Exception) { }
List <Task> remaining = new List <Task>();
foreach (Task t in pending)
{
if (t.IsFaulted || t.IsCanceled)
{
report.Failed++;
}
else if (t.IsCompleted)
{
report.Succeeded++;
}
else
{
remaining.Add(t);
}
}
return(remaining);
}
public async Task <IndexingReport> RunAsync(int run, int grainsPerRunner, int concurrentPerRun)
{
var load = this.host.Client.GetGrain <IIndexingLoadGrain <TGrainInterface> >(Guid.NewGuid());
await load.Generate(run, grainsPerRunner, this.indexingParams.NumProperties, concurrentPerRun);
IndexingReport report = null;
while (report == null)
{
await Task.Delay(TimeSpan.FromSeconds(10));
report = await load.TryGetReport();
}
return(report);
}
private async Task FullRunAsync()
{
int runners = Math.Max(1, (int)Math.Sqrt(this.indexingParams.NumConcurrentGrains));
int grainsPerRunner = Math.Max(1, this.indexingParams.NumGrains / runners);
IndexingReport[] reports = await Task.WhenAll(Enumerable.Range(0, runners).Select(i => RunAsync(i, grainsPerRunner, runners)));
var finalReport = new IndexingReport();
foreach (var report in reports)
{
finalReport.Succeeded += report.Succeeded;
finalReport.Failed += report.Failed;
finalReport.Elapsed = TimeSpan.FromMilliseconds(Math.Max(finalReport.Elapsed.TotalMilliseconds, report.Elapsed.TotalMilliseconds));
}
Console.WriteLine($"{finalReport.Succeeded} grains" +
$" ({this.indexingParams.NumProperties} indexed propert{(this.indexingParams.NumProperties == 1 ? "y" : "ies")} per grain)" +
$" in {finalReport.Elapsed.TotalMilliseconds}ms.");
Console.WriteLine($"{(int)(finalReport.Succeeded * 1000 / finalReport.Elapsed.TotalMilliseconds)} grains per second.");
Console.WriteLine(finalReport.Failed > 0 ? $"{finalReport.Failed} grains failed!!" : "All grains succeeded.");
}
private async Task <IndexingReport> RunGeneration(int run, int numGrainsPerRunner, int numPropertiesPerGrain, int concurrentGrainsPerRun)
{
var pending = new List <Task>();
var report = new IndexingReport();
var sw = Stopwatch.StartNew();
var generated = run * numGrainsPerRunner; // For producing grain IDs as well as loop variables
var max = generated + numGrainsPerRunner;
while (generated < max)
{
while (generated < max && pending.Count < concurrentGrainsPerRun)
{
pending.Add(this.StartIndexingTasks(generated++, numPropertiesPerGrain));
}
pending = await this.ResolvePending(pending, report);
}
await this.ResolvePending(pending, report, true);
sw.Stop();
report.Elapsed = sw.Elapsed;
return(report);
}
