Add generateCallGraphWithDominators method to generate a CallGraph from a precompiler trace.

Exposing this functionality makes it possible to use this logic in Dart DevTools.

This CL also includes some renames that make the code more readable. When there are both `ProgramInfoNode`s and `CallGraphNode`s in scope, the name "node" is ambiguous.

Bug: #43169
Change-Id: Ic8ef04e10c48db011cd28e1786bee34223766e47
Cq-Include-Trybots: luci.dart.try:pkg-linux-release-try,pkg-win-release-try,pkg-mac-release-try
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/160342
Commit-Queue: Kenzie Schmoll <[email protected]>
Reviewed-by: Vyacheslav Egorov <[email protected]>

Author: kenzieschmoll

pkg/vm_snapshot_analysis/CHANGELOG.md

@@ -5,6 +5,8 @@
 depth of outputted dependency trees configurable.
 - Rename `deps-collapse-depth` (formerly `-d`) flag for `summary` command to
 `deps-start-depth` (now `-s`).
+- Add `generateCallGraphWithDominators` method that generates a `CallGraph`
+object from precompiler trace.
 
 ## 0.5.4
 - Fix bug causing name clash for Type class.

pkg/vm_snapshot_analysis/lib/precompiler_trace.dart

@@ -105,21 +105,21 @@ class CallGraph {
 
   // Mapping from [ProgramInfoNode] to a corresponding [CallGraphNode] (if any)
   // via [ProgramInfoNode.id].
-  final List<CallGraphNode> _nodeByEntityId;
+  final List<CallGraphNode> _graphNodeByEntityId;
 
-  CallGraph._(this.program, this.nodes, this._nodeByEntityId);
+  CallGraph._(this.program, this.nodes, this._graphNodeByEntityId);
 
   CallGraphNode get root => nodes.first;
 
-  CallGraphNode lookup(ProgramInfoNode node) => _nodeByEntityId[node.id];
+  CallGraphNode lookup(ProgramInfoNode node) => _graphNodeByEntityId[node.id];
 
   Iterable<CallGraphNode> get dynamicCalls =>
       nodes.where((n) => n.isDynamicCallNode);
 
   /// Compute a collapsed version of the call-graph, where
   CallGraph collapse(NodeType type, {bool dropCallNodes = false}) {
-    final nodesByData = <Object, CallGraphNode>{};
-    final nodeByEntityId = <CallGraphNode>[];
+    final graphNodesByData = <Object, CallGraphNode>{};
+    final graphNodeByEntityId = <CallGraphNode>[];
 
     ProgramInfoNode collapsed(ProgramInfoNode nn) {
       // Root always collapses onto itself.
@@ -138,24 +138,24 @@ class CallGraph {
       return n;
     }
 
-    CallGraphNode nodeFor(Object data) {
-      return nodesByData.putIfAbsent(data, () {
-        final n = CallGraphNode(nodesByData.length, data: data);
+    CallGraphNode callGraphNodeFor(Object data) {
+      return graphNodesByData.putIfAbsent(data, () {
+        final n = CallGraphNode(graphNodesByData.length, data: data);
         if (data is ProgramInfoNode) {
-          if (nodeByEntityId.length <= data.id) {
-            nodeByEntityId.length = data.id * 2 + 1;
+          if (graphNodeByEntityId.length <= data.id) {
+            graphNodeByEntityId.length = data.id * 2 + 1;
           }
-          nodeByEntityId[data.id] = n;
+          graphNodeByEntityId[data.id] = n;
         }
         return n;
       });
     }
 
     final newNodes = nodes.map((n) {
       if (n.data is ProgramInfoNode) {
-        return nodeFor(collapsed(n.data));
+        return callGraphNodeFor(collapsed(n.data));
       } else if (!dropCallNodes) {
-        return nodeFor(n.data);
+        return callGraphNodeFor(n.data);
       }
     }).toList(growable: false);
 
@@ -170,8 +170,8 @@ class CallGraph {
       }
     }
 
-    return CallGraph._(
-        program, nodesByData.values.toList(growable: false), nodeByEntityId);
+    return CallGraph._(program, graphNodesByData.values.toList(growable: false),
+        graphNodeByEntityId);
   }
 
   /// Compute dominator tree of the call-graph.
@@ -529,3 +529,21 @@ class _TraceReader {
         name: libraryUri, parent: node, type: NodeType.libraryNode);
   }
 }
+
+/// Generates a [CallGraph] from the given [precompilerTrace], which is produced
+/// by `--trace-precompiler-to`, then collapses it down to the granularity
+/// specified by [nodeType], and computes dominators of the resulting graph.
+CallGraph generateCallGraphWithDominators(
+  Object precompilerTrace,
+  NodeType nodeType,
+) {
+  var callGraph = loadTrace(precompilerTrace);
+
+  // Convert call graph into the approximate dependency graph, dropping any
+  // dynamic and dispatch table based dependencies from the graph and only
+  // following the static call, field access and allocation edges.
+  callGraph = callGraph.collapse(nodeType, dropCallNodes: true)
+    ..computeDominators();
+
+  return callGraph;
+}

pkg/vm_snapshot_analysis/lib/src/commands/summary.dart

@@ -187,17 +187,13 @@ void outputSummary(File input,
       (granularity == HistogramType.byLibrary ||
           granularity == HistogramType.byPackage)) {
     final traceJsonRaw = await loadJsonFromFile(traceJson);
-    var callGraph = loadTrace(traceJsonRaw);
-
-    // Convert call graph into the approximate dependency graph, dropping any
-    // dynamic and dispatch table based dependencies from the graph and only
-    // following the static call, field access and allocation edges.
-    callGraph = callGraph.collapse(
-        granularity == HistogramType.byLibrary
-            ? NodeType.libraryNode
-            : NodeType.packageNode,
-        dropCallNodes: true);
-    callGraph.computeDominators();
+
+    final callGraph = generateCallGraphWithDominators(
+      traceJsonRaw,
+      granularity == HistogramType.byLibrary
+          ? NodeType.libraryNode
+          : NodeType.packageNode,
+    );
 
     // Compute name mapping from histogram buckets to new coarser buckets, by
     // collapsing dependency tree at [depsStartDepth] level: node 'Foo' with

pkg/vm_snapshot_analysis/pubspec.yaml

@@ -1,6 +1,6 @@
 name: vm_snapshot_analysis
 description: Utilities for analysing AOT snapshot size.
-version: 0.5.5-dev.1
+version: 0.5.5
 
 homepage: https://github.com/dart-lang/sdk/tree/master/pkg/vm_snapshot_analysis