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

Timestamp:

Dec 9, 2009 11:50:02 PM (15 years ago)

Author:

vboxsync

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

55833

Message:

Main: preparation for deadlock detection: remove AutoMultiLock* template

Location:

trunk/src/VBox/Main

Files:

• AudioAdapterImpl.cpp (modified) (1 diff)
• BIOSSettingsImpl.cpp (modified) (1 diff)
• NetworkAdapterImpl.cpp (modified) (1 diff)
• ParallelPortImpl.cpp (modified) (1 diff)
• SerialPortImpl.cpp (modified) (1 diff)
• StorageControllerImpl.cpp (modified) (1 diff)
• USBControllerImpl.cpp (modified) (1 diff)
• include/AutoLock.h (modified) (1 diff)

trunk/src/VBox/Main/AudioAdapterImpl.cpp

@@ -477 +477 @@
     /* peer is not modified, lock it for reading (aThat is "master" so locked
      * first) */
-    AutoMultiLock2 alock (aThat->rlock(), this->wlock());
+    AutoReadLock rl(aThat);
+    AutoWriteLock wl(this);
 
     /* this will back up current data */

trunk/src/VBox/Main/BIOSSettingsImpl.cpp

@@ -576 +576 @@
     /* peer is not modified, lock it for reading (aThat is "master" so locked
      * first) */
-    AutoMultiLock2 alock(aThat->rlock(), this->wlock());
+    AutoReadLock rl(aThat);
+    AutoWriteLock wl(this);
 
     /* this will back up current data */

trunk/src/VBox/Main/NetworkAdapterImpl.cpp

@@ -1103 +1103 @@
     /* peer is not modified, lock it for reading (aThat is "master" so locked
      * first) */
-    AutoMultiLock2 alock (aThat->rlock(), this->wlock());
+    AutoReadLock rl(aThat);
+    AutoWriteLock wl(this);
 
     /* this will back up current data */

trunk/src/VBox/Main/ParallelPortImpl.cpp

@@ -532 +532 @@
     /* peer is not modified, lock it for reading (aThat is "master" so locked
      * first) */
-    AutoMultiLock2 alock (aThat->rlock(), this->wlock());
+    AutoReadLock rl(aThat);
+    AutoWriteLock wl(this);
 
     /* this will back up current data */

trunk/src/VBox/Main/SerialPortImpl.cpp

@@ -645 +645 @@
     /* peer is not modified, lock it for reading (aThat is "master" so locked
      * first) */
-    AutoMultiLock2 alock (aThat->rlock(), this->wlock());
+    AutoReadLock rl(aThat);
+    AutoWriteLock wl(this);
 
     /* this will back up current data */

trunk/src/VBox/Main/StorageControllerImpl.cpp

@@ -772 +772 @@
     /* peer is not modified, lock it for reading (m->pPeer is "master" so locked
      * first) */
-    AutoMultiLock2 alock (m->pPeer->rlock(), this->wlock());
+    AutoReadLock rl(m->pPeer);
+    AutoWriteLock wl(this);
 
     if (m->bd.isShared())

trunk/src/VBox/Main/USBControllerImpl.cpp

@@ -1031 +1031 @@
     /* peer is not modified, lock it for reading (aThat is "master" so locked
      * first) */
-    AutoMultiLock2 alock (aThat->rlock(), this->wlock());
+    AutoReadLock rl(aThat);
+    AutoWriteLock wl(this);
 
     /* this will back up current data */

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

@@ -573 +573 @@
 };
 
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// AutoMulti*
-//
-////////////////////////////////////////////////////////////////////////////////
-
-/**
- * Helper template class for AutoMultiLockN classes.
- *
- * @param Cnt number of read/write semaphores to manage.
- */
-template <size_t Cnt>
-class AutoMultiLockBase
-{
-public:
-
-    /**
-     * Releases all locks if not yet released by #unlock() and destroys the
-     * instance.
-     */
-    ~AutoMultiLockBase()
-    {
-        if (mIsLocked)
-            unlock();
-    }
-
-    /**
-     * Calls LockOps::lock() methods of all managed semaphore handles
-     * in order they were passed to the constructor.
-     *
-     * Note that as opposed to LockHandle::lock(), this call cannot be nested
-     * and will assert if so.
-     */
-    void lock()
-    {
-        AssertReturnVoid (!mIsLocked);
-
-        size_t i = 0;
-        while (i < RT_ELEMENTS (mOps))
-            if (mOps [i])
-                mOps [i ++]->lock();
-        mIsLocked = true;
-    }
-
-    /**
-     * Calls LockOps::unlock() methods of all managed semaphore handles in
-     * reverse to the order they were passed to the constructor.
-     *
-     * Note that as opposed to LockHandle::unlock(), this call cannot be nested
-     * and will assert if so.
-     */
-    void unlock()
-    {
-        AssertReturnVoid (mIsLocked);
-
-        AssertReturnVoid (RT_ELEMENTS (mOps) > 0);
-        size_t i = RT_ELEMENTS (mOps);
-        do
-            if (mOps [-- i])
-                mOps [i]->unlock();
-        while (i != 0);
-        mIsLocked = false;
-    }
-
-protected:
-
-    AutoMultiLockBase() : mIsLocked (false) {}
-
-    LockOps *mOps [Cnt];
-    bool mIsLocked;
-
-private:
-
-    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP (AutoMultiLockBase)
-    DECLARE_CLS_NEW_DELETE_NOOP (AutoMultiLockBase)
-};
-
-/** AutoMultiLockBase <0> is meaningless and forbidden. */
-template<>
-class AutoMultiLockBase <0> { private : AutoMultiLockBase(); };
-
-/** AutoMultiLockBase <1> is meaningless and forbidden. */
-template<>
-class AutoMultiLockBase <1> { private : AutoMultiLockBase(); };
-
-////////////////////////////////////////////////////////////////////////////////
-
-/* AutoMultiLockN class definitions */
-
-#define A(n) LockOps *l##n
-#define B(n) mOps [n] = l##n
-
-/**
- * AutoMultiLock for 2 locks.
- *
- * The AutoMultiLockN family of classes provides a possibility to manage several
- * read/write semaphores at once. This is handy if all managed semaphores need
- * to be locked and unlocked synchronously and will also help to avoid locking
- * order errors.
- *
- * Instances of AutoMultiLockN classes are constructed from a list of LockOps
- * arguments. The AutoMultiLockBase::lock() method will make sure that the given
- * list of semaphores represented by LockOps pointers will be locked in order
- * they are passed to the constructor. The AutoMultiLockBase::unlock() method
- * will make sure that they will be unlocked in reverse order.
- *
- * The type of the lock to request is specified for each semaphore individually
- * using the corresponding LockOps getter of a LockHandle or Lockable object:
- * LockHandle::wlock() in order to request a write lock or LockHandle::rlock()
- * in order to request a read lock.
- *
- * Here is a typical usage pattern:
- * <code>
- *  ...
- *  LockHandle data1, data2;
- *  ...
- *  {
- *      AutoMultiLock2 multiLock (data1.wlock(), data2.rlock());
- *      // both locks are held here:
- *      // - data1 is locked in write mode (like AutoWriteLock)
- *      // - data2 is locked in read mode (like AutoReadLock)
- *  }
- *  // both locks are released here
- * </code>
- */
-class AutoMultiLock2 : public AutoMultiLockBase <2>
-{
-public:
-    AutoMultiLock2 (A(0), A(1))
-    { B(0); B(1); lock(); }
-};
-
-/** AutoMultiLock for 3 locks. See AutoMultiLock2 for more information. */
-class AutoMultiLock3 : public AutoMultiLockBase <3>
-{
-public:
-    AutoMultiLock3 (A(0), A(1), A(2))
-    { B(0); B(1); B(2); lock(); }
-};
-
-/** AutoMultiLock for 4 locks. See AutoMultiLock2 for more information. */
-class AutoMultiLock4 : public AutoMultiLockBase <4>
-{
-public:
-    AutoMultiLock4 (A(0), A(1), A(2), A(3))
-    { B(0); B(1); B(2); B(3); lock(); }
-};
-
-#undef B
-#undef A
-
 } /* namespace util */