[vm_snapshot_analysis] Add buildComparisonTreemap

This helper method compares two size profiles and returns result
as a treemap.

Cq-Include-Trybots: luci.dart.try:pkg-linux-debug-try,pkg-linux-release-try,pkg-win-release-try,pkg-mac-release-try
Change-Id: I82e5617bc367a2b89d3685ce7f7babc01492b531
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/152908
Reviewed-by: Vyacheslav Egorov <[email protected]>
Commit-Queue: Vyacheslav Egorov <[email protected]>

Author: mraleph

pkg/vm_snapshot_analysis/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.4.0
+
+- Add `buildComparisonTreemap` for constructing treemap representing the diff
+between two size profiles.
+
 ## 0.3.0
 
 - Extract treemap construction code into a separate library, to make it

pkg/vm_snapshot_analysis/lib/treemap.dart

@@ -93,40 +93,65 @@ Map<String, dynamic> treemapFromJson(Object inputJson,
       collapseSingleChildPathNodes: collapseSingleChildPathNodes);
 }
 
+/// Convert the given [ProgramInfo] object into a treemap in either
+/// [TreemapFormat.collapsed] or [TreemapFormat.simplified] format.
+///
+/// See [treemapFromJson] for the schema of the returned map object.
+Map<String, dynamic> treemapFromInfo(ProgramInfo info,
+    {TreemapFormat format = TreemapFormat.collapsed,
+    bool collapseSingleChildPathNodes = true}) {
+  final root = {'n': '', 'children': {}, 'k': kindPath, 'maxDepth': 0};
+  _treemapFromInfo(root, info, format: format);
+  return _flatten(root,
+      collapseSingleChildPathNodes: collapseSingleChildPathNodes);
+}
+
+void _treemapFromInfo(Map<String, dynamic> root, ProgramInfo info,
+    {TreemapFormat format = TreemapFormat.simplified}) {
+  if (format != TreemapFormat.collapsed && format != TreemapFormat.simplified) {
+    throw ArgumentError(
+      'can only build simplified or collapsed formats from the program info',
+    );
+  }
+
+  int cumulativeSize(ProgramInfoNode node) {
+    return (node.size ?? 0) +
+        node.children.values
+            .fold<int>(0, (sum, child) => sum + cumulativeSize(child));
+  }
+
+  void recurse(ProgramInfoNode node, String path, Map<String, dynamic> root,
+      TreemapFormat format) {
+    if (node.children.isEmpty ||
+        (node.type == NodeType.functionNode &&
+            format == TreemapFormat.simplified)) {
+      // For simple format we remove information about nested functions from
+      // the output.
+      _addSymbol(root, path, node.name, cumulativeSize(node));
+      return;
+    }
+
+    path = path != '' ? '$path/${node.name}' : node.name;
+    _addSymbol(root, path, '<self>', node.size);
+    for (var child in node.children.values) {
+      recurse(child, path, root, format);
+    }
+  }
+
+  _addSymbol(root, '', info.root.name, info.root.size);
+  for (var child in info.root.children.values) {
+    recurse(child, '', root, format);
+  }
+}
+
 void _treemapFromSnapshot(Map<String, dynamic> root, v8_profile.Snapshot snap,
     {TreemapFormat format = TreemapFormat.objectType}) {
   final info = v8_profile.toProgramInfo(snap);
 
   // For collapsed and simple formats there is no need to traverse snapshot
   // nodes. Just recurse into [ProgramInfo] structure instead.
   if (format == TreemapFormat.collapsed || format == TreemapFormat.simplified) {
-    int cumulativeSize(ProgramInfoNode node) {
-      return (node.size ?? 0) +
-          node.children.values
-              .fold<int>(0, (sum, child) => sum + cumulativeSize(child));
-    }
-
-    void recurse(ProgramInfoNode node, String path) {
-      if (node.children.isEmpty ||
-          (node.type == NodeType.functionNode &&
-              format == TreemapFormat.simplified)) {
-        // For simple format we remove information about nested functions from
-        // the output.
-        _addSymbol(root, path, node.name, cumulativeSize(node));
-        return;
-      }
-
-      path = path != '' ? '$path/${node.name}' : node.name;
-      _addSymbol(root, path, '<self>', node.size);
-      for (var child in node.children.values) {
-        recurse(child, path);
-      }
-    }
-
-    _addSymbol(root, '', info.root.name, info.root.size);
-    for (var child in info.root.children.values) {
-      recurse(child, '');
-    }
+    _treemapFromInfo(root, info, format: format);
     return;
   }
 

pkg/vm_snapshot_analysis/lib/utils.dart

@@ -10,6 +10,7 @@ import 'package:vm_snapshot_analysis/ascii_table.dart';
 import 'package:vm_snapshot_analysis/program_info.dart';
 import 'package:vm_snapshot_analysis/instruction_sizes.dart'
     as instruction_sizes;
+import 'package:vm_snapshot_analysis/treemap.dart';
 import 'package:vm_snapshot_analysis/v8_profile.dart' as v8_profile;
 
 Future<Object> loadJson(File input) async {
@@ -32,6 +33,20 @@ Future<ProgramInfo> loadProgramInfo(File input,
   }
 }
 
+/// Compare two size profiles and return result of the comparison as a treemap.
+Future<Map<String, dynamic>> buildComparisonTreemap(File oldJson, File newJson,
+    {TreemapFormat format = TreemapFormat.collapsed,
+    bool collapseAnonymousClosures = false}) async {
+  final oldSizes = await loadProgramInfo(oldJson,
+      collapseAnonymousClosures: collapseAnonymousClosures);
+  final newSizes = await loadProgramInfo(newJson,
+      collapseAnonymousClosures: collapseAnonymousClosures);
+
+  final diff = computeDiff(oldSizes, newSizes);
+
+  return treemapFromInfo(diff, format: format);
+}
+
 void printHistogram(ProgramInfo info, Histogram histogram,
     {Iterable<String> prefix = const [],
     Iterable<String> suffix = const [],

pkg/vm_snapshot_analysis/pubspec.yaml

@@ -1,6 +1,6 @@
 name: vm_snapshot_analysis
 description: Utilities for working with non-symbolic stack traces.
-version: 0.3.0
+version: 0.4.0
 
 homepage: https://github.com/dart-lang/sdk/tree/master/pkg/vm_snapshot_analysis