[Isolates] Merge crankshaft (r5922 from bleeding_edge).

src/v8threads.cc

 // Copyright 2008 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 56 matching lines @@
       // This only enters if not yet entered.
       internal::Isolate::EnterDefaultIsolate();
     }
 
     ASSERT(internal::Thread::HasThreadLocal(
         internal::Isolate::thread_id_key()));
 
     // Make sure that V8 is initialized.  Archiving of threads interferes
     // with deserialization by adding additional root pointers, so we must
     // initialize here, before anyone can call ~Locker() or Unlocker().
-    if (!internal::V8::IsRunning()) {
+    if (!isolate->IsInitialized()) {
       V8::Initialize();
     }
     // This may be a locker within an unlocker in which case we have to
     // get the saved state for this thread and restore it.
     if (isolate->thread_manager()->RestoreThread()) {
       top_level_ = false;
     } else {
-      internal::ExecutionAccess access;
+      internal::ExecutionAccess access(isolate);
       isolate->stack_guard()->ClearThread(access);
       isolate->stack_guard()->InitThread(access);
     }
   }
   ASSERT(isolate->thread_manager()->IsLockedByCurrentThread());
 }
 
 
 bool Locker::IsLocked() {
   return internal::Isolate::Current()->thread_manager()->
       IsLockedByCurrentThread();
 }
 
 
 Locker::~Locker() {
+  // TODO(isolate): this should use a field storing the isolate it
+  // locked instead.
   internal::Isolate* isolate = internal::Isolate::Current();
   ASSERT(isolate->thread_manager()->IsLockedByCurrentThread());
   if (has_lock_) {
     if (top_level_) {
       isolate->thread_manager()->FreeThreadResources();
     } else {
       isolate->thread_manager()->ArchiveThread();
     }
     isolate->thread_manager()->Unlock();
   }
 }
 
 
 Unlocker::Unlocker() {
   internal::Isolate* isolate = internal::Isolate::Current();
   ASSERT(isolate->thread_manager()->IsLockedByCurrentThread());
   isolate->thread_manager()->ArchiveThread();
   isolate->thread_manager()->Unlock();
 }
 
 
 Unlocker::~Unlocker() {
+  // TODO(isolates): check it's the isolate we unlocked.
   internal::Isolate* isolate = internal::Isolate::Current();
   ASSERT(!isolate->thread_manager()->IsLockedByCurrentThread());
   isolate->thread_manager()->Lock();
   isolate->thread_manager()->RestoreThread();
 }
 
 
 void Locker::StartPreemption(int every_n_ms) {
   v8::internal::ContextSwitcher::StartPreemption(every_n_ms);
 }
@@ skipping 17 matching lines @@
            lazily_archived_thread_state_);
     lazily_archived_thread_state_->set_id(kInvalidId);
     lazily_archived_thread_state_->LinkInto(ThreadState::FREE_LIST);
     lazily_archived_thread_state_ = NULL;
     Isolate::CurrentPerIsolateThreadData()->set_thread_state(NULL);
     return true;
   }
 
   // Make sure that the preemption thread cannot modify the thread state while
   // it is being archived or restored.
-  ExecutionAccess access;
+  ExecutionAccess access(isolate_);
 
   // If there is another thread that was lazily archived then we have to really
   // archive it now.
   if (lazily_archived_thread_.IsValid()) {
     EagerlyArchiveThread();
   }
   Isolate::PerIsolateThreadData* per_thread =
       Isolate::CurrentPerIsolateThreadData();
   if (per_thread == NULL || per_thread->thread_state() == NULL) {
     // This is a new thread.
@@ skipping 112 matching lines @@
       lazily_archived_thread_(ThreadHandle::INVALID),
       lazily_archived_thread_state_(NULL),
       free_anchor_(NULL),
       in_use_anchor_(NULL) {
   free_anchor_ = new ThreadState(this);
   in_use_anchor_ = new ThreadState(this);
 }
 
 
 ThreadManager::~ThreadManager() {
-  // TODO(isolates): Destroy TLS keys and mutexes.
+  // TODO(isolates): Destroy mutexes.
 }
 
 
 void ThreadManager::ArchiveThread() {
   ASSERT(!lazily_archived_thread_.IsValid());
   ASSERT(!IsArchived());
   ThreadState* state = GetFreeThreadState();
   state->Unlink();
   Isolate::CurrentPerIsolateThreadData()->set_thread_state(state);
   lazily_archived_thread_.Initialize(ThreadHandle::SELF);
@@ skipping 137 matching lines @@
 // Acknowledge the preemption by the receiving thread.
 void ContextSwitcher::PreemptionReceived() {
   ASSERT(Locker::IsLocked());
   // There is currently no accounting being done for this. But could be in the
   // future, which is why we leave this in.
 }
 
 
 }  // namespace internal
 }  // namespace v8