[turbofan] Collect invocation counts and compute relative call frequencies.

src/compiler/ast-graph-builder.cc

 // Copyright 2014 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/ast-graph-builder.h"
 
 #include "src/ast/compile-time-value.h"
 #include "src/ast/scopes.h"
 #include "src/compilation-info.h"
 #include "src/compiler.h"
@@ skipping 393 matching lines @@
     Node* token = commands_->RecordCommand(cmd, target, *value);
     control_->LeaveTry(token, *value);
     return true;
   }
 
  private:
   DeferredCommands* commands_;
   TryFinallyBuilder* control_;
 };
 
-
 AstGraphBuilder::AstGraphBuilder(Zone* local_zone, CompilationInfo* info,
-                                 JSGraph* jsgraph, LoopAssignmentAnalysis* loop,
+                                 JSGraph* jsgraph, float invocation_frequency,
+                                 LoopAssignmentAnalysis* loop,
                                  TypeHintAnalysis* type_hint_analysis)
     : isolate_(info->isolate()),
       local_zone_(local_zone),
       info_(info),
       jsgraph_(jsgraph),
+      invocation_frequency_(invocation_frequency),
       environment_(nullptr),
       ast_context_(nullptr),
       globals_(0, local_zone),
       execution_control_(nullptr),
       execution_context_(nullptr),
       try_nesting_level_(0),
       input_buffer_size_(0),
       input_buffer_(nullptr),
       exit_controls_(local_zone),
       loop_assignment_analysis_(loop),
@@ skipping 2665 matching lines @@
     if (s == variable->scope()) break;
   }
   return check_depths;
 }
 
 float AstGraphBuilder::ComputeCallFrequency(FeedbackVectorSlot slot) const {
   if (slot.IsInvalid()) return 0.0f;
   Handle<TypeFeedbackVector> feedback_vector(
       info()->closure()->feedback_vector(), isolate());
   CallICNexus nexus(feedback_vector, slot);
-  return nexus.ExtractCallCount();
+  double const invocation_count = feedback_vector->invocation_count();
+  double const call_count = nexus.ExtractCallCount();
+  return static_cast<float>(call_count / invocation_count) *
+         invocation_frequency_;

[mvstanton, 2016/09/14 09:26:09]

How about giving the CallICNexus responsibility for this computation...it can
see the invocation_count() after all.

[Benedikt Meurer, 2016/09/14 10:55:44]

Done.

 }
 
 Node* AstGraphBuilder::ProcessArguments(const Operator* op, int arity) {
   DCHECK(environment()->stack_height() >= arity);
   Node** all = info()->zone()->NewArray<Node*>(arity);
   for (int i = arity - 1; i >= 0; --i) {
     all[i] = environment()->Pop();
   }
   Node* value = NewNode(op, arity, all);
   return value;
@@ skipping 1201 matching lines @@
     // Phi does not exist yet, introduce one.
     value = NewPhi(inputs, value, control);
     value->ReplaceInput(inputs - 1, other);
   }
   return value;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8