[VM] Introduction of type testing stubs - Part 4

In order to avoid generating type testing stubs for too many types in
the system - and thereby potentially cause an increase in code size -
this change introduces a smarter way to decide for which types we should
generate optimized type testing stubs.

The precompiler creates a [TypeUsageInfo] which we use to collect
information.  More specifically:

   a) We collect the destination types for all type checks we emit
      (we do this inside AssertAssignableInstr::EmitNativeCode).

      -> These are types we might want to generate optimized type testing
         stubs for.

   b) We collect type argument vectors used in instance creations (we do
      this inside AllocateObjectInstr::EmitNativeCode) and keep a set of
      of used type argument vectors for each class.

After the precompiler has finished compiling normal code we scan the set
of destination types collected in a) for uninstantiated types (or more
specifically, type parameter types).

We then propagate the type argument vectors used on object allocation sites,
which were collected in b), in order to find out what kind of types are flowing
into those type parameters.

This allows us to extend the set of types which we test against, by
adding the types that flow into type parameters.

We use this final augmented set of destination types as a "filter" when
making the decision whether to generate an optimized type testing stub
for a given type.

Issue dart-lang/sdk#32603

Measured impact on flutter HEAD-HEAD-HEAD with TTS Part 1 - 4 applied (2018-04-03):

      * stock build benchmark: around 4% improvement
      * gallery app.so size: -2.68%  (13987348 -> 13612928)
      * gallery memory: no sigificant changes:
         - SubtypeTestCache: - 10kb
         - ObjectPool: + 6 kb
         - Type: no change (probably due to wasted alignment slot before)
         - TypeParameter: + 4 kb (can get rid of the field here later)
      * gallery AOT compile-time: measured +1.3%, inside flakiness range

Change-Id: I12a398d18f970ba2db741913bb47b0f36ae38d58
Reviewed-on: https://dart-review.googlesource.com/48640
Commit-Queue: Martin Kustermann <[email protected]>
Reviewed-by: Régis Crelier <[email protected]>

Author: mkustermann

runtime/vm/compiler/aot/precompiler.cc

@@ -272,6 +272,10 @@ void Precompiler::DoCompileAll(
 
       ClassFinalizer::SortClasses();
 
+      // Collects type usage information which allows us to decide when/how to
+      // optimize runtime type tests.
+      TypeUsageInfo type_usage_info(T);
+
       // The cid-ranges of subclasses of a class are e.g. used for is/as checks
       // as well as other type checks.
       HierarchyInfo hierarchy_info(T);
@@ -1897,6 +1901,12 @@ void Precompiler::AttachOptimizedTypeTestingStub() {
   // "dynamic") we need to mark it as writable.
   Dart::vm_isolate()->heap()->WriteProtect(false);
 
+  TypeUsageInfo* type_usage_info = Thread::Current()->type_usage_info();
+
+  // At this point we're not generating any new code, so we build a picture of
+  // which types we might type-test against.
+  type_usage_info->BuildTypeUsageInformation();
+
   TypeTestingStubGenerator type_testing_stubs;
   Instructions& instr = Instructions::Handle();
   for (intptr_t i = 0; i < types.length(); i++) {
@@ -1906,8 +1916,14 @@ void Precompiler::AttachOptimizedTypeTestingStub() {
     // corresponding to the class id, in Dart source code.
     if (type.IsResolved() && !type.IsMalformedOrMalbounded() &&
         (!type.IsType() || type.type_class_id() != kVectorCid)) {
-      instr = type_testing_stubs.OptimizedCodeForType(type);
-      type.SetTypeTestingStub(instr);
+      if (type_usage_info->IsUsedInTypeTest(type) || type.IsDynamicType() ||
+          type.IsObjectType()) {
+        instr = type_testing_stubs.OptimizedCodeForType(type);
+        type.SetTypeTestingStub(instr);
+
+        // Ensure we retain the type.
+        AddType(type);
+      }
     }
   }
   Dart::vm_isolate()->heap()->WriteProtect(true);

runtime/vm/compiler/backend/flow_graph_compiler.cc

@@ -31,6 +31,7 @@
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/timeline.h"
+#include "vm/type_testing_stubs.h"
 
 namespace dart {
 
@@ -1917,11 +1918,15 @@ void FlowGraphCompiler::GenerateAssertAssignableAOT(
     const Register dst_type_reg,
     const Register scratch_reg,
     Label* done) {
+  TypeUsageInfo* type_usage_info = thread()->type_usage_info();
+
   // If the int type is assignable to [dst_type] we special case it on the
   // caller side!
   const Type& int_type = Type::Handle(zone(), Type::IntType());
+  bool is_non_smi = false;
   if (int_type.IsSubtypeOf(dst_type, NULL, NULL, Heap::kOld)) {
     __ BranchIfSmi(instance_reg, done);
+    is_non_smi = true;
   }
 
   // We can handle certain types very efficiently on the call site (with a
@@ -1938,20 +1943,29 @@ void FlowGraphCompiler::GenerateAssertAssignableAOT(
     __ LoadField(dst_type_reg,
                  FieldAddress(kTypeArgumentsReg, TypeArguments::type_at_offset(
                                                      type_param.index())));
+    if (type_usage_info != NULL) {
+      type_usage_info->UseTypeInAssertAssignable(dst_type);
+    }
   } else {
     HierarchyInfo* hi = Thread::Current()->hierarchy_info();
     if (hi != NULL) {
       const Class& type_class = Class::Handle(zone(), dst_type.type_class());
 
+      bool check_handled_at_callsite = false;
       bool used_cid_range_check = false;
       const bool can_use_simple_cid_range_test =
           hi->CanUseSubtypeRangeCheckFor(dst_type);
       if (can_use_simple_cid_range_test) {
         const CidRangeVector& ranges = hi->SubtypeRangesForClass(type_class);
         if (ranges.length() <= kMaxNumberOfCidRangesToTest) {
-          __ LoadClassIdMayBeSmi(scratch_reg, instance_reg);
-          GenerateSubtypeRangeCheck(scratch_reg, type_class, done);
+          if (is_non_smi) {
+            __ LoadClassId(scratch_reg, instance_reg);
+          } else {
+            __ LoadClassIdMayBeSmi(scratch_reg, instance_reg);
+          }
+          GenerateCidRangesCheck(assembler(), scratch_reg, ranges, done);
           used_cid_range_check = true;
+          check_handled_at_callsite = true;
         }
       }
 
@@ -1961,6 +1975,14 @@ void FlowGraphCompiler::GenerateAssertAssignableAOT(
         GenerateListTypeCheck(scratch_reg, done);
         used_cid_range_check = true;
       }
+
+      // If we haven't handled the positive case of the type check on the
+      // call-site, we want an optimized type testing stub and therefore record
+      // it in the [TypeUsageInfo].
+      if (!check_handled_at_callsite) {
+        ASSERT(type_usage_info != NULL);
+        type_usage_info->UseTypeInAssertAssignable(dst_type);
+      }
     }
     __ LoadObject(dst_type_reg, dst_type);
   }

runtime/vm/compiler/backend/flow_graph_compiler.h

@@ -287,6 +287,7 @@ class FlowGraphCompiler : public ValueObject {
   // Accessors.
   Assembler* assembler() const { return assembler_; }
   const ParsedFunction& parsed_function() const { return parsed_function_; }
+  const Function& function() const { return parsed_function_.function(); }
   const GrowableArray<BlockEntryInstr*>& block_order() const {
     return block_order_;
   }

runtime/vm/compiler/backend/il.cc

@@ -26,6 +26,7 @@
 #include "vm/scopes.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
+#include "vm/type_testing_stubs.h"
 
 #include "vm/compiler/backend/il_printer.h"
 
@@ -45,23 +46,28 @@ DEFINE_FLAG(bool,
             "Support unboxed double and float32x4 fields.");
 DECLARE_FLAG(bool, eliminate_type_checks);
 
-const CidRangeVector& HierarchyInfo::SubtypeRangesForClass(const Class& klass) {
-  ClassTable* table = thread_->isolate()->class_table();
+const CidRangeVector& HierarchyInfo::SubtypeRangesForClass(
+    const Class& klass,
+    bool include_abstract) {
+  ClassTable* table = thread()->isolate()->class_table();
   const intptr_t cid_count = table->NumCids();
-  if (cid_subtype_ranges_ == NULL) {
-    cid_subtype_ranges_ = new CidRangeVector[cid_count];
+  CidRangeVector** cid_ranges =
+      include_abstract ? &cid_subtype_ranges_abstract_ : &cid_subtype_ranges_;
+  if (*cid_ranges == NULL) {
+    *cid_ranges = new CidRangeVector[cid_count];
   }
 
-  CidRangeVector& ranges = cid_subtype_ranges_[klass.id()];
+  CidRangeVector& ranges = (*cid_ranges)[klass.id()];
   if (ranges.length() == 0) {
-    BuildRangesFor(table, &ranges, klass, /*use_subtype_test=*/true);
+    BuildRangesFor(table, &ranges, klass, /*use_subtype_test=*/true,
+                   include_abstract);
   }
   return ranges;
 }
 
 const CidRangeVector& HierarchyInfo::SubclassRangesForClass(
     const Class& klass) {
-  ClassTable* table = thread_->isolate()->class_table();
+  ClassTable* table = thread()->isolate()->class_table();
   const intptr_t cid_count = table->NumCids();
   if (cid_subclass_ranges_ == NULL) {
     cid_subclass_ranges_ = new CidRangeVector[cid_count];
@@ -77,8 +83,9 @@ const CidRangeVector& HierarchyInfo::SubclassRangesForClass(
 void HierarchyInfo::BuildRangesFor(ClassTable* table,
                                    CidRangeVector* ranges,
                                    const Class& klass,
-                                   bool use_subtype_test) {
-  Zone* zone = thread_->zone();
+                                   bool use_subtype_test,
+                                   bool include_abstract) {
+  Zone* zone = thread()->zone();
   Class& cls = Class::Handle(zone);
 
   // Only really used if `use_subtype_test == true`.
@@ -91,16 +98,16 @@ void HierarchyInfo::BuildRangesFor(ClassTable* table,
   for (intptr_t cid = kInstanceCid; cid < cid_count; ++cid) {
     // Create local zone because deep hierarchies may allocate lots of handles
     // within one iteration of this loop.
-    StackZone stack_zone(thread_);
-    HANDLESCOPE(thread_);
+    StackZone stack_zone(thread());
+    HANDLESCOPE(thread());
 
     if (!table->HasValidClassAt(cid)) continue;
     if (cid == kTypeArgumentsCid) continue;
     if (cid == kVoidCid) continue;
     if (cid == kDynamicCid) continue;
     if (cid == kNullCid) continue;
     cls = table->At(cid);
-    if (cls.is_abstract()) continue;
+    if (!include_abstract && cls.is_abstract()) continue;
     if (cls.is_patch()) continue;
     if (cls.IsTopLevel()) continue;
 
@@ -148,7 +155,7 @@ bool HierarchyInfo::CanUseSubtypeRangeCheckFor(const AbstractType& type) {
     return false;
   }
 
-  Zone* zone = thread_->zone();
+  Zone* zone = thread()->zone();
   const Class& type_class = Class::Handle(zone, type.type_class());
 
   // The FutureOr<T> type cannot be handled by checking whether the instance is
@@ -194,7 +201,7 @@ bool HierarchyInfo::CanUseGenericSubtypeRangeCheckFor(
   // [CanUseSubtypeRangeCheckFor], since we handle type parameters in the type
   // expression in some cases (see below).
 
-  Zone* zone = thread_->zone();
+  Zone* zone = thread()->zone();
   const Class& type_class = Class::Handle(zone, type.type_class());
   const intptr_t num_type_parameters = type_class.NumTypeParameters();
   const intptr_t num_type_arguments = type_class.NumTypeArguments();
@@ -236,9 +243,7 @@ bool HierarchyInfo::CanUseGenericSubtypeRangeCheckFor(
   AbstractType& type_arg = AbstractType::Handle(zone);
   for (intptr_t i = 0; i < num_type_parameters; ++i) {
     type_arg = ta.TypeAt(num_type_arguments - num_type_parameters + i);
-    // NOTE: We can handle type parameters but it increases size by a
-    // significant amount.
-    if (!CanUseSubtypeRangeCheckFor(type_arg)) {
+    if (!CanUseSubtypeRangeCheckFor(type_arg) && !type_arg.IsTypeParameter()) {
       return false;
     }
   }
@@ -250,7 +255,8 @@ bool HierarchyInfo::InstanceOfHasClassRange(const AbstractType& type,
                                             intptr_t* lower_limit,
                                             intptr_t* upper_limit) {
   if (CanUseSubtypeRangeCheckFor(type)) {
-    const Class& type_class = Class::Handle(thread_->zone(), type.type_class());
+    const Class& type_class =
+        Class::Handle(thread()->zone(), type.type_class());
     const CidRangeVector& ranges = SubtypeRangesForClass(type_class);
     if (ranges.length() == 1) {
       const CidRange& range = ranges[0];
@@ -3791,6 +3797,14 @@ void StaticCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ArgumentsInfo args_info(type_args_len(), ArgumentCount(), argument_names());
   compiler->GenerateStaticCall(deopt_id(), token_pos(), function(), args_info,
                                locs(), *call_ic_data, rebind_rule_);
+  if (function().IsFactory()) {
+    TypeUsageInfo* type_usage_info = compiler->thread()->type_usage_info();
+    if (type_usage_info != nullptr) {
+      const Class& klass = Class::Handle(function().Owner());
+      RegisterTypeArgumentsUse(compiler->function(), type_usage_info, klass,
+                               ArgumentAt(0));
+    }
+  }
 #else
   const Array& arguments_descriptor = Array::Handle(
       zone, (ic_data() == NULL) ? GetArgumentsDescriptor()

runtime/vm/compiler/backend/il.h

@@ -37,6 +37,7 @@ class Range;
 class RangeAnalysis;
 class RangeBoundary;
 class UnboxIntegerInstr;
+class TypeUsageInfo;
 
 // CompileType describes type of the value produced by the definition.
 //
@@ -351,23 +352,27 @@ class HierarchyInfo : public StackResource {
  public:
   explicit HierarchyInfo(Thread* thread)
       : StackResource(thread),
-        thread_(thread),
         cid_subtype_ranges_(NULL),
+        cid_subtype_ranges_abstract_(NULL),
         cid_subclass_ranges_(NULL) {
     thread->set_hierarchy_info(this);
   }
 
   ~HierarchyInfo() {
-    thread_->set_hierarchy_info(NULL);
+    thread()->set_hierarchy_info(NULL);
 
     delete[] cid_subtype_ranges_;
     cid_subtype_ranges_ = NULL;
 
+    delete[] cid_subtype_ranges_abstract_;
+    cid_subtype_ranges_abstract_ = NULL;
+
     delete[] cid_subclass_ranges_;
     cid_subclass_ranges_ = NULL;
   }
 
-  const CidRangeVector& SubtypeRangesForClass(const Class& klass);
+  const CidRangeVector& SubtypeRangesForClass(const Class& klass,
+                                              bool include_abstract = false);
   const CidRangeVector& SubclassRangesForClass(const Class& klass);
 
   bool InstanceOfHasClassRange(const AbstractType& type,
@@ -396,10 +401,11 @@ class HierarchyInfo : public StackResource {
   void BuildRangesFor(ClassTable* table,
                       CidRangeVector* ranges,
                       const Class& klass,
-                      bool use_subtype_test);
+                      bool use_subtype_test,
+                      bool include_abstract = false);
 
-  Thread* thread_;
   CidRangeVector* cid_subtype_ranges_;
+  CidRangeVector* cid_subtype_ranges_abstract_;
   CidRangeVector* cid_subclass_ranges_;
 };
 

runtime/vm/compiler/backend/il_arm.cc

@@ -22,6 +22,7 @@
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
+#include "vm/type_testing_stubs.h"
 
 #define __ compiler->assembler()->
 #define Z (compiler->zone())
@@ -2433,6 +2434,14 @@ static void InlineArrayAllocation(FlowGraphCompiler* compiler,
 }
 
 void CreateArrayInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  TypeUsageInfo* type_usage_info = compiler->thread()->type_usage_info();
+  if (type_usage_info != nullptr) {
+    const Class& list_class = Class::Handle(
+        compiler->thread()->isolate()->class_table()->At(kArrayCid));
+    RegisterTypeArgumentsUse(compiler->function(), type_usage_info, list_class,
+                             element_type()->definition());
+  }
+
   const Register kLengthReg = R2;
   const Register kElemTypeReg = R1;
   const Register kResultReg = R0;
@@ -6389,6 +6398,13 @@ LocationSummary* AllocateObjectInstr::MakeLocationSummary(Zone* zone,
 }
 
 void AllocateObjectInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  if (ArgumentCount() == 1) {
+    TypeUsageInfo* type_usage_info = compiler->thread()->type_usage_info();
+    if (type_usage_info != nullptr) {
+      RegisterTypeArgumentsUse(compiler->function(), type_usage_info, cls_,
+                               ArgumentAt(0));
+    }
+  }
   const Code& stub = Code::ZoneHandle(
       compiler->zone(), StubCode::GetAllocationStubForClass(cls()));
   const StubEntry stub_entry(stub);

runtime/vm/compiler/backend/il_arm64.cc

@@ -21,6 +21,7 @@
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
+#include "vm/type_testing_stubs.h"
 
 #define __ compiler->assembler()->
 #define Z (compiler->zone())
@@ -2190,6 +2191,14 @@ static void InlineArrayAllocation(FlowGraphCompiler* compiler,
 }
 
 void CreateArrayInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  TypeUsageInfo* type_usage_info = compiler->thread()->type_usage_info();
+  if (type_usage_info != nullptr) {
+    const Class& list_class = Class::Handle(
+        compiler->thread()->isolate()->class_table()->At(kArrayCid));
+    RegisterTypeArgumentsUse(compiler->function(), type_usage_info, list_class,
+                             element_type()->definition());
+  }
+
   const Register kLengthReg = R2;
   const Register kElemTypeReg = R1;
   const Register kResultReg = R0;
@@ -5597,6 +5606,13 @@ LocationSummary* AllocateObjectInstr::MakeLocationSummary(Zone* zone,
 }
 
 void AllocateObjectInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  if (ArgumentCount() == 1) {
+    TypeUsageInfo* type_usage_info = compiler->thread()->type_usage_info();
+    if (type_usage_info != nullptr) {
+      RegisterTypeArgumentsUse(compiler->function(), type_usage_info, cls_,
+                               ArgumentAt(0));
+    }
+  }
   const Code& stub = Code::ZoneHandle(
       compiler->zone(), StubCode::GetAllocationStubForClass(cls()));
   const StubEntry stub_entry(stub);