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);
}
}
}
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 Vertex FindVertex(ulong id, GcObject gcObject, Graph graph, BuildTypeGraphOptions options)
{
Vertex vertex = gcObject.vertex;
if (vertex != null)
{
return(vertex);
}
string signature = SignatureOfObject(id, gcObject, options);
vertex = graph.FindOrCreateVertex(gcObject.Type(this).name, signature, null);
gcObject.vertex = vertex;
return(vertex);
}
internal void AddFunctionVertex(int funcId, string functionName, string signature, Graph graph, ref Vertex[] funcVertex, FilterForm filterForm)
{
EnsureVertexCapacity(funcId, ref funcVertex);
int moduleId = funcModule[funcId];
string moduleName = null;
if (moduleId >= 0)
moduleName = modBasicName[moduleId];
funcVertex[funcId] = graph.FindOrCreateVertex(functionName, signature, moduleName);
funcVertex[funcId].interestLevel = filterForm.InterestLevelOfMethodName(functionName, signature);
}
internal void AddTypeVertex(int typeId, string typeName, Graph graph, ref Vertex[] typeVertex, FilterForm filterForm)
{
EnsureVertexCapacity(typeId, ref typeVertex);
typeVertex[typeId] = graph.FindOrCreateVertex(typeName, null, null);
typeVertex[typeId].interestLevel = filterForm.InterestLevelOfTypeName(typeName, null, finalizableTypes.ContainsKey(typeId));
}
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;
Vertex fromVertex;
Edge edge;
if (ReadNewLog.InterestingCallStack(vertexStack, stackPtr, filterForm))
{
vertexStack[stackPtr] = graph.FindOrCreateVertex(className, null, null);
vertexStack[stackPtr].interestLevel = filterForm.InterestLevelOfMethodName(className, null);
stackPtr++;
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(size);
}
if (toVertex != graph.TopVertex)
{
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;
Vertex fromVertex;
Edge edge;
if (ReadNewLog.InterestingCallStack(vertexStack, stackPtr, filterForm))
{
vertexStack[stackPtr] = handleVertex;
stackPtr++;
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(count);
}
fromVertex = toVertex;
toVertex = graph.BottomVertex;
edge = graph.FindOrCreateEdge(fromVertex, toVertex);
edge.AddWeight(count);
}
}
private Vertex CloneVertex(Graph g, Vertex v)
{
Vertex vn = g.FindOrCreateVertex(v.name, v.signature, v.moduleName);
vn.basicName = v.basicName;
vn.basicSignature = v.basicSignature;
vn.active = true;
return vn;
}
internal void AddTypeVertex(int typeId, string typeName, Graph graph, ref Vertex[] typeVertex, FilterForm filterForm)
{
EnsureVertexCapacity(typeId, ref typeVertex);
typeVertex[typeId] = graph.FindOrCreateVertex(typeName, null, null);
typeVertex[typeId].interestLevel = filterForm.IsInterestingTypeName(typeName, null, finalizableTypes.ContainsKey(typeId))
? InterestLevel.Interesting | filterForm.InterestLevelForParentsAndChildren() : InterestLevel.Ignore;
}
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);
}
internal Vertex FindVertex(GcObject gcObject, Graph graph, BuildTypeGraphOptions options)
{
if (gcObject.vertex != null)
{
return(gcObject.vertex);
}
string signature = null;
StringBuilder sb = new StringBuilder();
if (gcObject.parent != null)
{
switch (options)
{
case BuildTypeGraphOptions.IndividualObjects:
sb.AppendFormat("Address = 0x{0:x}, size = {1:n0} bytes", gcObject.id, gcObject.size);
break;
case BuildTypeGraphOptions.LumpBySignature:
sb.Append(gcObject.parent.type.name);
sb.Append("->");
sb.Append(gcObject.type.name);
if (gcObject.references != null)
{
sb.Append("->(");
ArrayList al = new ArrayList();
string separator = "";
const int MAXREFTYPECOUNT = 3;
int refTypeCount = 0;
for (int i = 0; i < gcObject.references.Length; i++)
{
GcObject refObject = gcObject.references[i];
GcType refType = refObject.type;
if (typeHintTable[refType.index] < i && gcObject.references[typeHintTable[refType.index]].type == refType)
{
; // we already found this type - ignore further occurrences
}
else
{
typeHintTable[refType.index] = i;
refTypeCount++;
if (refTypeCount <= MAXREFTYPECOUNT)
{
al.Add(refType.name);
}
else
{
break;
}
}
}
al.Sort();
foreach (string typeName in al)
{
sb.Append(separator);
separator = ",";
sb.Append(typeName);
}
if (refTypeCount > MAXREFTYPECOUNT)
{
sb.Append(",...");
}
sb.Append(")");
}
break;
default:
Debug.Assert(false);
break;
}
signature = sb.ToString();
}
gcObject.vertex = graph.FindOrCreateVertex(gcObject.type.name, signature, null);
return(gcObject.vertex);
}
