[vm/aot] Add support to instance calls with unboxed parameters

In order to have instance calls with unboxed parameters, all
the possible targets need to be able to those parameters unboxed.
Then, the methods were partitioned according to the class hierarchy,
and the inferred types from TFA are used to determine the parameters
that could be unboxed.

This is done for non-nullable integer and double parameters, and
return value.

dart-aot linux x64:

Bench2D                8.028%
DeltaBlue              4.688%
ParticleSystemPaint    27.79%

Flutter release android-armv8:

velocity_tracker_bench -2.026% (less is better)

flutter_gallery_total_size -0.1460%
flutter_gallery_instructions_size -0.2715%
flutter_gallery_readonlydata_size 0.0539%

Issue dart-lang/sdk#33549

Change-Id: Iedd9b4321c3d78b406ea1708e15c747754433027
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/138501
Commit-Queue: Victor Agnez Lima <victoragnez@google.com>
Reviewed-by: Martin Kustermann <kustermann@google.com>
Reviewed-by: Samir Jindel <sjindel@google.com>

Author: victoragnez

pkg/vm/bin/dump_kernel.dart

@@ -16,6 +16,8 @@ import 'package:vm/metadata/procedure_attributes.dart'
     show ProcedureAttributesMetadataRepository;
 import 'package:vm/metadata/table_selector.dart'
     show TableSelectorMetadataRepository;
+import 'package:vm/metadata/unboxing_info.dart'
+    show UnboxingInfoMetadataRepository;
 import 'package:vm/metadata/unreachable.dart'
     show UnreachableNodeMetadataRepository;
 import 'package:vm/metadata/call_site_attributes.dart'
@@ -42,6 +44,7 @@ main(List<String> arguments) async {
   component.addMetadataRepository(new InferredTypeMetadataRepository());
   component.addMetadataRepository(new ProcedureAttributesMetadataRepository());
   component.addMetadataRepository(new TableSelectorMetadataRepository());
+  component.addMetadataRepository(new UnboxingInfoMetadataRepository());
   component.addMetadataRepository(new UnreachableNodeMetadataRepository());
   component.addMetadataRepository(new BytecodeMetadataRepository());
   component.addMetadataRepository(new CallSiteAttributesMetadataRepository());

pkg/vm/lib/metadata/unboxing_info.dart

@@ -0,0 +1,60 @@
+// Copyright (c) 2020, 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:kernel/ast.dart';
+
+class UnboxingInfoMetadata {
+  static const kBoxed = 0;
+  static const kUnboxedIntCandidate = 1 << 0;
+  static const kUnboxedDoubleCandidate = 1 << 1;
+  static const kUnboxingCandidate =
+      kUnboxedIntCandidate | kUnboxedDoubleCandidate;
+
+  final List<int> unboxedArgsInfo;
+  int returnInfo;
+
+  UnboxingInfoMetadata(int argsLen) : unboxedArgsInfo = [] {
+    for (int i = 0; i < argsLen; i++) {
+      unboxedArgsInfo.add(kUnboxingCandidate);
+    }
+    returnInfo = kUnboxingCandidate;
+  }
+
+  UnboxingInfoMetadata.readFromBinary(BinarySource source)
+      : unboxedArgsInfo = List<int>.generate(
+            source.readUInt(), (_) => source.readByte(),
+            growable: true),
+        returnInfo = source.readByte();
+
+  void writeToBinary(BinarySink sink) {
+    sink.writeUInt30(unboxedArgsInfo.length);
+    for (int val in unboxedArgsInfo) {
+      sink.writeByte(val);
+    }
+    sink.writeByte(returnInfo);
+  }
+}
+
+class UnboxingInfoMetadataRepository
+    extends MetadataRepository<UnboxingInfoMetadata> {
+  static const repositoryTag = 'vm.unboxing-info.metadata';
+
+  @override
+  final String tag = repositoryTag;
+
+  @override
+  final Map<TreeNode, UnboxingInfoMetadata> mapping =
+      <TreeNode, UnboxingInfoMetadata>{};
+
+  @override
+  void writeToBinary(
+      UnboxingInfoMetadata metadata, Node node, BinarySink sink) {
+    metadata.writeToBinary(sink);
+  }
+
+  @override
+  UnboxingInfoMetadata readFromBinary(Node node, BinarySource source) {
+    return UnboxingInfoMetadata.readFromBinary(source);
+  }
+}

pkg/vm/lib/transformations/type_flow/transformer.dart

@@ -19,13 +19,15 @@ import 'calls.dart';
 import 'summary.dart';
 import 'table_selector.dart';
 import 'types.dart';
+import 'unboxing_info.dart';
 import 'utils.dart';
 import '../pragma.dart';
 import '../devirtualization.dart' show Devirtualization;
 import '../../metadata/direct_call.dart';
 import '../../metadata/inferred_type.dart';
 import '../../metadata/procedure_attributes.dart';
 import '../../metadata/table_selector.dart';
+import '../../metadata/unboxing_info.dart';
 import '../../metadata/unreachable.dart';
 
 const bool kDumpClassHierarchy =
@@ -73,7 +75,12 @@ Component transformComponent(
   new TFADevirtualization(component, typeFlowAnalysis, hierarchy)
       .visitComponent(component);
 
-  new AnnotateKernel(component, typeFlowAnalysis).visitComponent(component);
+  final unboxingInfo = new UnboxingInfoManager(typeFlowAnalysis);
+
+  _makePartition(component, typeFlowAnalysis, unboxingInfo);
+
+  new AnnotateKernel(component, typeFlowAnalysis, unboxingInfo)
+      .visitComponent(component);
 
   transformsStopWatch.stop();
 
@@ -117,10 +124,13 @@ class AnnotateKernel extends RecursiveVisitor<Null> {
   final ProcedureAttributesMetadataRepository _procedureAttributesMetadata;
   final TableSelectorMetadataRepository _tableSelectorMetadata;
   final TableSelectorAssigner _tableSelectorAssigner;
+  final UnboxingInfoMetadataRepository _unboxingInfoMetadata;
+  final UnboxingInfoManager _unboxingInfo;
   final Class _intClass;
   Constant _nullConstant;
 
-  AnnotateKernel(Component component, this._typeFlowAnalysis)
+  AnnotateKernel(
+      Component component, this._typeFlowAnalysis, this._unboxingInfo)
       : _directCallMetadataRepository =
             component.metadata[DirectCallMetadataRepository.repositoryTag],
         _inferredTypeMetadata = new InferredTypeMetadataRepository(),
@@ -129,11 +139,13 @@ class AnnotateKernel extends RecursiveVisitor<Null> {
             new ProcedureAttributesMetadataRepository(),
         _tableSelectorMetadata = new TableSelectorMetadataRepository(),
         _tableSelectorAssigner = new TableSelectorAssigner(),
+        _unboxingInfoMetadata = new UnboxingInfoMetadataRepository(),
         _intClass = _typeFlowAnalysis.environment.coreTypes.intClass {
     component.addMetadataRepository(_inferredTypeMetadata);
     component.addMetadataRepository(_unreachableNodeMetadata);
     component.addMetadataRepository(_procedureAttributesMetadata);
     component.addMetadataRepository(_tableSelectorMetadata);
+    component.addMetadataRepository(_unboxingInfoMetadata);
   }
 
   // Query whether a call site was marked as a direct call by the analysis.
@@ -301,13 +313,35 @@ class AnnotateKernel extends RecursiveVisitor<Null> {
               skipCheck: uncheckedParameters.contains(param));
         }
 
-        Type resultType = _typeFlowAnalysis.getSummary(member).resultType;
-        _setInferredType(member, resultType);
+        final unboxingInfoMetadata =
+            _unboxingInfo.getUnboxingInfoOfMember(member);
+
+        if (unboxingInfoMetadata != null) {
+          _unboxingInfoMetadata.mapping[member] = unboxingInfoMetadata;
+        }
 
         // TODO(alexmarkov): figure out how to pass receiver type.
       }
     } else if (!member.isAbstract) {
       _setUnreachable(member);
+    } else if (member is! Field) {
+      final unboxingInfoMetadata =
+          _unboxingInfo.getUnboxingInfoOfMember(member);
+      if (unboxingInfoMetadata != null) {
+        // Check for partitions that only have abstract methods should be marked as boxed.
+        if (unboxingInfoMetadata.returnInfo ==
+            UnboxingInfoMetadata.kUnboxingCandidate) {
+          unboxingInfoMetadata.returnInfo = UnboxingInfoMetadata.kBoxed;
+        }
+        for (int i = 0; i < unboxingInfoMetadata.unboxedArgsInfo.length; i++) {
+          if (unboxingInfoMetadata.unboxedArgsInfo[i] ==
+              UnboxingInfoMetadata.kUnboxingCandidate) {
+            unboxingInfoMetadata.unboxedArgsInfo[i] =
+                UnboxingInfoMetadata.kBoxed;
+          }
+        }
+        _unboxingInfoMetadata.mapping[member] = unboxingInfoMetadata;
+      }
     }
 
     // We need to attach ProcedureAttributesMetadata to all members, even
@@ -427,6 +461,76 @@ class AnnotateKernel extends RecursiveVisitor<Null> {
   }
 }
 
+// Partition the methods in order to idenfity parameters and return values
+// that are unboxing candidates
+void _makePartition(Component component, TypeFlowAnalysis typeFlowAnalysis,
+    UnboxingInfoManager unboxingInfo) {
+  // Traverses all the members and creates the partition graph.
+  // Currently unboxed parameters and return value are not supported for
+  // closures, therefore they do not exist in this graph
+  for (bool registering in const [true, false]) {
+    for (Library library in component.libraries) {
+      for (Class cls in library.classes) {
+        for (Member member in cls.members) {
+          if (registering) {
+            unboxingInfo.registerMember(member);
+          } else {
+            unboxingInfo.linkWithSuperClasses(member);
+          }
+        }
+      }
+      if (registering) {
+        for (Member member in library.members) {
+          unboxingInfo.registerMember(member);
+        }
+      }
+    }
+  }
+  unboxingInfo.finishGraph();
+
+  for (Library library in component.libraries) {
+    for (Class cls in library.classes) {
+      for (Member member in cls.members) {
+        _updateUnboxingInfoOfMember(member, typeFlowAnalysis, unboxingInfo);
+      }
+    }
+    for (Member member in library.members) {
+      _updateUnboxingInfoOfMember(member, typeFlowAnalysis, unboxingInfo);
+    }
+  }
+}
+
+void _updateUnboxingInfoOfMember(Member member,
+    TypeFlowAnalysis typeFlowAnalysis, UnboxingInfoManager unboxingInfo) {
+  if (typeFlowAnalysis.isMemberUsed(member) && (member is! Field)) {
+    final Args<Type> argTypes = typeFlowAnalysis.argumentTypes(member);
+    assertx(argTypes != null);
+
+    final int firstParamIndex =
+        numTypeParams(member) + (hasReceiverArg(member) ? 1 : 0);
+
+    final positionalParams = member.function.positionalParameters;
+    assertx(
+        argTypes.positionalCount == firstParamIndex + positionalParams.length);
+
+    for (int i = 0; i < positionalParams.length; i++) {
+      final inferredType = argTypes.values[firstParamIndex + i];
+      unboxingInfo.applyToArg(member, i, inferredType);
+    }
+
+    final names = argTypes.names;
+    for (int i = 0; i < names.length; i++) {
+      final inferredType =
+          argTypes.values[firstParamIndex + positionalParams.length + i];
+      unboxingInfo.applyToArg(
+          member, positionalParams.length + i, inferredType);
+    }
+
+    final Type resultType = typeFlowAnalysis.getSummary(member).resultType;
+    unboxingInfo.applyToReturn(member, resultType);
+  }
+}
+
 /// Tree shaking based on results of type flow analysis (TFA).
 ///
 /// TFA provides information about allocated classes and reachable member