Bug 1313489 - Part 1: Remove dead code. r=froydnj
authorEric Rahm <erahm@mozilla.com>
Thu, 10 Nov 2016 12:47:47 -0800
changeset 352123 fd51f48870d92772efbf6156c98e1cb92c616c77
parent 352122 e27050b02d69b88e19e0dcd151916f78259f9bb1
child 352124 03fc16d0df1b81173e37fd65c515f335e2496a08
push id6795
push userjlund@mozilla.com
push dateMon, 23 Jan 2017 14:19:46 +0000
treeherdermozilla-esr52@76101b503191 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersfroydnj
bugs1313489
milestone52.0a1
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
 
 //-----------------------------------------------------------------------------