Count per check hits in ICData.

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/bigint_operations.h"
@@ skipping 7437 matching lines @@
 
 void ICData::set_deopt_reason(intptr_t deopt_reason) const {
   raw_ptr()->deopt_reason_ = deopt_reason;
 }
 
 void ICData::set_is_closure_call(bool value) const {
   raw_ptr()->is_closure_call_ = value ? 1 : 0;
 }
 
 
+intptr_t ICData::TestEntryLengthFor(intptr_t num_args) {
+  return num_args + 1 /* target function*/ + 1 /* frequency */;
+}
+
+
 intptr_t ICData::TestEntryLength() const {
-  return num_args_tested() + 1 /* target function*/;
+  return TestEntryLengthFor(num_args_tested());
 }
 
 
 intptr_t ICData::NumberOfChecks() const {
   // Do not count the sentinel;
   return (Array::Handle(ic_data()).Length() / TestEntryLength()) - 1;
 }
 
 
 void ICData::WriteSentinel() const {
@@ skipping 40 matching lines @@
   data = Array::Grow(data, new_len, Heap::kOld);
   set_ic_data(data);
   WriteSentinel();
   intptr_t data_pos = old_num * TestEntryLength();
   for (intptr_t i = 0; i < class_ids.length(); i++) {
     // kIllegalCid is used as terminating value, do not add it.
     ASSERT(class_ids[i] != kIllegalCid);
     data.SetAt(data_pos++, Smi::Handle(Smi::New(class_ids[i])));
   }
   ASSERT(!target.IsNull());
-  data.SetAt(data_pos, target);
+  data.SetAt(data_pos++, target);
+  data.SetAt(data_pos, Smi::Handle(Smi::New(1)));
 }
 
 
 void ICData::AddReceiverCheck(intptr_t receiver_class_id,
                               const Function& target) const {
 #if defined(DEBUG)
   GrowableArray<intptr_t> class_ids(1);
   class_ids.Add(receiver_class_id);
   ASSERT(!HasCheck(class_ids));
 #endif  // DEBUG
   ASSERT(num_args_tested() == 1);  // Otherwise use 'AddCheck'.
   ASSERT(receiver_class_id != kIllegalCid);
   ASSERT(!target.IsNull());
 
   const intptr_t old_num = NumberOfChecks();
   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();
   intptr_t data_pos = old_num * TestEntryLength();
   if ((receiver_class_id == kSmiCid) && (data_pos > 0)) {

[Kevin Millikin (Google), 2012/11/13 20:59:33]

This is pretty messy.  How about:

if ((receiver_class_id == kSmiCid) && (data_pos > 0)) {
  ASSERT(GetReceiverClassIdAt(0) != kSmiCid);  // Simple duplicate entry check.
  data.SetAt(data_pos, Smi::Handle(Smi::New(GetReceiverClassIdAt(0))));
  data.SetAt(data_pos + 1, Function::Handle(GetTargetAt(0)));
  data.SetAt(data_pos + 2, Smi::Handle(Smi::Handle(Smi::New(GetCountAt(0))));
  data_pos = 0;
}
data.SetAt(data_pos, Smi::Handle(Smi::New(receiver_class_id)));
data.SetAt(data_pos + 1, target);
data.SetAt(data_pos + 2, Smi::Handle(Smi::New(1)));

[Vyacheslav Egorov (Google), 2012/12/17 12:54:16]

Done.

-    // Instert kSmiCid in position 0.
+    // Insert kSmiCid in position 0.
     const intptr_t zero_class_id = GetReceiverClassIdAt(0);
     ASSERT(zero_class_id != kSmiCid);  // Simple duplicate entry check.
     const Function& zero_target = Function::Handle(GetTargetAt(0));
+    const intptr_t count = GetCountAt(0);
     data.SetAt(0, Smi::Handle(Smi::New(receiver_class_id)));
     data.SetAt(1, target);
+    data.SetAt(2, Smi::Handle(Smi::New(1)));
     data.SetAt(data_pos, Smi::Handle(Smi::New(zero_class_id)));
     data.SetAt(data_pos + 1, zero_target);
+    data.SetAt(data_pos + 2, Smi::Handle(Smi::New(count)));
   } else {
     data.SetAt(data_pos, Smi::Handle(Smi::New(receiver_class_id)));
     data.SetAt(data_pos + 1, target);
+    data.SetAt(data_pos + 2, Smi::Handle(Smi::New(1)));
   }
 }
 
 
 void ICData::GetCheckAt(intptr_t index,
                         GrowableArray<intptr_t>* class_ids,
-                        Function* target) const {
+                        Function* target,
+                        intptr_t* count) const {
   ASSERT(index < NumberOfChecks());
   ASSERT(class_ids != NULL);
   ASSERT(target != NULL);
   class_ids->Clear();
   const Array& data = Array::Handle(ic_data());
   intptr_t data_pos = index * TestEntryLength();
   Smi& smi = Smi::Handle();
   for (intptr_t i = 0; i < num_args_tested(); i++) {
     smi ^= data.At(data_pos++);
     class_ids->Add(smi.Value());
   }
-  (*target) ^= data.At(data_pos);
+  (*target) ^= data.At(data_pos++);
+  if (count != NULL) {
+    smi ^= data.At(data_pos);
+    *count = smi.Value();
+  }
 }
 
 
 void ICData::GetOneClassCheckAt(intptr_t index,
                                 intptr_t* class_id,
                                 Function* target) const {
   ASSERT(class_id != NULL);
   ASSERT(target != NULL);
   ASSERT(num_args_tested() == 1);
   const Array& data = Array::Handle(ic_data());
@@ skipping 24 matching lines @@
 
 
 RawFunction* ICData::GetTargetAt(intptr_t index) const {
   const Array& data = Array::Handle(ic_data());
   const intptr_t data_pos = index * TestEntryLength() + num_args_tested();
   ASSERT(Object::Handle(data.At(data_pos)).IsFunction());
   return reinterpret_cast<RawFunction*>(data.At(data_pos));
 }
 
 
+intptr_t ICData::GetCountAt(intptr_t index) const {
+  const Array& data = Array::Handle(ic_data());
+  const intptr_t data_pos = index * TestEntryLength() +
+      CountIndexFor(num_args_tested());
+  Smi& smi = Smi::Handle();
+  smi ^= data.At(data_pos);
+  return smi.Value();
+}
+
+
 RawFunction* ICData::GetTargetForReceiverClassId(intptr_t class_id) const {
   const intptr_t len = NumberOfChecks();
   for (intptr_t i = 0; i < len; i++) {
     if (GetReceiverClassIdAt(i) == class_id) {
       return GetTargetAt(i);
     }
   }
   return Function::null();
 }
 
@@ skipping 97 matching lines @@
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
   }
   result.set_function(function);
   result.set_target_name(target_name);
   result.set_deopt_id(deopt_id);
   result.set_num_args_tested(num_args_tested);
   result.set_deopt_reason(kDeoptUnknown);
   result.set_is_closure_call(false);
-  // Number of array elements in one test entry (num_args_tested + 1)
+  // Number of array elements in one test entry.
   intptr_t len = result.TestEntryLength();
   // IC data array must be null terminated (sentinel entry).
   const Array& ic_data = Array::Handle(Array::New(len, Heap::kOld));
   result.set_ic_data(ic_data);
   result.WriteSentinel();
   return result.raw();
 }
 
 
 RawSubtypeTestCache* SubtypeTestCache::New() {
@@ skipping 4243 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart