public void CallTree_TryGetNextSibling_NullNode()
{
List <CallTreeNode> list = new List <CallTreeNode>();
list.Add(new CallTreeNode());
CallTreeNode resultNode;
bool result = CallTree.TryGetNextSibling(list, null, out resultNode);
result.Should().BeFalse();
}
public void CallTree_TryGetIndexInCallTreeNodeList_NullNode()
{
List <CallTreeNode> list = new List <CallTreeNode>();
list.Add(new CallTreeNode());
int index;
bool result = CallTree.TryGetIndexInCallTreeNodeList(list, null, out index);
result.Should().BeFalse();
}
public void CallTree_TryGetNextSibling_NullList()
{
List <CallTreeNode> list = null;
CallTreeNode node = new CallTreeNode();
CallTreeNode resultNode;
bool result = CallTree.TryGetNextSibling(list, node, out resultNode);
result.Should().BeFalse();
}
public void CallTree_TryGetIndexInCallTreeNodeList_NullList()
{
List <CallTreeNode> list = null;
CallTreeNode node = new CallTreeNode();
int index;
bool result = CallTree.TryGetIndexInCallTreeNodeList(list, node, out index);
result.Should().BeFalse();
}
public static ImmutableArray <OverWeightResult> GenerateOverweightReport(CallTree source, CallTree baseline)
{
var sourceTotal = LoadTrace(source, out var sourceData);
var baselineTotal = LoadTrace(baseline, out var baselineData);
if (sourceTotal != baselineTotal)
{
return(ComputeOverweights(sourceTotal, sourceData, baselineTotal, baselineData));
}
return(ImmutableArray <OverWeightResult> .Empty);
public static bool TryCompareETL(string sourceEtlPath, string baselineEtlPath, out bool regression)
{
regression = false;
CallTree sourceCallTree = GetCallTree(sourceEtlPath);
CallTree baselineCallTree = GetCallTree(baselineEtlPath);
var report = GenerateOverweightReport(sourceCallTree, baselineCallTree);
// print results
Console.WriteLine(string.Join(Environment.NewLine, report.Take(10)));
return(true);
}
public void CallTree_ExpandAll()
{
CallTree tree = CreateCallTree();
tree.ExpandAll();
tree.TopLevelNodes[0].IsExpanded.Should().BeTrue();
tree.TopLevelNodes[0].Children[0].IsExpanded.Should().BeTrue();
tree.TopLevelNodes[0].Children[1].IsExpanded.Should().BeTrue();
tree.TopLevelNodes[0].Children[2].IsExpanded.Should().BeTrue();
tree.TopLevelNodes[1].IsExpanded.Should().BeTrue();
tree.TopLevelNodes[2].IsExpanded.Should().BeTrue();
}
public void CallTree_CollapseAll()
{
CallTree tree = CreateCallTree();
tree.CollapseAll();
tree.TopLevelNodes[0].IsExpanded.Should().BeFalse();
tree.TopLevelNodes[0].Children[0].IsExpanded.Should().BeFalse();
tree.TopLevelNodes[0].Children[1].IsExpanded.Should().BeFalse();
tree.TopLevelNodes[0].Children[2].IsExpanded.Should().BeFalse();
tree.TopLevelNodes[1].IsExpanded.Should().BeFalse();
tree.TopLevelNodes[2].IsExpanded.Should().BeFalse();
}
private Program SimplifyNode(int ix)
{
var callTree = new CallTree(_varnumber, _code, ref ix);
var constantsSet = new ConstantsSet(_constantsSet);
CallTree simplifiedCallTree = callTree.Simplify(constantsSet);
if (simplifiedCallTree != null)
{
return(new Program(_varnumber, new List <int>(simplifiedCallTree.Encode()), constantsSet,
WorkingVariablesCount));
}
return(null);
}
public void PushNode(TraceTree node)
{
if (CallStack.Count == 0)
{
CallTree.Add(node);
}
else
{
CallStack.Peek().Children.Add(node);
}
CallStack.Push(node);
node.StartTimer();
}
public void CallTree_IntelligentExpand()
{
CallTree tree = CreateCallTree();
tree.IntelligentExpand();
tree.TopLevelNodes[0].IsExpanded.Should().BeTrue();
tree.TopLevelNodes[0].Children[0].IsExpanded.Should().BeFalse();
tree.TopLevelNodes[0].Children[1].IsExpanded.Should().BeTrue();
tree.TopLevelNodes[0].Children[2].IsExpanded.Should().BeFalse();
tree.TopLevelNodes[1].IsExpanded.Should().BeFalse();
tree.TopLevelNodes[2].IsExpanded.Should().BeTrue();
}
public void CallTree_SetVerbosity_Essential()
{
CallTree tree = CreateCallTree();
tree.SetVerbosity(ThreadFlowLocationImportance.Essential);
tree.TopLevelNodes[0].Visibility.Should().Be(Visibility.Visible);
tree.TopLevelNodes[0].Children[0].Visibility.Should().Be(Visibility.Collapsed);
tree.TopLevelNodes[0].Children[1].Visibility.Should().Be(Visibility.Visible);
tree.TopLevelNodes[0].Children[2].Visibility.Should().Be(Visibility.Collapsed);
tree.TopLevelNodes[1].Visibility.Should().Be(Visibility.Collapsed);
tree.TopLevelNodes[2].Visibility.Should().Be(Visibility.Visible);
}
public void CallTree_SetVerbosity_Unimportant()
{
CallTree tree = CreateCallTree();
tree.SetVerbosity(ThreadFlowLocationImportance.Unimportant);
tree.TopLevelNodes[0].Visibility.Should().Be(Visibility.Visible);
tree.TopLevelNodes[0].Children[0].Visibility.Should().Be(Visibility.Visible);
tree.TopLevelNodes[0].Children[1].Visibility.Should().Be(Visibility.Visible);
tree.TopLevelNodes[0].Children[2].Visibility.Should().Be(Visibility.Visible);
tree.TopLevelNodes[1].Visibility.Should().Be(Visibility.Visible);
tree.TopLevelNodes[2].Visibility.Should().Be(Visibility.Visible);
}
public void CallTree_SetVerbosity_Important()
{
CallTree tree = CreateCallTree();
tree.SetVerbosity(AnnotatedCodeLocationImportance.Important);
tree.TopLevelNodes[0].Visibility.Should().Be(Visibility.Visible);
tree.TopLevelNodes[0].Children[0].Visibility.Should().Be(Visibility.Visible);
tree.TopLevelNodes[0].Children[1].Visibility.Should().Be(Visibility.Visible);
tree.TopLevelNodes[0].Children[2].Visibility.Should().Be(Visibility.Collapsed);
tree.TopLevelNodes[1].Visibility.Should().Be(Visibility.Collapsed);
tree.TopLevelNodes[2].Visibility.Should().Be(Visibility.Visible);
}
public CallNodeModel ExpandChild(int nodeIndex)
{
CallTree.EnsureLazyChildren();
foreach (CallNodeModel child in CallTree.Children)
{
if (child.CallRecordIndex == nodeIndex)
{
child.IsExpanded = true;
return(child);
}
}
return(null);
}
static void RunProgram(string code, decimal input, StringBuilder stringBuilder)
{
var program = Parser.Parser.Parse(Tokenizer.Tokenizer.Tokenize(code));
var runTimeState = new RuntimeState(1);
runTimeState.Inputs[0] = input;
int pc = 0;
var callTree = new CallTree(program, ref pc);
while (!callTree.Tick(runTimeState, program.Constants, stringBuilder))
{
}
}
public void CallTree_TryGetIndexInCallTreeNodeList_MiddleNode()
{
List <CallTreeNode> list = new List <CallTreeNode>();
CallTreeNode target = new CallTreeNode();
list.Add(new CallTreeNode());
list.Add(target);
list.Add(new CallTreeNode());
int index;
bool result = CallTree.TryGetIndexInCallTreeNodeList(list, target, out index);
result.Should().BeTrue();
index.Should().Be(1);
}
public CallTreeDataProvider(TraceLog log, FilterParams filterParams, SymbolReader reader, ITraceDataPlugin plugin)
{
if (log == null)
{
ThrowHelper.ThrowArgumentNullException(nameof(log));
}
if (filterParams == null)
{
ThrowHelper.ThrowArgumentNullException(nameof(filterParams));
}
if (reader == null)
{
ThrowHelper.ThrowArgumentNullException(nameof(reader));
}
if (plugin == null)
{
ThrowHelper.ThrowArgumentNullException(nameof(plugin));
}
this.reader = reader;
TraceEvents events = log.Events;
var unfilteredStacksource = plugin.GetStackSource(events);
this.summaryPredicate = plugin.SummaryPredicate;
CallTree.DisableParallelism = true; // important
this.stacksource = new FilterStackSource(filterParams, unfilteredStacksource, ScalingPolicyKind.TimeMetric);
this.callTree = new CallTree(ScalingPolicyKind.TimeMetric)
{
StackSource = this.stacksource
};
// Indicate I want the Time histograms to be computed.
double startTimeRelativeMsec = 0;
double.TryParse(filterParams.StartTimeRelativeMSec, out startTimeRelativeMsec);
//System.Diagnostics.Debug.WriteLine("\n\nTIME: 1" + filterParams.StartTimeRelativeMSec + "\n2 " + startTimeRelativeMsec + "\n3 " + this.stacksource.SampleTimeRelativeMSecLimit + "\n\n");
callTree.TimeHistogramController = new TimeHistogramController(callTree, startTimeRelativeMsec, this.stacksource.SampleTimeRelativeMSecLimit);
float minIncusiveTimePercent;
if (float.TryParse(filterParams.MinInclusiveTimePercent, out minIncusiveTimePercent) && minIncusiveTimePercent > 0)
{
this.callTree.FoldNodesUnder(minIncusiveTimePercent * this.callTree.Root.InclusiveMetric / 100, true);
}
}
private CallTree CreateCallTree()
{
var codeFlow = new CodeFlow
{
Locations = new List <AnnotatedCodeLocation>
{
new AnnotatedCodeLocation
{
Kind = AnnotatedCodeLocationKind.Call,
Importance = AnnotatedCodeLocationImportance.Unimportant,
},
new AnnotatedCodeLocation
{
Kind = AnnotatedCodeLocationKind.Declaration,
Importance = AnnotatedCodeLocationImportance.Important,
},
new AnnotatedCodeLocation
{
Kind = AnnotatedCodeLocationKind.Declaration,
Importance = AnnotatedCodeLocationImportance.Essential,
},
new AnnotatedCodeLocation
{
Kind = AnnotatedCodeLocationKind.CallReturn,
Importance = AnnotatedCodeLocationImportance.Unimportant,
},
new AnnotatedCodeLocation
{
Kind = AnnotatedCodeLocationKind.Declaration,
Importance = AnnotatedCodeLocationImportance.Unimportant,
},
new AnnotatedCodeLocation
{
Kind = AnnotatedCodeLocationKind.Declaration,
Importance = AnnotatedCodeLocationImportance.Essential,
}
}
};
var mockToolWindow = new Mock <IToolWindow>();
mockToolWindow.Setup(s => s.UpdateSelectionList(It.IsAny <object[]>()));
CallTree callTree = new CallTree(CodeFlowToTreeConverter.Convert(codeFlow), mockToolWindow.Object);
return(callTree);
}
private async Task Initialize()
{
await this.semaphoreSlim.WaitAsync();
try
{
if (this.initialized == 1)
{
return;
}
var filterParams = new FilterParams
{
StartTimeRelativeMSec = this.model.Start,
EndTimeRelativeMSec = this.model.End,
ExcludeRegExs = this.model.ExcPats,
IncludeRegExs = this.model.IncPats,
FoldRegExs = this.model.FoldPats,
GroupRegExs = this.model.GroupPats,
MinInclusiveTimePercent = this.model.FoldPct,
Name = "NoName",
};
var ss = new FilterStackSource(filterParams, this.stackSource, ScalingPolicyKind.TimeMetric);
double startTimeRelativeMsec = double.TryParse(filterParams.StartTimeRelativeMSec, out startTimeRelativeMsec) ? Math.Max(startTimeRelativeMsec, 0.0) : 0.0;
double endTimeRelativeMsec = double.TryParse(filterParams.EndTimeRelativeMSec, out endTimeRelativeMsec) ? Math.Min(endTimeRelativeMsec, this.stackSource.SampleTimeRelativeMSecLimit) : this.stackSource.SampleTimeRelativeMSecLimit;
var c = new CallTree(ScalingPolicyKind.TimeMetric);
c.TimeHistogramController = new TimeHistogramController(c, startTimeRelativeMsec, endTimeRelativeMsec);
c.StackSource = ss;
if (float.TryParse(filterParams.MinInclusiveTimePercent, out float minIncusiveTimePercent) && minIncusiveTimePercent > 0)
{
c.FoldNodesUnder(minIncusiveTimePercent * c.Root.InclusiveMetric / 100, true);
}
var t = new Tuple(c);
this.tuple = t;
this.initialized = 1;
}
finally
{
this.semaphoreSlim.Release();
}
}
public void CallTree_TryGetLastItem_LastNode()
{
List <CallTreeNode> list = new List <CallTreeNode>();
list.Add(new CallTreeNode());
list.Add(new CallTreeNode());
list.Add(new CallTreeNode()
{
FilePath = Expected
});
CallTreeNode resultNode;
bool result = CallTree.TryGetLastItem(list, out resultNode);
result.Should().BeTrue();
resultNode.FilePath.Should().Be(Expected);
}
public void CallTree_TryGetPreviousSibling_FirstNode()
{
List <CallTreeNode> list = new List <CallTreeNode>();
CallTreeNode target = new CallTreeNode();
list.Add(target);
list.Add(new CallTreeNode()
{
FilePath = Expected
});
list.Add(new CallTreeNode());
CallTreeNode resultNode;
bool result = CallTree.TryGetPreviousSibling(list, target, out resultNode);
result.Should().BeFalse();
}
public void CallTree_TryGetNextSibling_MiddleNode()
{
List <CallTreeNode> list = new List <CallTreeNode>();
CallTreeNode target = new CallTreeNode();
list.Add(new CallTreeNode());
list.Add(target);
list.Add(new CallTreeNode()
{
FilePath = Expected
});
CallTreeNode resultNode;
bool result = CallTree.TryGetNextSibling(list, target, out resultNode);
result.Should().BeTrue();
resultNode.FilePath.Should().Be(Expected);
}
private CallTree CreateCallTree()
{
var codeFlow = SarifUtilities.CreateSingleThreadedCodeFlow(new[]
{
new ThreadFlowLocation
{
NestingLevel = 0,
Importance = ThreadFlowLocationImportance.Unimportant,
},
new ThreadFlowLocation
{
NestingLevel = 1,
Importance = ThreadFlowLocationImportance.Important,
},
new ThreadFlowLocation
{
NestingLevel = 1,
Importance = ThreadFlowLocationImportance.Essential,
},
new ThreadFlowLocation
{
NestingLevel = 1,
Importance = ThreadFlowLocationImportance.Unimportant,
},
new ThreadFlowLocation
{
NestingLevel = 0,
Importance = ThreadFlowLocationImportance.Unimportant,
},
new ThreadFlowLocation
{
NestingLevel = 0,
Importance = ThreadFlowLocationImportance.Essential,
}
});
var mockToolWindow = new Mock <IToolWindow>();
mockToolWindow.Setup(s => s.UpdateSelectionList(It.IsAny <object[]>()));
CallTree callTree = new CallTree(CodeFlowToTreeConverter.Convert(codeFlow, run: null), mockToolWindow.Object);
return(callTree);
}
public CallNodeModel GetNodeModel(int nodeIndex)
{
CallTree.EnsureLazyChildren();
var parentIndexes = Frame.GetNodeParentIndexes(nodeIndex, 0).Reverse().ToList();
// Fist node is not a CallNodeModel
var currNode = CallTree.Children.Cast <CallNodeModel>().
FirstOrDefault(c => c.CallRecordIndex == parentIndexes.First());
if (currNode == null)
{
return(null);
}
foreach (var parentIndex in parentIndexes.Skip(1))
{
currNode = currNode.GetChild(parentIndex);
}
return(currNode.GetChild(nodeIndex));
}
public void CallTree_TryGetLastItem_NoVisibleNodes()
{
List <CallTreeNode> list = new List <CallTreeNode>();
CallTreeNode target = new CallTreeNode();
list.Add(new CallTreeNode()
{
Visibility = Visibility.Collapsed
});
list.Add(new CallTreeNode()
{
Visibility = Visibility.Hidden
});
CallTreeNode resultNode;
bool result = CallTree.TryGetLastItem(list, out resultNode);
result.Should().BeFalse();
}
static float LoadTrace(CallTree callTree, out Dictionary <string, float> data)
{
data = new Dictionary <string, float>();
float total = 0;
foreach (var node in callTree.ByID)
{
if (node.InclusiveMetric == 0)
{
continue;
}
string key = node.Name;
data.TryGetValue(key, out var weight);
data[key] = weight + node.InclusiveMetric;
total += node.ExclusiveMetric;
}
return(total);
}
public void SelectPreviousNextCommandsCallNoChildrenTest()
{
var codeFlow = SarifUtilities.CreateSingleThreadedCodeFlow(new[]
{
new ThreadFlowLocation
{
NestingLevel = 0
}
});
var mockToolWindow = new Mock <IToolWindow>();
mockToolWindow.Setup(s => s.UpdateSelectionList(It.IsAny <object[]>()));
CallTree callTree = new CallTree(CodeFlowToTreeConverter.Convert(codeFlow, run: null), mockToolWindow.Object);
callTree.SelectedItem = callTree.TopLevelNodes[0];
callTree.FindPrevious().Should().Be(callTree.TopLevelNodes[0]);
callTree.FindNext().Should().Be(callTree.TopLevelNodes[0]);
}
public void CallTree_TryGetPreviousSibling_DoesNotExistNode()
{
List <CallTreeNode> list = new List <CallTreeNode>();
list.Add(new CallTreeNode());
list.Add(new CallTreeNode());
list.Add(new CallTreeNode()
{
Visibility = Visibility.Collapsed
});
list.Add(new CallTreeNode()
{
Visibility = Visibility.Hidden
});
CallTreeNode resultNode;
bool result = CallTree.TryGetPreviousSibling(list, new CallTreeNode(), out resultNode);
result.Should().BeFalse();
}
public CallTreeDataProvider(TraceLog log, FilterParams filterParams, SymbolReader reader, ITraceDataPlugin plugin)
{
if (log == null)
{
ThrowHelper.ThrowArgumentNullException(nameof(log));
}
if (filterParams == null)
{
ThrowHelper.ThrowArgumentNullException(nameof(filterParams));
}
if (reader == null)
{
ThrowHelper.ThrowArgumentNullException(nameof(reader));
}
if (plugin == null)
{
ThrowHelper.ThrowArgumentNullException(nameof(plugin));
}
this.reader = reader;
TraceEvents events = log.Events;
this.stacksource = plugin.GetStackSource(events);
this.summaryPredicate = plugin.SummaryPredicate;
CallTree.DisableParallelism = true; // important
this.stacksource = new FilterStackSource(filterParams, this.stacksource, ScalingPolicyKind.TimeMetric);
this.callTree = new CallTree(ScalingPolicyKind.TimeMetric)
{
StackSource = this.stacksource
};
float minIncusiveTimePercent;
if (float.TryParse(filterParams.MinInclusiveTimePercent, out minIncusiveTimePercent) && minIncusiveTimePercent > 0)
{
this.callTree.FoldNodesUnder(minIncusiveTimePercent * this.callTree.Root.InclusiveMetric / 100, true);
}
}
