Two-threaded parser

src/parser.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 17 matching lines @@
 #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 {
 
@@ skipping 784 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()),
       symbol_cache_(0, info->zone()),
       script_(info->script()),
       scanner_(isolate_->unicode_cache()),
       reusable_preparser_(NULL),
       original_scope_(NULL),
       target_stack_(NULL),
       cached_data_(NULL),
@@ skipping 16 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.
+  source = String::Flatten(source);
+
   CompleteParserRecorder recorder;
   if (cached_data_mode_ == PRODUCE_CACHED_DATA) {
+    ASSERT(allow_lazy());
     log_ = &recorder;
+    if (source->length() >= FLAG_min_parallel_parse_length) {
+      // Start a thread for doing a fast pass over the script to find lazy
+      // functions with PreParser. Restrictions: 1) PreParser cannot yet parse
+      // everything that Parser can (e.g., harmony modules). So here we are on
+      // the safe side, and only use the FastParserThread when we're sure that
+      // the script is good (i.e., for scripts for which we produce cached
+      // data). TODO(marja): Use FastParserThread for other kinds of
+      // compilations too. 2) The thread cannot use the Isolate, or Handles, so
+      // this will only work if the actual data is kept outside the V8 heap as
+      // an external string.
+      if (source->IsExternalAsciiString()) {
+        thread_ = new FastParserThread(
+            new ExternalOneByteStringUtf16CharacterStream(

[Sven Panne, 2014/04/16 11:55:35]

Extract the creation of the Utf16CharacterStream* out into a separate function
(maybe returning NULL when it is not an ASCII/TwoByte string). If it returns
non-NULL, we do exactly the same thing, something which is not very obvious
right now and furthermore makes half of the comment above superfluous (or at
least this part should be moved as well).

[marja, 2014/04/16 14:33:10]

Extracted the Stream creation. But I don't get what you mean by "we do exactly
the same thing, something which is not very obvious right now and furthermore
makes half of the comment above superfluous (or  at least this part should be
moved as well)."

+                Handle<ExternalAsciiString>::cast(source)->GetChars(), 0,
+                source->length()),
+            allow_harmony_scoping(), allow_modules(), allow_natives_syntax(),
+            allow_generators(), allow_for_of(),
+            allow_harmony_numeric_literals());
+        thread_->Start();
+      } else if (source->IsExternalTwoByteString()) {
+        thread_ = new FastParserThread(
+            new ExternalTwoByteStringUtf16CharacterStream(
+                Handle<ExternalTwoByteString>::cast(source)->GetTwoByteData(0),
+                0, source->length()),
+            allow_harmony_scoping(), allow_modules(), allow_natives_syntax(),
+            allow_generators(), allow_for_of(),
+            allow_harmony_numeric_literals());
+        thread_->Start();
+      }
+    }
   } else if (cached_data_mode_ == CONSUME_CACHED_DATA) {
     (*cached_data_)->Initialize();
   }
 
-  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) {
     Vector<unsigned> store = recorder.ExtractData();
     *cached_data_ = new ScriptData(store);
     log_ = NULL;
+    if (thread_) {

[Sven Panne, 2014/04/16 11:55:35]

Lift this block out into a separate method, it's used identically below.

[marja, 2014/04/16 14:33:10]

Done, and I also added a function for (possibly) starting the thread, where the
above thread-starting code goes.

+      thread_->Join();
+      delete thread_;
+      thread_ = NULL;
+    }
   }
   return result;
 }
 
 
 FunctionLiteral* Parser::DoParseProgram(CompilationInfo* info,
                                         Handle<String> source) {
   ASSERT(scope_ == NULL);
   ASSERT(target_stack_ == NULL);
 
@@ skipping 90 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 2453 matching lines @@
           scope_->end_position() - function_block_pos);
       *materialized_literal_count = entry.literal_count();
       *expected_property_count = entry.property_count();
       scope_->SetStrictMode(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_) {

[Sven Panne, 2014/04/16 11:55:35]

Hmmm, the block below contains some heavy copy-n-paste from the code above, can
we somehow reduce this?

[marja, 2014/04/16 14:33:10]

Done.

+    int start, end;
+    StrictMode strict_mode;
+    // This will wait until the background thread has found the lazy function.
+    thread_->Consume(&start, &end, materialized_literal_count,
+                     expected_property_count, &strict_mode);
+    ASSERT(log_);
+    log_->LogFunction(start, end, *materialized_literal_count,
+                      *expected_property_count, strict_mode);
+    if (start == function_block_pos) {
+      scanner()->SeekForward(end - 1);
+      scope_->set_end_position(end);
+      Expect(Token::RBRACE, ok);
+      if (!ok) {
+        return;
+      }
+      isolate()->counters()->total_preparse_skipped()->Increment(end - start);
+      scope_->SetStrictMode(strict_mode);
+    } else {
+      // The thread might have found an error. Handle it.
+      const SingletonLogger* logger = thread_->recorder();
+      if (thread_->GetResult() == PreParser::kPreParseStackOverflow) {
+        set_stack_overflow();
+      } else if (logger->has_error()) {
+        const char* arg = logger->argument_opt();
+        Vector<const char*> args;
+        if (arg != NULL) {
+          args = Vector<const char*>(&arg, 1);
+        }
+        ParserTraits::ReportMessageAt(
+            Scanner::Location(logger->start(), logger->end()),
+            logger->message(), args, logger->is_reference_error());
+      } else {
+        // The thread produced data for a lazy function which was not the
+        // function we expected. This should never happen.
+        ASSERT(false);
+      }
+      thread_->Join();
+      delete thread_;
+      thread_ = NULL;
+      *ok = false;
+      return;
+    }
   } else {
     // With no cached data, we partially parse the function, without building an
     // AST. This gathers the data needed to build a lazy function.
     SingletonLogger logger;
     PreParser::PreParseResult result =
         ParseLazyFunctionBodyWithPreParser(&logger);
     if (result == PreParser::kPreParseStackOverflow) {
       // Propagate stack overflow.
       set_stack_overflow();
       *ok = false;
@@ skipping 93 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 =
@@ skipping 1066 matching lines @@
       ASSERT(info()->isolate()->has_pending_exception());
     } else {
       result = ParseProgram();
     }
   }
   info()->SetFunction(result);
   return (result != NULL);
 }
 
 } }  // namespace v8::internal