[Interpreter] Enable runtime profiler support for Ignition.

src/interpreter/interpreter-assembler.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/interpreter/interpreter-assembler.h"
 
 #include <ostream>
 
 #include "src/code-factory.h"
 #include "src/frames.h"
 #include "src/interface-descriptors.h"
 #include "src/interpreter/bytecodes.h"
+#include "src/interpreter/interpreter.h"
 #include "src/machine-type.h"
 #include "src/macro-assembler.h"
 #include "src/zone.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
 using compiler::Node;
 
@@ skipping 341 matching lines @@
       Int32Mul(function_id, Int32Constant(sizeof(Runtime::Function)));
   Node* function = IntPtrAdd(function_table, function_offset);
   Node* function_entry =
       Load(MachineType::Pointer(), function,
            Int32Constant(offsetof(Runtime::Function, entry)));
 
   return CallStub(callable.descriptor(), code_target, context, arg_count,
                   first_arg, function_entry, result_size);
 }
 
+void InterpreterAssembler::UpdateProfilingCount(Node* weight) {
+  CodeStubAssembler::Label ok(this);
+  CodeStubAssembler::Label interrupt_check(this);
+  CodeStubAssembler::Label end(this);
+  Node* counter_offset =
+      IntPtrConstant(BytecodeArray::kProfilingCountOffset - kHeapObjectTag);
+
+  // Update counter by |weight| and check if it reaches zero.
+  Node* old_count =
+      Load(MachineType::Int32(), BytecodeArrayTaggedPointer(), counter_offset);
+  Node* new_count = Int32Add(old_count, weight);
+  Node* condition = Int32GreaterThanOrEqual(new_count, Int32Constant(0));
+  Branch(condition, &ok, &interrupt_check);
+
+  // Perform interrupt and reset counter.
+  Bind(&interrupt_check);
+  CallRuntime(Runtime::kInterrupt, GetContext());
+  StoreNoWriteBarrier(MachineRepresentation::kWord32,
+                      BytecodeArrayTaggedPointer(), counter_offset,
+                      Int32Constant(Interpreter::InterruptBudget()));
+  Goto(&end);
+
+  // Update counter.
+  Bind(&ok);
+  StoreNoWriteBarrier(MachineRepresentation::kWord32,
+                      BytecodeArrayTaggedPointer(), counter_offset, new_count);
+  Goto(&end);
+  Bind(&end);
+}
+
 Node* InterpreterAssembler::Advance(int delta) {
   return IntPtrAdd(BytecodeOffset(), Int32Constant(delta));
 }
 
 Node* InterpreterAssembler::Advance(Node* delta) {
   return IntPtrAdd(BytecodeOffset(), delta);
 }
 
-void InterpreterAssembler::Jump(Node* delta) { DispatchTo(Advance(delta)); }
+void InterpreterAssembler::Jump(Node* delta) {
+  UpdateProfilingCount(delta);
+  DispatchTo(Advance(delta));
+}
 
 void InterpreterAssembler::JumpConditional(Node* condition, Node* delta) {
   CodeStubAssembler::Label match(this);
   CodeStubAssembler::Label no_match(this);
 
   Branch(condition, &match, &no_match);
   Bind(&match);
-  DispatchTo(Advance(delta));
+  Jump(delta);
   Bind(&no_match);
   Dispatch();
 }
 
 void InterpreterAssembler::JumpIfWordEqual(Node* lhs, Node* rhs, Node* delta) {
   JumpConditional(WordEqual(lhs, rhs), delta);
 }
 
 void InterpreterAssembler::JumpIfWordNotEqual(Node* lhs, Node* rhs,
                                               Node* delta) {
@@ skipping 21 matching lines @@
   Node* args[] = {GetAccumulator(),          RegisterFileRawPointer(),
                   new_bytecode_offset,       BytecodeArrayTaggedPointer(),
                   DispatchTableRawPointer(), GetContext()};
   TailCall(descriptor, target_code_object, args, 0);
 }
 
 void InterpreterAssembler::InterpreterReturn() {
   if (FLAG_trace_ignition) {
     TraceBytecode(Runtime::kInterpreterTraceBytecodeExit);
   }
+
+  // TODO(rmcilroy): Deal with self optimization of primitive functions.

[Michael Starzinger, 2016/02/18 17:55:26]

Just for posterity: Unless we have data supporting the need for the different
weighing when CompilationInfo::ShouldSelfOptimize is set, I would vote for not
porting that over to Ignition. I tried to remove it from full-codegen a while
ago and only caused tankage on a very small set of benchmarks.

[rmcilroy, 2016/02/19 12:32:32]

Ack. Updated comment.

+  // Update profiling count by -BytecodeOffset to simulate backedge to start of
+  // function.
+  Node* profiling_weight =
+      Int32Sub(Int32Constant(kHeapObjectTag + BytecodeArray::kHeaderSize),
+               BytecodeOffset());
+  UpdateProfilingCount(profiling_weight);
+
   InterpreterDispatchDescriptor descriptor(isolate());
   Node* exit_trampoline_code_object =
       HeapConstant(isolate()->builtins()->InterpreterExitTrampoline());
   Node* args[] = {GetAccumulator(),          RegisterFileRawPointer(),
                   BytecodeOffset(),          BytecodeArrayTaggedPointer(),
                   DispatchTableRawPointer(), GetContext()};
   TailCall(descriptor, exit_trampoline_code_object, args, 0);
 }
 
 void InterpreterAssembler::StackCheck() {
@@ skipping 50 matching lines @@
 #elif V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X64 || V8_TARGET_ARCH_X87
   return true;
 #else
 #error "Unknown Architecture"
 #endif
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8