[CFE] Additions to benchmarker.dart et al

## Added --cache to benchmarker.dart

This doubles the amount of runs by running an additional round of `perf
stat` runs outputting low level cache information: L1-icache-load-misses
(instruction load misses), LLC-loads (last level cache loads, i.e.
probably how many loads goes to L3 cache) and LLC-load-misses (last
level cache load misses, i.e. how many loads goes to ram). I don't know
if these are generally available, only that they are available on my
machine.

## Added --silent to benchmarker.dart

Some benchmarks output information to stdout which is great when running
it by hand, but when running it via the benchmarker script it just
pollutes the output: The benchmarker script et al measures what is
supposed to be measured. This CL adds the `--silent` option to the
benchmarker script which then won't print the stdout output from the
benchmarkee.

## Output filename in benchmarker.dart

This CL adds the filenames of the benchmarked snapshots in an attempt to
avoid confusion. Example output before:

```
Comparing snapshot #1 with snapshot #2
```

```
Example output now:
Comparing snapshot #1 (optimization_attempt_41.aot) with snapshot #2 (optimization_attempt_42.aot)
```

## Utility to summarize --verbose-gc output

Takes input from --verbose-gc from stdin and summarizes the time taken
on GC and reports it back. Example:

```
$ out/ReleaseX64/dart --verbose-gc hello.dart 2> /dev/stdout 1> /dev/null | out/ReleaseX64/dart pkg/front_end/tool/verbose_gc_helper.dart
6.1
```

Change-Id: I206f21cd8b42f844e60358aed711e676e453c77c
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/406845
Reviewed-by: Johnni Winther <johnniwinther@google.com>
Commit-Queue: Jens Johansen <jensj@google.com>

Author: jensjoha

pkg/front_end/test/spell_checking_list_tests.txt

@@ -424,6 +424,7 @@ hunk
 hurray
 i'm
 ia
+icache
 identification
 idle
 if's
@@ -499,6 +500,7 @@ linebreaks
 lints
 listening
 listing
+llc
 ln
 locale
 locating

pkg/front_end/tool/benchmarker.dart

@@ -12,6 +12,8 @@ late final Uri repoDir = computeRepoDirUri();
 void main(List<String> args) {
   if (args.contains("--help")) return _help();
   _checkEnvironment();
+  bool doCacheBenchmarkingToo = false;
+  bool silent = false;
   int iterations = 5;
   int core = 7;
   String? aotRuntime;
@@ -31,6 +33,10 @@ void main(List<String> args) {
       arguments.add(arg.substring("--arguments=".length));
     } else if (arg.startsWith("--filesize=")) {
       checkFileSize = arg.substring("--filesize=".length);
+    } else if (arg == "--cache") {
+      doCacheBenchmarkingToo = true;
+    } else if (arg == "--silent") {
+      silent = true;
     } else {
       throw "Don't know argument '$arg'";
     }
@@ -44,6 +50,17 @@ void main(List<String> args) {
     print("Note: Running without any arguments to the snapshots.");
   }
 
+  _doRun(iterations, snapshots, aotRuntime, core, arguments, checkFileSize,
+      cacheBenchmarking: false, silent: silent);
+  if (doCacheBenchmarkingToo) {
+    _doRun(iterations, snapshots, aotRuntime, core, arguments, checkFileSize,
+        cacheBenchmarking: true, silent: silent);
+  }
+}
+
+void _doRun(int iterations, List<String> snapshots, String aotRuntime, int core,
+    List<String> arguments, String? checkFileSize,
+    {required bool cacheBenchmarking, required bool silent}) {
   print("Will now run $iterations iterations with "
       "${snapshots.length} snapshots.");
 
@@ -54,9 +71,14 @@ void main(List<String> args) {
     List<Map<String, num>> snapshotResults = [];
     runResults.add(snapshotResults);
     for (int iteration = 0; iteration < iterations; iteration++) {
+      // We want this silent to mean no stdout print, but still want progress
+      // info which is what the dot provides.
+      if (silent) stdout.write(".");
       Map<String, num> benchmarkRun = _benchmark(
           aotRuntime, core, snapshot, [], arguments,
-          warnings: warnings);
+          warnings: warnings,
+          cacheBenchmarking: cacheBenchmarking,
+          silent: silent);
       if (checkFileSize != null) {
         File f = new File(checkFileSize);
         if (f.existsSync()) {
@@ -67,14 +89,17 @@ void main(List<String> args) {
     }
 
     // Do a single GC run too.
-    gcInfos.add(_verboseGcRun(aotRuntime, snapshot, [], arguments));
+    if (silent) stdout.write(".");
+    gcInfos
+        .add(_verboseGcRun(aotRuntime, snapshot, [], arguments, silent: true));
   }
   stdout.write("\n\n");
 
   List<Map<String, num>> firstSnapshotResults = runResults.first;
   for (int i = 1; i < runResults.length; i++) {
     if (i > 1) print("");
-    print("Comparing snapshot #1 with snapshot #${i + 1}");
+    print("Comparing snapshot #1 (${_getName(snapshots[0])}) with "
+        "snapshot #${i + 1} (${_getName(snapshots[i])})");
     List<Map<String, num>> compareToResults = runResults[i];
     if (!_compare(firstSnapshotResults, compareToResults)) {
       print("No change.");
@@ -92,6 +117,10 @@ void main(List<String> args) {
   }
 }
 
+String _getName(String urlIsh) {
+  return Uri.parse(urlIsh).pathSegments.last;
+}
+
 void _help() {
   print("CFE benchmarker tool");
   print("");
@@ -170,30 +199,38 @@ List<num> _extractDataForCaption(String caption, List<Map<String, num>> data) {
 
 Map<String, num> benchmark(
     String snapshot, List<String> extraVmArguments, List<String> arguments,
-    {String? aotRuntime, int? core}) {
+    {String? aotRuntime, int? core, bool cacheBenchmarking = false}) {
   return _benchmark(aotRuntime ?? _computeAotRuntime(), core ?? 7, snapshot,
       extraVmArguments, arguments,
-      silent: true);
+      silent: true, cacheBenchmarking: cacheBenchmarking);
 }
 
 late final RegExp _extractNumbers =
     new RegExp(r"([\d+\,\.]+)\s+(.+)\s*", caseSensitive: false);
 
 Map<String, num> _benchmark(String aotRuntime, int core, String snapshot,
     List<String> extraVmArguments, List<String> arguments,
-    {bool silent = false, Warnings? warnings}) {
+    {bool silent = false, Warnings? warnings, bool cacheBenchmarking = false}) {
   if (!silent) stdout.write(".");
+
+  // These influence scaling, so only pick 3 (apparently that's now the
+  // magic limit)
+  String scalingEvents = "cycles:u,"
+      "instructions:u,"
+      "branch-misses:u";
+  if (cacheBenchmarking) {
+    scalingEvents = "L1-icache-load-misses:u,"
+        "LLC-loads:u,"
+        "LLC-load-misses:u";
+  }
   ProcessResult processResult = Process.runSync("perf", [
     "stat",
     "-B",
     "-e",
     // These doesn't influence scaling
     "task-clock:u,context-switches:u,cpu-migrations:u,page-faults:u,"
-        // These influence scaling, so only pick 3 (apparently that's now the
-        // magic limit)
-        "cycles:u,"
-        "instructions:u,"
-        "branch-misses:u",
+        // These influence scaling
+        "$scalingEvents",
     "taskset",
     "-c",
     "$core",
@@ -309,6 +346,10 @@ bool _whichOk(String what) {
 
 GCInfo parseVerboseGcOutput(ProcessResult processResult) {
   List<String> stderrLines = processResult.stderr.split("\n");
+  return parseVerboseGcText(stderrLines);
+}
+
+GCInfo parseVerboseGcText(List<String> stderrLines) {
   double combinedTime = 0;
   Map<String, int> countWhat = {};
   for (String line in stderrLines) {

pkg/front_end/tool/verbose_gc_helper.dart

@@ -0,0 +1,30 @@
+import 'dart:async';
+import 'dart:convert';
+import 'dart:typed_data' show BytesBuilder;
+import 'dart:io';
+
+import 'benchmarker.dart';
+
+/// Take --verbose-gc data from stdin and print the combined runtime.
+///
+/// E.g. (and this is not pretty):
+/// out/ReleaseX64/dart --verbose-gc \
+///   hello.dart 2> /dev/stdout 1> /dev/null | out/ReleaseX64/dart \
+///   pkg/front_end/tool/verbose_gc_helper.dart
+Future<void> main() async {
+  Completer completer = new Completer();
+  BytesBuilder bb = new BytesBuilder();
+  late StreamSubscription<List<int>> subscription;
+  subscription = stdin.listen((List<int> data) {
+    bb.add(data);
+  }, onDone: () {
+    subscription.cancel();
+    completer.complete();
+  }, onError: (_) {
+    subscription.cancel();
+    completer.complete();
+  });
+  await completer.future;
+  GCInfo gcInfo = parseVerboseGcText(utf8.decode(bb.takeBytes()).split("\n"));
+  print(gcInfo.combinedTime);
+}