[Compiler] Track Ignition background compilation separately in RuntimeStats.

src/interpreter/interpreter.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.h"
 
 #include <fstream>
 #include <memory>
 
 #include "src/ast/prettyprinter.h"
@@ skipping 26 matching lines @@
 
  protected:
   Status PrepareJobImpl() final;
   Status ExecuteJobImpl() final;
   Status FinalizeJobImpl() final;
 
  private:
   BytecodeGenerator* generator() { return &generator_; }
 
   BytecodeGenerator generator_;
+  RuntimeCallStats* runtime_call_stats_;
 
   DISALLOW_COPY_AND_ASSIGN(InterpreterCompilationJob);
 };
 
 Interpreter::Interpreter(Isolate* isolate) : isolate_(isolate) {
   memset(dispatch_table_, 0, sizeof(dispatch_table_));
 }
 
 void Interpreter::Initialize() {
   if (!ShouldInitializeDispatchTable()) return;
@@ skipping 96 matching lines @@
     }
   }
 }
 
 // static
 int Interpreter::InterruptBudget() {
   return FLAG_interrupt_budget * kCodeSizeMultiplier;
 }
 
 InterpreterCompilationJob::InterpreterCompilationJob(CompilationInfo* info)
-    : CompilationJob(info->isolate(), info, "Ignition"), generator_(info) {}
+    : CompilationJob(info->isolate(), info, "Ignition"),
+      generator_(info),
+      runtime_call_stats_(info->isolate()->counters()->runtime_call_stats()) {}
 
 InterpreterCompilationJob::Status InterpreterCompilationJob::PrepareJobImpl() {
   CodeGenerator::MakeCodePrologue(info(), "interpreter");
   if (FLAG_print_bytecode) {
     OFStream os(stdout);
     std::unique_ptr<char[]> name = info()->GetDebugName();
     os << "[generating bytecode for function: " << info()->GetDebugName().get()
        << "]" << std::endl
        << std::flush;
   }
 
   return SUCCEEDED;
 }
 
 InterpreterCompilationJob::Status InterpreterCompilationJob::ExecuteJobImpl() {
-  // TODO(5203): These timers aren't thread safe, move to using the CompilerJob
-  // timers.
-  RuntimeCallTimerScope runtimeTimer(info()->isolate(),
-                                     &RuntimeCallStats::CompileIgnition);
-  TimerEventScope<TimerEventCompileIgnition> timer(info()->isolate());
+  if (FLAG_runtime_stats && executed_on_background_thread()) {
+    // Create separate runtime stats for background compilation.
+    runtime_call_stats_ = new (info()->zone()) RuntimeCallStats();

[jochen (gone - plz use gerrit), 2016/12/16 10:47:38]

this allocates a potentially pretty large object even though we just need one
counter. Should we rather just instantiate the one counter?

[Camillo Bruni, 2016/12/16 11:42:54]

I think we initially discussed to do exactly that, using a separate timer and
directly sum up the values in the correct counter
(RuntimeCallStats::CompileBackgroundIgnition).

[rmcilroy, 2016/12/16 23:48:05]

Yeah good point. I was basing this on the approach taken by the background
parser, but have changed to use a separate counter (with a special TimerScope to
ensure we still correctly nest timers if running on the main thread). If we are
worried about allocating a large object on every compile then we should probably
adapt the approach taken in the parser too, since it will end up running as
often as this code with the CompilerDispatcher.

+  }
+  RuntimeCallTimerScope runtimeTimer(
+      runtime_call_stats_, executed_on_background_thread()
+                               ? &RuntimeCallStats::CompileBackgroundIgnition
+                               : &RuntimeCallStats::CompileIgnition);
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"), "V8.CompileIgnition");

[Camillo Bruni, 2016/12/16 09:25:05]

Please add: TODO(lpy): add support for background compilation RCS trace
see https://codereview.chromium.org/2559403002

[rmcilroy, 2016/12/16 23:48:05]

Done.

 
   generator()->GenerateBytecode(stack_limit());
 
   if (generator()->HasStackOverflow()) {
     return FAILED;
   }
   return SUCCEEDED;
 }
 
 InterpreterCompilationJob::Status InterpreterCompilationJob::FinalizeJobImpl() {
+  // Add background runtime call stats.
+  if (executed_on_background_thread() &&
+      FLAG_runtime_stats ==
+          v8::tracing::TracingCategoryObserver::ENABLED_BY_NATIVE) {
+    info()->isolate()->counters()->runtime_call_stats()->Add(
+        runtime_call_stats_);
+    // Reset runtime_call_stats_.
+    runtime_call_stats_ = info()->isolate()->counters()->runtime_call_stats();
+  }
+
+  RuntimeCallTimerScope runtimeTimer(
+      runtime_call_stats_, &RuntimeCallStats::CompileIgnitionFinalization);
+
   Handle<BytecodeArray> bytecodes = generator()->FinalizeBytecode(isolate());
   if (generator()->HasStackOverflow()) {
     return FAILED;
   }
 
   if (FLAG_print_bytecode) {
     OFStream os(stdout);
     bytecodes->Print(os);
     os << std::flush;
   }
@@ skipping 2661 matching lines @@
   __ StoreObjectField(generator, JSGeneratorObject::kContinuationOffset,
       __ SmiTag(new_state));
   __ SetAccumulator(old_state);
 
   __ Dispatch();
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8