[counters] Implement off-isolate RuntimeCallStats for the Preparser

src/parsing/parser.cc

 // Copyright 2012 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/parsing/parser.h"
 
 #include <memory>
 
 #include "src/api.h"
 #include "src/ast/ast-expression-rewriter.h"
@@ skipping 569 matching lines @@
     ReportMessage(MessageTemplate::kNotDefined, name);
     *ok = false;
     return nullptr;
   }
 
   return factory()->NewCallRuntime(context_index, args, pos);
 }
 
 Parser::Parser(ParseInfo* info)
     : ParserBase<Parser>(info->zone(), &scanner_, info->stack_limit(),
-                         info->extension(), info->ast_value_factory()),
+                         info->extension(), info->ast_value_factory(),
+                         info->isolate()->counters()->runtime_call_stats()),
       scanner_(info->unicode_cache()),
       reusable_preparser_(nullptr),
       original_scope_(nullptr),
       mode_(PARSE_EAGERLY),  // Lazy mode must be set explicitly.
       target_stack_(nullptr),
       compile_options_(info->compile_options()),
       cached_parse_data_(nullptr),
       total_preparse_skipped_(0),
       parsing_on_main_thread_(true),
       log_(nullptr) {
@@ skipping 57 matching lines @@
     scope = Scope::DeserializeScopeChain(
         info->isolate(), zone(), *outer_scope_info, script_scope,
         ast_value_factory(), Scope::DeserializationMode::kScopesOnly);
     DCHECK(!info->is_module() || scope->is_module_scope());
   }
   original_scope_ = scope;
 }
 
 FunctionLiteral* Parser::ParseProgram(Isolate* isolate, ParseInfo* info) {
   // TODO(bmeurer): We temporarily need to pass allow_nesting = true here,
   // see comment for HistogramTimerScope class.

[vogelheim, 2016/11/14 10:20:33]

[Not yours, but..] Is this comment/TODO still accurate? I take it the
HistogramTimerScope was once in the place that RuntimeCallTimerScope is now? Or
did that morph into the TRACE_EVENT?

 
   // It's OK to use the Isolate & counters here, since this function is only
   // called in the main thread.
   DCHECK(parsing_on_main_thread_);
 
-  RuntimeCallTimerScope runtime_timer(isolate, &RuntimeCallStats::ParseProgram);
+  RuntimeCallTimerScope runtime_timer(
+      runtime_call_stats_, info->is_eval() ? &RuntimeCallStats::ParseEval
+                                           : &RuntimeCallStats::ParseProgram);
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"), "V8.ParseProgram");
   Handle<String> source(String::cast(info->script()->source()));
   isolate->counters()->total_parse_size()->Increment(source->length());
   base::ElapsedTimer timer;
   if (FLAG_trace_parse) {
     timer.Start();
   }
   fni_ = new (zone()) FuncNameInferrer(ast_value_factory(), zone());
 
   // Initialize parser state.
@@ skipping 142 matching lines @@
   // Make sure the target stack is empty.
   DCHECK(target_stack_ == NULL);
 
   return result;
 }
 
 FunctionLiteral* Parser::ParseFunction(Isolate* isolate, ParseInfo* info) {
   // It's OK to use the Isolate & counters here, since this function is only
   // called in the main thread.
   DCHECK(parsing_on_main_thread_);
-  RuntimeCallTimerScope runtime_timer(isolate,
+  RuntimeCallTimerScope runtime_timer(runtime_call_stats_,
                                       &RuntimeCallStats::ParseFunction);
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"), "V8.ParseFunction");
   Handle<String> source(String::cast(info->script()->source()));
   isolate->counters()->total_parse_size()->Increment(source->length());
   base::ElapsedTimer timer;
   if (FLAG_trace_parse) {
     timer.Start();
   }
   Handle<SharedFunctionInfo> shared_info = info->shared_info();
   DeserializeScopeChain(info, info->maybe_outer_scope_info());
@@ skipping 1726 matching lines @@
   DCHECK_IMPLIES(parse_lazily(), FLAG_lazy);
   DCHECK_IMPLIES(parse_lazily(), allow_lazy());
   DCHECK_IMPLIES(parse_lazily(), extension_ == nullptr);
 
   bool can_preparse = parse_lazily() &&
                       eager_compile_hint == FunctionLiteral::kShouldLazyCompile;
 
   bool is_lazy_top_level_function =
       can_preparse && impl()->AllowsLazyParsingWithoutUnresolvedVariables();
 
+  RuntimeCallTimerScope runtime_timer(runtime_call_stats_,
+                                      &RuntimeCallStats::ParseFunctionLiteral);
+
   // Determine whether we can still lazy parse the inner function.
   // The preconditions are:
   // - Lazy compilation has to be enabled.
   // - Neither V8 natives nor native function declarations can be allowed,
   //   since parsing one would retroactively force the function to be
   //   eagerly compiled.
   // - The invoker of this parser can't depend on the AST being eagerly
   //   built (either because the function is about to be compiled, or
   //   because the AST is going to be inspected for some reason).
   // - Because of the above, we can't be attempting to parse a
@@ skipping 97 matching lines @@
       scope->AnalyzePartially(&previous_zone_ast_node_factory);
     }
 
     if (FLAG_trace_preparse) {
       PrintF("  [%s]: %i-%i %.*s\n",
              is_lazy_top_level_function
                  ? "Preparse no-resolution"
                  : (use_temp_zone ? "Preparse resolution" : "Full parse"),
              scope->start_position(), scope->end_position(),
              function_name->byte_length(), function_name->raw_data());
+      if (is_lazy_top_level_function) {
+        CHANGE_CURRENT_RUNTIME_COUNTER(runtime_call_stats_,
+                                       PreParseNoVariableResolution);
+      } else if (use_temp_zone) {
+        CHANGE_CURRENT_RUNTIME_COUNTER(runtime_call_stats_,
+                                       PreParseWithVariableResolution);
+      }
     }
 
     // Validate function name. We can do this only after parsing the function,
     // since the function can declare itself strict.
     language_mode = scope->language_mode();
     CheckFunctionName(language_mode, function_name, function_name_validity,
                       function_name_location, CHECK_OK);
 
     if (is_strict(language_mode)) {
       CheckStrictOctalLiteral(scope->start_position(), scope->end_position(),
@@ skipping 574 matching lines @@
   MarkCollectedTailCallExpressions();
   return result;
 }
 
 PreParser::PreParseResult Parser::ParseFunctionWithPreParser(
     FunctionKind kind, DeclarationScope* function_scope, bool is_inner_function,
     bool may_abort) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"), "V8.PreParse");
 
   if (reusable_preparser_ == NULL) {
-    reusable_preparser_ =
-        new PreParser(zone(), &scanner_, ast_value_factory(), stack_limit_);
+    reusable_preparser_ = new PreParser(zone(), &scanner_, ast_value_factory(),
+                                        runtime_call_stats_, stack_limit_);
     reusable_preparser_->set_allow_lazy(true);
 #define SET_ALLOW(name) reusable_preparser_->set_allow_##name(allow_##name());
     SET_ALLOW(natives);
     SET_ALLOW(harmony_do_expressions);
     SET_ALLOW(harmony_function_sent);
     SET_ALLOW(harmony_async_await);
     SET_ALLOW(harmony_trailing_commas);
     SET_ALLOW(harmony_class_fields);
 #undef SET_ALLOW
   }
@@ skipping 498 matching lines @@
 
 
 void Parser::ParseOnBackground(ParseInfo* info) {
   parsing_on_main_thread_ = false;
 
   DCHECK(info->literal() == NULL);
   FunctionLiteral* result = NULL;
 
   ParserLogger logger;
   if (produce_cached_parse_data()) log_ = &logger;
+  RuntimeCallStats* default_runtime_call_stats = runtime_call_stats_;
+  if (FLAG_runtime_stats) {
+    // Create separate runtime stats for background parsing.
+    runtime_call_stats_ = new (zone()) RuntimeCallStats();
+  }
 
   std::unique_ptr<Utf16CharacterStream> stream;
   Utf16CharacterStream* stream_ptr;
   if (info->character_stream()) {
     DCHECK(info->source_stream() == nullptr);
     stream_ptr = info->character_stream();
   } else {
     DCHECK(info->character_stream() == nullptr);
     stream.reset(ScannerStream::For(info->source_stream(),
                                     info->source_stream_encoding()));
@@ skipping 19 matching lines @@
 
   info->set_literal(result);
 
   // We cannot internalize on a background thread; a foreground task will take
   // care of calling Parser::Internalize just before compilation.
 
   if (produce_cached_parse_data()) {
     if (result != NULL) *info->cached_data() = logger.GetScriptData();
     log_ = NULL;
   }
+  if (FLAG_runtime_stats) {
+    // Copy over the counters from the background thread to the main counters on
+    // the isolate.
+    // TODO(cbruni,lpy): properly attach the runtime stats to the trace for
+    // background parsing.
+    default_runtime_call_stats->Add(runtime_call_stats_);

[vogelheim, 2016/11/14 10:20:33]

Hmm. I'm not sure, but aren't we still on the background thread when arriving
here? If so, this would be a rather big race condition...

Maybe we could do this work when Parser::Internalize happens? That's the logic
point where we reconcile the background parse data with the main
thread-accessible runtime state.

[Camillo Bruni, 2016/11/14 12:43:46]

Indeed a better place.

+  }
 }
 
 Parser::TemplateLiteralState Parser::OpenTemplateLiteral(int pos) {
   return new (zone()) TemplateLiteral(zone(), pos);
 }
 
 
 void Parser::AddTemplateSpan(TemplateLiteralState* state, bool tail) {
   int pos = scanner()->location().beg_pos;
   int end = scanner()->location().end_pos - (tail ? 1 : 2);
@@ skipping 1557 matching lines @@
 
   return final_loop;
 }
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8