Two-threaded parser

src/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 "v8.h"
 
 #include "api.h"
 #include "ast.h"
 #include "bootstrapper.h"
 #include "char-predicates-inl.h"
 #include "codegen.h"
 #include "compiler.h"
 #include "messages.h"
 #include "parser.h"
+#include "parser-thread.h"
 #include "platform.h"
 #include "preparser.h"
 #include "runtime.h"
 #include "scanner-character-streams.h"
 #include "scopeinfo.h"
 #include "string-stream.h"
 
 namespace v8 {
 namespace internal {
 
+namespace {
+
+// Returns NULL if the string is not external. Caller takes ownership of the
+// returned stream.
+Utf16CharacterStream* ExternalCharacterStreamFromString(Handle<String> string) {
+  if (string->IsExternalAsciiString()) {
+    return new ExternalOneByteStringUtf16CharacterStream(
+        Handle<ExternalAsciiString>::cast(string)->GetChars(), 0,
+        string->length());
+  }
+  if (string->IsExternalTwoByteString()) {
+    return new ExternalTwoByteStringUtf16CharacterStream(
+        Handle<ExternalTwoByteString>::cast(string)->GetTwoByteData(0), 0,
+        string->length());
+  }
+  return NULL;
+}
+
+}  // namespace
+
+
 RegExpBuilder::RegExpBuilder(Zone* zone)
     : zone_(zone),
       pending_empty_(false),
       characters_(NULL),
       terms_(),
       alternatives_()
 #ifdef DEBUG
     , last_added_(ADD_NONE)
 #endif
   {}
@@ skipping 738 matching lines @@
                                        name_is_strict_reserved, is_generator,
                                        function_token_position, type, ok);
 }
 
 
 Parser::Parser(CompilationInfo* info)
     : ParserBase<ParserTraits>(&scanner_,
                                info->isolate()->stack_guard()->real_climit(),
                                info->extension(),
                                NULL,
+                               NULL,
                                info->zone(),
                                this),
       isolate_(info->isolate()),
       script_(info->script()),
       scanner_(isolate_->unicode_cache()),
       reusable_preparser_(NULL),
       original_scope_(NULL),
       target_stack_(NULL),
       cached_data_(NULL),
       cached_data_mode_(NO_CACHED_DATA),
@@ skipping 15 matching lines @@
   // see comment for HistogramTimerScope class.
   HistogramTimerScope timer_scope(isolate()->counters()->parse(), true);
   Handle<String> source(String::cast(script_->source()));
   isolate()->counters()->total_parse_size()->Increment(source->length());
   ElapsedTimer timer;
   if (FLAG_trace_parse) {
     timer.Start();
   }
   fni_ = new(zone()) FuncNameInferrer(isolate(), zone());
 
-  // Initialize parser state.
   CompleteParserRecorder recorder;
+
   if (cached_data_mode_ == PRODUCE_CACHED_DATA) {
+    ASSERT(allow_lazy());
     log_ = &recorder;
   } else if (cached_data_mode_ == CONSUME_CACHED_DATA) {
     (*cached_data_)->Initialize();
   }
+  source = String::Flatten(source);
+  StartFastParserTaskIfPossible(source);
 
-  source = String::Flatten(source);
   FunctionLiteral* result;
   if (source->IsExternalTwoByteString()) {
     // Notice that the stream is destroyed at the end of the branch block.
     // The last line of the blocks can't be moved outside, even though they're
     // identical calls.
     ExternalTwoByteStringUtf16CharacterStream stream(
-        Handle<ExternalTwoByteString>::cast(source), 0, source->length());
+        Handle<ExternalTwoByteString>::cast(source)->GetTwoByteData(0), 0,
+        source->length());
     scanner_.Initialize(&stream);
     result = DoParseProgram(info(), source);
   } else {
     GenericStringUtf16CharacterStream stream(source, 0, source->length());
     scanner_.Initialize(&stream);
     result = DoParseProgram(info(), source);
   }
 
   if (FLAG_trace_parse && result != NULL) {
     double ms = timer.Elapsed().InMillisecondsF();
     if (info()->is_eval()) {
       PrintF("[parsing eval");
     } else if (info()->script()->name()->IsString()) {
       String* name = String::cast(info()->script()->name());
       SmartArrayPointer<char> name_chars = name->ToCString();
       PrintF("[parsing script: %s", name_chars.get());
     } else {
       PrintF("[parsing script");
     }
     PrintF(" - took %0.3f ms]\n", ms);
   }
   if (cached_data_mode_ == PRODUCE_CACHED_DATA) {
     if (result != NULL) {
       Vector<unsigned> store = recorder.ExtractData();
       *cached_data_ = new ScriptData(store);
     }
     log_ = NULL;
   }
+  FinishFastParserTask();
   return result;
 }
 
 
 FunctionLiteral* Parser::DoParseProgram(CompilationInfo* info,
                                         Handle<String> source) {
   ASSERT(scope_ == NULL);
   ASSERT(target_stack_ == NULL);
 
   Handle<String> no_name = isolate()->factory()->empty_string();
@@ skipping 88 matching lines @@
   if (FLAG_trace_parse) {
     timer.Start();
   }
   Handle<SharedFunctionInfo> shared_info = info()->shared_info();
 
   // Initialize parser state.
   source = String::Flatten(source);
   FunctionLiteral* result;
   if (source->IsExternalTwoByteString()) {
     ExternalTwoByteStringUtf16CharacterStream stream(
-        Handle<ExternalTwoByteString>::cast(source),
+        Handle<ExternalTwoByteString>::cast(source)->GetTwoByteData(0),
         shared_info->start_position(),
         shared_info->end_position());
     result = ParseLazy(&stream);
   } else {
     GenericStringUtf16CharacterStream stream(source,
                                              shared_info->start_position(),
                                              shared_info->end_position());
     result = ParseLazy(&stream);
   }
 
@@ skipping 2319 matching lines @@
     // that it will be compiled lazily.
 
     // To make this additional case work, both Parser and PreParser implement a
     // logic where only top-level functions will be parsed lazily.
     bool is_lazily_parsed = (mode() == PARSE_LAZILY &&
                              scope_->AllowsLazyCompilation() &&
                              !parenthesized_function_);
     parenthesized_function_ = false;  // The bit was set for this function only.
 
     if (is_lazily_parsed) {
-      SkipLazyFunctionBody(function_name, &materialized_literal_count,
-                           &expected_property_count, CHECK_OK);
+      int function_block_pos = position();
+      StrictMode strict_mode;
+      SkipLazyFunctionBody(
+          function_name, function_block_pos, &materialized_literal_count,
+          &expected_property_count, &strict_mode, CHECK_OK);
+      scope_->SetStrictMode(strict_mode);
+      Expect(Token::RBRACE, CHECK_OK);
+      // Position right after terminal '}'.
+      int body_end = scanner()->location().end_pos;
+      scope_->set_end_position(body_end);
+      isolate()->counters()->total_preparse_skipped()->Increment(
+          body_end - function_block_pos);
+      if (cached_data_mode_ == PRODUCE_CACHED_DATA) {
+        ASSERT(log_);
+        log_->LogFunction(function_block_pos, body_end,
+                          materialized_literal_count, expected_property_count,
+                          strict_mode);
+      }
     } else {
       body = ParseEagerFunctionBody(function_name, pos, fvar, fvar_init_op,
                                     is_generator, CHECK_OK);
       materialized_literal_count = function_state.materialized_literal_count();
       expected_property_count = function_state.expected_property_count();
       handler_count = function_state.handler_count();
     }
 
     // Validate strict mode. We can do this only after parsing the function,
     // since the function can declare itself strict.
@@ skipping 55 matching lines @@
   function_literal->set_function_token_position(function_token_pos);
   function_literal->set_ast_properties(&ast_properties);
   function_literal->set_dont_optimize_reason(dont_optimize_reason);
 
   if (fni_ != NULL && should_infer_name) fni_->AddFunction(function_literal);
   return function_literal;
 }
 
 
 void Parser::SkipLazyFunctionBody(Handle<String> function_name,
+                                  int function_block_pos,
                                   int* materialized_literal_count,
                                   int* expected_property_count,
+                                  StrictMode* strict_mode,
                                   bool* ok) {
-  int function_block_pos = position();
   if (cached_data_mode_ == CONSUME_CACHED_DATA) {
     // If we have cached data, we use it to skip parsing the function body. The
     // data contains the information we need to construct the lazy function.
     FunctionEntry entry =
         (*cached_data())->GetFunctionEntry(function_block_pos);
     if (entry.is_valid()) {
       if (entry.end_pos() <= function_block_pos) {
         // End position greater than end of stream is safe, and hard to check.
         ReportInvalidCachedData(function_name, ok);
-        if (!*ok) {
-          return;
-        }
+        return;
       }
       scanner()->SeekForward(entry.end_pos() - 1);
-
-      scope_->set_end_position(entry.end_pos());
-      Expect(Token::RBRACE, ok);
-      if (!*ok) {
-        return;
-      }
-      isolate()->counters()->total_preparse_skipped()->Increment(
-          scope_->end_position() - function_block_pos);
       *materialized_literal_count = entry.literal_count();
       *expected_property_count = entry.property_count();
-      scope_->SetStrictMode(entry.strict_mode());
+      *strict_mode = entry.strict_mode();
     } else {
       // This case happens when we have preparse data but it doesn't contain an
       // entry for the function. Fail the compilation.
       ReportInvalidCachedData(function_name, ok);
       return;
     }
+  } else if (thread_) {
+    int start, end;
+    // This will wait until the background thread has found the lazy function.
+    thread_->Consume(&start, &end, materialized_literal_count,
+                     expected_property_count, strict_mode);
+    if (start == function_block_pos) {
+      scanner()->SeekForward(end - 1);
+    } else {
+      ProcessErrorFromRecorder(thread_->result(), thread_->recorder(), ok);
+      // If there is no error, the thread produced data for a lazy function
+      // which was not the function we expected. That should never happen.
+      ASSERT(!*ok);
+      *ok = false;
+      FinishFastParserTask();
+    }
   } else {
     // With no cached data, we partially parse the function, without building an
-    // AST. This gathers the data needed to build a lazy function.
+    // AST. This gathers the data needed to build a lazy function. The PreParser
+    // uses the same scanner, so it will be automatically positioned in the
+    // right position without additional seeking.
     SingletonLogger logger;
     PreParser::PreParseResult result =
         ParseLazyFunctionBodyWithPreParser(&logger);
-    if (result == PreParser::kPreParseStackOverflow) {
-      // Propagate stack overflow.
-      set_stack_overflow();
-      *ok = false;
-      return;
-    }
-    if (logger.has_error()) {
-      ParserTraits::ReportMessageAt(
-          Scanner::Location(logger.start(), logger.end()),
-          logger.message(), logger.argument_opt(), logger.is_reference_error());
-      *ok = false;
-      return;
-    }
-    scope_->set_end_position(logger.end());
-    Expect(Token::RBRACE, ok);
+    ProcessErrorFromRecorder(result, &logger, ok);
     if (!*ok) {
       return;
     }
-    isolate()->counters()->total_preparse_skipped()->Increment(
-        scope_->end_position() - function_block_pos);
     *materialized_literal_count = logger.literals();
     *expected_property_count = logger.properties();
-    scope_->SetStrictMode(logger.strict_mode());
-    if (cached_data_mode_ == PRODUCE_CACHED_DATA) {
-      ASSERT(log_);
-      // Position right after terminal '}'.
-      int body_end = scanner()->location().end_pos;
-      log_->LogFunction(function_block_pos, body_end,
-                        *materialized_literal_count,
-                        *expected_property_count,
-                        scope_->strict_mode());
-    }
+    *strict_mode = logger.strict_mode();
   }
 }
 
 
+void Parser::ProcessErrorFromRecorder(PreParser::PreParseResult result,
+                                      const SingletonLogger* logger, bool* ok) {
+  if (result == PreParser::kPreParseStackOverflow) {
+    set_stack_overflow();
+    *ok = false;
+  } else if (logger->has_error()) {
+    ParserTraits::ReportMessageAt(
+        Scanner::Location(logger->start(), logger->end()), logger->message(),
+        logger->argument_opt(), logger->is_reference_error());
+    *ok = false;
+  }
+}
+
 ZoneList<Statement*>* Parser::ParseEagerFunctionBody(
     Handle<String> function_name, int pos, Variable* fvar,
     Token::Value fvar_init_op, bool is_generator, bool* ok) {
   // Everything inside an eagerly parsed function will be parsed eagerly
   // (see comment above).
   ParsingModeScope parsing_mode(this, PARSE_EAGERLY);
   ZoneList<Statement*>* body = new(zone()) ZoneList<Statement*>(8, zone());
   if (fvar != NULL) {
     VariableProxy* fproxy = scope_->NewUnresolved(
         factory(), function_name, Interface::NewConst());
@@ skipping 46 matching lines @@
 }
 
 
 PreParser::PreParseResult Parser::ParseLazyFunctionBodyWithPreParser(
     SingletonLogger* logger) {
   HistogramTimerScope preparse_scope(isolate()->counters()->pre_parse());
   ASSERT_EQ(Token::LBRACE, scanner()->current_token());
 
   if (reusable_preparser_ == NULL) {
     intptr_t stack_limit = isolate()->stack_guard()->real_climit();
-    reusable_preparser_ = new PreParser(&scanner_, NULL, stack_limit);
+    reusable_preparser_ = new PreParser(&scanner_, NULL, stack_limit, NULL);
     reusable_preparser_->set_allow_harmony_scoping(allow_harmony_scoping());
     reusable_preparser_->set_allow_modules(allow_modules());
     reusable_preparser_->set_allow_natives_syntax(allow_natives_syntax());
     reusable_preparser_->set_allow_lazy(true);
     reusable_preparser_->set_allow_generators(allow_generators());
     reusable_preparser_->set_allow_for_of(allow_for_of());
     reusable_preparser_->set_allow_harmony_numeric_literals(
         allow_harmony_numeric_literals());
   }
-  PreParser::PreParseResult result =
-      reusable_preparser_->PreParseLazyFunction(strict_mode(),
-                                                is_generator(),
-                                                logger);
+  PreParser::PreParseResult result = reusable_preparser_->PreParseLazyFunction(
+      strict_mode(), is_generator(), logger);
   return result;
 }
 
 
+void Parser::StartFastParserTaskIfPossible(Handle<String> source) {
+  if (cached_data_mode_ == PRODUCE_CACHED_DATA && FLAG_parallel_parse &&
+      source->length() >= FLAG_min_parallel_parse_length) {
+    Utf16CharacterStream* stream = ExternalCharacterStreamFromString(source);
+    if (stream) {
+      ASSERT(isolate()->fast_parser_thread());
+      thread_ = isolate()->fast_parser_thread();
+      thread_->StartBackgroundParsing(stream, allow_harmony_scoping(),
+                                      allow_modules(), allow_natives_syntax(),
+                                      allow_generators(), allow_for_of(),
+                                      allow_harmony_numeric_literals());
+    }
+  }
+}
+
+
+void Parser::FinishFastParserTask() {
+  if (thread_) {
+    thread_->FinishBackgroundParsing();
+    thread_ = NULL;
+  }
+}
+
+
 Expression* Parser::ParseV8Intrinsic(bool* ok) {
   // CallRuntime ::
   //   '%' Identifier Arguments
 
   int pos = peek_position();
   Expect(Token::MOD, CHECK_OK);
   // Allow "eval" or "arguments" for backward compatibility.
   Handle<String> name = ParseIdentifier(kAllowEvalOrArguments, CHECK_OK);
   ZoneList<Expression*>* args = ParseArguments(CHECK_OK);
 
@@ skipping 1041 matching lines @@
       ASSERT(info()->isolate()->has_pending_exception());
     } else {
       result = ParseProgram();
     }
   }
   info()->SetFunction(result);
   return (result != NULL);
 }
 
 } }  // namespace v8::internal