Backed out changeset 7b0acef284ad (bug 1313489)
authorSebastian Hengst <archaeopteryx@coole-files.de>
Wed, 09 Nov 2016 21:10:06 +0100
changeset 321973 3aa99c2ab46d92ca0f1480d36aed87b49c575efd
parent 321972 2e21f3a89751b5bf85d8c10b983dfcc845452cf8
child 321974 f2311b5d668122ebaea4aa132bec5da88b23f9f1
push id21
push usermaklebus@msu.edu
push dateThu, 01 Dec 2016 06:22:08 +0000
bugs1313489
milestone52.0a1
backs out7b0acef284ad19804d1d3d681cba2f5ba6622377
Backed out changeset 7b0acef284ad (bug 1313489)
xpcom/tests/TestDeadlockDetectorScalability.cpp
--- a/xpcom/tests/TestDeadlockDetectorScalability.cpp
+++ b/xpcom/tests/TestDeadlockDetectorScalability.cpp
@@ -5,30 +5,43 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 // Avoid DMD-specific parts of MOZ_DEFINE_MALLOC_SIZE_OF
 #undef MOZ_DMD
 
 #include "TestHarness.h"
 #include "nsIMemoryReporter.h"
 
-#include "mozilla/Mutex.h"
+//#define OLD_API
 
 #define PASS()                                  \
     do {                                        \
         passed(__FUNCTION__);                   \
         return NS_OK;                           \
     } while (0)
 
 #define FAIL(why)                               \
     do {                                        \
         fail("%s | %s - %s", __FILE__, __FUNCTION__, why); \
         return NS_ERROR_FAILURE;                \
     } while (0)
 
+#ifdef OLD_API
+#  include "nsAutoLock.h"
+   typedef PRLock* moz_lock_t;
+#  define NEWLOCK(n) nsAutoLock::NewLock(n)
+#  define DELETELOCK(v) nsAutoLock::DestroyLock(v)
+#  define AUTOLOCK(v, l) nsAutoLock v(l)
+#else
+#  include "mozilla/Mutex.h"
+   typedef mozilla::Mutex* moz_lock_t;
+#  define NEWLOCK(n) new mozilla::Mutex(n)
+#  define DELETELOCK(v) delete (v)
+#  define AUTOLOCK(v, l) mozilla::MutexAutoLock v(*l)
+#endif
 
 // def/undef these to run particular tests.
 #undef DD_TEST1
 #undef DD_TEST2
 #undef DD_TEST3
 #undef DD_TEST4
 
 //-----------------------------------------------------------------------------
@@ -36,22 +49,22 @@
 #ifdef DD_TEST1
 
 static void
 AllocLockRecurseUnlockFree(int i)
 {
     if (0 == i)
         return;
 
-    mozilla::Mutex* lock = new mozilla::Mutex("deadlockDetector.scalability.t1");
+    moz_lock_t lock = NEWLOCK("deadlockDetector.scalability.t1");
     {
-        mozilla::MutexAutoLock _(*lock);
+        AUTOLOCK(_, lock);
         AllocLockRecurseUnlockFree(i - 1);
     }
-    delete lock;
+    DELETELOCK(lock);
 }
 
 // This test creates a resource dependency chain N elements long, then
 // frees all the resources in the chain.
 static nsresult
 LengthNDepChain(int N)
 {
     AllocLockRecurseUnlockFree(N);
@@ -64,40 +77,40 @@ LengthNDepChain(int N)
 
 #ifdef DD_TEST2
 
 // This test creates a single lock that is ordered < N resources, then
 // repeatedly exercises this order k times.
 static nsresult
 OneLockNDeps(const int N, const int K)
 {
-    mozilla::Mutex* lock = new mozilla::Mutex("deadlockDetector.scalability.t2.master");
-    mozilla::Mutex** locks = new mozilla::Mutex*[N];
+    moz_lock_t lock = NEWLOCK("deadlockDetector.scalability.t2.master");
+    moz_lock_t* locks = new moz_lock_t[N];
     if (!locks)
         NS_RUNTIMEABORT("couldn't allocate lock array");
 
     for (int i = 0; i < N; ++i)
         locks[i] =
-            new mozilla::Mutex("deadlockDetector.scalability.t2.dep");
+            NEWLOCK("deadlockDetector.scalability.t2.dep");
 
     // establish orders
-    {mozilla::MutexAutoLock m(*lock);
+    {AUTOLOCK(m, lock);
         for (int i = 0; i < N; ++i)
-            mozilla::MutexAutoLock s(*locks[i]);
+            AUTOLOCK(s, locks[i]);
     }
 
     // exercise order check
-    {mozilla::MutexAutoLock m(*lock);
+    {AUTOLOCK(m, lock);
         for (int i = 0; i < K; ++i)
             for (int j = 0; j < N; ++j)
-                mozilla::MutexAutoLock s(*locks[i]);
+                AUTOLOCK(s, locks[i]);
     }
 
     for (int i = 0; i < N; ++i)
-        delete locks[i];
+        DELETELOCK(locks[i]);
     delete[] locks;
 
     PASS();
 }
 
 #endif
 
 //-----------------------------------------------------------------------------
@@ -109,39 +122,39 @@ OneLockNDeps(const int N, const int K)
 // acquisitions k times.  Finally, all resources are freed.
 //
 // It's very difficult to perform well on this test.  It's put forth as a
 // challenge problem.
 
 static nsresult
 MaxDepsNsq(const int N, const int K)
 {
-    mozilla::Mutex** locks = new mozilla::Mutex*[N];
+    moz_lock_t* locks = new moz_lock_t[N];
     if (!locks)
         NS_RUNTIMEABORT("couldn't allocate lock array");
 
     for (int i = 0; i < N; ++i)
-        locks[i] = new mozilla::Mutex("deadlockDetector.scalability.t3");
+        locks[i] = NEWLOCK("deadlockDetector.scalability.t3");
 
     for (int i = 0; i < N; ++i) {
-        mozilla::MutexAutoLock al1(*locks[i]);
+        AUTOLOCK(al1, locks[i]);
         for (int j = i+1; j < N; ++j)
-            mozilla::MutexAutoLock al2(*locks[j]);
+            AUTOLOCK(al2, locks[j]);
     }
 
     for (int i = 0; i < K; ++i) {
         for (int j = 0; j < N; ++j) {
-            mozilla::MutexAutoLock al1(*locks[j]);
+            AUTOLOCK(al1, locks[j]);
             for (int k = j+1; k < N; ++k)
-                mozilla::MutexAutoLock al2(*locks[k]);
+                AUTOLOCK(al2, locks[k]);
         }
     }
 
     for (int i = 0; i < N; ++i)
-        delete locks[i];
+        DELETELOCK(locks[i]);
     delete[] locks;
 
     PASS();
 }
 
 #endif
 
 //-----------------------------------------------------------------------------
@@ -151,35 +164,35 @@ MaxDepsNsq(const int N, const int K)
 // This test creates a single lock that is ordered < N resources. The
 // resources are allocated, exercised K times, and deallocated one at
 // a time.
 
 static nsresult
 OneLockNDepsUsedSeveralTimes(const size_t N, const size_t K)
 {
     // Create master lock.
-    mozilla::Mutex* lock_1 = new mozilla::Mutex("deadlockDetector.scalability.t4.master");
+    moz_lock_t lock_1 = NEWLOCK("deadlockDetector.scalability.t4.master");
     for (size_t n = 0; n < N; n++) {
         // Create child lock.
-        mozilla::Mutex* lock_2 = new mozilla::Mutex("deadlockDetector.scalability.t4.child");
+        moz_lock_t lock_2 = NEWLOCK("deadlockDetector.scalability.t4.child");
 
         // First lock the master.
-        mozilla::MutexAutoLock m(*lock_1);
+        AUTOLOCK(m, lock_1);
 
         // Now lock and unlock the child a few times.
         for (size_t k = 0; k < K; k++) {
-            mozilla::MutexAutoLock c(*lock_2);
+            AUTOLOCK(c, lock_2);
         }
 
         // Destroy the child lock.
-        delete lock_2;
+        DELETELOCK(lock_2);
     }
 
     // Cleanup the master lock.
-    delete lock_1;
+    DELETELOCK(lock_1);
 
     PASS();
 }
 
 #endif
 
 //-----------------------------------------------------------------------------