Two-threaded parser

src/isolate.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 24 matching lines @@
 #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 1425 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 72 matching lines @@
 #ifdef ENABLE_DEBUGGER_SUPPORT
     debugger()->UnloadDebugger();
 #endif
 
     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 351 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();
+  }
+
 #ifdef ENABLE_DEBUGGER_SUPPORT
   debug_->SetUp(create_heap_objects);
 #endif
 
   // If we are deserializing, read the state into the now-empty heap.
   if (!create_heap_objects) {
     des->Deserialize(this);
   }
   stub_cache_->Initialize();
 
@@ skipping 287 matching lines @@
       Handle<JSObject> obj = factory()->NewJSObjectFromMap(map);
       JSObject::NormalizeProperties(obj, KEEP_INOBJECT_PROPERTIES, 8);
       JSObject::SetProperty(registry, name, obj, NONE, STRICT).Assert();
     }
   }
   return Handle<JSObject>::cast(factory()->symbol_registry());
 }
 
 
 } }  // namespace v8::internal