[dart2wasm] Optimize initialization of dispatch table

This reduces essentials main module by 8.3% (-730 KB)

The dispatch table contains displaced selector rows. Each selector row
contains an entry for each class that provides the selector.

This can lead to very large dispatch tables with repeated elements:
Especially common is a base class with selectors that get inherited
by many subclasses where few subclasses override the selector.

This is common e.g. for `Object.{hashCode,operator==,noSuchMethod}` but
also for user defined base classes that have many subclasses.

This led to the element section being very large: It often contains
large consecutive sub-ranges which refer to the same target function.

To shrink the element size we instead move the initialization of those
large regions homogenious regions to the module init function: We can
utilize the `table.fill` instruction which can initialize a large range
of the table with the same value.

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

Author: mkustermann

pkg/dart2wasm/lib/dispatch_table.dart

@@ -827,45 +827,86 @@ class DispatchTable {
   void output() {
     final Map<w.BaseFunction, w.BaseFunction> wrappedDynamicSubmoduleImports =
         {};
-    for (int i = 0; i < _table.length; i++) {
-      Reference? target = _table[i];
-      if (target != null) {
-        w.BaseFunction? fun = translator.functions.getExistingFunction(target);
-        // Any call to the dispatch table is guaranteed to hit a target.
-        //
-        // If a target is in a deferred module and that deferred module hasn't
-        // been loaded yet, then the entry is `null`.
-        //
-        // Though we can only hit a target if that target's class has been
-        // allocated. In order for the class to be allocated, the deferred
-        // module must've been loaded to call the constructor.
-        if (fun != null) {
-          final targetModule = fun.enclosingModule;
-          final targetModuleBuilder =
-              translator.moduleToBuilder[fun.enclosingModule]!;
-          if (targetModule == _definedWasmTable.enclosingModule) {
-            if (isDynamicSubmoduleTable &&
-                targetModuleBuilder == translator.dynamicSubmodule &&
-                fun is w.ImportedFunction) {
-              // Functions imported into submodules may need to be wrapped to
-              // match the updated dispatch table signature.
-              fun = wrappedDynamicSubmoduleImports[fun] ??=
-                  _wrapDynamicSubmoduleFunction(target, fun);
-            }
+    int start = 0;
+    while (start < _table.length) {
+      Reference? target = _table[start];
+      if (target == null) {
+        start++;
+        continue;
+      }
+      w.BaseFunction? fun = translator.functions.getExistingFunction(target);
+      if (fun == null) {
+        start++;
+        continue;
+      }
+
+      // Any call to the dispatch table is guaranteed to hit a target.
+      //
+      // If a target is in a deferred module and that deferred module hasn't
+      // been loaded yet, then the entry is `null`.
+      //
+      // Though we can only hit a target if that target's class has been
+      // allocated. In order for the class to be allocated, the deferred
+      // module must've been loaded to call the constructor.
+      int end = start + 1;
+      while (end < _table.length && _table[end] == target) {
+        end++;
+      }
+      final strideWidth = end - start;
+
+      // If the stride of the current function is more than this (i.e. the table
+      // contains a large subsection with identical function entries) we
+      // initialize that section in #start function.
+      const strideElementTableLimit = 100;
+
+      final targetModule = fun.enclosingModule;
+      final targetModuleBuilder =
+          translator.moduleToBuilder[fun.enclosingModule]!;
+      if (targetModule == _definedWasmTable.enclosingModule) {
+        if (isDynamicSubmoduleTable &&
+            targetModuleBuilder == translator.dynamicSubmodule &&
+            fun is w.ImportedFunction) {
+          // Functions imported into submodules may need to be wrapped to
+          // match the updated dispatch table signature.
+          fun = wrappedDynamicSubmoduleImports[fun] ??=
+              _wrapDynamicSubmoduleFunction(target, fun);
+        }
+
+        if (strideWidth < strideElementTableLimit) {
+          for (int i = start; i < end; ++i) {
             _definedWasmTable.moduleBuilder.elements
                 .activeFunctionSegmentBuilderFor(_definedWasmTable)
                 .setFunctionAt(i, fun);
-          } else {
-            // This will generate the imported table if it doesn't already
-            // exist.
-            final importedTable =
-                getWasmTable(targetModuleBuilder) as w.ImportedTable;
+          }
+        } else {
+          targetModuleBuilder.elements.declarativeSegmentBuilder.declare(fun);
+          final b = targetModuleBuilder.startFunction.body;
+          b.i32_const(start);
+          b.ref_func(fun);
+          b.i32_const(strideWidth);
+          b.table_fill(_definedWasmTable);
+        }
+      } else {
+        // This will generate the imported table if it doesn't already
+        // exist.
+        final importedTable =
+            getWasmTable(targetModuleBuilder) as w.ImportedTable;
+        if (strideWidth < strideElementTableLimit) {
+          for (int i = start; i < end; ++i) {
             targetModuleBuilder.elements
                 .activeFunctionSegmentBuilderFor(importedTable)
                 .setFunctionAt(i, fun);
           }
+        } else {
+          targetModuleBuilder.elements.declarativeSegmentBuilder.declare(fun);
+          final b = targetModuleBuilder.startFunction.body;
+          b.i32_const(start);
+          b.ref_func(fun);
+          b.i32_const(strideWidth);
+          b.table_fill(importedTable);
         }
       }
+      start += strideWidth;
     }
   }
 

pkg/dart2wasm/lib/dynamic_modules.dart

@@ -425,8 +425,7 @@ class DynamicModuleInfo {
   DynamicModuleInfo(this.translator, this.metadata);
 
   void initSubmodule() {
-    submodule.startFunction = initFunction = submodule.functions.define(
-        translator.typesBuilder.defineFunction(const [], const []), "#init");
+    initFunction = submodule.startFunction;
 
     // Make sure the exception tag is exported from the main module.
     translator.getExceptionTag(submodule);
@@ -653,8 +652,6 @@ class DynamicModuleInfo {
   void finishDynamicModule() {
     _registerModuleRefs(
         isSubmodule ? initFunction.body : translator.initFunction.body);
-
-    initFunction.body.end();
   }
 
   void _registerModuleRefs(w.InstructionsBuilder b) {

pkg/dart2wasm/lib/translator.dart

@@ -558,9 +558,7 @@ class Translator with KernelNodes {
   Map<ModuleMetadata, w.Module> translate(
       Uri Function(String moduleName)? sourceMapUrlGenerator) {
     _initModules(sourceMapUrlGenerator);
-    initFunction = mainModule.functions
-        .define(typesBuilder.defineFunction(const [], const []), "#init");
-    mainModule.startFunction = initFunction;
+    initFunction = mainModule.startFunction;
 
     closureLayouter.collect();
     classInfoCollector.collect();
@@ -587,7 +585,6 @@ class Translator with KernelNodes {
     constructorClosures.clear();
     dispatchTable.output();
     staticTablesPerType.outputTables();
-    initFunction.body.end();
 
     for (ConstantInfo info in constants.constantInfo.values) {
       info.printInitializer((function) {

pkg/wasm_builder/lib/src/builder/instructions.dart

@@ -245,6 +245,8 @@ class InstructionsBuilder with Builder<ir.Instructions> {
 
   bool get recordSourceMaps => _sourceMappings != null;
 
+  bool get isEmpty => _instructions.isEmpty;
+
   void collectUsedTypes(Set<ir.DefType> usedTypes) {
     for (final local in locals) {
       final localDefType = local.type.containedDefType;
@@ -923,6 +925,14 @@ class InstructionsBuilder with Builder<ir.Instructions> {
     _add(ir.TableSet(table));
   }
 
+  /// Emit a `table.size` instruction.
+  void table_fill(ir.Table table) {
+    assert(_verifyTypes([ir.NumType.i32, table.type, ir.NumType.i32], const [],
+        trace: ['table.fill', table.name]));
+    assert(table.enclosingModule == module);
+    _add(ir.TableFill(table));
+  }
+
   /// Emit a `table.size` instruction.
   void table_size(ir.Table table) {
     assert(_verifyTypes(const [], const [ir.NumType.i32],

pkg/wasm_builder/lib/src/builder/module.dart

@@ -33,7 +33,7 @@ class ModuleBuilder with Builder<ir.Module> {
   final dataSegments = DataSegmentsBuilder();
   late final globals = GlobalsBuilder(this);
   final exports = ExportsBuilder();
-  ir.BaseFunction? _startFunction;
+  FunctionBuilder? _startFunction;
 
   /// Create a new, initially empty, module.
   ///
@@ -46,13 +46,14 @@ class ModuleBuilder with Builder<ir.Module> {
     types = TypesBuilder(this, parent: parent?.types);
   }
 
-  set startFunction(ir.BaseFunction init) {
-    assert(_startFunction == null);
-    _startFunction = init;
-  }
+  FunctionBuilder get startFunction => _startFunction ??=
+      functions.define(types.defineFunction(const [], const []), "#init");
 
   @override
   ir.Module forceBuild() {
+    if (_startFunction case final start?) {
+      start.body.end();
+    }
     final finalFunctions = functions.build();
     final finalTables = tables.build();
     final finalElements = elements.build();

pkg/wasm_builder/lib/src/ir/instruction.dart

@@ -554,6 +554,8 @@ abstract class Instruction implements Serializable {
               return I64TruncSatF64U.deserialize(d);
             case 0x10:
               return TableSize.deserialize(d, tables);
+            case 0x11:
+              return TableFill.deserialize(d, tables);
             default:
               throw "Invalid instruction byte: 0xFC $opcode";
           }
@@ -1485,6 +1487,32 @@ class TableGet extends Instruction {
   }
 }
 
+class TableFill extends Instruction {
+  final Table table;
+
+  TableFill(this.table);
+
+  static TableFill deserialize(Deserializer d, Tables tables) {
+    return TableFill(tables[d.readUnsigned()]);
+  }
+
+  @override
+  void serialize(Serializer s) {
+    s.writeByte(0xFC);
+    s.writeByte(0x11);
+    s.writeUnsigned(table.index);
+  }
+
+  @override
+  String get name => 'table.fill';
+
+  @override
+  void printTo(IrPrinter p) {
+    p.write(name);
+    p.writeTableReference(table);
+  }
+}
+
 class TableSize extends Instruction {
   final Table table;