lazy instantiation of the default isolate

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 312 matching lines @@
     FreeStoreAllocationPolicy::Delete(p);
     return;
   }
   PreallocatedStorage* storage = reinterpret_cast<PreallocatedStorage*>(p) - 1;
   ASSERT(storage->next_->previous_ == storage);
   ASSERT(storage->previous_->next_ == storage);
   storage->Unlink();
   storage->LinkTo(&free_list_);
 }
 
-Isolate* Isolate::default_isolate_ = NULL;
 Thread::LocalStorageKey Isolate::isolate_key_;
 Thread::LocalStorageKey Isolate::thread_id_key_;
 Thread::LocalStorageKey Isolate::per_isolate_thread_data_key_;
 #ifdef DEBUG
 Thread::LocalStorageKey PerThreadAssertScopeBase::thread_local_key;
 #endif  // DEBUG
 Mutex Isolate::process_wide_mutex_;
 // TODO(dcarney): Remove with default isolate.
 enum DefaultIsolateStatus {
   kDefaultIsolateUninitialized,
   kDefaultIsolateInitialized,
   kDefaultIsolateCrashIfInitialized
 };
 static DefaultIsolateStatus default_isolate_status_
     = kDefaultIsolateUninitialized;
 Isolate::ThreadDataTable* Isolate::thread_data_table_ = NULL;
 Atomic32 Isolate::isolate_counter_ = 0;
+Atomic32 Isolate::living_isolates_ = 0;
 
 Isolate::PerIsolateThreadData*
     Isolate::FindOrAllocatePerThreadDataForThisThread() {
   ThreadId thread_id = ThreadId::Current();
   PerIsolateThreadData* per_thread = NULL;
   {
     LockGuard<Mutex> lock_guard(&process_wide_mutex_);
     per_thread = thread_data_table_->Lookup(this, thread_id);
     if (per_thread == NULL) {
       per_thread = new PerIsolateThreadData(this, thread_id);
@@ skipping 22 matching lines @@
 }
 
 
 void Isolate::SetCrashIfDefaultIsolateInitialized() {
   LockGuard<Mutex> lock_guard(&process_wide_mutex_);
   CHECK(default_isolate_status_ != kDefaultIsolateInitialized);
   default_isolate_status_ = kDefaultIsolateCrashIfInitialized;
 }
 
 
-void Isolate::EnsureDefaultIsolate() {
+Isolate* Isolate::EnsureDefaultIsolate() {
+  static Isolate* default_isolate_ = NULL;
   LockGuard<Mutex> lock_guard(&process_wide_mutex_);
   CHECK(default_isolate_status_ != kDefaultIsolateCrashIfInitialized);
   if (default_isolate_ == NULL) {
-    isolate_key_ = Thread::CreateThreadLocalKey();
-    thread_id_key_ = Thread::CreateThreadLocalKey();
-    per_isolate_thread_data_key_ = Thread::CreateThreadLocalKey();
-#ifdef DEBUG
-    PerThreadAssertScopeBase::thread_local_key = Thread::CreateThreadLocalKey();
-#endif  // DEBUG
-    thread_data_table_ = new Isolate::ThreadDataTable();
-    default_isolate_ = new Isolate();
+    default_isolate_ = new Isolate(true);
   }
   // Can't use SetIsolateThreadLocals(default_isolate_, NULL) here
   // because a non-null thread data may be already set.
   if (Thread::GetThreadLocal(isolate_key_) == NULL) {
     Thread::SetThreadLocal(isolate_key_, default_isolate_);
   }
+
+  return default_isolate_;
 }
 
+
+void Isolate::InitializeThreadLocalStorage() {
+  // Double checked locking on existence of thread_data_table_.
+  if (thread_data_table_ != NULL) return;
+  LockGuard<Mutex> lock_guard(&process_wide_mutex_);
+  if (thread_data_table_ != NULL) return;
+  isolate_key_ = Thread::CreateThreadLocalKey();
+  thread_id_key_ = Thread::CreateThreadLocalKey();
+  per_isolate_thread_data_key_ = Thread::CreateThreadLocalKey();
+#ifdef DEBUG
+  PerThreadAssertScopeBase::thread_local_key = Thread::CreateThreadLocalKey();
+#endif  // DEBUG
+  thread_data_table_ = new Isolate::ThreadDataTable();
+  CHECK(thread_data_table_ != NULL);
+}
+
+
+// TODO(dcarney): Remove this with default_isolate_ and Isolate::Current.
 struct StaticInitializer {
   StaticInitializer() {
-    Isolate::EnsureDefaultIsolate();
+    Isolate::InitializeThreadLocalStorage();
   }
 } static_initializer;
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
 Debugger* Isolate::GetDefaultIsolateDebugger() {
-  EnsureDefaultIsolate();
-  return default_isolate_->debugger();
+  return EnsureDefaultIsolate()->debugger();
 }
 #endif
 
 
 StackGuard* Isolate::GetDefaultIsolateStackGuard() {
-  EnsureDefaultIsolate();
-  return default_isolate_->stack_guard();
+  return EnsureDefaultIsolate()->stack_guard();
 }
 
 
 void Isolate::EnterDefaultIsolate() {
-  EnsureDefaultIsolate();
-  ASSERT(default_isolate_ != NULL);
+  Isolate* default_isolate = EnsureDefaultIsolate();
+  ASSERT(default_isolate != NULL);
 
   PerIsolateThreadData* data = CurrentPerIsolateThreadData();
   // If not yet in default isolate - enter it.
-  if (data == NULL || data->isolate() != default_isolate_) {
-    default_isolate_->Enter();
+  if (data == NULL || data->isolate() != default_isolate) {
+    default_isolate->Enter();
   }
 }
 
 
 v8::Isolate* Isolate::GetDefaultIsolateForLocking() {
-  EnsureDefaultIsolate();
-  return reinterpret_cast<v8::Isolate*>(default_isolate_);
+  return reinterpret_cast<v8::Isolate*>(EnsureDefaultIsolate());
 }
 
 
 Address Isolate::get_address_from_id(Isolate::AddressId id) {
   return isolate_addresses_[id];
 }
 
 
 char* Isolate::Iterate(ObjectVisitor* v, char* thread_storage) {
   ThreadLocalTop* thread = reinterpret_cast<ThreadLocalTop*>(thread_storage);
@@ skipping 1269 matching lines @@
     if (FLAG_trace_isolates) {                                          \
       PrintF("Isolate %p (id %d)" #tag "\n",                            \
              reinterpret_cast<void*>(this), id());                      \
     }                                                                   \
   } while (false)
 #else
 #define TRACE_ISOLATE(tag)
 #endif
 
 
-Isolate::Isolate()
+Isolate::Isolate(bool is_default_isolate)
     : state_(UNINITIALIZED),
       embedder_data_(NULL),
       entry_stack_(NULL),
       stack_trace_nesting_level_(0),
       incomplete_message_(NULL),
       preallocated_memory_thread_(NULL),
       preallocated_message_space_(NULL),
       bootstrapper_(NULL),
       runtime_profiler_(NULL),
       compilation_cache_(NULL),
@@ skipping 29 matching lines @@
       string_tracker_(NULL),
       regexp_stack_(NULL),
       date_cache_(NULL),
       code_stub_interface_descriptors_(NULL),
       // TODO(bmeurer) Initialized lazily because it depends on flags; can
       // be fixed once the default isolate cleanup is done.
       random_number_generator_(NULL),
       has_fatal_error_(false),
       use_crankshaft_(true),
       initialized_from_snapshot_(false),
+      is_default_isolate_(is_default_isolate),
       cpu_profiler_(NULL),
       heap_profiler_(NULL),
       function_entry_hook_(NULL),
       deferred_handles_head_(NULL),
       optimizing_compiler_thread_(NULL),
       sweeper_thread_(NULL),
       stress_deopt_count_(0) {
+  InitializeThreadLocalStorage();
+
   id_ = NoBarrier_AtomicIncrement(&isolate_counter_, 1);
+  NoBarrier_AtomicIncrement(&living_isolates_, 1);
   TRACE_ISOLATE(constructor);
 
   memset(isolate_addresses_, 0,
       sizeof(isolate_addresses_[0]) * (kIsolateAddressCount + 1));
 
   heap_.isolate_ = this;
   stack_guard_.isolate_ = this;
 
   // ThreadManager is initialized early to support locking an isolate
   // before it is entered.
@@ skipping 162 matching lines @@
 
 Isolate::~Isolate() {
   TRACE_ISOLATE(destructor);
 
   // Has to be called while counters_ are still alive
   runtime_zone_.DeleteKeptSegment();
 
   // The entry stack must be empty when we get here,
   // except for the default isolate, where it can
   // still contain up to one entry stack item
-  ASSERT(entry_stack_ == NULL || this == default_isolate_);
+  ASSERT(entry_stack_ == NULL || is_default_isolate_);
   ASSERT(entry_stack_ == NULL || entry_stack_->previous_item == NULL);
 
   delete entry_stack_;
   entry_stack_ = NULL;
 
   delete[] assembler_spare_buffer_;
   assembler_spare_buffer_ = NULL;
 
   delete unicode_cache_;
   unicode_cache_ = NULL;
@@ skipping 64 matching lines @@
 
   delete random_number_generator_;
   random_number_generator_ = NULL;
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
   delete debugger_;
   debugger_ = NULL;
   delete debug_;
   debug_ = NULL;
 #endif
+
+  NoBarrier_AtomicIncrement(&living_isolates_, -1);
 }
 
 
 void Isolate::InitializeThreadLocal() {
   thread_local_top_.isolate_ = this;
   thread_local_top_.Initialize();
 }
 
 
 void Isolate::PropagatePendingExceptionToExternalTryCatch() {
@@ skipping 442 matching lines @@
 
 #ifdef DEBUG
 #define ISOLATE_FIELD_OFFSET(type, name, ignored)                       \
 const intptr_t Isolate::name##_debug_offset_ = OFFSET_OF(Isolate, name##_);
 ISOLATE_INIT_LIST(ISOLATE_FIELD_OFFSET)
 ISOLATE_INIT_ARRAY_LIST(ISOLATE_FIELD_OFFSET)
 #undef ISOLATE_FIELD_OFFSET
 #endif
 
 } }  // namespace v8::internal