Faster IC stubs by specializing them for Binary Smi operations

runtime/vm/object.cc

 // Copyright (c) 2012, 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.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 6616 matching lines @@
   }
 }
 
 
 void Function::RestoreICDataMap(
     ZoneGrowableArray<const ICData*>* deopt_id_to_ic_data) const {
   Isolate* isolate = Isolate::Current();
   const Array& saved_icd = Array::Handle(isolate, ic_data_array());
   if (saved_icd.Length() == 0) {
     deopt_id_to_ic_data->Clear();
-    return;;
+    return;
   }
   ICData& icd = ICData::Handle();
   icd ^= saved_icd.At(saved_icd.Length() - 1);
   const intptr_t len = icd.deopt_id() + 1;
   deopt_id_to_ic_data->SetLength(len);
   for (intptr_t i = 0; i < len; i++) {
     (*deopt_id_to_ic_data)[i] = NULL;
   }
   for (intptr_t i = 0; i < saved_icd.Length(); i++) {
     ICData& icd = ICData::ZoneHandle(isolate);
     icd ^= saved_icd.At(i);
+    // Remove unused entries that have been added at creation time (e.g.,
+    // optimistic Smi/Smi assumption).
+    if (icd.HasUnusedEntries()) {
+      icd = icd.FilterUnusedEntries();
+    }
     (*deopt_id_to_ic_data)[icd.deopt_id()] = &icd;
   }
 }
 
 
 void Function::set_ic_data_array(const Array& value) const {
   StorePointer(&raw_ptr()->ic_data_array_, value.raw());
 }
 
 
@@ skipping 4682 matching lines @@
   ASSERT(!target.IsNull());
   if (NumArgsTested() > 0) {
     // Create a fake cid entry, so that we can store the target.
     GrowableArray<intptr_t> class_ids(NumArgsTested());
     for (intptr_t i = 0; i < NumArgsTested(); i++) {
       class_ids.Add(kObjectCid);
     }
     AddCheck(class_ids, target);
     return;
   }
-  ASSERT(NumArgsTested() >= 0);
+  ASSERT(NumArgsTested() == 0);
   // Can add only once.
   const intptr_t old_num = NumberOfChecks();
   ASSERT(old_num == 0);
   Array& data = Array::Handle(ic_data());
   const intptr_t new_len = data.Length() + TestEntryLength();
   data = Array::Grow(data, new_len, Heap::kOld);
   set_ic_data(data);
   WriteSentinel(data);
   intptr_t data_pos = old_num * TestEntryLength();
   ASSERT(!target.IsNull());
   data.SetAt(data_pos++, target);
+  // Set count to 0 as this is called during compilation, before the
+  // call has been executed.
   const Smi& value = Smi::Handle(Smi::New(0));
   data.SetAt(data_pos, value);
 }
 
 
 void ICData::AddCheck(const GrowableArray<intptr_t>& class_ids,
                       const Function& target) const {
   ASSERT(!target.IsNull());
+  if (target.name() != target_name()) {
+    OS::Print("%s vs %s\n",
+        String::Handle(target.name()).ToCString(),

[Cutch, 2014/08/15 21:23:28]

Should this be an ASSERT?

[srdjan, 2014/08/15 21:49:00]

This is gone, forgot to upload after removing it. Sorry. The assert is below,
this was debugging code as I could not print from LLDB

+        String::Handle(target_name()).ToCString());
+  }
+  ASSERT(target.name() == target_name());
   DEBUG_ASSERT(!HasCheck(class_ids));
   ASSERT(NumArgsTested() > 1);  // Otherwise use 'AddReceiverCheck'.
   ASSERT(class_ids.length() == NumArgsTested());
   const intptr_t old_num = NumberOfChecks();
   Array& data = Array::Handle(ic_data());
   // ICData of static calls with NumArgsTested() > 0 have initially a
   // dummy set of cids entered (see ICData::AddTarget). That entry is
   // overwritten by first real type feedback data.
   if (old_num == 1) {
     bool has_dummy_entry = true;
@@ skipping 278 matching lines @@
   const intptr_t len = NumberOfChecks();
   for (intptr_t i = 1; i < len; i++) {
     if (GetTargetAt(i) != first_target.raw()) {
       return false;
     }
   }
   return true;
 }
 
 
+bool ICData::HasUnusedEntries() const {
+  const intptr_t len = NumberOfChecks();
+  for (intptr_t i = 0; i < len; i++) {
+    if (GetCountAt(i) == 0) {
+      // Do not mistake unoptimized static call ICData for unused.
+      // See ICData::AddTarget.
+      // TODO(srdjan): Make this test more robust.

[Cutch, 2014/08/15 21:23:28]

What about factoring this check into:

bool IsUnused(intptr_t i) const;

And then using it below in FilterUnusedEntries for consistency.

[srdjan, 2014/08/15 21:49:00]

FilterUnusedEntries currently always creates a new ICData, I would like to do
that only if needed, i.e., I need first one pass to determine if allocation and
copying is needed at all.

[srdjan, 2014/08/18 20:28:40]

Discussed offline, misunderstood the comment.
Done.

+      if (NumArgsTested() > 0) {
+        const intptr_t cid = GetReceiverClassIdAt(i);
+        if (cid != kObjectCid) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+
+RawICData* ICData::FilterUnusedEntries() const {
+  ICData& result = ICData::Handle(ICData::New(
+      Function::Handle(owner()),
+      String::Handle(target_name()),
+      Array::Handle(arguments_descriptor()),
+      deopt_id(),
+      NumArgsTested()));
+  const intptr_t len = NumberOfChecks();
+  GrowableArray<intptr_t> class_ids;
+  Function& target = Function::Handle();
+  for (intptr_t i = 0; i < len; i++) {
+    const intptr_t count = GetCountAt(i);
+    if (count <= 0) continue;

[zra, 2014/08/15 21:45:08]

Above, GetCountAt(i) is checked for equality with zero. Why is it different
here? Also, please use curly braces around continue;

Above, there are also a checks for NumArgsTest() > 0 and on the cid. Why don't
you need to do those here, too? Couldn't you be filtering too many things?

[srdjan, 2014/08/18 20:28:40]

Done using Cutch's suggestion.

+    GetCheckAt(i, &class_ids, &target);
+    result.AddCheck(class_ids, target);
+    result.SetCountAt(result.NumberOfChecks() - 1, count);
+  }
+  return result.raw();
+}
+
+
 RawICData* ICData::New(const Function& owner,
                        const String& target_name,
                        const Array& arguments_descriptor,
                        intptr_t deopt_id,
                        intptr_t num_args_tested) {
   ASSERT(!owner.IsNull());
   ASSERT(!target_name.IsNull());
   ASSERT(!arguments_descriptor.IsNull());
   ASSERT(Object::icdata_class() != Class::null());
   ASSERT(num_args_tested >= 0);
@@ skipping 7804 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart