public static void CompareExchangeMin <T>(this ConcurrentNodeDictionary <T> map, NodeId node, T comparand) where T : IComparable <T>
{
if (comparand.IsLessThan(map[node]))
{
map[node] = comparand;
}
}
public ConcurrentNodeDictionary <ulong> ComputeAggregateCosts(ConcurrentNodeDictionary <ulong> durations)
{
ConcurrentNodeDictionary <ulong> aggregateCosts = new ConcurrentNodeDictionary <ulong>(true);
List <NodeId> sortedNodes = new List <NodeId>();
sortedNodes.AddRange(DataflowGraph.Nodes);
sortedNodes.Sort((n1, n2) => - DataflowGraph.GetNodeHeight(n1).CompareTo(DataflowGraph.GetNodeHeight(n2)));
foreach (var node in sortedNodes)
{
//int maxConeConcurrency = 0;
ulong aggregateCost = 0;
NodeId maxChild = NodeId.Invalid;
foreach (var outgoing in DataflowGraph.GetOutgoingEdges(node))
{
if (aggregateCosts[outgoing.OtherNode].Max(ref aggregateCost) || !maxChild.IsValid())
{
maxChild = outgoing.OtherNode;
}
}
aggregateCost += durations[node];
aggregateCosts[node] = aggregateCost;
}
return(aggregateCosts);
}
public static void Write <T>(this BuildXLWriter writer, uint maxNode, ConcurrentNodeDictionary <T> map, Action <BuildXLWriter, T> writeItem)
{
for (uint i = NodeId.MinValue; i <= maxNode; i++)
{
writeItem(writer, map[i]);
}
}
public static void Read <T>(this BuildXLReader reader, uint maxNode, ConcurrentNodeDictionary <T> map, Func <BuildXLReader, T> readItem)
{
for (uint i = NodeId.MinValue; i <= maxNode; i++)
{
map[i] = readItem(reader);
}
}
private ConcurrentNodeDictionary <long> GenerateSamples()
{
ConcurrentNodeDictionary <long> samples = new ConcurrentNodeDictionary <long>(false);
return(samples);
}
public void ComputeEstimate()
{
ConcurrentNodeDictionary <long> maxSamples = new ConcurrentNodeDictionary <long>(false);
var samples = GenerateSamples();
foreach (var node in Graph.Nodes)
{
AggregateEstimate[node] += ComputeEstimateHelper(node, maxSamples, samples);
}
}
public ConcurrentNodeDictionary <ulong> GetAdjustedDurations(ulong threshold)
{
ConcurrentNodeDictionary <ulong> durations = new ConcurrentNodeDictionary <ulong>(true);
foreach (var node in ExecutionData.DataflowGraph.Nodes)
{
if (EndTimes[node] > threshold)
{
//Debugger.Launch();
}
durations[node] = ExecutionData.Durations[node] + Math.Max(0, EndTimes[node] - threshold);
}
return(durations);
}
private long ComputeEstimateHelper(NodeId node, ConcurrentNodeDictionary <long> maxSamples, ConcurrentNodeDictionary <long> samples)
{
long maxSample = maxSamples[node];
if (maxSample == 0)
{
maxSample = samples[node];
foreach (var outgoingEdge in Graph.GetOutgoingEdges(node))
{
var childMaxSample = ComputeEstimateHelper(outgoingEdge.OtherNode, maxSamples, samples);
childMaxSample.Max(ref maxSample);
}
maxSamples[node] = maxSample;
}
return(maxSample);
}
public SimulationResult(PipExecutionData executionData, ConcurrentNodeDictionary <ulong> priorities)
{
ExecutionData = executionData;
CriticalPathSet.UnionWith(executionData.CriticalPath);
Priorities = priorities;
}
