xpcom/threads/ReentrantMonitor.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_ReentrantMonitor_h
   8 #define mozilla_ReentrantMonitor_h
   9
  10 #include "prmon.h"
  11
  12 #if defined(MOZILLA_INTERNAL_API) && !defined(DEBUG)
  13 #  include "mozilla/ProfilerThreadSleep.h"
  14 #endif  // defined( MOZILLA_INTERNAL_API) && !defined(DEBUG)
  15
  16 #include "mozilla/BlockingResourceBase.h"
  17 #include "mozilla/ThreadSafety.h"
  18 #include "nsISupports.h"
  19 //
  20 // Provides:
  21 //
  22 //  - ReentrantMonitor, a Java-like monitor
  23 //  - ReentrantMonitorAutoEnter, an RAII class for ensuring that
  24 //    ReentrantMonitors are properly entered and exited
  25 //
  26 // Using ReentrantMonitorAutoEnter is MUCH preferred to making bare calls to
  27 // ReentrantMonitor.Enter and Exit.
  28 //
  29 namespace mozilla {
  30
  31 /**
  32  * ReentrantMonitor
  33  * Java-like monitor.
  34  * When possible, use ReentrantMonitorAutoEnter to hold this monitor within a
  35  * scope, instead of calling Enter/Exit directly.
  36  **/
  37 class MOZ_CAPABILITY("reentrant monitor") ReentrantMonitor
  38     : BlockingResourceBase {
  39  public:
  40   /**
  41    * ReentrantMonitor
  42    * @param aName A name which can reference this monitor
  43    */
  44   explicit ReentrantMonitor(const char* aName)
  45       : BlockingResourceBase(aName, eReentrantMonitor)
  46 #ifdef DEBUG
  47         ,
  48         mEntryCount(0)
  49 #endif
  50   {
  51     MOZ_COUNT_CTOR(ReentrantMonitor);
  52     mReentrantMonitor = PR_NewMonitor();
  53     if (!mReentrantMonitor) {
  54       MOZ_CRASH("Can't allocate mozilla::ReentrantMonitor");
  55     }
  56   }
  57
  58   /**
  59    * ~ReentrantMonitor
  60    **/
  61   ~ReentrantMonitor() {
  62     NS_ASSERTION(mReentrantMonitor,
  63                  "improperly constructed ReentrantMonitor or double free");
  64     PR_DestroyMonitor(mReentrantMonitor);
  65     mReentrantMonitor = 0;
  66     MOZ_COUNT_DTOR(ReentrantMonitor);
  67   }
  68
  69 #ifndef DEBUG
  70   /**
  71    * Enter
  72    * @see prmon.h
  73    **/
  74   void Enter() MOZ_CAPABILITY_ACQUIRE() { PR_EnterMonitor(mReentrantMonitor); }
  75
  76   /**
  77    * Exit
  78    * @see prmon.h
  79    **/
  80   void Exit() MOZ_CAPABILITY_RELEASE() { PR_ExitMonitor(mReentrantMonitor); }
  81
  82   /**
  83    * Wait
  84    * @see prmon.h
  85    **/
  86   nsresult Wait(PRIntervalTime aInterval = PR_INTERVAL_NO_TIMEOUT) {
  87     PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mReentrantMonitor);
  88 #  ifdef MOZILLA_INTERNAL_API
  89     AUTO_PROFILER_THREAD_SLEEP;
  90 #  endif  // MOZILLA_INTERNAL_API
  91     return PR_Wait(mReentrantMonitor, aInterval) == PR_SUCCESS
  92                ? NS_OK
  93                : NS_ERROR_FAILURE;
  94   }
  95
  96 #else  // ifndef DEBUG
  97   void Enter() MOZ_CAPABILITY_ACQUIRE();
  98   void Exit() MOZ_CAPABILITY_RELEASE();
  99   nsresult Wait(PRIntervalTime aInterval = PR_INTERVAL_NO_TIMEOUT);
 100
 101 #endif  // ifndef DEBUG
 102
 103   /**
 104    * Notify
 105    * @see prmon.h
 106    **/
 107   nsresult Notify() {
 108     return PR_Notify(mReentrantMonitor) == PR_SUCCESS ? NS_OK
 109                                                       : NS_ERROR_FAILURE;
 110   }
 111
 112   /**
 113    * NotifyAll
 114    * @see prmon.h
 115    **/
 116   nsresult NotifyAll() {
 117     return PR_NotifyAll(mReentrantMonitor) == PR_SUCCESS ? NS_OK
 118                                                          : NS_ERROR_FAILURE;
 119   }
 120
 121 #ifdef DEBUG
 122   /**
 123    * AssertCurrentThreadIn
 124    * @see prmon.h
 125    **/
 126   void AssertCurrentThreadIn() MOZ_ASSERT_CAPABILITY(this) {
 127     PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mReentrantMonitor);
 128   }
 129
 130   /**
 131    * AssertNotCurrentThreadIn
 132    * @see prmon.h
 133    **/
 134   void AssertNotCurrentThreadIn() MOZ_ASSERT_CAPABILITY(!this) {
 135     // FIXME bug 476536
 136   }
 137
 138 #else
 139   void AssertCurrentThreadIn() MOZ_ASSERT_CAPABILITY(this) {}
 140   void AssertNotCurrentThreadIn() MOZ_ASSERT_CAPABILITY(!this) {}
 141
 142 #endif  // ifdef DEBUG
 143
 144  private:
 145   ReentrantMonitor();
 146   ReentrantMonitor(const ReentrantMonitor&);
 147   ReentrantMonitor& operator=(const ReentrantMonitor&);
 148
 149   PRMonitor* mReentrantMonitor;
 150 #ifdef DEBUG
 151   int32_t mEntryCount;
 152 #endif
 153 };
 154
 155 /**
 156  * ReentrantMonitorAutoEnter
 157  * Enters the ReentrantMonitor when it enters scope, and exits it when
 158  * it leaves scope.
 159  *
 160  * MUCH PREFERRED to bare calls to ReentrantMonitor.Enter and Exit.
 161  */
 162 class MOZ_SCOPED_CAPABILITY MOZ_STACK_CLASS ReentrantMonitorAutoEnter {
 163  public:
 164   /**
 165    * Constructor
 166    * The constructor aquires the given lock.  The destructor
 167    * releases the lock.
 168    *
 169    * @param aReentrantMonitor A valid mozilla::ReentrantMonitor*.
 170    **/
 171   explicit ReentrantMonitorAutoEnter(
 172       mozilla::ReentrantMonitor& aReentrantMonitor)
 173       MOZ_CAPABILITY_ACQUIRE(aReentrantMonitor)
 174       : mReentrantMonitor(&aReentrantMonitor) {
 175     NS_ASSERTION(mReentrantMonitor, "null monitor");
 176     mReentrantMonitor->Enter();
 177   }
 178
 179   ~ReentrantMonitorAutoEnter(void) MOZ_CAPABILITY_RELEASE() {
 180     mReentrantMonitor->Exit();
 181   }
 182
 183   nsresult Wait(PRIntervalTime aInterval = PR_INTERVAL_NO_TIMEOUT) {
 184     return mReentrantMonitor->Wait(aInterval);
 185   }
 186
 187   nsresult Notify() { return mReentrantMonitor->Notify(); }
 188   nsresult NotifyAll() { return mReentrantMonitor->NotifyAll(); }
 189
 190  private:
 191   ReentrantMonitorAutoEnter();
 192   ReentrantMonitorAutoEnter(const ReentrantMonitorAutoEnter&);
 193   ReentrantMonitorAutoEnter& operator=(const ReentrantMonitorAutoEnter&);
 194   static void* operator new(size_t) noexcept(true);
 195
 196   friend class ReentrantMonitorAutoExit;
 197
 198   mozilla::ReentrantMonitor* mReentrantMonitor;
 199 };
 200
 201 /**
 202  * ReentrantMonitorAutoExit
 203  * Exit the ReentrantMonitor when it enters scope, and enters it when it leaves
 204  * scope.
 205  *
 206  * MUCH PREFERRED to bare calls to ReentrantMonitor.Exit and Enter.
 207  */
 208 class MOZ_SCOPED_CAPABILITY MOZ_STACK_CLASS ReentrantMonitorAutoExit {
 209  public:
 210   /**
 211    * Constructor
 212    * The constructor releases the given lock.  The destructor
 213    * acquires the lock. The lock must be held before constructing
 214    * this object!
 215    *
 216    * @param aReentrantMonitor A valid mozilla::ReentrantMonitor*. It
 217    *                 must be already locked.
 218    **/
 219   explicit ReentrantMonitorAutoExit(ReentrantMonitor& aReentrantMonitor)
 220       MOZ_EXCLUSIVE_RELEASE(aReentrantMonitor)
 221       : mReentrantMonitor(&aReentrantMonitor) {
 222     NS_ASSERTION(mReentrantMonitor, "null monitor");
 223     mReentrantMonitor->AssertCurrentThreadIn();
 224     mReentrantMonitor->Exit();
 225   }
 226
 227   explicit ReentrantMonitorAutoExit(
 228       ReentrantMonitorAutoEnter& aReentrantMonitorAutoEnter)
 229       MOZ_EXCLUSIVE_RELEASE(aReentrantMonitorAutoEnter.mReentrantMonitor)
 230       : mReentrantMonitor(aReentrantMonitorAutoEnter.mReentrantMonitor) {
 231     NS_ASSERTION(mReentrantMonitor, "null monitor");
 232     mReentrantMonitor->AssertCurrentThreadIn();
 233     mReentrantMonitor->Exit();
 234   }
 235
 236   ~ReentrantMonitorAutoExit(void) MOZ_EXCLUSIVE_RELEASE() {
 237     mReentrantMonitor->Enter();
 238   }
 239
 240  private:
 241   ReentrantMonitorAutoExit();
 242   ReentrantMonitorAutoExit(const ReentrantMonitorAutoExit&);
 243   ReentrantMonitorAutoExit& operator=(const ReentrantMonitorAutoExit&);
 244   static void* operator new(size_t) noexcept(true);
 245
 246   ReentrantMonitor* mReentrantMonitor;
 247 };
 248
 249 }  // namespace mozilla
 250
 251 #endif  // ifndef mozilla_ReentrantMonitor_h