commit 81d425b0b232962441616f8b14f73620bffef5e5
author Ian Rogers <irogers@google.com> Thu Sep 27 16:03:43 2012 -0700
committer Ian Rogers <irogers@google.com> Thu Sep 27 17:19:25 2012 -0700
tree cd1e46656269acf20e78817d675e56d9b9133e6c
parent bfaf917edbb1de8d158c3615e0da8ac3143d10c8

Pass self to lock methods.

This avoids frequent recomputation of
Thread::Current/pthread_getspecific.

Also add a futex based reader/writer mutex that is disabled.

Change-Id: I118fdb99ef1d1c4bfda6446ba3a0d8b6ab31eaee

src/mutex_test.cc

diff --git a/src/mutex_test.cc b/src/mutex_test.cc
index a998939..4dac3c6 100644
--- a/src/mutex_test.cc
+++ b/src/mutex_test.cc
@@ -28,9 +28,9 @@
 
     // This test is single-threaded, so we also know _who_ should hold the lock.
     if (expected_depth == 0) {
-      mu.AssertNotHeld();
+      mu.AssertNotHeld(Thread::Current());
     } else {
-      mu.AssertHeld();
+      mu.AssertHeld(Thread::Current());
     }
   }
 };
@@ -38,9 +38,9 @@
 TEST_F(MutexTest, LockUnlock) {
   Mutex mu("test mutex");
   MutexTester::AssertDepth(mu, 0U);
-  mu.Lock();
+  mu.Lock(Thread::Current());
   MutexTester::AssertDepth(mu, 1U);
-  mu.Unlock();
+  mu.Unlock(Thread::Current());
   MutexTester::AssertDepth(mu, 0U);
 }
 
@@ -48,9 +48,9 @@
 static void TryLockUnlockTest() NO_THREAD_SAFETY_ANALYSIS {
   Mutex mu("test mutex");
   MutexTester::AssertDepth(mu, 0U);
-  ASSERT_TRUE(mu.TryLock());
+  ASSERT_TRUE(mu.TryLock(Thread::Current()));
   MutexTester::AssertDepth(mu, 1U);
-  mu.Unlock();
+  mu.Unlock(Thread::Current());
   MutexTester::AssertDepth(mu, 0U);
 }
 
@@ -62,13 +62,13 @@
 static void RecursiveLockUnlockTest() NO_THREAD_SAFETY_ANALYSIS {
   Mutex mu("test mutex", kDefaultMutexLevel, true);
   MutexTester::AssertDepth(mu, 0U);
-  mu.Lock();
+  mu.Lock(Thread::Current());
   MutexTester::AssertDepth(mu, 1U);
-  mu.Lock();
+  mu.Lock(Thread::Current());
   MutexTester::AssertDepth(mu, 2U);
-  mu.Unlock();
+  mu.Unlock(Thread::Current());
   MutexTester::AssertDepth(mu, 1U);
-  mu.Unlock();
+  mu.Unlock(Thread::Current());
   MutexTester::AssertDepth(mu, 0U);
 }
 
@@ -80,13 +80,13 @@
 static void RecursiveTryLockUnlockTest() NO_THREAD_SAFETY_ANALYSIS {
   Mutex mu("test mutex", kDefaultMutexLevel, true);
   MutexTester::AssertDepth(mu, 0U);
-  ASSERT_TRUE(mu.TryLock());
+  ASSERT_TRUE(mu.TryLock(Thread::Current()));
   MutexTester::AssertDepth(mu, 1U);
-  ASSERT_TRUE(mu.TryLock());
+  ASSERT_TRUE(mu.TryLock(Thread::Current()));
   MutexTester::AssertDepth(mu, 2U);
-  mu.Unlock();
+  mu.Unlock(Thread::Current());
   MutexTester::AssertDepth(mu, 1U);
-  mu.Unlock();
+  mu.Unlock(Thread::Current());
   MutexTester::AssertDepth(mu, 0U);
 }
 
@@ -102,9 +102,9 @@
 
   static void* Callback(void* arg) {
     RecursiveLockWait* state = reinterpret_cast<RecursiveLockWait*>(arg);
-    state->mu.Lock();
+    state->mu.Lock(Thread::Current());
     state->cv.Signal();
-    state->mu.Unlock();
+    state->mu.Unlock(Thread::Current());
     return NULL;
   }
 
@@ -115,17 +115,17 @@
 // GCC has trouble with our mutex tests, so we have to turn off thread safety analysis.
 static void RecursiveLockWaitTest() NO_THREAD_SAFETY_ANALYSIS {
   RecursiveLockWait state;
-  state.mu.Lock();
-  state.mu.Lock();
+  state.mu.Lock(Thread::Current());
+  state.mu.Lock(Thread::Current());
 
   pthread_t pthread;
   int pthread_create_result = pthread_create(&pthread, NULL, RecursiveLockWait::Callback, &state);
   ASSERT_EQ(0, pthread_create_result);
 
-  state.cv.Wait(state.mu);
+  state.cv.Wait(Thread::Current(), state.mu);
 
-  state.mu.Unlock();
-  state.mu.Unlock();
+  state.mu.Unlock(Thread::Current());
+  state.mu.Unlock(Thread::Current());
 }
 
 // This ensures we don't hang when waiting on a recursively locked mutex,
@@ -136,33 +136,33 @@
 
 TEST_F(MutexTest, SharedLockUnlock) {
   ReaderWriterMutex mu("test rwmutex");
-  mu.AssertNotHeld();
-  mu.AssertNotExclusiveHeld();
-  mu.SharedLock();
-  mu.AssertSharedHeld();
-  mu.AssertNotExclusiveHeld();
-  mu.SharedUnlock();
-  mu.AssertNotHeld();
+  mu.AssertNotHeld(Thread::Current());
+  mu.AssertNotExclusiveHeld(Thread::Current());
+  mu.SharedLock(Thread::Current());
+  mu.AssertSharedHeld(Thread::Current());
+  mu.AssertNotExclusiveHeld(Thread::Current());
+  mu.SharedUnlock(Thread::Current());
+  mu.AssertNotHeld(Thread::Current());
 }
 
 TEST_F(MutexTest, ExclusiveLockUnlock) {
   ReaderWriterMutex mu("test rwmutex");
-  mu.AssertNotHeld();
-  mu.ExclusiveLock();
-  mu.AssertSharedHeld();
-  mu.AssertExclusiveHeld();
-  mu.ExclusiveUnlock();
-  mu.AssertNotHeld();
+  mu.AssertNotHeld(Thread::Current());
+  mu.ExclusiveLock(Thread::Current());
+  mu.AssertSharedHeld(Thread::Current());
+  mu.AssertExclusiveHeld(Thread::Current());
+  mu.ExclusiveUnlock(Thread::Current());
+  mu.AssertNotHeld(Thread::Current());
 }
 
 // GCC has trouble with our mutex tests, so we have to turn off thread safety analysis.
 static void SharedTryLockUnlockTest() NO_THREAD_SAFETY_ANALYSIS {
   ReaderWriterMutex mu("test rwmutex");
-  mu.AssertNotHeld();
-  ASSERT_TRUE(mu.SharedTryLock());
-  mu.AssertSharedHeld();
-  mu.SharedUnlock();
-  mu.AssertNotHeld();
+  mu.AssertNotHeld(Thread::Current());
+  ASSERT_TRUE(mu.SharedTryLock(Thread::Current()));
+  mu.AssertSharedHeld(Thread::Current());
+  mu.SharedUnlock(Thread::Current());
+  mu.AssertNotHeld(Thread::Current());
 }
 
 TEST_F(MutexTest, SharedTryLockUnlock) {