[dart2wasm] Add self-compile dart2wasm benchmark.

We make the core of dart2wasm independent of dart:io and add a
`pkg/dart2wasm/benchmark/self_compile_benchmark.dart` file.

We can compile it with

  * `dart compile exe` and measure
  * `dart compile wasm` and masure on various JS engines

The current results (assuming I measured correctly) are:

            | Time | Memory
    -----------------------
    VM AOT  |  32s | 0.8 GB
    -----------------------
    D8      |  32s | 1.3 GB
    ----------------------
    JSShell |  87s | 2.8 GB
    -----------------------
    JSC     |  70s | 4.4 GB

Measured via something like
```
% dart compile exe -o selfcompile.exe \
    pkg/dart2wasm/benchmark/self_compile_benchmark.dart
% dart compile wasm --no-minify --no-strip-wasm -O2 \
    -o selfcompile.wasm \
    pkg/dart2wasm/benchmark/self_compile_benchmark.dart

% alias measure="/usr/bin/time -f '%M peak KB, %e seconds'"

% measure ./selfcompile.exe
% measure pkg/dart2wasm/tool/run_benchmark --d8 selfcompile.wasm
% measure pkg/dart2wasm/tool/run_benchmark --jsc selfcompile.wasm
% measure pkg/dart2wasm/tool/run_benchmark --jsshell selfcompile.wasm
```

The added test can be run via
```
% python3 tools/test.py -n unittest-mac pkg/dart2wasm/test/self_compile_test
...
```

Change-Id: I9a3eeb5e8a7867f0e3ec7729cec57f10da221ae5
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/442860
Reviewed-by: Ömer Ağacan <[email protected]>
Commit-Queue: Martin Kustermann <[email protected]>

Author: mkustermann

pkg/dart2wasm/benchmark/filesystem_base.dart

@@ -0,0 +1,96 @@
+// Copyright (c) 2025, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:convert';
+import 'dart:io' show FileSystemException;
+import 'dart:typed_data';
+
+import 'package:front_end/src/api_prototype/file_system.dart'
+    show FileSystem, FileSystemEntity;
+
+final _fakeSdkRoot = '/FakeSdkRoot';
+
+abstract class WasmCompilerFileSystemBase implements FileSystem {
+  final String sdkRoot = _fakeSdkRoot;
+
+  @override
+  FileSystemEntity entityForUri(Uri uri) =>
+      WasmCompilerFileSystemEntity(this, uri);
+
+  Future<String?> _tryReadString(Uri uri) async {
+    final bytes = await _tryReadBytes(uri);
+    if (bytes == null) return null;
+    return utf8.decode(bytes);
+  }
+
+  Future<Uint8List?> _tryReadBytes(Uri uri) async {
+    String relativePath;
+    final path = uri.path;
+    if (path.startsWith('/')) {
+      assert(uri.path.startsWith(_fakeSdkRoot));
+      relativePath = uri.path.substring(_fakeSdkRoot.length + 1);
+    } else {
+      relativePath = path;
+    }
+
+    return tryReadBytesSync(relativePath);
+  }
+
+  void writeStringSync(String filename, String value) {
+    writeBytesSync(filename, utf8.encode(value));
+  }
+
+  // Overriden by subclasses.
+  Uint8List? tryReadBytesSync(String relativePath);
+
+  // Overriden by subclasses.
+  void writeBytesSync(String filename, Uint8List bytes);
+}
+
+class WasmCompilerFileSystemEntity implements FileSystemEntity {
+  final WasmCompilerFileSystemBase _fileSystem;
+
+  @override
+  final Uri uri;
+
+  WasmCompilerFileSystemEntity(this._fileSystem, this.uri);
+
+  @override
+  int get hashCode => Object.hash(_fileSystem, uri);
+
+  @override
+  bool operator ==(Object other) =>
+      other is WasmCompilerFileSystemEntity &&
+      other._fileSystem == _fileSystem &&
+      other.uri == uri;
+
+  @override
+  Future<bool> exists() async {
+    // CFE uses it to detect whether a directory exists.
+    // We claim it does (because we cannot use JS APIs to detect existence of
+    // directory).
+    if (uri.path.endsWith('/')) return true;
+    return (await _fileSystem._tryReadBytes(uri)) != null;
+  }
+
+  @override
+  Future<bool> existsAsyncIfPossible() => exists();
+
+  @override
+  Future<Uint8List> readAsBytes() async {
+    final result = await _fileSystem._tryReadBytes(uri);
+    if (result != null) return result;
+    throw FileSystemException('Failed to read $uri');
+  }
+
+  @override
+  Future<Uint8List> readAsBytesAsyncIfPossible() => readAsBytes();
+
+  @override
+  Future<String> readAsString() async {
+    final result = await _fileSystem._tryReadString(uri);
+    if (result != null) return result;
+    throw FileSystemException('Failed to read $uri');
+  }
+}

pkg/dart2wasm/benchmark/filesystem_io.dart

@@ -0,0 +1,25 @@
+// Copyright (c) 2025, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:io';
+import 'dart:typed_data';
+
+import 'filesystem_base.dart';
+
+class WasmCompilerFileSystem extends WasmCompilerFileSystemBase {
+  @override
+  Uint8List? tryReadBytesSync(String relativePath) {
+    try {
+      return File(relativePath).readAsBytesSync();
+    } catch (_) {
+      print('-> failed to load $relativePath');
+      return null;
+    }
+  }
+
+  @override
+  void writeBytesSync(String filename, Uint8List bytes) {
+    File(filename).writeAsBytesSync(bytes);
+  }
+}

pkg/dart2wasm/benchmark/filesystem_js.dart

@@ -0,0 +1,79 @@
+// Copyright (c) 2025, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:js_interop';
+import 'dart:typed_data';
+
+import 'filesystem_base.dart';
+
+class WasmCompilerFileSystem extends WasmCompilerFileSystemBase {
+  @override
+  Uint8List? tryReadBytesSync(String path) {
+    try {
+      if (isD8) {
+        return d8Read(path).toDart.asUint8List();
+      }
+      if (isJSC) {
+        path = path.startsWith('/') ? path : '../../$path';
+        return jscRead(path, 'binary').toDart;
+      }
+      if (isJSShell) {
+        return jsshellRead(path, 'binary').toDart;
+      }
+      throw 'Unknown JS Shell';
+    } catch (_) {
+      print('-> failed to load $path');
+      return null;
+    }
+  }
+
+  @override
+  void writeBytesSync(String path, Uint8List bytes) {
+    try {
+      if (isJSShell) {
+        return jsshellWrite(path, bytes.toJS);
+      }
+      final buffer =
+          (Uint8List(bytes.length)..setRange(0, bytes.length, bytes)).buffer;
+      if (isD8) {
+        return d8Write(path, buffer.toJS);
+      }
+      if (isJSC) {
+        path = path.startsWith('/') ? path : '../../$path';
+        return jscWrite(path, buffer.toJS);
+      }
+      throw 'Unknown JS Shell';
+    } catch (_) {
+      print('-> failed to write to $path');
+    }
+  }
+}
+
+final bool isD8 = d8Only != null;
+final bool isJSC = !isD8 && notD8JSCOnly != null;
+final bool isJSShell = !isD8 && !isJSC;
+
+@JS('readbuffer')
+external JSArrayBuffer d8Read(String filename);
+
+@JS('writeFile')
+external void d8Write(String filename, JSArrayBuffer bytes);
+
+@JS('readFile') // Have to prepend ../../ for relative paths
+external JSUint8Array jscRead(String filename, String binary);
+
+@JS('writeFile') // Have to prepend ../../ for relative paths
+external void jscWrite(String filename, JSArrayBuffer bytes);
+
+@JS('os.file.readFile')
+external JSUint8Array jsshellRead(String filename, String binary);
+
+@JS('os.file.writeTypedArrayToFile')
+external void jsshellWrite(String filename, JSUint8Array bytes);
+
+@JS('readbuffer')
+external JSAny? d8Only;
+
+@JS('readFile')
+external JSAny? notD8JSCOnly;

pkg/dart2wasm/benchmark/self_compile_benchmark.dart

@@ -0,0 +1,46 @@
+// Copyright (c) 2025, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:_fe_analyzer_shared/src/util/colors.dart' as colors;
+import 'package:dart2wasm/compile.dart';
+import 'package:dart2wasm/compiler_options.dart';
+
+import 'filesystem_io.dart' if (dart.library.js_interop) 'filesystem_js.dart';
+
+Future main(List<String> args) async {
+  final sw = Stopwatch()..start();
+  final fileSystem = WasmCompilerFileSystem();
+  final result = await compile(
+      fileSystem, 'pkg/dart2wasm/benchmark/self_compile_benchmark.dart');
+  print('Dart2WasmSelfCompile(RunTimeRaw): ${sw.elapsed.inMilliseconds} ms.');
+
+  if (args.isNotEmpty) {
+    final module = result.wasmModules.values.single;
+    final wasmFile = args.single;
+    fileSystem.writeBytesSync(wasmFile, module.moduleBytes);
+  }
+}
+
+Future<CompilationSuccess> compile(
+    WasmCompilerFileSystem fileSystem, String mainFile) async {
+  // Avoid CFE self-detecting whether `stdout`/`stderr` is terminal and supports
+  // colors (as we don't have `dart:io` available when we run dart2wasm in a
+  // wasm runtime).
+  colors.enableColors = false;
+
+  final main = Uri.file('${fileSystem.sdkRoot}/$mainFile');
+
+  final options = WasmCompilerOptions(mainUri: main, outputFile: 'out.wasm');
+  options.librariesSpecPath =
+      Uri.file('${fileSystem.sdkRoot}/sdk/lib/libraries.json');
+
+  final result = await compileToModule(
+      options, fileSystem, (mod) => Uri.parse('$mod.maps'), (diag) {
+    print('Diagnostics: ${diag.severity} ${diag.plainTextFormatted}');
+  });
+  if (result is! CompilationSuccess) {
+    throw 'Compilation Failed: $result';
+  }
+  return result;
+}

pkg/dart2wasm/lib/compile.dart

@@ -7,8 +7,7 @@ import 'dart:typed_data';
 
 import 'package:build_integration/file_system/multi_root.dart'
     show MultiRootFileSystem, MultiRootFileSystemEntity;
-import 'package:front_end/src/api_prototype/standard_file_system.dart'
-    show StandardFileSystem;
+import 'package:front_end/src/api_prototype/file_system.dart' show FileSystem;
 import 'package:front_end/src/api_unstable/vm.dart'
     show
         CompilerOptions,
@@ -21,6 +20,7 @@ import 'package:kernel/class_hierarchy.dart';
 import 'package:kernel/core_types.dart';
 import 'package:kernel/kernel.dart' show writeComponentToText;
 import 'package:kernel/library_index.dart';
+import 'package:kernel/text/ast_to_text.dart';
 import 'package:kernel/type_environment.dart';
 import 'package:kernel/verifier.dart';
 import 'package:vm/kernel_front_end.dart' show writeDepfile;
@@ -30,6 +30,7 @@ import 'package:vm/transformations/to_string_transformer.dart'
     as to_string_transformer;
 import 'package:vm/transformations/type_flow/transformer.dart' as globalTypeFlow
     show transformComponent;
+import 'package:vm/transformations/type_flow/utils.dart' as tfa_utils;
 import 'package:vm/transformations/unreachable_code_elimination.dart'
     as unreachable_code_elimination;
 import 'package:wasm_builder/wasm_builder.dart' show Serializer;
@@ -64,7 +65,7 @@ class CompilationSuccess extends CompilationResult {
   CompilationSuccess(this.wasmModules, this.jsRuntime, this.supportJs);
 }
 
-class CompilationError extends CompilationResult {}
+abstract class CompilationError extends CompilationResult {}
 
 /// The CFE has crashed with an exception.
 ///
@@ -74,6 +75,9 @@ class CFECrashError extends CompilationError {
   final StackTrace stackTrace;
 
   CFECrashError(this.error, this.stackTrace);
+
+  @override
+  String toString() => 'CFECrashError($error):\n$stackTrace';
 }
 
 /// Compiling the Dart program resulted in compile-time errors.
@@ -122,8 +126,10 @@ const List<String> _librariesToIndex = [
 /// mappings.
 Future<CompilationResult> compileToModule(
     compiler.WasmCompilerOptions options,
+    FileSystem fileSystem,
     Uri Function(String moduleName)? sourceMapUrlGenerator,
-    void Function(DiagnosticMessage) handleDiagnosticMessage) async {
+    void Function(DiagnosticMessage) handleDiagnosticMessage,
+    {void Function(String, String)? writeFile}) async {
   var hadCompileTimeError = false;
   void diagnosticMessageHandler(DiagnosticMessage message) {
     if (message.severity == Severity.error) {
@@ -161,12 +167,13 @@ Future<CompilationResult> compileToModule(
     }
     ..explicitExperimentalFlags = options.feExperimentalFlags
     ..verbose = false
-    ..onDiagnostic = diagnosticMessageHandler;
+    ..onDiagnostic = diagnosticMessageHandler
+    ..fileSystem = fileSystem;
   if (options.multiRootScheme != null) {
     compilerOptions.fileSystem = MultiRootFileSystem(
         options.multiRootScheme!,
         options.multiRoots.isEmpty ? [Uri.base] : options.multiRoots,
-        StandardFileSystem.instance);
+        compilerOptions.fileSystem);
   }
 
   Future<Uri?> resolveUri(Uri? uri) async {
@@ -229,8 +236,8 @@ Future<CompilationResult> compileToModule(
       ClassHierarchy(component, coreTypes) as ClosedWorldClassHierarchy;
   LibraryIndex libraryIndex = LibraryIndex(component, _librariesToIndex);
 
-  if (options.dumpKernelAfterCfe != null) {
-    writeComponentToText(component, path: options.dumpKernelAfterCfe!);
+  if (options.dumpKernelAfterCfe != null && writeFile != null) {
+    writeFile(options.dumpKernelAfterCfe!, writeComponentToString(component));
   }
 
   if (options.deleteToStringPackageUri.isNotEmpty) {
@@ -269,8 +276,8 @@ Future<CompilationResult> compileToModule(
       isDynamicSubmodule: isDynamicSubmodule);
   target.recordClasses = recordClasses;
 
-  if (options.dumpKernelBeforeTfa != null) {
-    writeComponentToText(component, path: options.dumpKernelBeforeTfa!);
+  if (options.dumpKernelBeforeTfa != null && writeFile != null) {
+    writeFile(options.dumpKernelBeforeTfa!, writeComponentToString(component));
   }
 
   mixin_deduplication.transformLibraries(librariesToTransform);
@@ -313,6 +320,11 @@ Future<CompilationResult> compileToModule(
   if (!isDynamicSubmodule) {
     _patchMainTearOffs(coreTypes, component);
 
+    // We initialize the [printStats] to `false` to prevent it's field
+    // initializer to run (which only works on VM -- but we want our compiler
+    // to also run if compiled via dart2js/dart2wasm)
+    tfa_utils.printStats = false;
+
     // Keep the flags in-sync with
     // pkg/vm/test/transformations/type_flow/transformer_test.dart
     globalTypeFlow.transformComponent(target, coreTypes, component,
@@ -454,3 +466,9 @@ String _generateSupportJs(TranslatorOptions options) {
   ];
   return '(${requiredFeatures.join('&&')})';
 }
+
+String writeComponentToString(Component component) {
+  final buffer = StringBuffer();
+  Printer(buffer).writeComponentFile(component);
+  return '$buffer';
+}

pkg/dart2wasm/lib/generate_wasm.dart

@@ -4,6 +4,8 @@
 
 import 'dart:io';
 
+import 'package:front_end/src/api_prototype/standard_file_system.dart'
+    show StandardFileSystem;
 import 'package:front_end/src/api_unstable/vm.dart' show printDiagnosticMessage;
 import 'package:path/path.dart' as path;
 
@@ -76,9 +78,12 @@ Future<int> generateWasm(WasmCompilerOptions options,
       ? moduleNameToRelativeSourceMapUri
       : null;
 
-  CompilationResult result =
-      await compileToModule(options, relativeSourceMapUrlMapper, (message) {
+  CompilationResult result = await compileToModule(
+      options, StandardFileSystem.instance, relativeSourceMapUrlMapper,
+      (message) {
     if (!options.dryRun) printDiagnosticMessage(message, errorPrinter);
+  }, writeFile: (String filename, String content) {
+    File(filename).writeAsStringSync(content);
   });
 
   if (result is CompilationDryRunResult) {