[counters] Use separate counters for background parsing

src/parsing/parser-base.h

 // 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.
 
 #ifndef V8_PARSING_PARSER_BASE_H
 #define V8_PARSING_PARSER_BASE_H
 
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
@@ skipping 174 matching lines @@
   typedef typename Types::Block BlockT;
   typedef typename v8::internal::ExpressionClassifier<Types>
       ExpressionClassifier;
 
   // All implementation-specific methods must be called through this.
   Impl* impl() { return static_cast<Impl*>(this); }
   const Impl* impl() const { return static_cast<const Impl*>(this); }
 
   ParserBase(Zone* zone, Scanner* scanner, uintptr_t stack_limit,
              v8::Extension* extension, AstValueFactory* ast_value_factory,
-             RuntimeCallStats* runtime_call_stats)
+             RuntimeCallStats* runtime_call_stats,
+             bool parsing_on_main_thread = true)
       : scope_state_(nullptr),
         function_state_(nullptr),
         extension_(extension),
         fni_(nullptr),
         ast_value_factory_(ast_value_factory),
         ast_node_factory_(ast_value_factory),
         runtime_call_stats_(runtime_call_stats),
+        parsing_on_main_thread_(parsing_on_main_thread),
         parsing_module_(false),
         stack_limit_(stack_limit),
         zone_(zone),
         classifier_(nullptr),
         scanner_(scanner),
         stack_overflow_(false),
         default_eager_compile_hint_(FunctionLiteral::kShouldLazyCompile),
         allow_natives_(false),
         allow_tailcalls_(false),
         allow_harmony_do_expressions_(false),
@@ skipping 1201 matching lines @@
 
   // Parser base's protected field members.
 
   ScopeState* scope_state_;        // Scope stack.
   FunctionState* function_state_;  // Function state stack.
   v8::Extension* extension_;
   FuncNameInferrer* fni_;
   AstValueFactory* ast_value_factory_;  // Not owned.
   typename Types::Factory ast_node_factory_;
   RuntimeCallStats* runtime_call_stats_;
+  bool parsing_on_main_thread_;
   bool parsing_module_;
   uintptr_t stack_limit_;
 
   // Parser base's private field members.
 
  private:
   Zone* zone_;
   ExpressionClassifier* classifier_;
 
   Scanner* scanner_;
@@ skipping 2448 matching lines @@
   }
   return false;
 }
 
 template <typename Impl>
 typename ParserBase<Impl>::ExpressionT
 ParserBase<Impl>::ParseArrowFunctionLiteral(
     bool accept_IN, const FormalParametersT& formal_parameters, bool* ok) {
   RuntimeCallTimerScope runtime_timer(
       runtime_call_stats_,
-      Impl::IsPreParser() ? &RuntimeCallStats::ParseArrowFunctionLiteral
-                          : &RuntimeCallStats::PreParseArrowFunctionLiteral);
+      Impl::IsPreParser()

[vogelheim, 2016/11/16 17:23:15]

style: These two-level ternary operator expressions aren't super pretty to read.
Admittedly the alternatives aren't either, and the formatting makes it bearable,
so... please decide as you see fit.


---------------------------------
I see two alternatives:

- Either make a separate variable, and assign the proper value within two ifs.
  E.g., RuntimeCallCounter* counter; if (...) ... counter = &,...

- Or have a static const array that you can index with the two booleans you want
to decide on.
  E.g.:
   static const RuntimeCallCounter* const kCounters[2][2] = {
     {&RuntimeCallStats::ParseArrowFunctionLiteral, .... }, {...} };

  ... runtime_timer(...,
         kCounters[Impl::IsPreParser()][parsing_on_main_thread_]);

[Camillo Bruni, 2016/11/16 18:21:24]

You're right :)
Went with the helper array which makes it look a bit cleaner.

+          ? parsing_on_main_thread_
+                ? &RuntimeCallStats::ParseArrowFunctionLiteral
+                : &RuntimeCallStats::ParseBackgroundArrowFunctionLiteral
+          : parsing_on_main_thread_
+                ? &RuntimeCallStats::PreParseArrowFunctionLiteral
+                : &RuntimeCallStats::PreParseBackgroundArrowFunctionLiteral);
 
   if (peek() == Token::ARROW && scanner_->HasAnyLineTerminatorBeforeNext()) {
     // ASI inserts `;` after arrow parameters if a line terminator is found.
     // `=> ...` is never a valid expression, so report as syntax error.
     // If next token is not `=>`, it's a syntax error anyways.
     ReportUnexpectedTokenAt(scanner_->peek_location(), Token::ARROW);
     *ok = false;
     return impl()->EmptyExpression();
   }
 
@@ skipping 1547 matching lines @@
     has_seen_constructor_ = true;
     return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H