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 ConcurrentNodeDictionary <ulong> GetAdjustedDurations(ulong threshold)
{
ConcurrentNodeDictionary <ulong> durations = new ConcurrentNodeDictionary <ulong>(true);
foreach (var node in ExecutionData.DataflowGraph.Nodes)
{
if (EndTimes[node] > threshold)
{
// TODO: find out what this means!
// Debugger.Launch();
}
durations[node] = ExecutionData.Durations[node] + Math.Max(0, EndTimes[node] - threshold);
}
return(durations);
}
public SimulationResult(PipExecutionData executionData, ConcurrentNodeDictionary <ulong> priorities)
{
ExecutionData = executionData;
Priorities = priorities;
}
public static T GetOrDefault <T>(this ConcurrentNodeDictionary <T> d, NodeId node)
{
if (!node.IsValid)
{
return(default);
