Two-threaded parser

src/isolate.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 <stdlib.h>
 
 #include "v8.h"
 
 #include "ast.h"
 #include "bootstrapper.h"
 #include "codegen.h"
 #include "compilation-cache.h"
 #include "cpu-profiler.h"
 #include "debug.h"
 #include "deoptimizer.h"
 #include "heap-profiler.h"
 #include "hydrogen.h"
 #include "isolate-inl.h"
 #include "lithium-allocator.h"
 #include "log.h"
 #include "messages.h"
+#include "parser-thread.h"
 #include "platform.h"
 #include "regexp-stack.h"
 #include "runtime-profiler.h"
 #include "sampler.h"
 #include "scopeinfo.h"
 #include "serialize.h"
 #include "simulator.h"
 #include "spaces.h"
 #include "stub-cache.h"
 #include "sweeper-thread.h"
@@ skipping 1440 matching lines @@
       // be fixed once the default isolate cleanup is done.
       random_number_generator_(NULL),
       has_fatal_error_(false),
       use_crankshaft_(true),
       initialized_from_snapshot_(false),
       cpu_profiler_(NULL),
       heap_profiler_(NULL),
       function_entry_hook_(NULL),
       deferred_handles_head_(NULL),
       optimizing_compiler_thread_(NULL),
+      fast_parser_thread_(NULL),
       sweeper_thread_(NULL),
       num_sweeper_threads_(0),
       stress_deopt_count_(0),
       next_optimization_id_(0) {
   id_ = NoBarrier_AtomicIncrement(&isolate_counter_, 1);
   TRACE_ISOLATE(constructor);
 
   memset(isolate_addresses_, 0,
       sizeof(isolate_addresses_[0]) * (kIsolateAddressCount + 1));
 
@@ skipping 67 matching lines @@
     TRACE_ISOLATE(deinit);
 
     debugger()->UnloadDebugger();
 
     if (concurrent_recompilation_enabled()) {
       optimizing_compiler_thread_->Stop();
       delete optimizing_compiler_thread_;
       optimizing_compiler_thread_ = NULL;
     }
 
+    if (fast_parser_thread_) {
+      fast_parser_thread_->Stop();
+      delete fast_parser_thread_;
+      fast_parser_thread_ = NULL;
+    }
+
     for (int i = 0; i < num_sweeper_threads_; i++) {
       sweeper_thread_[i]->Stop();
       delete sweeper_thread_[i];
       sweeper_thread_[i] = NULL;
     }
     delete[] sweeper_thread_;
     sweeper_thread_ = NULL;
 
     if (FLAG_job_based_sweeping &&
         heap_.mark_compact_collector()->IsConcurrentSweepingInProgress()) {
@@ skipping 337 matching lines @@
   }
 
   if (num_sweeper_threads_ > 0) {
     sweeper_thread_ = new SweeperThread*[num_sweeper_threads_];
     for (int i = 0; i < num_sweeper_threads_; i++) {
       sweeper_thread_[i] = new SweeperThread(this);
       sweeper_thread_[i]->Start();
     }
   }
 
+  if (FLAG_parallel_parse) {
+    fast_parser_thread_ = new FastParserThread();
+    fast_parser_thread_->Start();
+  }
+
   // If we are deserializing, read the state into the now-empty heap.
   if (!create_heap_objects) {
     des->Deserialize(this);
   }
   stub_cache_->Initialize();
 
   // Finish initialization of ThreadLocal after deserialization is done.
   clear_pending_exception();
   clear_pending_message();
   clear_scheduled_exception();
@@ skipping 365 matching lines @@
       Execution::Call(this, microtask, factory()->undefined_value(),
                       0, NULL).Check();
     }
   }
 
   handle_scope_implementer()->DecrementCallDepth();
 }
 
 
 } }  // namespace v8::internal