[Isolates] Add a preprocessor flag to guard using TLS for the global isolate....

src/isolate.cc

 // Copyright 2006-2010 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 26 matching lines @@
 #include "serialize.h"
 #include "scopeinfo.h"
 #include "simulator.h"
 #include "stub-cache.h"
 #include "oprofile-agent.h"
 
 namespace v8 {
 namespace internal {
 
 
-Isolate* Isolate::global_isolate = NULL;
+#ifdef V8_USE_TLS_FOR_GLOBAL_ISOLATE
+Thread::LocalStorageKey Isolate::global_isolate_key_;
+
+
+Isolate* Isolate::InitThreadForGlobalIsolate() {
+  ASSERT(global_isolate_ != NULL);
+  Thread::SetThreadLocal(global_isolate_key_, global_isolate_);
+  return global_isolate_;
+}
+#endif
+
+Isolate* Isolate::global_isolate_ = NULL;
 int Isolate::number_of_isolates_ = 0;
 
 
 class IsolateInitializer {
  public:
   IsolateInitializer() {
     Isolate::InitOnce();
   }
 };
 
 
 static IsolateInitializer isolate_initializer;
 
 
 void Isolate::InitOnce() {
-  ASSERT(global_isolate == NULL);
-  global_isolate = new Isolate();
-  CHECK(global_isolate->PreInit());
+  ASSERT(global_isolate_ == NULL);
+#ifdef V8_USE_TLS_FOR_GLOBAL_ISOLATE
+  global_isolate_key_ = Thread::CreateThreadLocalKey();
+#endif
+  global_isolate_ = new Isolate();
+  CHECK(global_isolate_->PreInit());
 }
 
 
 Isolate* Isolate::Create(Deserializer* des) {
   // While we're still building out support for isolates, only support
   // one single global isolate.
 
-  if (global_isolate != NULL) {
+  if (global_isolate_ != NULL) {
     // Allow for two-phase initialization.
-    ASSERT(global_isolate->state_ != INITIALIZED);
+    ASSERT(global_isolate_->state_ != INITIALIZED);
   } else {
-    global_isolate = new Isolate();
+    global_isolate_ = new Isolate();
   }
 
-  if (global_isolate->Init(des)) {
+  if (global_isolate_->Init(des)) {
     ++number_of_isolates_;
-    return global_isolate;
+    return global_isolate_;
   } else {
-    delete global_isolate;
-    global_isolate = NULL;
+    delete global_isolate_;
+    global_isolate_ = NULL;
+#ifdef V8_USE_TLS_FOR_GLOBAL_ISOLATE
+    Thread::SetThreadLocal(global_isolate_key_, NULL);
+#endif
     return NULL;
   }
 }
 
 
 Isolate::Isolate()
     : state_(UNINITIALIZED),
       bootstrapper_(NULL),
       cpu_features_(NULL),
       break_access_(OS::CreateMutex()),
@@ skipping 36 matching lines @@
   cpu_features_ = NULL;
   delete bootstrapper_;
   bootstrapper_ = NULL;
 
   if (state_ == INITIALIZED) --number_of_isolates_;
 }
 
 
 bool Isolate::PreInit() {
   if (state_ != UNINITIALIZED) return true;
-  ASSERT(global_isolate == this);
+  ASSERT(global_isolate_ == this);
+
+#ifdef V8_USE_TLS_FOR_GLOBAL_ISOLATE
+  InitThreadForGlobalIsolate();
+#endif
 
   // Safe after setting Heap::isolate_, initializing StackGuard and
   // ensuring that Isolate::Current() == this.
   heap_.SetStackLimits();
 
 #ifdef DEBUG
   DisallowAllocationFailure disallow_allocation_failure;
 #endif
   bootstrapper_ = new Bootstrapper();
   cpu_features_ = new CpuFeatures();
   handle_scope_implementer_ = new HandleScopeImplementer();
   stub_cache_ = new StubCache();
   state_ = PREINITIALIZED;
   return true;
 }
 
 
 bool Isolate::Init(Deserializer* des) {
-  ASSERT(global_isolate == this);
+  ASSERT(global_isolate_ == this);
 
   bool create_heap_objects = des == NULL;
 
 #ifdef DEBUG
   // The initialization process does not handle memory exhaustion.
   DisallowAllocationFailure disallow_allocation_failure;
 #endif
 
   if (state_ == UNINITIALIZED && !PreInit()) return false;
 
@@ skipping 64 matching lines @@
     LOG(LogCodeObjects());
     LOG(LogCompiledFunctions());
   }
 
   state_ = INITIALIZED;
   return true;
 }
 
 
 } }  // namespace v8::internal