[RuntimeStats] Add some additional RCS events for background events.

Adds some additional RCS counters to correctly account background
compilation to the background thread.

Also adds a ParseBackgroundProgram as a top-level event for background
parsing since otherwise only pre-parsing was being tracked.

Perf Sheriffs: Note this is likely to increase the Parse-Background
bucket in v8.runtime_stats benchmarks as it now accounts all background
parsing correclty.

BUG=v8:5203

Change-Id: I6ff614b725d85b0bc1901a7bf0e2bac8de1f7cff
Reviewed-on: https://chromium-review.googlesource.com/786237Reviewed-by: Marja Hölttä <marja@chromium.org>
Commit-Queue: Ross McIlroy <rmcilroy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#49603}

src/ast/scopes.cc

@@ -646,8 +646,11 @@ void DeclarationScope::AttachOuterScopeInfo(ParseInfo* info, Isolate* isolate) {
 }
 
 void DeclarationScope::Analyze(ParseInfo* info) {
-  RuntimeCallTimerScope runtimeTimer(info->runtime_call_stats(),
-                                     &RuntimeCallStats::CompileScopeAnalysis);
+  RuntimeCallTimerScope runtimeTimer(
+      info->runtime_call_stats(),
+      info->on_background_thread()
+          ? &RuntimeCallStats::CompileBackgroundScopeAnalysis
+          : &RuntimeCallStats::CompileScopeAnalysis);
   DCHECK_NOT_NULL(info->literal());
   DeclarationScope* scope = info->literal()->scope();
 

src/compiler.cc

@@ -372,8 +372,11 @@ CompilationJob::Status FinalizeUnoptimizedCompilationJob(CompilationJob* job,
 
 bool Renumber(ParseInfo* parse_info,
               Compiler::EagerInnerFunctionLiterals* eager_literals) {
-  RuntimeCallTimerScope runtimeTimer(parse_info->runtime_call_stats(),
-                                     &RuntimeCallStats::CompileRenumber);
+  RuntimeCallTimerScope runtimeTimer(
+      parse_info->runtime_call_stats(),
+      parse_info->on_background_thread()
+          ? &RuntimeCallStats::CompileBackgroundRenumber
+          : &RuntimeCallStats::CompileRenumber);
   return AstNumbering::Renumber(parse_info->stack_limit(), parse_info->zone(),
                                 parse_info->literal(), eager_literals);
 }

src/counters.h

@@ -789,6 +789,9 @@ class RuntimeCallTimer final {
   V(CompileBackgroundEval)                     \
   V(CompileBackgroundIgnition)                 \
   V(CompileBackgroundScript)                   \
+  V(CompileBackgroundRenumber)                 \
+  V(CompileBackgroundRewriteReturnResult)      \
+  V(CompileBackgroundScopeAnalysis)            \
   V(CompileDeserialize)                        \
   V(CompileEval)                               \
   V(CompileAnalyse)                            \
@@ -835,6 +838,7 @@ class RuntimeCallTimer final {
   V(ParseArrowFunctionLiteral)                 \
   V(ParseBackgroundArrowFunctionLiteral)       \
   V(ParseBackgroundFunctionLiteral)            \
+  V(ParseBackgroundProgram)                    \
   V(ParseEval)                                 \
   V(ParseFunction)                             \
   V(ParseFunctionLiteral)                      \

src/interpreter/interpreter.cc

@@ -182,14 +182,13 @@ InterpreterCompilationJob::Status InterpreterCompilationJob::ExecuteJobImpl() {
       parse_info()->on_background_thread()
           ? &RuntimeCallStats::CompileBackgroundIgnition
           : &RuntimeCallStats::CompileIgnition);
+  // TODO(lpy): add support for background compilation RCS trace.
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"), "V8.CompileIgnition");
 
   // Print AST if flag is enabled. Note, if compiling on a background thread
   // then ASTs from different functions may be intersperse when printed.
   MaybePrintAst(parse_info(), compilation_info());
 
-  // TODO(lpy): add support for background compilation RCS trace.
-  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"), "V8.CompileIgnition");
-
   generator()->GenerateBytecode(stack_limit());
 
   if (generator()->HasStackOverflow()) {
@@ -203,6 +202,8 @@ InterpreterCompilationJob::Status InterpreterCompilationJob::FinalizeJobImpl(
   RuntimeCallTimerScope runtimeTimerScope(
       parse_info()->runtime_call_stats(),
       &RuntimeCallStats::CompileIgnitionFinalization);
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"),
+               "V8.CompileIgnitionFinalization");
 
   Handle<BytecodeArray> bytecodes =
       generator()->FinalizeBytecode(isolate, parse_info()->script());

src/parsing/parser.cc

@@ -3486,6 +3486,8 @@ void Parser::UpdateStatistics(Isolate* isolate, Handle<Script> script) {
 }
 
 void Parser::ParseOnBackground(ParseInfo* info) {
+  RuntimeCallTimerScope runtimeTimer(runtime_call_stats_,
+                                     &RuntimeCallStats::ParseBackgroundProgram);
   parsing_on_main_thread_ = false;
   if (!info->script().is_null()) {
     set_script_id(info->script()->id());

src/parsing/rewriter.cc

@@ -363,7 +363,9 @@ bool Rewriter::Rewrite(ParseInfo* info) {
 
   RuntimeCallTimerScope runtimeTimer(
       info->runtime_call_stats(),
-      &RuntimeCallStats::CompileRewriteReturnResult);
+      info->on_background_thread()
+          ? &RuntimeCallStats::CompileBackgroundRewriteReturnResult
+          : &RuntimeCallStats::CompileRewriteReturnResult);
 
   FunctionLiteral* function = info->literal();
   DCHECK_NOT_NULL(function);