[vm] Introduce ReentrantMonitor.

Existing Monitor is not reentrable, doesn't support acquiring it if it is already acquired by this thread.

TEST=ReentrantMonitorAllowsReentrance

Change-Id: Id74479388a99ca907bca6e379c3a7e08191e841b
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/436542
Commit-Queue: Alexander Aprelev <[email protected]>
Reviewed-by: Ryan Macnak <[email protected]>

Author: aam

runtime/platform/synchronization.h

@@ -130,6 +130,92 @@ class Monitor {
   DISALLOW_COPY_AND_ASSIGN(Monitor);
 };
 
+class ReentrantMonitor {
+ public:
+  using WaitResult = ConditionVariable::WaitResult;
+  static constexpr WaitResult kNotified = ConditionVariable::kNotified;
+  static constexpr WaitResult kTimedOut = ConditionVariable::kTimedOut;
+
+  static constexpr int64_t kNoTimeout = ConditionVariable::kNoTimeout;
+
+  ReentrantMonitor() {}
+  ~ReentrantMonitor() {}
+
+  bool IsOwnedByCurrentThread() const {
+    return owner_ == platform::GetCurrentThreadId();
+  }
+
+  bool TryEnter() {
+    bool entered = false;
+    if (IsOwnedByCurrentThread()) {
+      entered = true;
+    } else {
+      entered = mutex_.TryLock();
+      if (entered) {
+        owner_ = platform::GetCurrentThreadId();
+      }
+    }
+    if (entered) {
+      ++depth_;
+      ASSERT(owner_ == platform::GetCurrentThreadId());
+    }
+    return entered;
+  }
+
+  void Enter() {
+    ASSERT(depth_ >= 0);
+    if (!IsOwnedByCurrentThread()) {
+      mutex_.Lock();
+      owner_ = platform::GetCurrentThreadId();
+    }
+    ASSERT(owner_ == platform::GetCurrentThreadId());
+    ++depth_;
+  }
+
+  void Exit() {
+    ASSERT(depth_ > 0);
+    ASSERT(owner_ == platform::GetCurrentThreadId());
+    if (--depth_ == 0) {
+      owner_ = platform::kInvalidThreadId;
+      mutex_.Unlock();
+    }
+  }
+
+  WaitResult Wait(int64_t timeout_millis) {
+    ASSERT(IsOwnedByCurrentThread() && depth_ == 1);
+    --depth_;
+    owner_ = platform::kInvalidThreadId;
+    WaitResult result = cv_.Wait(&mutex_, timeout_millis);
+    owner_ = platform::GetCurrentThreadId();
+    ++depth_;
+    return result;
+  }
+
+  WaitResult WaitMicros(int64_t timeout_micros) {
+    ASSERT(IsOwnedByCurrentThread() && depth_ == 1);
+    --depth_;
+    owner_ = platform::kInvalidThreadId;
+    WaitResult result = cv_.WaitMicros(&mutex_, timeout_micros);
+    owner_ = platform::GetCurrentThreadId();
+    ++depth_;
+    return result;
+  }
+
+  // Notify waiting threads.
+  void Notify() { cv_.Notify(); }
+
+  void NotifyAll() { cv_.NotifyAll(); }
+
+ private:
+  Mutex mutex_;  // OS-specific data.
+  ConditionVariable cv_;
+
+  intptr_t depth_ = 0;
+  platform::ThreadId owner_ = platform::kInvalidThreadId;
+
+  DISALLOW_COPY_AND_ASSIGN(ReentrantMonitor);
+};
+
 }  // namespace dart
 
 #endif  // RUNTIME_PLATFORM_SYNCHRONIZATION_H_

runtime/vm/lockers.cc

@@ -55,7 +55,8 @@ SafepointMutexLocker::SafepointMutexLocker(ThreadState* thread, Mutex* mutex)
   }
 }
 
-void SafepointMonitorLocker::AcquireLock() {
+template <typename M>
+void SafepointLocker<M>::AcquireLock() {
   ASSERT(monitor_ != nullptr);
   if (!monitor_->TryEnter()) {
     // We did not get the lock and could potentially block, so transition
@@ -70,14 +71,11 @@ void SafepointMonitorLocker::AcquireLock() {
   }
 }
 
-void SafepointMonitorLocker::ReleaseLock() {
-  monitor_->Exit();
-}
-
-Monitor::WaitResult SafepointMonitorLocker::Wait(int64_t millis) {
+template <typename M>
+M::WaitResult SafepointLocker<M>::Wait(int64_t millis) {
   Thread* thread = Thread::Current();
   if (thread != nullptr) {
-    Monitor::WaitResult result;
+    typename M::WaitResult result;
     {
       TransitionVMToBlocked transition(thread);
       result = monitor_->Wait(millis);
@@ -88,6 +86,9 @@ Monitor::WaitResult SafepointMonitorLocker::Wait(int64_t millis) {
   }
 }
 
+template class SafepointLocker<ReentrantMonitor>;
+template class SafepointLocker<Monitor>;
+
 #if defined(DEBUG)
 bool SafepointRwLock::IsCurrentThreadReader() {
   ThreadId id = OSThread::GetCurrentThreadId();

runtime/vm/lockers.h

@@ -273,28 +273,30 @@ class SafepointMutexLocker : public StackResource {
  *      ...
  *    }
  */
-class SafepointMonitorLocker : public ValueObject {
+template <typename M>
+class SafepointLocker : public ValueObject {
  public:
-  explicit SafepointMonitorLocker(Monitor* monitor) : monitor_(monitor) {
-    AcquireLock();
-  }
-  virtual ~SafepointMonitorLocker() { ReleaseLock(); }
+  explicit SafepointLocker(M* monitor) : monitor_(monitor) { AcquireLock(); }
+  virtual ~SafepointLocker() { ReleaseLock(); }
 
-  Monitor::WaitResult Wait(int64_t millis = Monitor::kNoTimeout);
+  M::WaitResult Wait(int64_t millis = Monitor::kNoTimeout);
 
   void NotifyAll() { monitor_->NotifyAll(); }
 
  private:
   friend class SafepointMonitorUnlockScope;
 
   void AcquireLock();
-  void ReleaseLock();
 
-  Monitor* const monitor_;
+  void ReleaseLock() { monitor_->Exit(); }
 
-  DISALLOW_COPY_AND_ASSIGN(SafepointMonitorLocker);
+  M* const monitor_;
+
+  DISALLOW_COPY_AND_ASSIGN(SafepointLocker);
 };
 
+typedef SafepointLocker<Monitor> SafepointMonitorLocker;
+
 class SafepointMonitorUnlockScope : public ValueObject {
  public:
   explicit SafepointMonitorUnlockScope(SafepointMonitorLocker* locker)

runtime/vm/thread_test.cc

@@ -1154,4 +1154,17 @@ ISOLATE_UNIT_TEST_CASE(SafepointMonitorUnlockScope) {
   }
 }
 
+ISOLATE_UNIT_TEST_CASE(ReentrantMonitorAllowsReentrance) {
+  ReentrantMonitor monitor;
+  {
+    SafepointLocker<ReentrantMonitor> ml1(&monitor);
+    ASSERT(monitor.IsOwnedByCurrentThread());
+    {
+      SafepointLocker<ReentrantMonitor> ml2(&monitor);
+      ASSERT(monitor.IsOwnedByCurrentThread());
+    }
+    ASSERT(monitor.IsOwnedByCurrentThread());
+  }
+}
+
 }  // namespace dart