Add locker support to DebugMessageDispatchHandler

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 28 matching lines @@
 static internal::Thread::LocalStorageKey thread_state_key =
     internal::Thread::CreateThreadLocalKey();
 static internal::Thread::LocalStorageKey thread_id_key =
     internal::Thread::CreateThreadLocalKey();
 
 
 // Track whether this V8 instance has ever called v8::Locker. This allows the
 // API code to verify that the lock is always held when V8 is being entered.
 bool Locker::active_ = false;
 
-
 // Constructor for the Locker object.  Once the Locker is constructed the
 // current thread will be guaranteed to have the big V8 lock.
-Locker::Locker() : has_lock_(false), top_level_(true) {
+Locker::Locker(LockParameters* lock_parameters) : has_lock_(false), top_level_(true) {
   // Record that the Locker has been used at least once.
   active_ = true;
+  effective_ = false;
   // Get the big lock if necessary.
   if (!internal::ThreadManager::IsLockedByCurrentThread()) {
+
+#ifdef ENABLE_DEBUGGER_SUPPORT
+    if (lock_parameters == NULL) {
+      internal::ThreadManager::Lock();
+    } else {
+      bool res = internal::ThreadManager::LockOrAsk(&internal::Promises::promise_to_process_debug_commands);
+      if (!res) {
+        lock_parameters->successfully_relaied = true;
+        return;
+      }
+    }
+#else
     internal::ThreadManager::Lock();
+#endif
     has_lock_ = true;
     // 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()) {
       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 (internal::ThreadManager::RestoreThread()) {
       top_level_ = false;
     } else {
       internal::ExecutionAccess access;
       internal::StackGuard::ClearThread(access);
       internal::StackGuard::InitThread(access);
     }
   }
   ASSERT(internal::ThreadManager::IsLockedByCurrentThread());
 
   // Make sure this thread is assigned a thread id.
   internal::ThreadManager::AssignId();
+  effective_ = true;
 }
 
 
 bool Locker::IsLocked() {
   return internal::ThreadManager::IsLockedByCurrentThread();
 }
 
 
 Locker::~Locker() {
+  if (!effective_) {
+    return;
+  }
   ASSERT(internal::ThreadManager::IsLockedByCurrentThread());
   if (has_lock_) {
     if (top_level_) {
       internal::ThreadManager::FreeThreadResources();
     } else {
       internal::ThreadManager::ArchiveThread();
     }
     internal::ThreadManager::Unlock();
   }
 }
@@ skipping 71 matching lines @@
   if (state->terminate_on_restore()) {
     StackGuard::TerminateExecution();
     state->set_terminate_on_restore(false);
   }
   state->set_id(kInvalidId);
   state->Unlink();
   state->LinkInto(ThreadState::FREE_LIST);
   return true;
 }
 
+#ifdef ENABLE_DEBUGGER_SUPPORT
+
+class PromisesHandler {
+ public:
+  static bool CanUnlock(Promises* promises) {
+    return !promises->promise_to_process_debug_commands;
+  }
+  static void KeepPromises(const Promises* promises) {
+    v8::Debug::ProcessDebuggerCommands();
+  }
+};
+
+
+MutexWithResponsibilities::MutexWithResponsibilities()
+: flag_mutex_(OS::CreateMutex()),
+  sem_(OS::CreateSemaphore(1)), // Am I accurate with semaphore?
+  locked_(false)
+{
+}
+
+MutexWithResponsibilities::~MutexWithResponsibilities() {
+  delete sem_;
+  delete flag_mutex_;
+}
+
+
+void MutexWithResponsibilities::Lock() {
+  while (true) {
+    {
+      ScopedLock lock(flag_mutex_);
+      if (!locked_) {
+        locked_ = true;
+        has_promises_ = true;
+        return;
+      }
+    }
+    sem_->Wait();
+  }
+}
+
+bool MutexWithResponsibilities::LockOrAsk(bool Promises::* promise) {
+  ScopedLock lock(flag_mutex_);
+  if (locked_) {
+    ASSERT(has_promises_);
+    promises_.*promise = true;
+    return false;
+  } else {
+    locked_ = true;
+    has_promises_ = false;
+    return true;
+  }
+}
+
+void MutexWithResponsibilities::Unlock() {
+  while (true) {
+    Promises promises_copy;
+    {
+      ScopedLock lock(flag_mutex_);
+      ASSERT(locked_);
+      bool has_to_do = has_promises_ && PromisesHandler::CanUnlock(&promises_);
+      if (!has_to_do) {
+        locked_ = false;
+        break;
+      }
+      promises_copy = promises_;
+      promises_.Reset();
+    }
+    PromisesHandler::KeepPromises(&promises_copy);
+  }
+  sem_->Signal();
+}
+
+#endif
+
+
 
 void ThreadManager::Lock() {
   mutex_->Lock();
   mutex_owner_.Initialize(ThreadHandle::SELF);
   ASSERT(IsLockedByCurrentThread());
 }
 
 
 void ThreadManager::Unlock() {
   mutex_owner_.Initialize(ThreadHandle::INVALID);
   mutex_->Unlock();
 }
 
+#ifdef ENABLE_DEBUGGER_SUPPORT
+bool ThreadManager::LockOrAsk(bool Promises::* promise) {
+  bool res = mutex_->LockOrAsk(promise);
+  if (res) {
+    mutex_owner_.Initialize(ThreadHandle::SELF);
+    ASSERT(IsLockedByCurrentThread());
+  }
+  return res;
+}
+#endif
+
 
 static int ArchiveSpacePerThread() {
   return HandleScopeImplementer::ArchiveSpacePerThread() +
                             Top::ArchiveSpacePerThread() +
 #ifdef ENABLE_DEBUGGER_SUPPORT
                           Debug::ArchiveSpacePerThread() +
 #endif
                      StackGuard::ArchiveSpacePerThread() +
                     RegExpStack::ArchiveSpacePerThread() +
                    Bootstrapper::ArchiveSpacePerThread() +
@@ skipping 52 matching lines @@
 ThreadState* ThreadState::Next() {
   if (next_ == in_use_anchor_) return NULL;
   return next_;
 }
 
 
 // Thread ids must start with 1, because in TLS having thread id 0 can't
 // be distinguished from not having a thread id at all (since NULL is
 // defined as 0.)
 int ThreadManager::last_id_ = 0;
+#ifdef ENABLE_DEBUGGER_SUPPORT
+MutexWithResponsibilities* ThreadManager::mutex_ = new MutexWithResponsibilities;
+#else
 Mutex* ThreadManager::mutex_ = OS::CreateMutex();
+#endif
 ThreadHandle ThreadManager::mutex_owner_(ThreadHandle::INVALID);
 ThreadHandle ThreadManager::lazily_archived_thread_(ThreadHandle::INVALID);
 ThreadState* ThreadManager::lazily_archived_thread_state_ = NULL;
 
 
 void ThreadManager::ArchiveThread() {
   ASSERT(!lazily_archived_thread_.IsValid());
   ASSERT(!IsArchived());
   ThreadState* state = ThreadState::GetFree();
   state->Unlink();
@@ skipping 166 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