private void ProcessMarkStack() { do { while (_markStack.Count > 0) { // Pop the top node of the mark stack DependencyNodeCore <DependencyContextType> currentNode = _markStack.Pop(); Debug.Assert(currentNode.Marked); // Only some marked objects are interesting for dynamic dependencies // store those in a seperate list to avoid excess scanning over non-interesting // nodes during dynamic dependency discovery if (currentNode.InterestingForDynamicDependencyAnalysis) { _dynamicDependencyInterestingList.Add(currentNode); _newDynamicDependenciesMayHaveAppeared = true; } // Add all static dependencies to the mark stack GetStaticDependencies(currentNode); // If there are dynamic dependencies, note for later if (currentNode.HasDynamicDependencies) { _newDynamicDependenciesMayHaveAppeared = true; _markedNodesWithDynamicDependencies.Add(new DynamicDependencyNode(currentNode)); } // If this new node satisfies any stored conditional dependencies, // add them to the mark stack HashSet <DependencyNodeCore <DependencyContextType> .CombinedDependencyListEntry> storedDependencySet = null; if (_conditional_dependency_store.TryGetValue(currentNode, out storedDependencySet)) { foreach (DependencyNodeCore <DependencyContextType> .CombinedDependencyListEntry newlySatisfiedDependency in storedDependencySet) { AddToMarkStack(newlySatisfiedDependency.Node, newlySatisfiedDependency.Reason, newlySatisfiedDependency.OtherReasonNode, currentNode); } _conditional_dependency_store.Remove(currentNode); } } // Find new dependencies introduced by dynamic depedencies if (_newDynamicDependenciesMayHaveAppeared) { _newDynamicDependenciesMayHaveAppeared = false; for (int i = 0; i < _markedNodesWithDynamicDependencies.Count; i++) { DynamicDependencyNode dynamicNode = _markedNodesWithDynamicDependencies[i]; dynamicNode.MarkNewDynamicDependencies(this); // Update the copy in the list _markedNodesWithDynamicDependencies[i] = dynamicNode; } } } while (_markStack.Count != 0); }
public CombinedDependencyListEntry(DependencyNodeCore <DependencyContextType> node, DependencyNodeCore <DependencyContextType> otherReasonNode, string reason) { Node = node; OtherReasonNode = otherReasonNode; Reason = reason; }
bool IDependencyAnalysisMarkStrategy <DependencyContextType> .MarkNode( DependencyNodeCore <DependencyContextType> node, DependencyNodeCore <DependencyContextType> reasonNode, DependencyNodeCore <DependencyContextType> reasonNode2, string reason) { bool retVal = false; int nodeIndex; if (!node.Marked) { nodeIndex = Interlocked.Increment(ref ObjectIndex); node.SetMark(nodeIndex); if (GraphId == 0) { lock (GraphEventSource.Log) { if (GraphId == 0) { GraphId = Interlocked.Increment(ref s_GraphIds); GraphEventSource.Log.Graph(GraphId, ""); RootIndex = Interlocked.Increment(ref ObjectIndex); GraphEventSource.Log.Node(GraphId, RootIndex, "roots"); } } } retVal = true; GraphEventSource.Log.Node(GraphId, nodeIndex, node.GetNameInternal(_context)); } else { nodeIndex = (int)node.GetMark(); } if (reasonNode != null) { if (reasonNode2 != null) { GraphEventSource.Log.ConditionalEdge(GraphId, (int)reasonNode.GetMark(), (int)reasonNode2.GetMark(), nodeIndex, reason); } else { GraphEventSource.Log.Edge(GraphId, (int)reasonNode.GetMark(), nodeIndex, reason); } } else { GraphEventSource.Log.Edge(GraphId, RootIndex, nodeIndex, reason); } return(retVal); }
private void GetStaticDependencies(DependencyNodeCore<DependencyContextType> node) { if (node.StaticDependenciesAreComputed) { GetStaticDependenciesImpl(node); } else { _deferredStaticDependencies.Add(node); } }
bool IDependencyAnalysisMarkStrategy <DependencyContextType> .MarkNode( DependencyNodeCore <DependencyContextType> node, DependencyNodeCore <DependencyContextType> reasonNode, DependencyNodeCore <DependencyContextType> reasonNode2, string reason) { if (node.Marked) { return(false); } node.SetMark(s_singleton); return(true); }
private bool AddToMarkStack(DependencyNodeCore <DependencyContextType> node, string reason, DependencyNodeCore <DependencyContextType> reason1, DependencyNodeCore <DependencyContextType> reason2) { if (_marker.MarkNode(node, reason1, reason2, reason)) { if (PerfEventSource.Log.IsEnabled()) { PerfEventSource.Log.AddedNodeToMarkStack(); } // Pop the top node of the mark stack if (_stackPopRandomizer == null) { _markStack.Push(node); } else { // // Expose output file determinism bugs in our system by randomizing the order nodes are pushed // on to the mark stack. // int randomNodeIndex = _stackPopRandomizer.Next(_markStack.Count); var tempStack = new Stack <DependencyNodeCore <DependencyContextType> >(); for (int i = 0; i < randomNodeIndex; i++) { tempStack.Push(_markStack.Pop()); } _markStack.Push(node); while (tempStack.Count > 0) { _markStack.Push(tempStack.Pop()); } } _markedNodes.Add(node); node.CallOnMarked(_dependencyContext); if (NewMarkedNode != null) { NewMarkedNode(node); } return(true); } return(false); }
private void GetStaticDependencies(DependencyNodeCore <DependencyContextType> node) { if (node.StaticDependenciesAreComputed) { GetStaticDependenciesImpl(node); } else { int dependencyPhase = Math.Max(node.DependencyPhaseForDeferredStaticComputation, _currentDependencyPhase); if (!_deferredStaticDependencies.TryGetValue(dependencyPhase, out var deferredPerPhaseDependencies)) { deferredPerPhaseDependencies = new List <DependencyNodeCore <DependencyContextType> >(); _deferredStaticDependencies.Add(dependencyPhase, deferredPerPhaseDependencies); } deferredPerPhaseDependencies.Add(node); } }
private bool AddToMarkStack(DependencyNodeCore <DependencyContextType> node, string reason, DependencyNodeCore <DependencyContextType> reason1, DependencyNodeCore <DependencyContextType> reason2) { if (_marker.MarkNode(node, reason1, reason2, reason)) { _markStack.Push(node); _markedNodes.Add(node); node.CallOnMarked(_dependencyContext); if (NewMarkedNode != null) { NewMarkedNode(node); } return(true); } return(false); }
// Internal details private void GetStaticDependenciesImpl(DependencyNodeCore <DependencyContextType> node) { IEnumerable <DependencyNodeCore <DependencyContextType> .DependencyListEntry> staticDependencies = node.GetStaticDependencies(_dependencyContext); if (staticDependencies != null) { foreach (DependencyNodeCore <DependencyContextType> .DependencyListEntry dependency in staticDependencies) { AddToMarkStack(dependency.Node, dependency.Reason, node, null); } } if (node.HasConditionalStaticDependencies) { foreach (DependencyNodeCore <DependencyContextType> .CombinedDependencyListEntry dependency in node.GetConditionalStaticDependencies(_dependencyContext)) { if (dependency.OtherReasonNode.Marked) { AddToMarkStack(dependency.Node, dependency.Reason, node, dependency.OtherReasonNode); } else { HashSet <DependencyNodeCore <DependencyContextType> .CombinedDependencyListEntry> storedDependencySet = null; if (!_conditional_dependency_store.TryGetValue(dependency.OtherReasonNode, out storedDependencySet)) { storedDependencySet = new HashSet <DependencyNodeCore <DependencyContextType> .CombinedDependencyListEntry>(); _conditional_dependency_store.Add(dependency.OtherReasonNode, storedDependencySet); } // Swap out other reason node as we're storing that as the dictionary key DependencyNodeCore <DependencyContextType> .CombinedDependencyListEntry conditionalDependencyStoreEntry = new DependencyNodeCore <DependencyContextType> .CombinedDependencyListEntry(); conditionalDependencyStoreEntry.Node = dependency.Node; conditionalDependencyStoreEntry.Reason = dependency.Reason; conditionalDependencyStoreEntry.OtherReasonNode = node; storedDependencySet.Add(conditionalDependencyStoreEntry); } } } }
public DynamicDependencyNode(DependencyNodeCore<DependencyContextType> node) { _node = node; _next = 0; }
public MarkData(string reason, DependencyNodeCore <DependencyContextType> reason1, DependencyNodeCore <DependencyContextType> reason2) { Reason = reason; Reason1 = reason1; Reason2 = reason2; }
public void Add(DependencyNodeCore <DependencyContextType> node, string reason) { this.Add(new DependencyListEntry(node, reason)); }
public DependencyListEntry(DependencyNodeCore <DependencyContextType> node, string reason) { Node = node; Reason = reason; }
/// <summary> /// Add a root node /// </summary> public abstract void AddRoot(DependencyNodeCore <DependencyContextType> rootNode, string reason);