Bug 1313489 - Part 1: Remove dead code. r=froydnj
☠☠ backed out by 01800003ec3b ☠ ☠
authorEric Rahm <erahm@mozilla.com>
Mon, 07 Nov 2016 14:27:18 -0800
changeset 321438 5a062f72097d95c6f8c92515380d889286d0daa3
parent 321437 dbd9b56b50e73bf584c5ae8b38e08faac490d7e7
child 321439 276b093c968ffc889f465161b7aa1fe80c796988
push id83602
push usererahm@mozilla.com
push dateMon, 07 Nov 2016 22:27:30 +0000
treeherdermozilla-inbound@276b093c968f [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersfroydnj
bugs1313489
milestone52.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1313489 - Part 1: Remove dead code. r=froydnj MozReview-Commit-ID: HSS4Sf7O1I6
xpcom/tests/TestDeadlockDetectorScalability.cpp
--- a/xpcom/tests/TestDeadlockDetectorScalability.cpp
+++ b/xpcom/tests/TestDeadlockDetectorScalability.cpp
@@ -5,43 +5,30 @@
  * 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"
 
-//#define OLD_API
+#include "mozilla/Mutex.h"
 
 #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
 
 //-----------------------------------------------------------------------------
@@ -49,22 +36,22 @@
 #ifdef DD_TEST1
 
 static void
 AllocLockRecurseUnlockFree(int i)
 {
     if (0 == i)
         return;
 
-    moz_lock_t lock = NEWLOCK("deadlockDetector.scalability.t1");
+    mozilla::Mutex* lock = new mozilla::Mutex("deadlockDetector.scalability.t1");
     {
-        AUTOLOCK(_, lock);
+        mozilla::MutexAutoLock _(*lock);
         AllocLockRecurseUnlockFree(i - 1);
     }
-    DELETELOCK(lock);
+    delete 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);
@@ -77,40 +64,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)
 {
-    moz_lock_t lock = NEWLOCK("deadlockDetector.scalability.t2.master");
-    moz_lock_t* locks = new moz_lock_t[N];
+    mozilla::Mutex* lock = new mozilla::Mutex("deadlockDetector.scalability.t2.master");
+    mozilla::Mutex** locks = new mozilla::Mutex*[N];
     if (!locks)
         NS_RUNTIMEABORT("couldn't allocate lock array");
 
     for (int i = 0; i < N; ++i)
         locks[i] =
-            NEWLOCK("deadlockDetector.scalability.t2.dep");
+            new mozilla::Mutex("deadlockDetector.scalability.t2.dep");
 
     // establish orders
-    {AUTOLOCK(m, lock);
+    {mozilla::MutexAutoLock m(*lock);
         for (int i = 0; i < N; ++i)
-            AUTOLOCK(s, locks[i]);
+            mozilla::MutexAutoLock s(*locks[i]);
     }
 
     // exercise order check
-    {AUTOLOCK(m, lock);
+    {mozilla::MutexAutoLock m(*lock);
         for (int i = 0; i < K; ++i)
             for (int j = 0; j < N; ++j)
-                AUTOLOCK(s, locks[i]);
+                mozilla::MutexAutoLock s(*locks[i]);
     }
 
     for (int i = 0; i < N; ++i)
-        DELETELOCK(locks[i]);
+        delete locks[i];
     delete[] locks;
 
     PASS();
 }
 
 #endif
 
 //-----------------------------------------------------------------------------
@@ -122,39 +109,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)
 {
-    moz_lock_t* locks = new moz_lock_t[N];
+    mozilla::Mutex** locks = new mozilla::Mutex*[N];
     if (!locks)
         NS_RUNTIMEABORT("couldn't allocate lock array");
 
     for (int i = 0; i < N; ++i)
-        locks[i] = NEWLOCK("deadlockDetector.scalability.t3");
+        locks[i] = new mozilla::Mutex("deadlockDetector.scalability.t3");
 
     for (int i = 0; i < N; ++i) {
-        AUTOLOCK(al1, locks[i]);
+        mozilla::MutexAutoLock al1(*locks[i]);
         for (int j = i+1; j < N; ++j)
-            AUTOLOCK(al2, locks[j]);
+            mozilla::MutexAutoLock al2(*locks[j]);
     }
 
     for (int i = 0; i < K; ++i) {
         for (int j = 0; j < N; ++j) {
-            AUTOLOCK(al1, locks[j]);
+            mozilla::MutexAutoLock al1(*locks[j]);
             for (int k = j+1; k < N; ++k)
-                AUTOLOCK(al2, locks[k]);
+                mozilla::MutexAutoLock al2(*locks[k]);
         }
     }
 
     for (int i = 0; i < N; ++i)
-        DELETELOCK(locks[i]);
+        delete locks[i];
     delete[] locks;
 
     PASS();
 }
 
 #endif
 
 //-----------------------------------------------------------------------------
@@ -164,35 +151,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.
-    moz_lock_t lock_1 = NEWLOCK("deadlockDetector.scalability.t4.master");
+    mozilla::Mutex* lock_1 = new mozilla::Mutex("deadlockDetector.scalability.t4.master");
     for (size_t n = 0; n < N; n++) {
         // Create child lock.
-        moz_lock_t lock_2 = NEWLOCK("deadlockDetector.scalability.t4.child");
+        mozilla::Mutex* lock_2 = new mozilla::Mutex("deadlockDetector.scalability.t4.child");
 
         // First lock the master.
-        AUTOLOCK(m, lock_1);
+        mozilla::MutexAutoLock m(*lock_1);
 
         // Now lock and unlock the child a few times.
         for (size_t k = 0; k < K; k++) {
-            AUTOLOCK(c, lock_2);
+            mozilla::MutexAutoLock c(*lock_2);
         }
 
         // Destroy the child lock.
-        DELETELOCK(lock_2);
+        delete lock_2;
     }
 
     // Cleanup the master lock.
-    DELETELOCK(lock_1);
+    delete lock_1;
 
     PASS();
 }
 
 #endif
 
 //-----------------------------------------------------------------------------