[turbofan] Call frequencies for JSCallFunction and JSCallConstruct.

src/compiler/js-inlining-heuristic.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/js-inlining-heuristic.h"
 
 #include "src/compilation-info.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/simplified-operator.h"
@@ skipping 105 matching lines @@
             "%d exceeds maximum allowed level %d\n",
             node->id(), node->op()->mnemonic(), level,
             FLAG_max_inlining_levels);
         return NoChange();
       }
     }
   }
 
   // Gather feedback on how often this call site has been hit before.
   if (node->opcode() == IrOpcode::kJSCallFunction) {
-    CallFunctionParameters p = CallFunctionParametersOf(node->op());
-    if (p.feedback().IsValid()) {
-      CallICNexus nexus(p.feedback().vector(), p.feedback().slot());
-      candidate.calls = nexus.ExtractCallCount();
-    }
+    CallFunctionParameters const p = CallFunctionParametersOf(node->op());
+    candidate.frequency = p.frequency();
   } else {
     DCHECK_EQ(IrOpcode::kJSCallConstruct, node->opcode());
-    CallConstructParameters p = CallConstructParametersOf(node->op());
-    if (p.feedback().IsValid()) {
-      int const extra_index =
-          p.feedback().vector()->GetIndex(p.feedback().slot()) + 1;
-      Object* feedback_extra = p.feedback().vector()->get(extra_index);
-      if (feedback_extra->IsSmi()) {
-        candidate.calls = Smi::cast(feedback_extra)->value();
-      }
-    }
+    CallConstructParameters const p = CallConstructParametersOf(node->op());
+    candidate.frequency = p.frequency();
   }
 
   // Handling of special inlining modes right away:
   //  - For restricted inlining: stop all handling at this point.
   //  - For stressing inlining: immediately handle all functions.
   switch (mode_) {
     case kRestrictedInlining:
       return NoChange();
     case kStressInlining:
       return InlineCandidate(candidate);
@@ skipping 121 matching lines @@
     if (reduction.Changed()) {
       cumulative_count_ += function->shared()->ast_node_count();
     }
   }
 
   return Replace(value);
 }
 
 bool JSInliningHeuristic::CandidateCompare::operator()(
     const Candidate& left, const Candidate& right) const {
-  if (left.calls != right.calls) {
-    return left.calls > right.calls;
+  if (left.frequency > right.frequency) {
+    return true;
+  } else if (left.frequency < right.frequency) {
+    return false;
+  } else {
+    return left.node < right.node;

[Jarin, 2016/09/12 13:10:01]

Could we compare on node->id(), so that we do not depend on the whim of the zone
allocator (and on undefined behaviour).

[Benedikt Meurer, 2016/09/13 17:45:07]

Done.

   }
-  return left.node < right.node;
 }
 
 void JSInliningHeuristic::PrintCandidates() {
   PrintF("Candidates for inlining (size=%zu):\n", candidates_.size());
   for (const Candidate& candidate : candidates_) {
-    PrintF("  #%d:%s, calls:%d\n", candidate.node->id(),
-           candidate.node->op()->mnemonic(), candidate.calls);
+    PrintF("  #%d:%s, frequency:%g\n", candidate.node->id(),
+           candidate.node->op()->mnemonic(), candidate.frequency);
     for (int i = 0; i < candidate.num_functions; ++i) {
       Handle<JSFunction> function = candidate.functions[i];
       PrintF("  - size[source]:%d, size[ast]:%d, name: %s\n",
              function->shared()->SourceSize(),
              function->shared()->ast_node_count(),
              function->shared()->DebugName()->ToCString().get());
     }
   }
 }
 
 Graph* JSInliningHeuristic::graph() const { return jsgraph()->graph(); }
 
 CommonOperatorBuilder* JSInliningHeuristic::common() const {
   return jsgraph()->common();
 }
 
 SimplifiedOperatorBuilder* JSInliningHeuristic::simplified() const {
   return jsgraph()->simplified();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8