private void BuildClassTrace(Graph graph, int stackTraceIndex, int funcIndex, ulong size, Vertex[] funcVertex, ref Vertex[] vertexStack, FilterForm filterForm) { string className = ClassNameOfFunc(funcIndex); int functionsToSkip = FunctionsInSameClass(className, stackTraceIndex); int stackPtr = BuildVertexStack(stackTraceIndex, funcVertex, ref vertexStack, 0) - functionsToSkip; Vertex toVertex = graph.TopVertex; if (ReadNewLog.InterestingCallStack(vertexStack, stackPtr, filterForm)) { vertexStack[stackPtr] = graph.FindOrCreateVertex(className, null, null); vertexStack[stackPtr].interestLevel = filterForm.IsInterestingMethodName(className, null) ? InterestLevel.Interesting | filterForm.InterestLevelForParentsAndChildren() : InterestLevel.Ignore; stackPtr++; stackPtr = ReadNewLog.FilterVertices(vertexStack, stackPtr); stackPtr = Vertex.SqueezeOutRepetitions(vertexStack, stackPtr); Edge edge; Vertex fromVertex; for (int i = 0; i < stackPtr; i++) { fromVertex = toVertex; toVertex = vertexStack[i]; edge = graph.FindOrCreateEdge(fromVertex, toVertex); edge.AddWeight(size); } if (toVertex != graph.TopVertex) { fromVertex = toVertex; toVertex = graph.BottomVertex; edge = graph.FindOrCreateEdge(fromVertex, toVertex); edge.AddWeight(size); } } }
private void BuildFunctionTrace(Graph graph, int stackTraceIndex, int funcIndex, ulong size, Vertex[] funcVertex, ref Vertex[] vertexStack, FilterForm filterForm) { int stackPtr = BuildVertexStack(stackTraceIndex, funcVertex, ref vertexStack, 0); Vertex toVertex = graph.TopVertex; if ((funcVertex[funcIndex].interestLevel & InterestLevel.Interesting) == InterestLevel.Interesting && ReadNewLog.InterestingCallStack(vertexStack, stackPtr, filterForm)) { vertexStack[stackPtr] = funcVertex[funcIndex]; stackPtr++; stackPtr = ReadNewLog.FilterVertices(vertexStack, stackPtr); stackPtr = Vertex.SqueezeOutRepetitions(vertexStack, stackPtr); Edge edge; Vertex fromVertex; for (int i = 0; i < stackPtr; i++) { fromVertex = toVertex; toVertex = vertexStack[i]; edge = graph.FindOrCreateEdge(fromVertex, toVertex); edge.AddWeight(size); } fromVertex = toVertex; toVertex = graph.BottomVertex; edge = graph.FindOrCreateEdge(fromVertex, toVertex); edge.AddWeight(size); } }
private void BuildModuleTrace(Graph graph, int stackTraceIndex, int modIndex, ulong size, Vertex[] funcVertex, Vertex[] modVertex, ref Vertex[] vertexStack, FilterForm filterForm) { int functionsToSkip = FunctionsInSameModule(modIndex, stackTraceIndex); int stackPtr = BuildVertexStack(stackTraceIndex, funcVertex, ref vertexStack, 0) - functionsToSkip; Vertex toVertex = graph.TopVertex; if (ReadNewLog.InterestingCallStack(vertexStack, stackPtr, filterForm)) { vertexStack[stackPtr] = modVertex[modIndex]; stackPtr++; stackPtr = ReadNewLog.FilterVertices(vertexStack, stackPtr); stackPtr = Vertex.SqueezeOutRepetitions(vertexStack, stackPtr); Edge edge; Vertex fromVertex; for (int i = 0; i < stackPtr; i++) { fromVertex = toVertex; toVertex = vertexStack[i]; edge = graph.FindOrCreateEdge(fromVertex, toVertex); edge.AddWeight(size); } fromVertex = toVertex; toVertex = graph.BottomVertex; edge = graph.FindOrCreateEdge(fromVertex, toVertex); edge.AddWeight(size); } }
internal void BuildHandleAllocationTrace(Graph graph, int stackTraceIndex, uint count, Vertex[] funcVertex, ref Vertex[] vertexStack, FilterForm filterForm) { int stackPtr = BuildVertexStack(stackTraceIndex, funcVertex, ref vertexStack, 0); Vertex handleVertex = graph.FindOrCreateVertex("Handle", null, null); handleVertex.interestLevel = InterestLevel.Interesting; Vertex toVertex = graph.TopVertex; if (ReadNewLog.InterestingCallStack(vertexStack, stackPtr, filterForm)) { vertexStack[stackPtr] = handleVertex; stackPtr++; stackPtr = ReadNewLog.FilterVertices(vertexStack, stackPtr); stackPtr = Vertex.SqueezeOutRepetitions(vertexStack, stackPtr); Edge edge; Vertex fromVertex; for (int i = 0; i < stackPtr; i++) { fromVertex = toVertex; toVertex = vertexStack[i]; edge = graph.FindOrCreateEdge(fromVertex, toVertex); edge.AddWeight(count); } fromVertex = toVertex; toVertex = graph.BottomVertex; edge = graph.FindOrCreateEdge(fromVertex, toVertex); edge.AddWeight(count); } }
internal void BuildAssemblyTrace(Graph graph, int stackTraceIndex, Vertex assembly, Vertex typeVertex, Vertex[] funcVertex, ref Vertex[] vertexStack) { int stackPtr = BuildVertexStack(Math.Abs(stackTraceIndex), funcVertex, ref vertexStack, stackTraceIndex < 0 ? 2 : 0); Vertex toVertex = graph.TopVertex; Vertex fromVertex; Edge edge; if (typeVertex != null) { vertexStack[stackPtr++] = typeVertex; } vertexStack[stackPtr++] = assembly; stackPtr = ReadNewLog.FilterVertices(vertexStack, stackPtr); stackPtr = Vertex.SqueezeOutRepetitions(vertexStack, stackPtr); for (int i = 0; i < stackPtr; i++) { fromVertex = toVertex; toVertex = vertexStack[i]; edge = graph.FindOrCreateEdge(fromVertex, toVertex); edge.AddWeight(1); } fromVertex = toVertex; toVertex = graph.BottomVertex; edge = graph.FindOrCreateEdge(fromVertex, toVertex); edge.AddWeight(1); }
internal void BuildCallTrace(Graph graph, int stackTraceIndex, Vertex[] funcVertex, ref Vertex[] vertexStack, int count, FilterForm filterForm) { int stackPtr = BuildVertexStack(stackTraceIndex, funcVertex, ref vertexStack, 0); Vertex toVertex = graph.TopVertex; if (ReadNewLog.InterestingCallStack(vertexStack, stackPtr, filterForm)) { stackPtr = ReadNewLog.FilterVertices(vertexStack, stackPtr); stackPtr = Vertex.SqueezeOutRepetitions(vertexStack, stackPtr); for (int i = 0; i < stackPtr; i++) { Vertex fromVertex = toVertex; toVertex = vertexStack[i]; Edge edge = graph.FindOrCreateEdge(fromVertex, toVertex); edge.AddWeight((uint)count); } } }
internal Graph BuildTypeGraph(int allocatedAfterTickIndex, int allocatedBeforeTickIndex, BuildTypeGraphOptions options, FilterForm filterForm) { Graph graph; if (filterForm.filterVersion != 0 || options != BuildTypeGraphOptions.LumpBySignature || allocatedAfterTickIndex > 0 || allocatedBeforeTickIndex < int.MaxValue) { graph = new Graph(this); graph.graphType = Graph.GraphType.HeapGraph; graph.previousGraphTickIndex = allocatedAfterTickIndex; } else { Graph previousGraph = cachedGraph; if (previousGraph != null && previousGraph.graphSource == this) { return(previousGraph); } cachedGraph = graph = new Graph(this); graph.graphType = Graph.GraphType.HeapGraph; graph.graphSource = this; if (previousGraph != null) { graph.previousGraphTickIndex = ((ObjectGraph)previousGraph.graphSource).tickIndex; foreach (Vertex v in previousGraph.vertices.Values) { Vertex newV = graph.FindOrCreateVertex(v.name, v.signature, v.moduleName); if (v.weightHistory == null) { newV.weightHistory = new ulong[1]; } else { ulong[] weightHistory = v.weightHistory; newV.weightHistory = new ulong[Math.Min(weightHistory.Length + 1, historyDepth)]; for (int i = v.weightHistory.Length - 1; i > 0; i--) { newV.weightHistory[i] = weightHistory[i - 1]; } } newV.weightHistory[0] = v.weight; } } } graph.typeGraphOptions = options; graph.filterVersion = filterForm.filterVersion; if (graph.previousGraphTickIndex < graph.allocatedAfterTickIndex) { graph.previousGraphTickIndex = graph.allocatedAfterTickIndex; } graph.allocatedAfterTickIndex = allocatedAfterTickIndex; graph.allocatedBeforeTickIndex = allocatedBeforeTickIndex; GcObject rootObject = CreateRootObject(); for (int i = 0; i < rootCount; i++) { roots[i].InterestLevel = InterestLevel.Ignore; } foreach (GcObject gcObject in idToObject.Values) { gcObject.parent = null; gcObject.vertex = null; gcObject.InterestLevel = InterestLevel.Ignore; } AssignParents(rootObject); int index = 0; foreach (GcType gcType in typeIdToGcType.Values) { gcType.index = index++; } GcType[] gcTypes = new GcType[index]; typeHintTable = new int[index]; foreach (GcType gcType in typeIdToGcType.Values) { gcTypes[gcType.index] = gcType; } AssignInterestLevelsToTypes(options, filterForm); for (int i = 0; i < rootCount; i++) { AssignInterestLevelToObject(rootIDs[i], roots[i], options, filterForm); } foreach (KeyValuePair <ulong, GcObject> keyValuePair in idToObject) { AssignInterestLevelToObject(keyValuePair.Key, keyValuePair.Value, options, filterForm); } foreach (GcObject gcObject in idToObject.Values) { if (gcObject.InterestLevel == InterestLevel.Ignore) { CheckForParentMarkingDescendant(gcObject); } } FindVertex(0, rootObject, graph, options); for (int i = 0; i < rootCount; i++) { roots[i].vertex = null; FindVertex(rootIDs[i], roots[i], graph, options); } foreach (KeyValuePair <ulong, GcObject> keyValuePair in idToObject) { ulong id = keyValuePair.Key; GcObject gcObject = keyValuePair.Value; if (gcObject.parent == null || (gcObject.InterestLevel & (InterestLevel.Interesting | InterestLevel.Display)) == InterestLevel.Ignore) { continue; } FindVertex(id, gcObject, graph, options); } Vertex[] pathFromRoot = new Vertex[32]; foreach (GcObject gcObject in idToObject.Values) { if (gcObject.parent == null || (gcObject.InterestLevel & (InterestLevel.Interesting | InterestLevel.Display)) == InterestLevel.Ignore || gcObject.AllocTickIndex <= allocatedAfterTickIndex || gcObject.AllocTickIndex >= allocatedBeforeTickIndex) { continue; } int levels = 0; for (GcObject pathObject = gcObject; pathObject != null; pathObject = pathObject.parent) { if (pathObject.vertex != null) { levels++; } } while (pathFromRoot.Length < levels + 1) { pathFromRoot = new Vertex[pathFromRoot.Length * 2]; } int level = levels; for (GcObject pathObject = gcObject; pathObject != null; pathObject = pathObject.parent) { if (pathObject.vertex != null) { level--; pathFromRoot[level] = pathObject.vertex; } } levels = Vertex.SqueezeOutRepetitions(pathFromRoot, levels); for (int j = 0; j < levels - 1; j++) { Vertex fromVertex = pathFromRoot[j]; Vertex toVertex = pathFromRoot[j + 1]; Edge edge = graph.FindOrCreateEdge(fromVertex, toVertex); edge.AddWeight(gcObject.Size(this)); } Vertex thisVertex = pathFromRoot[levels - 1]; thisVertex.basicWeight += gcObject.Size(this); thisVertex.count += 1; } foreach (Vertex v in graph.vertices.Values) { if (v.weight < v.outgoingWeight) { v.weight = v.outgoingWeight; } if (v.weight < v.incomingWeight) { v.weight = v.incomingWeight; } if (v.weightHistory == null) { v.weightHistory = new ulong[1]; } } foreach (Vertex v in graph.vertices.Values) { v.active = true; } graph.BottomVertex.active = false; return(graph); }
internal Graph BuildReferenceGraph(Graph orgGraph) { Graph graph = new Graph(this); graph.graphType = Graph.GraphType.ReferenceGraph; Vertex[] pathFromRoot = new Vertex[32]; GcObject rootObject = CreateRootObject(); FindVertex(0, rootObject, graph, BuildTypeGraphOptions.LumpBySignature); rootObject.InterestLevel = InterestLevel.Interesting; foreach (GcObject gcObject in idToObject.Values) { gcObject.parent = null; } // We wish to find all references to certain selected objects, // or, to be precise, all references that keep these objects alive. // To do this, we use a breadth first traversal of the object graph, using // a queue of objects still to process. If we find a reference to one of the // selected objects, we don't actually include this object, but instead // just make note of the reference // Initialize rootObject.parent = null; GcObject foundBeforeMarker = new GcObject(); Queue <GcObject> queue = new Queue <GcObject>(); queue.Enqueue(rootObject); // Loop while (queue.Count != 0) { GcObject head = queue.Dequeue(); foreach (GcObject refObject in head.References) { if (refObject.parent == null || refObject.parent == foundBeforeMarker) { // this is a reference to either one of the "selected" objects // or just to a new object if (refObject.vertex != null && refObject.vertex.selected && (refObject.InterestLevel & (InterestLevel.Interesting | InterestLevel.Display)) != InterestLevel.Ignore && refObject.AllocTickIndex > orgGraph.allocatedAfterTickIndex && refObject.AllocTickIndex < orgGraph.allocatedBeforeTickIndex) { // add <root> -> ... -> head -> refObject to the reference graph int levels = 0; for (GcObject pathObject = head; pathObject != null; pathObject = pathObject.parent) { levels++; } while (pathFromRoot.Length < levels + 2) { pathFromRoot = new Vertex[pathFromRoot.Length * 2]; } pathFromRoot[levels + 1] = graph.FindOrCreateVertex(refObject.vertex.name, refObject.vertex.signature, refObject.vertex.moduleName); int level = levels; for (GcObject pathObject = head; pathObject != null; pathObject = pathObject.parent) { if ((pathObject.InterestLevel & (InterestLevel.Interesting | InterestLevel.Display)) == InterestLevel.Ignore || pathObject.vertex == null) { pathFromRoot[level] = null; } else { pathFromRoot[level] = graph.FindOrCreateVertex(pathObject.vertex.name, pathObject.vertex.signature, pathObject.vertex.moduleName); } level--; } int nonZeroLevels = 0; for (int j = 0; j <= levels + 1; j++) { if (pathFromRoot[j] != null) { pathFromRoot[nonZeroLevels++] = pathFromRoot[j]; } } levels = Vertex.SqueezeOutRepetitions(pathFromRoot, nonZeroLevels); for (int j = 0; j < levels - 1; j++) { Vertex fromVertex = pathFromRoot[j]; Vertex toVertex = pathFromRoot[j + 1]; Edge edge = graph.FindOrCreateEdge(fromVertex, toVertex); edge.AddWeight(1); } Vertex thisVertex = pathFromRoot[levels - 1]; thisVertex.basicWeight += 1; if (refObject.parent == null) { thisVertex.count += 1; refObject.parent = foundBeforeMarker; } } else { refObject.parent = head; queue.Enqueue(refObject); } } } } foreach (Vertex v in graph.vertices.Values) { if (v.weight < v.outgoingWeight) { v.weight = v.outgoingWeight; } if (v.weight < v.incomingWeight) { v.weight = v.incomingWeight; } if (v.weightHistory == null) { v.weightHistory = new ulong[1]; } } foreach (Vertex v in graph.vertices.Values) { v.active = true; } graph.BottomVertex.active = false; return(graph); }
private Dictionary <GcObject, ulong> objectToId; // reverse mapping from gc objects to their addresses internal void WriteVertexPaths(int allocatedAfterTickIndex, int allocatedBeforeTickIndex, string typeName) { BuildTypeGraph(new FilterForm()); if (objectToId == null) { objectToId = new Dictionary <GcObject, ulong>(); // initialize the reverse mapping foreach (KeyValuePair <ulong, GcObject> keyValuePair in idToObject) { objectToId[keyValuePair.Value] = keyValuePair.Key; } } ulong[][] idsFromRoot = new ulong[1][]; Vertex[] pathFromRoot = new Vertex[32]; int counter = 0; foreach (GcObject gcObject in idToObject.Values) { if (gcObject.Type(this).name.CompareTo(typeName) != 0) { continue; } if (gcObject.AllocTickIndex <= allocatedAfterTickIndex || gcObject.AllocTickIndex >= allocatedBeforeTickIndex) { continue; } ulong[][] _idsFromRoot = idsFromRoot; if (_idsFromRoot.Length <= counter) { idsFromRoot = new ulong[counter + 1][]; for (int i = 0; i < _idsFromRoot.Length; i++) { idsFromRoot[i] = _idsFromRoot[i]; } } int levels = 0; for (GcObject pathObject = gcObject; pathObject != null; pathObject = pathObject.parent) { if (pathObject.vertex != null) { levels++; } } while (pathFromRoot.Length < levels + 1) { pathFromRoot = new Vertex[pathFromRoot.Length * 2]; } int level = levels; //System.Console.WriteLine("{0} -- {1}:", counter, gcObject.id); for (GcObject pathObject = gcObject; pathObject != null; pathObject = pathObject.parent) { if (pathObject.vertex != null) { level--; pathFromRoot[level] = pathObject.vertex; pathObject.vertex.id = 0; objectToId.TryGetValue(pathObject, out pathObject.vertex.id); } } levels = Vertex.SqueezeOutRepetitions(pathFromRoot, levels); idsFromRoot[counter] = new ulong[levels]; for (int i = 0; i < levels; i++) { //System.Console.Write("{0}, {1} ->", pathFromRoot[i].name, pathFromRoot[i].id); idsFromRoot[counter][i] = pathFromRoot[i].id; } //System.Console.WriteLine("---------------------------------------"); counter++; } Console.WriteLine("<TotalAllocations>{0}</TotalAllocations>", idsFromRoot.Length); Console.WriteLine("</Difference>"); Console.WriteLine("</Summary>"); Console.WriteLine("<PossibleCulPrits>"); // Display the reference list and stack trace for 0th object // Find Culprit here. var mismatchedObjects = new List <int>(); var differentCulprits = new List <string>(); for (int j = 1; j < idsFromRoot.Length; j++) { for (int i = 0; i < idsFromRoot[0].Length; i++) { if ((i > idsFromRoot[j].Length) || ((i < idsFromRoot[j].Length) && (idsFromRoot[0][i] != idsFromRoot[j][i]))) { if (i < idsFromRoot[0].Length - 1) { mismatchedObjects.Add(j); } GcObject temp = idToObject[idsFromRoot[0][i - 1]]; if (temp != null) { if (!differentCulprits.Contains(temp.Type(this).name)) { differentCulprits.Add(temp.Type(this).name); if (differentCulprits.Count <= 5) { System.Console.WriteLine("<CulPrit><!--{0}--></CulPrit>", temp.Type(this).name); } } } break; } } } Console.WriteLine("</PossibleCulPrits>"); Console.WriteLine("<FirstObject>"); PrintGCRoot(idsFromRoot[0]); PrintStackTrace(idsFromRoot[0]); Console.WriteLine("</FirstObject>"); Console.WriteLine("<MisMatchedObjects>"); if (mismatchedObjects.Count > 0) { Console.WriteLine(); int limit = (mismatchedObjects.Count > 5) ? 5 : mismatchedObjects.Count; for (int i = 0; i < limit; i++) { Console.WriteLine("<Object>"); PrintGCRoot(idsFromRoot[mismatchedObjects[i]]); PrintStackTrace(idsFromRoot[mismatchedObjects[i]]); Console.WriteLine("</Object>"); } } Console.WriteLine("</MisMatchedObjects>"); }
internal Graph BuildTypeGraph(int allocatedAfterTickIndex, int allocatedBeforeTickIndex, BuildTypeGraphOptions options) { if (graph == null || FilterForm.filterVersion != graphFilterVersion || allocatedAfterTickIndex >= 0 || allocatedBeforeTickIndex < int.MaxValue) { graph = new Graph(this); graph.graphType = Graph.GraphType.HeapGraph; graphFilterVersion = FilterForm.filterVersion; graph.previousGraphTickIndex = allocatedAfterTickIndex; } else { ObjectGraph previousGraph = (ObjectGraph)graph.graphSource; graph.previousGraphTickIndex = previousGraph.tickIndex; graph.graphSource = this; foreach (Vertex v in graph.vertices.Values) { if (v.weightHistory == null) { v.weightHistory = new uint[1]; } else { uint[] weightHistory = v.weightHistory; if (weightHistory.Length < historyDepth) { v.weightHistory = new uint[weightHistory.Length + 1]; } for (int i = v.weightHistory.Length - 1; i > 0; i--) { v.weightHistory[i] = weightHistory[i - 1]; } } v.weightHistory[0] = v.weight; v.weight = v.incomingWeight = v.outgoingWeight = v.basicWeight = 0; v.count = 0; foreach (Edge e in v.outgoingEdges.Values) { e.weight = 0; } } } if (graph.previousGraphTickIndex < graph.allocatedAfterTickIndex) { graph.previousGraphTickIndex = graph.allocatedAfterTickIndex; } graph.allocatedAfterTickIndex = allocatedAfterTickIndex; graph.allocatedBeforeTickIndex = allocatedBeforeTickIndex; GcType rootType = GetOrCreateGcType("<root>", 0); GcObject rootObject = GetOrCreateObject(0); rootObject.type = rootType; rootObject.references = roots; foreach (GcObject gcObject in idToObject.Values) { gcObject.level = int.MaxValue; gcObject.vertex = null; } AssignLevels(rootObject); AssignInterestLevels(); int index = 0; foreach (GcType gcType in typeNameToGcType.Values) { gcType.index = index++; } GcType[] gcTypes = new GcType[index]; typeHintTable = new int[index]; foreach (GcType gcType in typeNameToGcType.Values) { gcTypes[gcType.index] = gcType; } Vertex[] pathFromRoot = new Vertex[32]; foreach (GcObject gcObject in idToObject.Values) { if (gcObject.level == int.MaxValue || (gcObject.interestLevel & (InterestLevel.Interesting | InterestLevel.Display)) == InterestLevel.Ignore || gcObject.allocTickIndex <= allocatedAfterTickIndex || gcObject.allocTickIndex >= allocatedBeforeTickIndex) { continue; } while (pathFromRoot.Length < gcObject.level + 1) { pathFromRoot = new Vertex[pathFromRoot.Length * 2]; } for (GcObject pathObject = gcObject; pathObject != null; pathObject = pathObject.parent) { if ((pathObject.interestLevel & (InterestLevel.Interesting | InterestLevel.Display)) == InterestLevel.Ignore) { pathFromRoot[pathObject.level] = null; } else { pathFromRoot[pathObject.level] = FindVertex(pathObject, graph, options); } } int levels = 0; for (int i = 0; i <= gcObject.level; i++) { if (pathFromRoot[i] != null) { pathFromRoot[levels++] = pathFromRoot[i]; } } levels = Vertex.SqueezeOutRepetitions(pathFromRoot, levels); for (int i = 0; i < levels - 1; i++) { Vertex fromVertex = pathFromRoot[i]; Vertex toVertex = pathFromRoot[i + 1]; Edge edge = graph.FindOrCreateEdge(fromVertex, toVertex); edge.AddWeight(gcObject.size); } Vertex thisVertex = pathFromRoot[levels - 1]; thisVertex.basicWeight += gcObject.size; thisVertex.count += 1; } foreach (Vertex v in graph.vertices.Values) { if (v.weight < v.outgoingWeight) { v.weight = v.outgoingWeight; } if (v.weight < v.incomingWeight) { v.weight = v.incomingWeight; } if (v.weightHistory == null) { v.weightHistory = new uint[1]; } } foreach (Vertex v in graph.vertices.Values) { v.active = true; } graph.BottomVertex.active = false; return(graph); }