Changeset 25282 in vbox for trunk/src/VBox/Main

Timestamp:

Dec 9, 2009 7:21:21 PM (15 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

55828

Message:

Main: preparation for deadlock detection: move more logic to AutoLockBase

Location:

trunk/src/VBox/Main

Files:

• AutoLock.cpp (modified) (3 diffs)
• include/AutoLock.h (modified) (3 diffs)

trunk/src/VBox/Main/AutoLock.cpp

@@ -115 +115 @@
 {
     delete m;
+}
+
+/**
+ * Requests ownership of all contained lock handles by calling
+ * the pure virtual acquireImpl() function on each of them,
+ * which must be implemented by the descendant class; in the
+ * implementation, AutoWriteLock will request a write lock
+ * whereas AutoReadLock will request a read lock.
+ */
+void AutoLockBase::acquire()
+{
+    if (m->pHandle)
+    {
+        AssertMsg(!m->fIsLocked, ("m->fIsLocked is true, attempting to lock twice!"));
+        // call virtual function implemented in AutoWriteLock or AutoReadLock
+        this->acquireImpl(*m->pHandle);
+        m->fIsLocked = true;
+    }
+}
+
+/**
+ * Releases ownership of all contained lock handles by calling
+ * the pure virtual releaseImpl() function on each of them,
+ * which must be implemented by the descendant class; in the
+ * implementation, AutoWriteLock will release a write lock
+ * whereas AutoReadLock will release a read lock.
+ */
+void AutoLockBase::release()
+{
+    if (m->pHandle)
+    {
+        AssertMsg(m->fIsLocked, ("m->fIsLocked is false, cannot release!"));
+        // call virtual function implemented in AutoWriteLock or AutoReadLock
+        this->releaseImpl(*m->pHandle);
+        m->fIsLocked = false;
+    }
 }
 
@@ -145 +181 @@
 }
 
-void AutoWriteLock::acquire()
-{
-    if (m->pHandle)
-    {
-        AssertMsg(!m->fIsLocked, ("m->fIsLocked is true, attempting to lock twice!"));
-        m->pHandle->lockWrite();
-        m->fIsLocked = true;
-    }
-}
-
-void AutoWriteLock::release()
-{
-    if (m->pHandle)
-    {
-        AssertMsg(m->fIsLocked, ("m->fIsLocked is false, cannot release!"));
-        m->pHandle->unlockWrite();
-        m->fIsLocked = false;
-    }
+/**
+ * Implementation of the pure virtual declared in AutoLockBase.
+ * This gets called by AutoLockBase.acquire() to actually request
+ * the semaphore; in the AutoWriteLock implementation, we request
+ * the semaphore in write mode.
+ */
+/*virtual*/ void AutoWriteLock::acquireImpl(LockHandle &l)
+{
+    l.lockWrite();
+}
+
+/**
+ * Implementation of the pure virtual declared in AutoLockBase.
+ * This gets called by AutoLockBase.release() to actually release
+ * the semaphore; in the AutoWriteLock implementation, we release
+ * the semaphore in write mode.
+ */
+/*virtual*/ void AutoWriteLock::releaseImpl(LockHandle &l)
+{
+    l.unlockWrite();
 }
 
@@ -307 +345 @@
 
 /**
- * Requests a read (shared) lock. If a read lock is already owned by
- * this thread, increases the lock level (allowing for nested read locks on
- * the same thread). Blocks indefinitely if a write lock is already owned by
- * another thread until that tread releases the write lock, otherwise
- * returns immediately.
- *
- * Note that this method returns immediately even if any number of other
- * threads owns read locks on the same semaphore. Also returns immediately
- * if a write lock on this semaphore is owned by the current thread which
- * allows for read locks nested into write locks on the same thread.
- */
-void AutoReadLock::acquire()
-{
-    if (m->pHandle)
-    {
-        AssertMsg(!m->fIsLocked, ("m->fIsLocked is true, attempting to lock twice!"));
-        m->pHandle->lockRead();
-        m->fIsLocked = true;
-    }
-}
-
-/**
- * Decreases the read lock level increased by #lock(). If the level drops to
- * zero (e.g. the number of nested #unlock() calls matches the number of
- * nested #lock() calls), releases the lock making the managed semaphore
- * available for locking by other threads.
- */
-void AutoReadLock::release()
-{
-    if (m->pHandle)
-    {
-        AssertMsg(m->fIsLocked, ("m->fIsLocked is false, cannot release!"));
-        m->pHandle->unlockRead();
-        m->fIsLocked = false;
-    }
-}
-
+ * Implementation of the pure virtual declared in AutoLockBase.
+ * This gets called by AutoLockBase.acquire() to actually request
+ * the semaphore; in the AutoReadLock implementation, we request
+ * the semaphore in read mode.
+ */
+/*virtual*/ void AutoReadLock::acquireImpl(LockHandle &l)
+{
+    l.lockRead();
+}
+
+/**
+ * Implementation of the pure virtual declared in AutoLockBase.
+ * This gets called by AutoLockBase.release() to actually release
+ * the semaphore; in the AutoReadLock implementation, we release
+ * the semaphore in read mode.
+ */
+/*virtual*/ void AutoReadLock::releaseImpl(LockHandle &l)
+{
+    l.unlockRead();
+}
 
 } /* namespace util */

trunk/src/VBox/Main/include/AutoLock.h

@@ -323 +323 @@
     Data *m;
 
+    virtual void acquireImpl(LockHandle &l) = 0;
+    virtual void releaseImpl(LockHandle &l) = 0;
+
+public:
+    void acquire();
+    void release();
+
 private:
     // prohibit copy + assignment
@@ -407 +414 @@
     void cleanup();
 
-    void acquire();
-    void release();
+    virtual void acquireImpl(LockHandle &l);
+    virtual void releaseImpl(LockHandle &l);
+
     void leave();
     void enter();
@@ -524 +532 @@
     virtual ~AutoReadLock();
 
-    void acquire();
-    void release();
+    virtual void acquireImpl(LockHandle &l);
+    virtual void releaseImpl(LockHandle &l);
 };