[vm/tool] Improvements to snapshot_analysis summary command.

It now supports filtering by name and displaying additional
histogram bucketed by object type.

Issue dart-lang/sdk#41249

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

Author: mraleph

pkg/vm/lib/snapshot/commands/compare.dart

@@ -41,8 +41,9 @@ Use --narrow flag to limit column widths.''';
           help: 'Truncate column content to the given width'
               ' (${AsciiTable.unlimitedWidth} means do not truncate).',
           defaultsTo: AsciiTable.unlimitedWidth.toString())
-      ..addOption('granularity',
-          help: 'Choose the granularity of the output.',
+      ..addOption('by',
+          abbr: 'b',
+          help: 'Choose the breakdown rule for the output.',
           allowed: ['method', 'class', 'library', 'package'],
           defaultsTo: 'method')
       ..addFlag('collapse-anonymous-closures', help: '''
@@ -75,7 +76,7 @@ precisely based on their source position (which is included in their name).
     final newJsonPath = _checkExists(argResults.rest[1]);
     printComparison(oldJsonPath, newJsonPath,
         maxWidth: maxWidth,
-        granularity: _parseHistogramType(argResults['granularity']),
+        granularity: _parseHistogramType(argResults['by']),
         collapseAnonymousClosures: argResults['collapse-anonymous-closures']);
   }
 
@@ -121,12 +122,12 @@ precisely based on their source position (which is included in their name).
     final totalDiff = diff.totalSize;
 
     // Compute histogram.
-    final histogram = SizesHistogram.from(diff, granularity);
+    final histogram = computeHistogram(diff, granularity);
 
     // Now produce the report table.
     const numLargerSymbolsToReport = 30;
     const numSmallerSymbolsToReport = 10;
-    printHistogram(histogram,
+    printHistogram(diff, histogram,
         sizeHeader: 'Diff (Bytes)',
         prefix: histogram.bySize
             .where((k) => histogram.buckets[k] > 0)

pkg/vm/lib/snapshot/commands/summary.dart

@@ -35,10 +35,16 @@ This tool can process snapshot size reports produced by
           help: 'Truncate column content to the given width'
               ' (${AsciiTable.unlimitedWidth} means do not truncate).',
           defaultsTo: AsciiTable.unlimitedWidth.toString())
-      ..addOption('granularity',
-          help: 'Choose the granularity of the output.',
+      ..addOption('by',
+          abbr: 'b',
+          help: 'Choose breakdown rule of the output.',
           allowed: ['method', 'class', 'library', 'package'],
           defaultsTo: 'method')
+      ..addOption(
+        'where',
+        abbr: 'w',
+        help: 'Filter output using the given glob.',
+      )
       ..addFlag('collapse-anonymous-closures', help: '''
 Collapse all anonymous closures from the same scope into a single entry.
 When comparing size of AOT snapshots for two different versions of a
@@ -76,8 +82,9 @@ precisely based on their source position (which is included in their name).
 
     await outputSummary(input,
         maxWidth: maxWidth,
-        granularity: _parseHistogramType(argResults['granularity']),
-        collapseAnonymousClosures: argResults['collapse-anonymous-closures']);
+        granularity: _parseHistogramType(argResults['by']),
+        collapseAnonymousClosures: argResults['collapse-anonymous-closures'],
+        filter: argResults['where']);
   }
 
   static HistogramType _parseHistogramType(String value) {
@@ -98,14 +105,23 @@ precisely based on their source position (which is included in their name).
 void outputSummary(File input,
     {int maxWidth = 0,
     bool collapseAnonymousClosures = false,
-    HistogramType granularity = HistogramType.bySymbol}) async {
+    HistogramType granularity = HistogramType.bySymbol,
+    String filter}) async {
   final info = await loadProgramInfo(input);
 
   // Compute histogram.
-  final histogram = SizesHistogram.from(info, granularity);
+  final histogram = computeHistogram(info, granularity, filter: filter);
 
   // Now produce the report table.
   const topToReport = 30;
-  printHistogram(histogram,
+  printHistogram(info, histogram,
       prefix: histogram.bySize.take(topToReport), maxWidth: maxWidth);
+
+  if (info.snapshotInfo != null) {
+    print('\nBreakdown by object type:');
+    final typeHistogram =
+        computeHistogram(info, HistogramType.byNodeType, filter: filter);
+    printHistogram(info, typeHistogram,
+        prefix: typeHistogram.bySize, maxWidth: maxWidth);
+  }
 }

pkg/vm/lib/snapshot/program_info.dart

@@ -59,7 +59,8 @@ class ProgramInfo {
   /// Recursively visit all function nodes, which have [FunctionInfo.info]
   /// populated.
   void visit(
-      void Function(String pkg, String lib, String cls, String fun, int size)
+      void Function(
+              String pkg, String lib, String cls, String fun, ProgramInfoNode n)
           callback) {
     final context = List<String>(NodeType.values.length);
 
@@ -71,13 +72,11 @@ class ProgramInfo {
         context[node._type] = node.name;
       }
 
-      if (node.size != null) {
-        final String pkg = context[NodeType.packageNode.index];
-        final String lib = context[NodeType.libraryNode.index];
-        final String cls = context[NodeType.classNode.index];
-        final String mem = context[NodeType.functionNode.index];
-        callback(pkg, lib, cls, mem, node.size);
-      }
+      final String pkg = context[NodeType.packageNode.index];
+      final String lib = context[NodeType.libraryNode.index];
+      final String cls = context[NodeType.classNode.index];
+      final String mem = context[NodeType.functionNode.index];
+      callback(pkg, lib, cls, mem, node);
 
       for (var child in node.children.values) {
         recurse(child);
@@ -91,8 +90,8 @@ class ProgramInfo {
 
   int get totalSize {
     var result = 0;
-    visit((pkg, lib, cls, fun, size) {
-      result += size;
+    visit((pkg, lib, cls, fun, node) {
+      result += node.size ?? 0;
     });
     return result;
   }
@@ -181,13 +180,11 @@ Iterable<T> _allKeys<T>(Map<T, dynamic> a, Map<T, dynamic> b) {
   return <T>{...?a?.keys, ...?b?.keys};
 }
 
-/// Histogram of sizes based on a [ProgramInfo] bucketed using one of the
-/// [HistogramType] rules.
-class SizesHistogram {
+class Histogram {
   /// Rule used to produce this histogram. Specifies how bucket names
   /// are constructed given (library-uri,class-name,function-name) tuples and
   /// how these bucket names can be deconstructed back into human readable form.
-  final Bucketing bucketing;
+  final BucketInfo bucketInfo;
 
   /// Histogram buckets.
   final Map<String, int> buckets;
@@ -200,24 +197,77 @@ class SizesHistogram {
 
   int get length => bySize.length;
 
-  SizesHistogram._(this.bucketing, this.buckets, this.bySize, this.totalSize);
+  Histogram._(this.bucketInfo, this.buckets)
+      : bySize = buckets.keys.toList(growable: false)
+          ..sort((a, b) => buckets[b] - buckets[a]),
+        totalSize = buckets.values.fold(0, (sum, size) => sum + size);
+
+  static Histogram fromIterable<T>(
+    Iterable<T> entries, {
+    @required int Function(T) sizeOf,
+    @required String Function(T) bucketFor,
+    @required BucketInfo bucketInfo,
+  }) {
+    final buckets = <String, int>{};
+
+    for (var e in entries) {
+      final bucket = bucketFor(e);
+      final size = sizeOf(e);
+      buckets[bucket] = (buckets[bucket] ?? 0) + size;
+    }
+
+    return Histogram._(bucketInfo, buckets);
+  }
+}
+
+/// Construct the histogram of specific [type] given a [ProgramInfo].
+Histogram computeHistogram(ProgramInfo info, HistogramType type,
+    {String filter}) {
+  bool Function(String, String, String) matchesFilter;
+
+  if (filter != null) {
+    final re = RegExp(filter.replaceAll('*', '.*'), caseSensitive: false);
+    matchesFilter = (lib, cls, fun) => re.hasMatch("${lib}::${cls}.${fun}");
+  } else {
+    matchesFilter = (_, __, ___) => true;
+  }
+
+  if (type == HistogramType.byNodeType) {
+    final Set<int> filteredNodes = {};
+    if (filter != null) {
+      info.visit((pkg, lib, cls, fun, node) {
+        if (matchesFilter(lib, cls, fun)) {
+          filteredNodes.add(node.id);
+        }
+      });
+    }
 
-  /// Construct the histogram of specific [type] given a [ProgramInfo].
-  static SizesHistogram from(ProgramInfo info, HistogramType type) {
+    return Histogram.fromIterable<Node>(
+        info.snapshotInfo.snapshot.nodes.where((n) =>
+            filter == null ||
+            filteredNodes.contains(info.snapshotInfo.ownerOf(n).id)),
+        sizeOf: (n) {
+          return n.selfSize;
+        },
+        bucketFor: (n) => n.type,
+        bucketInfo: const BucketInfo(nameComponents: ['Type']));
+  } else {
     final buckets = <String, int>{};
     final bucketing = Bucketing._forType[type];
 
-    var totalSize = 0;
-    info.visit((pkg, lib, cls, fun, size) {
+    info.visit((pkg, lib, cls, fun, node) {
+      if (node.size == null || node.size == 0) {
+        return;
+      }
+
       final bucket = bucketing.bucketFor(pkg, lib, cls, fun);
-      buckets[bucket] = (buckets[bucket] ?? 0) + size;
-      totalSize += size;
+      if (!matchesFilter(lib, cls, fun)) {
+        return;
+      }
+      buckets[bucket] = (buckets[bucket] ?? 0) + node.size;
     });
 
-    final bySize = buckets.keys.toList(growable: false);
-    bySize.sort((a, b) => buckets[b] - buckets[a]);
-
-    return SizesHistogram._(bucketing, buckets, bySize, totalSize);
+    return Histogram._(bucketing, buckets);
   }
 }
 
@@ -226,22 +276,28 @@ enum HistogramType {
   byClass,
   byLibrary,
   byPackage,
+  byNodeType,
 }
 
-abstract class Bucketing {
+class BucketInfo {
   /// Specifies which human readable name components can be extracted from
   /// the bucket name.
-  List<String> get nameComponents;
+  final List<String> nameComponents;
 
+  /// Deconstructs bucket name into human readable components (the order matches
+  /// one returned by [nameComponents]).
+  List<String> namesFromBucket(String bucket) => [bucket];
+
+  const BucketInfo({@required this.nameComponents});
+}
+
+abstract class Bucketing extends BucketInfo {
   /// Constructs the bucket name from the given library name [lib], class name
   /// [cls] and function name [fun].
   String bucketFor(String pkg, String lib, String cls, String fun);
 
-  /// Deconstructs bucket name into human readable components (the order matches
-  /// one returned by [nameComponents]).
-  List<String> namesFromBucket(String bucket);
-
-  const Bucketing();
+  const Bucketing({@required List<String> nameComponents})
+      : super(nameComponents: nameComponents);
 
   static const _forType = {
     HistogramType.bySymbol: _BucketBySymbol(),
@@ -255,9 +311,6 @@ abstract class Bucketing {
 const String _nameSeparator = ';;;';
 
 class _BucketBySymbol extends Bucketing {
-  @override
-  List<String> get nameComponents => const ['Library', 'Symbol'];
-
   @override
   String bucketFor(String pkg, String lib, String cls, String fun) {
     if (fun == null) {
@@ -269,13 +322,10 @@ class _BucketBySymbol extends Bucketing {
   @override
   List<String> namesFromBucket(String bucket) => bucket.split(_nameSeparator);
 
-  const _BucketBySymbol();
+  const _BucketBySymbol() : super(nameComponents: const ['Library', 'Symbol']);
 }
 
 class _BucketByClass extends Bucketing {
-  @override
-  List<String> get nameComponents => ['Library', 'Class'];
-
   @override
   String bucketFor(String pkg, String lib, String cls, String fun) {
     if (cls == null) {
@@ -287,34 +337,22 @@ class _BucketByClass extends Bucketing {
   @override
   List<String> namesFromBucket(String bucket) => bucket.split(_nameSeparator);
 
-  const _BucketByClass();
+  const _BucketByClass() : super(nameComponents: const ['Library', 'Class']);
 }
 
 class _BucketByLibrary extends Bucketing {
-  @override
-  List<String> get nameComponents => ['Library'];
-
   @override
   String bucketFor(String pkg, String lib, String cls, String fun) => '$lib';
 
-  @override
-  List<String> namesFromBucket(String bucket) => [bucket];
-
-  const _BucketByLibrary();
+  const _BucketByLibrary() : super(nameComponents: const ['Library']);
 }
 
 class _BucketByPackage extends Bucketing {
-  @override
-  List<String> get nameComponents => ['Package'];
-
   @override
   String bucketFor(String pkg, String lib, String cls, String fun) =>
       pkg ?? lib;
 
-  @override
-  List<String> namesFromBucket(String bucket) => [bucket];
-
-  const _BucketByPackage();
+  const _BucketByPackage() : super(nameComponents: const ['Package']);
 }
 
 String packageOf(String lib) {