[runtime] Refine runtime call stats for IC misses.

[runtime] Refine runtime call stats for IC misses.

Now we are able to distinguish different kind of misses based on which handler/stub did we actually use.

Committed: https://crrev.com/61b49b3c09aa7cad1e039e2832ea0b824c13ee74
Cr-Commit-Position: refs/heads/master@{#36175}

[Igor Sheludko, 2016-05-11 10:05:14]

Patchset #1 (id:1) has been deleted

[Igor Sheludko, 2016-05-11 10:06:45]

ishell@chromium.org changed reviewers:
+ verwaest@chromium.org

[Igor Sheludko, 2016-05-11 10:06:45]

PTAL

[Igor Sheludko, 2016-05-11 10:10:58]

The CQ bit was checked by ishell@chromium.org to run a CQ dry run

[commit-bot: I haz the power, 2016-05-11 10:11:00]

Dry run: CQ is trying da patch. Follow status at
 https://chromium-cq-status.appspot.com/patch-status/1969733002/20001
View timeline at
 https://chromium-cq-status.appspot.com/patch-timeline/1969733002/20001

[Toon Verwaest, 2016-05-11 11:19:01]

lgtm

[Igor Sheludko, 2016-05-11 11:19:15]

The CQ bit was checked by ishell@chromium.org

[commit-bot: I haz the power, 2016-05-11 11:19:23]

CQ is trying da patch. Follow status at
 https://chromium-cq-status.appspot.com/patch-status/1969733002/40001
View timeline at
 https://chromium-cq-status.appspot.com/patch-timeline/1969733002/40001

[commit-bot: I haz the power, 2016-05-11 11:52:17]

The CQ bit was unchecked by commit-bot@chromium.org

[commit-bot: I haz the power, 2016-05-11 11:52:18]

Failed to apply patch for src/ic/ic.cc:
While running git apply --index -3 -p1;
  error: patch failed: src/ic/ic.cc:1071
  Falling back to three-way merge...
  Applied patch to 'src/ic/ic.cc' with conflicts.
  U src/ic/ic.cc

Patch:       src/ic/ic.cc
Index: src/ic/ic.cc
diff --git a/src/ic/ic.cc b/src/ic/ic.cc
index
73f72c3e4e658c529c35617f2d067854c2af77b8..e4c7482540ef667280b02801c7d59677c3c44780
100644
--- a/src/ic/ic.cc
+++ b/src/ic/ic.cc
@@ -631,6 +631,7 @@ MaybeHandle<Object> LoadIC::Load(Handle<Object> object,
Handle<Name> name) {
       }
 
       if (use_ic && LoadScriptContextFieldStub::Accepted(&lookup_result)) {
+        TRACE_HANDLER_STATS(isolate(), LoadIC_LoadScriptContextFieldStub);
         LoadScriptContextFieldStub stub(isolate(), &lookup_result);
         PatchCache(name, stub.GetCode());
       }
@@ -835,6 +836,7 @@ Handle<Code> KeyedStoreIC::ChooseMegamorphicStub(Isolate*
isolate,
 
 
 Handle<Code> LoadIC::SimpleFieldLoad(FieldIndex index) {
+  TRACE_HANDLER_STATS(isolate(), LoadIC_LoadFieldStub);
   LoadFieldStub stub(isolate(), index);
   return stub.GetCode();
 }
@@ -946,7 +948,10 @@ Handle<Code> IC::ComputeHandler(LookupIterator* lookup,
Handle<Object> value) {
   if (!code.is_null()) {
     Handle<Code> handler;
     if (maybe_handler_.ToHandle(&handler)) {
-      if (!handler.is_identical_to(code)) return code;
+      if (!handler.is_identical_to(code)) {
+        TRACE_HANDLER_STATS(isolate(), IC_HandlerCacheHit);
+        return code;
+      }
     } else {
       // maybe_handler_ is only populated for MONOMORPHIC and POLYMORPHIC ICs.
       // In MEGAMORPHIC case, check if the handler in the megamorphic stub
@@ -955,8 +960,12 @@ Handle<Code> IC::ComputeHandler(LookupIterator* lookup,
Handle<Object> value) {
         Map* map = Handle<HeapObject>::cast(lookup->GetReceiver())->map();
         Code* megamorphic_cached_code =
             isolate()->stub_cache()->Get(*lookup->name(), map, code->flags());
-        if (megamorphic_cached_code != *code) return code;
+        if (megamorphic_cached_code != *code) {
+          TRACE_HANDLER_STATS(isolate(), IC_HandlerCacheHit);
+          return code;
+        }
       } else {
+        TRACE_HANDLER_STATS(isolate(), IC_HandlerCacheHit);
         return code;
       }
     }
@@ -992,6 +1001,7 @@ Handle<Code> LoadIC::CompileHandler(LookupIterator* lookup,
 
   if (receiver->IsStringWrapper() &&
       Name::Equals(isolate()->factory()->length_string(), lookup->name())) {
+    TRACE_HANDLER_STATS(isolate(), LoadIC_StringLengthStub);
     StringLengthStub string_length_stub(isolate());
     return string_length_stub.GetCode();
   }
@@ -1004,6 +1014,7 @@ Handle<Code> LoadIC::CompileHandler(LookupIterator*
lookup,
            ->map()
            ->has_non_instance_prototype()) {
     Handle<Code> stub;
+    TRACE_HANDLER_STATS(isolate(), LoadIC_FunctionPrototypeStub);
     FunctionPrototypeStub function_prototype_stub(isolate());
     return function_prototype_stub.GetCode();
   }
@@ -1014,6 +1025,7 @@ Handle<Code> LoadIC::CompileHandler(LookupIterator*
lookup,
   switch (lookup->state()) {
     case LookupIterator::INTERCEPTOR: {
       DCHECK(!holder->GetNamedInterceptor()->getter()->IsUndefined());
+      TRACE_HANDLER_STATS(isolate(), LoadIC_LoadInterceptor);
       NamedLoadHandlerCompiler compiler(isolate(), map, holder, cache_holder);
       // Perform a lookup behind the interceptor. Copy the LookupIterator since
       // the original iterator will be used to fetch the value.
@@ -1035,6 +1047,7 @@ Handle<Code> LoadIC::CompileHandler(LookupIterator*
lookup,
       }
       if (Accessors::IsJSArrayBufferViewFieldAccessor(map, lookup->name(),
                                                       &object_offset)) {
+        TRACE_HANDLER_STATS(isolate(), LoadIC_ArrayBufferViewLoadFieldStub);
         FieldIndex index = FieldIndex::ForInObjectOffset(object_offset, *map);
         ArrayBufferViewLoadFieldStub stub(isolate(), index);
         return stub.GetCode();
@@ -1052,10 +1065,12 @@ Handle<Code> LoadIC::CompileHandler(LookupIterator*
lookup,
           NamedLoadHandlerCompiler compiler(isolate(), map, holder,
                                             cache_holder);
           if (call_optimization.is_simple_api_call()) {
+            TRACE_HANDLER_STATS(isolate(), LoadIC_LoadCallback);
             int index = lookup->GetAccessorIndex();
             return compiler.CompileLoadCallback(lookup->name(),
                                                 call_optimization, index);
           }
+          TRACE_HANDLER_STATS(isolate(), LoadIC_LoadViaGetter);
           int expected_arguments = Handle<JSFunction>::cast(getter)
                                        ->shared()
                                        ->internal_formal_parameter_count();
@@ -1071,10 +1086,12 @@ Handle<Code> LoadIC::CompileHandler(LookupIterator*
lookup,
           }
           if (!holder->HasFastProperties()) break;
           if (receiver_is_holder) {
+            TRACE_HANDLER_STATS(isolate(), LoadIC_LoadApiGetterStub);
             int index = lookup->GetAccessorIndex();
             LoadApiGetterStub stub(isolate(), true, index);
             return stub.GetCode();
           }
+          TRACE_HANDLER_STATS(isolate(), LoadIC_LoadCallback);
           NamedLoadHandlerCompiler compiler(isolate(), map, holder,
                                             cache_holder);
           return compiler.CompileLoadCallback(lookup->name(), info);
@@ -1087,6 +1104,7 @@ Handle<Code> LoadIC::CompileHandler(LookupIterator*
lookup,
       if (lookup->is_dictionary_holder()) {
         if (kind() != Code::LOAD_IC) break;
         if (holder->IsJSGlobalObject()) {
+          TRACE_HANDLER_STATS(isolate(), LoadIC_LoadGlobal);
           NamedLoadHandlerCompiler compiler(isolate(), map, holder,
                                             cache_holder);
           Handle<PropertyCell> cell = lookup->GetPropertyCell();
@@ -1104,6 +1122,7 @@ Handle<Code> LoadIC::CompileHandler(LookupIterator*
lookup,
         // property must be found in the object for the stub to be
         // applicable.
         if (!receiver_is_holder) break;
+        TRACE_HANDLER_STATS(isolate(), LoadIC_LoadNormal);
         return isolate()->builtins()->LoadIC_Normal();
       }
 
@@ -1113,6 +1132,7 @@ Handle<Code> LoadIC::CompileHandler(LookupIterator*
lookup,
         if (receiver_is_holder) {
           return SimpleFieldLoad(field);
         }
+        TRACE_HANDLER_STATS(isolate(), LoadIC_LoadField);
         NamedLoadHandlerCompiler compiler(isolate(), map, holder,
cache_holder);
         return compiler.CompileLoadField(lookup->name(), field);
       }
@@ -1120,16 +1140,18 @@ Handle<Code> LoadIC::CompileHandler(LookupIterator*
lookup,
       // -------------- Constant properties --------------
       DCHECK(lookup->property_details().type() == DATA_CONSTANT);
       if (receiver_is_holder) {
+        TRACE_HANDLER_STATS(isolate(), LoadIC_LoadConstantStub);
         LoadConstantStub stub(isolate(), lookup->GetConstantIndex());
         return stub.GetCode();
       }
+      TRACE_HANDLER_STATS(isolate(), LoadIC_LoadConstant);
       NamedLoadHandlerCompiler compiler(isolate(), map, holder, cache_holder);
       return compiler.CompileLoadConstant(lookup->name(),
                                           lookup->GetConstantIndex());
     }
 
     case LookupIterator::INTEGER_INDEXED_EXOTIC:
-      return slow_stub();
+      break;
     case LookupIterator::ACCESS_CHECK:
     case LookupIterator::JSPROXY:
     case LookupIterator::NOT_FOUND:
@@ -1137,6 +1159,7 @@ Handle<Code> LoadIC::CompileHandler(LookupIterator*
lookup,
       UNREACHABLE();
   }
 
+  TRACE_HANDLER_STATS(isolate(), LoadIC_SlowStub);
   return slow_stub();
 }
 
@@ -1223,6 +1246,7 @@ void KeyedLoadIC::UpdateLoadElement(Handle<HeapObject>
receiver) {
   }
 
   CodeHandleList handlers(target_receiver_maps.length());
+  TRACE_HANDLER_STATS(isolate(), KeyedLoadIC_PolymorphicElement);
   ElementHandlerCompiler compiler(isolate());
   compiler.CompileElementHandlers(&target_receiver_maps, &handlers);
   ConfigureVectorState(Handle<Name>(), &target_receiver_maps, &handlers);
@@ -1388,6 +1412,7 @@ MaybeHandle<Object> StoreIC::Store(Handle<Object> object,
Handle<Name> name,
 
       if (FLAG_use_ic &&
           StoreScriptContextFieldStub::Accepted(&lookup_result)) {
+        TRACE_HANDLER_STATS(isolate(), StoreIC_StoreScriptContextFieldStub);
         StoreScriptContextFieldStub stub(isolate(), &lookup_result);
         PatchCache(name, stub.GetCode());
       }
@@ -1502,6 +1527,7 @@ Handle<Code> StoreIC::CompileHandler(LookupIterator*
lookup,
       auto store_target = lookup->GetStoreTarget();
       if (store_target->IsJSGlobalObject()) {
         // TODO(dcarney): this currently just deopts. Use the transition cell.
+        TRACE_HANDLER_STATS(isolate(), StoreIC_StoreGlobalTransition);
         auto cell = isolate()->factory()->NewPropertyCell();
         cell->set_value(*value);
         auto code = PropertyCellStoreHandler(
@@ -1518,12 +1544,14 @@ Handle<Code> StoreIC::CompileHandler(LookupIterator*
lookup,
       }
 
       DCHECK(lookup->IsCacheableTransition());
+      TRACE_HANDLER_STATS(isolate(), StoreIC_StoreTransition);
       NamedStoreHandlerCompiler compiler(isolate(), receiver_map(), holder);
       return compiler.CompileStoreTransition(transition, lookup->name());
     }
 
     case LookupIterator::INTERCEPTOR: {
       DCHECK(!holder->GetNamedInterceptor()->setter()->IsUndefined());
+      TRACE_HANDLER_STATS(isolate(), StoreIC_StoreInterceptorStub);
       StoreInterceptorStub stub(isolate());
       return stub.GetCode();
     }
@@ -1551,6 +1579,7 @@ Handle<Code> StoreIC::CompileHandler(LookupIterator*
lookup,
           TRACE_GENERIC_IC(isolate(), "StoreIC", "incompatible receiver type");
           break;
         }
+        TRACE_HANDLER_STATS(isolate(), StoreIC_StoreCallback);
       …
(message too large)

[Igor Sheludko, 2016-05-11 12:00:25]

The CQ bit was checked by ishell@chromium.org

[Igor Sheludko, 2016-05-11 12:00:26]

The patchset sent to the CQ was uploaded after l-g-t-m from
verwaest@chromium.org
Link to the patchset: https://codereview.chromium.org/1969733002/#ps60001
(title: "Rebasing")

[commit-bot: I haz the power, 2016-05-11 12:00:32]

CQ is trying da patch. Follow status at
 https://chromium-cq-status.appspot.com/patch-status/1969733002/60001
View timeline at
 https://chromium-cq-status.appspot.com/patch-timeline/1969733002/60001

[commit-bot: I haz the power, 2016-05-11 12:37:26]

Committed patchset #3 (id:60001)

[commit-bot: I haz the power, 2016-05-11 12:38:35]

Description was changed from

==========
[runtime] Refine runtime call stats for IC misses.

Now we are able to distinguish different kind of misses based on which
handler/stub did we actually use.
==========

to

==========
[runtime] Refine runtime call stats for IC misses.

Now we are able to distinguish different kind of misses based on which
handler/stub did we actually use.

Committed: https://crrev.com/61b49b3c09aa7cad1e039e2832ea0b824c13ee74
Cr-Commit-Position: refs/heads/master@{#36175}
==========

[commit-bot: I haz the power, 2016-05-11 12:38:36]

Patchset 3 (id:??) landed as
https://crrev.com/61b49b3c09aa7cad1e039e2832ea0b824c13ee74
Cr-Commit-Position: refs/heads/master@{#36175}