public async Task <IEnumerable <MethodDescriptor> > GetRootsAsync(AnalysisRootKind rootKind = AnalysisRootKind.Default)
{
if (this.rootMethods == null)
{
if (this.rootKind.HasValue)
{
rootKind = this.rootKind.Value;
}
var cancellationTokenSource = new CancellationTokenSource();
var result = new HashSet <MethodDescriptor>();
foreach (var project in this.Projects)
{
var provider = await this.GetProjectCodeProviderAsync(project.AssemblyName);
var rootMethods = await provider.GetRootsAsync(rootKind);
result.UnionWith(rootMethods);
if (rootKind != AnalysisRootKind.MainMethods)
{
var mainMethods = await provider.GetRootsAsync(AnalysisRootKind.MainMethods);
result.UnionWith(mainMethods);
}
}
this.rootMethods = result;
this.rootKind = rootKind;
}
return(this.rootMethods);
}
//public Task AddInstantiatedTypesAsync(IEnumerable<TypeDescriptor> types)
//{
// StatsHelper.RegisterMsg("SolutionGrain::AddInstantiatedTypes", this.GrainFactory);
// return solutionManager.AddInstantiatedTypesAsync(types);
//}
//public Task<ISet<TypeDescriptor>> GetInstantiatedTypesAsync()
//{
// StatsHelper.RegisterMsg("SolutionGrain::GetInstantiatedTypes", this.GrainFactory);
// return this.solutionManager.GetInstantiatedTypesAsync();
//}
public async Task <IEnumerable <MethodDescriptor> > GetRootsAsync(AnalysisRootKind rootKind = AnalysisRootKind.Default)
{
await StatsHelper.RegisterMsg("SolutionGrain::GetRoots", this.GrainFactory);
Logger.LogVerbose(this.GetLogger(), "SolutionGrain", "GetRoots", "Enter");
var sw = new Stopwatch();
sw.Start();
var roots = await this.solutionManager.GetRootsAsync(rootKind);
Logger.LogInfo(this.GetLogger(), "SolutionGrain", "GetRoots", "End Time elapsed {0}", sw.Elapsed);
return(roots);
}
public Task <IEnumerable <MethodDescriptor> > GetRootsAsync(AnalysisRootKind rootKind = AnalysisRootKind.Default)
{
return(solutionGrain.GetRootsAsync(rootKind));
}
public Task <IEnumerable <MethodDescriptor> > GetRootsAsync(AnalysisRootKind rootKind = AnalysisRootKind.Default)
{
this.SetRequestContext();
return(providerGrain.GetRootsAsync(rootKind));
}
public Task <IEnumerable <MethodDescriptor> > GetRootsAsync(AnalysisRootKind rootKind = AnalysisRootKind.Default)
{
var result = new HashSet <MethodDescriptor>();
return(Task.FromResult(result.AsEnumerable()));
}
public Task <IEnumerable <MethodDescriptor> > GetRootsAsync(AnalysisRootKind rootKind = AnalysisRootKind.Default)
{
return(codeProvider.GetRootsAsync(rootKind));
}
public Task <IEnumerable <MethodDescriptor> > GetRootsAsync(AnalysisRootKind rootKind = AnalysisRootKind.Default)
{
return(Utils.GetRootsAsync(this.Compilation, rootKind));
}
public static async Task <IEnumerable <MethodDescriptor> > GetRootsAsync(Compilation compilation, AnalysisRootKind rootKind = AnalysisRootKind.Default)
{
IEnumerable <MethodDescriptor> result = null;
switch (rootKind)
{
case AnalysisRootKind.MainMethods:
result = await Utils.GetMainMethodsAsync(compilation);
break;
case AnalysisRootKind.TestMethods:
result = await Utils.GetTestMethodsAsync(compilation);
break;
case AnalysisRootKind.PublicMethods:
result = await Utils.GetPublicMethodsAsync(compilation);
break;
case AnalysisRootKind.RootMethods:
result = await Utils.GetRootMethodsAsync(compilation);
break;
default:
throw new ArgumentException("rootKind");
}
return(result);
}
public async Task RunExperiment(IGrainFactory grainFactory, string expId = "DummyExperimentID", AnalysisRootKind rootKind = AnalysisRootKind.Default)
{
try
{
this.ExperimentID = expId;
// await systemManagement.ForceActivationCollection(System.TimeSpan.MaxValue);
AnalysisClient.ErrorMessage = "OK so far";
var myStatsGrain = StatsHelper.GetStatGrain(grainFactory);
await myStatsGrain.ResetStats();
#if COMPUTE_STATS
this.series = 0;
// Repeat every 30 seconds.
IObservable <long> observable = System.Reactive.Linq.Observable.Interval(TimeSpan.FromSeconds(60));
// Token for cancelation
CancellationTokenSource source = new CancellationTokenSource();
Action action = (async() => await this.SaveUpdateInfo(myStatsGrain));
// Subscribe the obserable to the task on execution.
observable.Subscribe(x => { Task task = new Task(action); task.Start(); }, source.Token);
#endif
this.stopWatch = Stopwatch.StartNew();
AnalysisClient.ExperimentStatus = ExperimentStatus.Compiling;
this.analyzer.RootKind = rootKind;
await this.analyzer.InitializeOnDemandOrleansAnalysis();
await this.analyzer.WaitForOnDemandOrleansAnalysisToBeReady();
var compilationElapsedTime = stopWatch.ElapsedMilliseconds;
if (AnalysisClient.ExperimentStatus == ExperimentStatus.Cancelled)
{
AnalysisClient.ErrorMessage = "Cancelled by user";
return;
}
AnalysisClient.ExperimentStatus = ExperimentStatus.Running;
await this.analyzer.ContinueOnDemandOrleansAnalysis();
AnalysisClient.ExperimentStatus = ExperimentStatus.ComputingResults;
this.stopWatch.Stop();
#if COMPUTE_STATS
source.Cancel();
#endif
var totalRecvNetwork = 0L;
var totalSentLocal = 0L;
var totalSentNetwork = 0L;
var totalRecvLocal = 0L;
var totalAct = 0L;
var totalDeact = 0L;
var time = DateTime.Now;
var acummulatedPerSiloMemoryUsage = 0L;
var maxPerSiloMemoryUsage = 0L;
var acummulatedPerSiloCPUUsage = 0D;
var maxPerSiloCPUUsage = 0D;
var methods = await this.SolutionManager.GetReachableMethodsCountAsync();
this.systemManagement = grainFactory.GetGrain <IManagementGrain>(SYSTEM_MANAGEMENT_ID);
await systemManagement.ForceGarbageCollection(null);
var hosts = await systemManagement.GetHosts();
var averagePerSiloMemoryUsage = 0L;
var orleansStats = await systemManagement.GetRuntimeStatistics(null);
#if COMPUTE_STATS
//var silos = hosts.Keys.ToArray();
//this.methods = -1;
// var messageMetric = new MessageMetrics();
//var myStatsGrain = StatsHelper.GetStatGrain(grainFactory);
var silosEnumeration = await myStatsGrain.GetSilos();
var silos = silosEnumeration.ToArray();
var siloComputedStats = new SiloComputedStats[silos.Length];
var silosSize = silos.Length;
for (var i = 0; i < silos.Length; i++)
{
var silo = silos[i];
var addrString = silo; /*/silo.Endpoint.Address.ToString();*/
siloComputedStats[i] = new SiloComputedStats();
siloComputedStats[i].TotalSentLocalSilo += await myStatsGrain.GetSiloLocalMsgs(addrString);
siloComputedStats[i].TotalRecvLocalSilo += await myStatsGrain.GetSiloLocalMsgs(addrString);
siloComputedStats[i].TotalSentNetworkSilo += await myStatsGrain.GetSiloNetworkSentMsgs(addrString);
siloComputedStats[i].TotalRecvNetworkSilo += await myStatsGrain.GetSiloNetworkReceivedMsgs(addrString);
siloComputedStats[i].MemoryUsage += await myStatsGrain.GetSiloMemoryUsage(addrString);
var activationDic = await myStatsGrain.GetActivationsPerSilo(addrString);
var deactivationDic = await myStatsGrain.GetDeactivationsPerSilo(addrString);
var activations = activationDic.Sum(items => items.Value);
var deactivations = deactivationDic.Sum(items => items.Value);
siloComputedStats[i].TotalActivations += activations;
siloComputedStats[i].TotalDeactivations += deactivations;
siloComputedStats[i].TotalClientMessages += await myStatsGrain.GetTotalClientMsgsPerSilo(addrString);
// totalAct += orleansStats[i].ActivationCount;
totalAct += activations;
totalDeact += deactivations;
//AddSiloMetric(silos[i], siloComputedStats[i], time, machines);
// Save results in per silo table
if (orleansStats.Length <= i)
{
throw new IndexOutOfRangeException(String.Format("OrlenasStats Lenght is {0} and silos Lenght is {1}", orleansStats.Length, silos.Length));
}
AddSiloMetricWithOrleans(silos[i], orleansStats[i], siloComputedStats[i], time, machines);
totalSentNetwork += siloComputedStats[i].TotalSentNetworkSilo;
totalRecvNetwork += siloComputedStats[i].TotalRecvNetworkSilo;
totalSentLocal += siloComputedStats[i].TotalSentLocalSilo;
totalRecvLocal += siloComputedStats[i].TotalSentLocalSilo;
acummulatedPerSiloMemoryUsage += orleansStats[i].MemoryUsage;
acummulatedPerSiloCPUUsage += orleansStats[i].CpuUsage;
if (maxPerSiloMemoryUsage < orleansStats[i].MemoryUsage)
{
maxPerSiloMemoryUsage = orleansStats[i].MemoryUsage;
}
if (maxPerSiloCPUUsage < orleansStats[i].CpuUsage)
{
maxPerSiloCPUUsage = orleansStats[i].CpuUsage;
}
}
var avgLatency = await myStatsGrain.GetAverageLatency();
var maxLatency = await myStatsGrain.GetMaxLatency();
var maxLatencyMsg = await myStatsGrain.GetMaxLatencyMsg();
var totalMessages = await myStatsGrain.GetTotalMessages();
var clientMessages = await myStatsGrain.GetTotalClientMessages();
#else
var avgLatency = 0;
var maxLatency = 0;
var maxLatencyMsg = "";
var totalMessages = 0;
var clientMessages = 0;
for (int i = 0; i < this.machines; i++)
{
if (maxPerSiloMemoryUsage < orleansStats[i].MemoryUsage)
{
maxPerSiloMemoryUsage = orleansStats[i].MemoryUsage;
}
acummulatedPerSiloMemoryUsage += orleansStats[i].MemoryUsage;
}
var silosSize = this.machines; // hosts.Keys.Count;
#endif
averagePerSiloMemoryUsage = acummulatedPerSiloMemoryUsage / silosSize;
var testFullName = this.subject;
var results = new SubjectExperimentResults()
{
ExpID = expId,
Time = time,
Subject = testFullName,
Machines = machines,
Methods = methods,
Messages = totalMessages,
ClientMessages = clientMessages, // SolutionAnalyzer.MessageCounter,
CompilationTime = compilationElapsedTime,
ElapsedTime = stopWatch.ElapsedMilliseconds,
Activations = totalAct,
Deactivations = totalDeact,
Observations = "From web",
PartitionKey = expId + " " + testFullName, // + " " + time.ToFileTime().ToString(),
RowKey = testFullName + " " + time.ToFileTime().ToString(),
TotalRecvNetwork = totalRecvNetwork,
TotalSentLocal = totalSentLocal,
TotalSentNetwork = totalSentNetwork,
TotalRecvLocal = totalRecvLocal,
AverageLatency = avgLatency,
MaxLatency = maxLatency,
MaxLatencyMsg = maxLatencyMsg,
AveragePerSiloMemoryUsage = averagePerSiloMemoryUsage, // acummulatedPerSiloMemoryUsage / silosSize,
AveragePerSiloCPUUsage = acummulatedPerSiloCPUUsage / silosSize,
MaxPerSiloMemoryUsage = maxPerSiloMemoryUsage,
MaxPerSiloCPUUsage = maxPerSiloCPUUsage
};
// Save results in main table
this.AddSubjetResults(results);
//SaveResults(@"Y:\");
AnalysisClient.ExperimentStatus = ExperimentStatus.Ready;
AnalysisClient.ErrorMessage = "OK";
Logger.LogWarning(GrainClient.Logger, "AnalysisClient", "RunExperiment", "Finished OK");
}
catch (Exception ex)
{
var innerEx = ex;
while (innerEx is AggregateException)
{
innerEx = innerEx.InnerException;
}
AnalysisClient.ErrorMessage = "Error connecting to Orleans: " + innerEx + " at " + DateTime.Now;
AnalysisClient.ExperimentStatus = ExperimentStatus.Failed;
Logger.LogError(GrainClient.Logger, "AnalysisClient", "RunExperiment", "Finished with ERRORS {0}", ex);
throw ex;
}
}
public async Task StartRunningExperiment(IGrainFactory grainFactory, string expId = "DummyExperimentID", AnalysisRootKind rootKind = AnalysisRootKind.Default)
{
AnalysisClient.instance = this;
//Task.Run(async () =>
await Task.Factory.StartNew(async() =>
{
await this.RunExperiment(grainFactory, expId, rootKind);
});
}
public static SolutionAnalyzer CreateFromTest(IClusterClient grainClient, string testName, AnalysisRootKind rootKind = AnalysisRootKind.Default)
{
var analyzer = new SolutionAnalyzer(grainClient);
analyzer.testName = testName;
analyzer.RootKind = rootKind;
return(analyzer);
}
public static SolutionAnalyzer CreateFromSource(IClusterClient grainClient, string source, AnalysisRootKind rootKind = AnalysisRootKind.Default)
{
var analyzer = new SolutionAnalyzer(grainClient);
analyzer.solutionPath = TestConstants.SolutionPath;
analyzer.source = source;
analyzer.RootKind = rootKind;
return(analyzer);
}
public Task <IEnumerable <MethodDescriptor> > GetRootsAsync(AnalysisRootKind rootKind = AnalysisRootKind.Default)
{
StatsHelper.RegisterMsg("ProjectGrain::GetRoots", this.GrainFactory);
return(this.projectCodeProvider.GetRootsAsync(rootKind));
}
