Beispiel #1
0
        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);
        }
Beispiel #2
0
        internal string SignatureOfObject(ulong id, GcObject gcObject, BuildTypeGraphOptions options)
        {
            StringBuilder sb = new StringBuilder();

            if (gcObject.parent != null)
            {
                switch (options)
                {
                case    BuildTypeGraphOptions.IndividualObjects:
                    if (gcObject.Type(this).name == "Stack" || gcObject.Type(this).name.StartsWith("Stack, "))
                    {
                        if (id < (ulong)readNewLog.funcName.Length)
                        {
                            sb.AppendFormat(readNewLog.funcName[id] + "  " + readNewLog.funcSignature[id]);
                        }
                        else
                        {
                            sb.AppendFormat("Function id = {0}", id);
                        }
                    }
                    else
                    {
                        sb.AppendFormat("Address = {0}, size = {1:n0} bytes", FormatAddress(id), gcObject.Size(this));
                    }
                    break;

                case    BuildTypeGraphOptions.LumpBySignature:
                    sb.Append(gcObject.parent.Type(this).name);
                    sb.Append("->");
                    sb.Append(gcObject.Type(this).name);
                    List <GcObject> references = new List <GcObject>();
                    foreach (GcObject refObject in gcObject.References)
                    {
                        references.Add(refObject);
                    }

                    if (references.Count > 0)
                    {
                        sb.Append("->(");

                        const int     MAXREFTYPECOUNT = 3;
                        List <string> typeNameList    = new List <string>(MAXREFTYPECOUNT);
                        string        separator       = "";
                        int           refTypeCount    = 0;
                        for (int i = 0; i < references.Count; i++)
                        {
                            GcObject refObject = references[i];
                            GcType   refType   = refObject.Type(this);
                            if (typeHintTable[refType.index] < i && references[typeHintTable[refType.index]].Type(this) == refType)
                            {
                                ;       // we already found this type - ignore further occurrences
                            }
                            else
                            {
                                typeHintTable[refType.index] = i;
                                refTypeCount++;
                                if (refTypeCount <= MAXREFTYPECOUNT)
                                {
                                    typeNameList.Add(refType.name);
                                }
                                else
                                {
                                    break;
                                }
                            }
                            i++;
                        }
                        typeNameList.Sort();

                        foreach (string typeName in typeNameList)
                        {
                            sb.Append(separator);
                            separator = ",";
                            sb.Append(typeName);
                        }

                        if (refTypeCount > MAXREFTYPECOUNT)
                        {
                            sb.Append(",...");
                        }

                        sb.Append(")");
                    }
                    break;

                default:
                    Debug.Assert(false);
                    break;
                }
            }
            return(sb.ToString());
        }