[turbofan] Introduce dedicated CallFrequency class.

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 131 matching lines @@
       return NoChange();
     case kStressInlining:
       return InlineCandidate(candidate);
     case kGeneralInlining:
       break;
   }
 
   // Don't consider a {candidate} whose frequency is below the
   // threshold, i.e. a call site that is only hit once every N
   // invocations of the caller.
-  if (candidate.frequency < FLAG_min_inlining_frequency) {
+  if (candidate.frequency.IsKnown() &&
+      candidate.frequency.value() < FLAG_min_inlining_frequency) {
     return NoChange();
   }
 
   // In the general case we remember the candidate for later.
   candidates_.insert(candidate);
   return NoChange();
 }
 
 void JSInliningHeuristic::Finalize() {
   if (candidates_.empty()) return;  // Nothing to do without candidates.
   if (FLAG_trace_turbo_inlining) PrintCandidates();
 
   // We inline at most one candidate in every iteration of the fixpoint.
   // This is to ensure that we don't consume the full inlining budget
   // on things that aren't called very often.
   // TODO(bmeurer): Use std::priority_queue instead of std::set here.
   while (!candidates_.empty()) {
     if (cumulative_count_ > FLAG_max_inlined_nodes_cumulative) return;
     auto i = candidates_.begin();
     Candidate candidate = *i;
     candidates_.erase(i);
-    // Only include candidates that we've successfully called before.
-    // The candidate list is sorted, so we can exit at the first occurance of
-    // frequency 0 in the list.
-    if (candidate.frequency <= 0.0) return;
     // Make sure we don't try to inline dead candidate nodes.
     if (!candidate.node->IsDead()) {
       Reduction const reduction = InlineCandidate(candidate);
       if (reduction.Changed()) return;
     }
   }
 }
 
 Reduction JSInliningHeuristic::InlineCandidate(Candidate const& candidate) {
   int const num_calls = candidate.num_functions;
@@ skipping 94 matching lines @@
       node->Kill();
       cumulative_count_ += function->shared()->ast_node_count();
     }
   }
 
   return Replace(value);
 }
 
 bool JSInliningHeuristic::CandidateCompare::operator()(
     const Candidate& left, const Candidate& right) const {
-  if (left.frequency > right.frequency) {
+  if (right.frequency.IsUnknown()) {
     return true;
-  } else if (left.frequency < right.frequency) {
+  } else if (left.frequency.IsUnknown()) {
+    return false;
+  } else if (left.frequency.value() > right.frequency.value()) {
+    return true;
+  } else if (left.frequency.value() < right.frequency.value()) {
     return false;
   } else {
     return left.node->id() > right.node->id();
   }
 }
 
 void JSInliningHeuristic::PrintCandidates() {
-  PrintF("Candidates for inlining (size=%zu):\n", candidates_.size());
+  OFStream os(stdout);
+  os << "Candidates for inlining (size=" << candidates_.size() << "):\n";
   for (const Candidate& candidate : candidates_) {
-    PrintF("  #%d:%s, frequency:%g\n", candidate.node->id(),
-           candidate.node->op()->mnemonic(), candidate.frequency);
+    os << "  #" << candidate.node->id() << ":"
+       << candidate.node->op()->mnemonic()
+       << ", frequency: " << candidate.frequency << std::endl;
     for (int i = 0; i < candidate.num_functions; ++i) {
       Handle<SharedFunctionInfo> shared =
           candidate.functions[i].is_null()
               ? candidate.shared_info
               : handle(candidate.functions[i]->shared());
       PrintF("  - size:%d, name: %s\n", shared->ast_node_count(),
              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