From f3b9ece6a4db94f3ce11866d69314ea729cf8189 Mon Sep 17 00:00:00 2001 From: "yangguo@chromium.org" Date: Thu, 3 Jul 2014 12:33:16 +0000 Subject: [PATCH] Revert "Reland^2 r22105 "Remove static initializer from isolate"" This reverts r22167. BUG=v8:3421 LOG=N TBR=jochen@chromium.org Review URL: https://codereview.chromium.org/366123002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22197 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/isolate.cc | 36 ++++++++++++++++++++++++++---------- src/isolate.h | 26 ++++++++------------------ src/sampler.cc | 2 +- tools/check-static-initializers.sh | 3 ++- 4 files changed, 37 insertions(+), 30 deletions(-) diff --git a/src/isolate.cc b/src/isolate.cc index 5eb1021..04327b1 100644 --- a/src/isolate.cc +++ b/src/isolate.cc @@ -46,7 +46,6 @@ int ThreadId::AllocateThreadId() { int ThreadId::GetCurrentThreadId() { - Isolate::EnsureInitialized(); int thread_id = base::Thread::GetThreadLocalInt(Isolate::thread_id_key_); if (thread_id == 0) { thread_id = AllocateThreadId(); @@ -105,17 +104,24 @@ base::Thread::LocalStorageKey Isolate::per_isolate_thread_data_key_; #ifdef DEBUG base::Thread::LocalStorageKey PerThreadAssertScopeBase::thread_local_key; #endif // DEBUG -base::LazyMutex Isolate::process_wide_mutex_ = LAZY_MUTEX_INITIALIZER; +base::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; base::Atomic32 Isolate::isolate_counter_ = 0; Isolate::PerIsolateThreadData* Isolate::FindOrAllocatePerThreadDataForThisThread() { - EnsureInitialized(); ThreadId thread_id = ThreadId::Current(); PerIsolateThreadData* per_thread = NULL; { - base::LockGuard lock_guard(process_wide_mutex_.Pointer()); + base::LockGuard 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); @@ -135,18 +141,25 @@ Isolate::PerIsolateThreadData* Isolate::FindPerThreadDataForThisThread() { Isolate::PerIsolateThreadData* Isolate::FindPerThreadDataForThread( ThreadId thread_id) { - EnsureInitialized(); PerIsolateThreadData* per_thread = NULL; { - base::LockGuard lock_guard(process_wide_mutex_.Pointer()); + base::LockGuard lock_guard(&process_wide_mutex_); per_thread = thread_data_table_->Lookup(this, thread_id); } return per_thread; } -void Isolate::EnsureInitialized() { - base::LockGuard lock_guard(process_wide_mutex_.Pointer()); +void Isolate::SetCrashIfDefaultIsolateInitialized() { + base::LockGuard lock_guard(&process_wide_mutex_); + CHECK(default_isolate_status_ != kDefaultIsolateInitialized); + default_isolate_status_ = kDefaultIsolateCrashIfInitialized; +} + + +void Isolate::EnsureDefaultIsolate() { + base::LockGuard lock_guard(&process_wide_mutex_); + CHECK(default_isolate_status_ != kDefaultIsolateCrashIfInitialized); if (thread_data_table_ == NULL) { isolate_key_ = base::Thread::CreateThreadLocalKey(); thread_id_key_ = base::Thread::CreateThreadLocalKey(); @@ -159,6 +172,10 @@ void Isolate::EnsureInitialized() { } } +struct StaticInitializer { + StaticInitializer() { Isolate::EnsureDefaultIsolate(); } +} static_initializer; + Address Isolate::get_address_from_id(Isolate::AddressId id) { return isolate_addresses_[id]; @@ -1516,7 +1533,7 @@ void Isolate::TearDown() { Deinit(); { - base::LockGuard lock_guard(process_wide_mutex_.Pointer()); + base::LockGuard lock_guard(&process_wide_mutex_); thread_data_table_->RemoveAllThreads(this); } @@ -1617,7 +1634,6 @@ void Isolate::PushToPartialSnapshotCache(Object* obj) { void Isolate::SetIsolateThreadLocals(Isolate* isolate, PerIsolateThreadData* data) { - EnsureInitialized(); base::Thread::SetThreadLocal(isolate_key_, isolate); base::Thread::SetThreadLocal(per_isolate_thread_data_key_, data); } diff --git a/src/isolate.h b/src/isolate.h index 5c4725b..3b572d7 100644 --- a/src/isolate.h +++ b/src/isolate.h @@ -447,14 +447,12 @@ class Isolate { // Returns the PerIsolateThreadData for the current thread (or NULL if one is // not currently set). static PerIsolateThreadData* CurrentPerIsolateThreadData() { - EnsureInitialized(); return reinterpret_cast( base::Thread::GetThreadLocal(per_isolate_thread_data_key_)); } // Returns the isolate inside which the current thread is running. INLINE(static Isolate* Current()) { - EnsureInitialized(); Isolate* isolate = reinterpret_cast( base::Thread::GetExistingThreadLocal(isolate_key_)); ASSERT(isolate != NULL); @@ -462,17 +460,6 @@ class Isolate { } INLINE(static Isolate* UncheckedCurrent()) { - EnsureInitialized(); - return reinterpret_cast( - base::Thread::GetThreadLocal(isolate_key_)); - } - - // Like UncheckCurrent, but returns NULL if called reentrantly during - // initialization. - INLINE(static Isolate* UncheckedReentrantCurrent()) { - if (!process_wide_mutex_.Pointer()->TryLock()) return NULL; - process_wide_mutex_.Pointer()->Unlock(); - EnsureInitialized(); return reinterpret_cast( base::Thread::GetThreadLocal(isolate_key_)); } @@ -498,6 +485,13 @@ class Isolate { static void GlobalTearDown(); + static void SetCrashIfDefaultIsolateInitialized(); + // Ensures that process-wide resources and the default isolate have been + // allocated. It is only necessary to call this method in rare cases, for + // example if you are using V8 from within the body of a static initializer. + // Safe to call multiple times. + static void EnsureDefaultIsolate(); + // Find the PerThread for this particular (isolate, thread) combination // If one does not yet exist, return null. PerIsolateThreadData* FindPerThreadDataForThisThread(); @@ -510,13 +504,11 @@ class Isolate { // Used internally for V8 threads that do not execute JavaScript but still // are part of the domain of an isolate (like the context switcher). static base::Thread::LocalStorageKey isolate_key() { - EnsureInitialized(); return isolate_key_; } // Returns the key used to store process-wide thread IDs. static base::Thread::LocalStorageKey thread_id_key() { - EnsureInitialized(); return thread_id_key_; } @@ -1097,8 +1089,6 @@ class Isolate { void CountUsage(v8::Isolate::UseCounterFeature feature); private: - static void EnsureInitialized(); - Isolate(); friend struct GlobalState; @@ -1158,7 +1148,7 @@ class Isolate { }; // This mutex protects highest_thread_id_ and thread_data_table_. - static base::LazyMutex process_wide_mutex_; + static base::Mutex process_wide_mutex_; static base::Thread::LocalStorageKey per_isolate_thread_data_key_; static base::Thread::LocalStorageKey isolate_key_; diff --git a/src/sampler.cc b/src/sampler.cc index 0ed4b37..7ee7216 100644 --- a/src/sampler.cc +++ b/src/sampler.cc @@ -331,7 +331,7 @@ void SignalHandler::HandleProfilerSignal(int signal, siginfo_t* info, #else USE(info); if (signal != SIGPROF) return; - Isolate* isolate = Isolate::UncheckedReentrantCurrent(); + Isolate* isolate = Isolate::UncheckedCurrent(); if (isolate == NULL || !isolate->IsInitialized() || !isolate->IsInUse()) { // We require a fully initialized and entered isolate. return; diff --git a/tools/check-static-initializers.sh b/tools/check-static-initializers.sh index da43170..11ba080 100755 --- a/tools/check-static-initializers.sh +++ b/tools/check-static-initializers.sh @@ -32,7 +32,8 @@ # Allow: # - _GLOBAL__I__ZN2v810LineEditor6first_E # - _GLOBAL__I__ZN2v88internal32AtomicOps_Internalx86CPUFeaturesE -expected_static_init_count=2 +# - _GLOBAL__I__ZN2v88internal8ThreadId18highest_thread_id_E +expected_static_init_count=3 v8_root=$(readlink -f $(dirname $BASH_SOURCE)/../) -- 2.7.4