tsan: rename test Mutex to UserMutex

[dvyukov]

Summary

Rename Mutex class in tests to avoid conflicts with sanitizer_common Mutex.

[dvyukov]

re-upload in the hope that arc will auto-set dependent reviews

[dvyukov]

reupload

compiler-rt/lib/tsan/tests/rtl/tsan_bench.cpp

for (int i = 0; i < kRepeat; i++) {
     for (int j = 0; j < kSize; j++)
       __tsan_func_entry((void*)(uintptr_t)j);
     for (int j = 0; j < kSize; j++)
       __tsan_func_exit();
   }
 }
 
 TEST(DISABLED_BENCH, MutexLocal) {
-  Mutex m;
+  UserMutex m;
   ScopedThread().Create(m);
   for (int i = 0; i < 50; i++) {
     ScopedThread t;
     t.Lock(m);
     t.Unlock(m);
   }
   for (int i = 0; i < 16*1024*1024; i++) {
     m.Lock();
     m.Unlock();
   }
   ScopedThread().Destroy(m);
 }

compiler-rt/lib/tsan/tests/rtl/tsan_mop.cpp

TEST(ThreadSanitizer, WriteThenRead) {
   MemLoc l;
   ScopedThread t1, t2;
   t1.Write1(l);
   t1.Read1(l);
   t2.Read1(l, true);
 }
 
 TEST(ThreadSanitizer, WriteThenLockedRead) {
-  Mutex m(Mutex::RW);
+  UserMutex m(UserMutex::RW);
   MainThread t0;
   t0.Create(m);
   MemLoc l;
   {
     ScopedThread t1, t2;
 
     t1.Write8(l);
 
     t1.Lock(m);
     t1.Read8(l);
     t1.Unlock(m);
 
     t2.Read8(l, true);
   }
   t0.Destroy(m);
 }
 
 TEST(ThreadSanitizer, LockedWriteThenRead) {
-  Mutex m(Mutex::RW);
+  UserMutex m(UserMutex::RW);
   MainThread t0;
   t0.Create(m);
   MemLoc l;
   {
     ScopedThread t1, t2;
 
     t1.Lock(m);
     t1.Write8(l);

compiler-rt/lib/tsan/tests/rtl/tsan_mutex.cpp

 #include "tsan_test_util.h"
 #include "gtest/gtest.h"
 #include <stdint.h>
 
 namespace __tsan {
 
 TEST(ThreadSanitizer, BasicMutex) {
   ScopedThread t;
-  Mutex m;
+  UserMutex m;
   t.Create(m);
 
   t.Lock(m);
   t.Unlock(m);
 
   CHECK(t.TryLock(m));
   t.Unlock(m);
 
   t.Lock(m);
   CHECK(!t.TryLock(m));
   t.Unlock(m);
 
   t.Destroy(m);
 }
 
 TEST(ThreadSanitizer, BasicSpinMutex) {
   ScopedThread t;
-  Mutex m(Mutex::Spin);
+  UserMutex m(UserMutex::Spin);
   t.Create(m);
 
   t.Lock(m);
   t.Unlock(m);
 
   CHECK(t.TryLock(m));
   t.Unlock(m);
 
   t.Lock(m);
   CHECK(!t.TryLock(m));
   t.Unlock(m);
 
   t.Destroy(m);
 }
 
 TEST(ThreadSanitizer, BasicRwMutex) {
   ScopedThread t;
-  Mutex m(Mutex::RW);
+  UserMutex m(UserMutex::RW);
   t.Create(m);
 
   t.Lock(m);
   t.Unlock(m);
 
   CHECK(t.TryLock(m));
   t.Unlock(m);
 
TEST(ThreadSanitizer, BasicRwMutex) {
   CHECK(t.TryReadLock(m));
   t.ReadUnlock(m);
   t.ReadUnlock(m);
 
   t.Destroy(m);
 }
 
 TEST(ThreadSanitizer, Mutex) {
-  Mutex m;
+  UserMutex m;
   MainThread t0;
   t0.Create(m);
 
   ScopedThread t1, t2;
   MemLoc l;
   t1.Lock(m);
   t1.Write1(l);
   t1.Unlock(m);
   t2.Lock(m);
   t2.Write1(l);
   t2.Unlock(m);
   t2.Destroy(m);
 }
 
 TEST(ThreadSanitizer, SpinMutex) {
-  Mutex m(Mutex::Spin);
+  UserMutex m(UserMutex::Spin);
   MainThread t0;
   t0.Create(m);
 
   ScopedThread t1, t2;
   MemLoc l;
   t1.Lock(m);
   t1.Write1(l);
   t1.Unlock(m);
   t2.Lock(m);
   t2.Write1(l);
   t2.Unlock(m);
   t2.Destroy(m);
 }
 
 TEST(ThreadSanitizer, RwMutex) {
-  Mutex m(Mutex::RW);
+  UserMutex m(UserMutex::RW);
   MainThread t0;
   t0.Create(m);
 
   ScopedThread t1, t2, t3;
   MemLoc l;
   t1.Lock(m);
   t1.Write1(l);
   t1.Unlock(m);
TEST(ThreadSanitizer, RwMutex) {
   t2.Lock(m);
   t2.Write1(l);
   t2.Unlock(m);
   t2.Destroy(m);
 }
 
 TEST(ThreadSanitizer, StaticMutex) {
   // Emulates statically initialized mutex.
-  Mutex m;
+  UserMutex m;
   m.StaticInit();
   {
     ScopedThread t1, t2;
     t1.Lock(m);
     t1.Unlock(m);
     t2.Lock(m);
     t2.Unlock(m);
   }

compiler-rt/lib/tsan/tests/rtl/tsan_test_util.h

public:
   ~MemLoc();
   void *loc() const { return loc_; }
  private:
   void *const loc_;
   MemLoc(const MemLoc&);
   void operator = (const MemLoc&);
 };
 
-class Mutex {
+class UserMutex {
  public:
   enum Type {
     Normal,
     RW,
 #ifndef __APPLE__
     Spin
 #else
     Spin = Normal
 #endif
   };
 
-  explicit Mutex(Type type = Normal);
-  ~Mutex();
+  explicit UserMutex(Type type = Normal);
+  ~UserMutex();
 
   void Init();
   void StaticInit();  // Emulates static initialization (tsan invisible).
   void Destroy();
   void Lock();
   bool TryLock();
   void Unlock();
   void ReadLock();
   bool TryReadLock();
   void ReadUnlock();
 
  private:
   // Placeholder for pthread_mutex_t, CRITICAL_SECTION or whatever.
   void *mtx_[128];
   bool alive_;
   const Type type_;
 
-  Mutex(const Mutex&);
-  void operator = (const Mutex&);
+  UserMutex(const UserMutex &);
+  void operator=(const UserMutex &);
 };
 
 // A thread is started in CTOR and joined in DTOR.
 class ScopedThread {
  public:
   explicit ScopedThread(bool detached = false, bool main = false);
   ~ScopedThread();
   void Detach();
void Write8(const MemLoc &ml, bool expect_race = false) {
     Write(ml, 8, expect_race); }
 
   void VptrUpdate(const MemLoc &vptr, const MemLoc &new_val,
                   bool expect_race = false);
 
   void Call(void(*pc)());
   void Return();
 
-  void Create(const Mutex &m);
-  void Destroy(const Mutex &m);
-  void Lock(const Mutex &m);
-  bool TryLock(const Mutex &m);
-  void Unlock(const Mutex &m);
-  void ReadLock(const Mutex &m);
-  bool TryReadLock(const Mutex &m);
-  void ReadUnlock(const Mutex &m);
+  void Create(const UserMutex &m);
+  void Destroy(const UserMutex &m);
+  void Lock(const UserMutex &m);
+  bool TryLock(const UserMutex &m);
+  void Unlock(const UserMutex &m);
+  void ReadLock(const UserMutex &m);
+  bool TryReadLock(const UserMutex &m);
+  void ReadUnlock(const UserMutex &m);
 
   void Memcpy(void *dst, const void *src, int size, bool expect_race = false);
   void Memset(void *dst, int val, int size, bool expect_race = false);
 
  private:
   struct Impl;
   Impl *impl_;
   ScopedThread(const ScopedThread&);  // Not implemented.

compiler-rt/lib/tsan/tests/rtl/tsan_test_util_posix.cpp

 
 MemLoc::MemLoc(int offset_from_aligned)
   : loc_(allocate_addr(16, offset_from_aligned)) {
 }
 
 MemLoc::~MemLoc() {
 }
 
-Mutex::Mutex(Type type)
-  : alive_()
-  , type_(type) {
-}
+UserMutex::UserMutex(Type type) : alive_(), type_(type) {}
 
-Mutex::~Mutex() {
-  CHECK(!alive_);
-}
+UserMutex::~UserMutex() { CHECK(!alive_); }
 
-void Mutex::Init() {
+void UserMutex::Init() {
   CHECK(!alive_);
   alive_ = true;
   if (type_ == Normal)
     CHECK_EQ(__interceptor_pthread_mutex_init((pthread_mutex_t*)mtx_, 0), 0);
 #ifndef __APPLE__
   else if (type_ == Spin)
     CHECK_EQ(pthread_spin_init((pthread_spinlock_t*)mtx_, 0), 0);
 #endif
   else if (type_ == RW)
     CHECK_EQ(__interceptor_pthread_rwlock_init((pthread_rwlock_t*)mtx_, 0), 0);
   else
     CHECK(0);
 }
 
-void Mutex::StaticInit() {
+void UserMutex::StaticInit() {
   CHECK(!alive_);
   CHECK(type_ == Normal);
   alive_ = true;
   pthread_mutex_t tmp = PTHREAD_MUTEX_INITIALIZER;
   memcpy(mtx_, &tmp, sizeof(tmp));
 }
 
-void Mutex::Destroy() {
+void UserMutex::Destroy() {
   CHECK(alive_);
   alive_ = false;
   if (type_ == Normal)
     CHECK_EQ(__interceptor_pthread_mutex_destroy((pthread_mutex_t*)mtx_), 0);
 #ifndef __APPLE__
   else if (type_ == Spin)
     CHECK_EQ(pthread_spin_destroy((pthread_spinlock_t*)mtx_), 0);
 #endif
   else if (type_ == RW)
     CHECK_EQ(__interceptor_pthread_rwlock_destroy((pthread_rwlock_t*)mtx_), 0);
 }
 
-void Mutex::Lock() {
+void UserMutex::Lock() {
   CHECK(alive_);
   if (type_ == Normal)
     CHECK_EQ(__interceptor_pthread_mutex_lock((pthread_mutex_t*)mtx_), 0);
 #ifndef __APPLE__
   else if (type_ == Spin)
     CHECK_EQ(pthread_spin_lock((pthread_spinlock_t*)mtx_), 0);
 #endif
   else if (type_ == RW)
     CHECK_EQ(__interceptor_pthread_rwlock_wrlock((pthread_rwlock_t*)mtx_), 0);
 }
 
-bool Mutex::TryLock() {
+bool UserMutex::TryLock() {
   CHECK(alive_);
   if (type_ == Normal)
     return __interceptor_pthread_mutex_trylock((pthread_mutex_t*)mtx_) == 0;
 #ifndef __APPLE__
   else if (type_ == Spin)
     return pthread_spin_trylock((pthread_spinlock_t*)mtx_) == 0;
 #endif
   else if (type_ == RW)
     return __interceptor_pthread_rwlock_trywrlock((pthread_rwlock_t*)mtx_) == 0;
   return false;
 }
 
-void Mutex::Unlock() {
+void UserMutex::Unlock() {
   CHECK(alive_);
   if (type_ == Normal)
     CHECK_EQ(__interceptor_pthread_mutex_unlock((pthread_mutex_t*)mtx_), 0);
 #ifndef __APPLE__
   else if (type_ == Spin)
     CHECK_EQ(pthread_spin_unlock((pthread_spinlock_t*)mtx_), 0);
 #endif
   else if (type_ == RW)
     CHECK_EQ(__interceptor_pthread_rwlock_unlock((pthread_rwlock_t*)mtx_), 0);
 }
 
-void Mutex::ReadLock() {
+void UserMutex::ReadLock() {
   CHECK(alive_);
   CHECK(type_ == RW);
   CHECK_EQ(__interceptor_pthread_rwlock_rdlock((pthread_rwlock_t*)mtx_), 0);
 }
 
-bool Mutex::TryReadLock() {
+bool UserMutex::TryReadLock() {
   CHECK(alive_);
   CHECK(type_ == RW);
   return __interceptor_pthread_rwlock_tryrdlock((pthread_rwlock_t*)mtx_) ==  0;
 }
 
-void Mutex::ReadUnlock() {
+void UserMutex::ReadUnlock() {
   CHECK(alive_);
   CHECK(type_ == RW);
   CHECK_EQ(__interceptor_pthread_rwlock_unlock((pthread_rwlock_t*)mtx_), 0);
 }
 
 struct Event {
   enum Type {
     SHUTDOWN,
case Event::VPTR_UPDATE:
     break;
   case Event::CALL:
     __tsan_func_entry((void*)((uptr)ev->ptr));
     break;
   case Event::RETURN:
     __tsan_func_exit();
     break;
   case Event::MUTEX_CREATE:
-    static_cast<Mutex*>(ev->ptr)->Init();
+    static_cast<UserMutex *>(ev->ptr)->Init();
     break;
   case Event::MUTEX_DESTROY:
-    static_cast<Mutex*>(ev->ptr)->Destroy();
+    static_cast<UserMutex *>(ev->ptr)->Destroy();
     break;
   case Event::MUTEX_LOCK:
-    static_cast<Mutex*>(ev->ptr)->Lock();
+    static_cast<UserMutex *>(ev->ptr)->Lock();
     break;
   case Event::MUTEX_TRYLOCK:
-    ev->res = static_cast<Mutex*>(ev->ptr)->TryLock();
+    ev->res = static_cast<UserMutex *>(ev->ptr)->TryLock();
     break;
   case Event::MUTEX_UNLOCK:
-    static_cast<Mutex*>(ev->ptr)->Unlock();
+    static_cast<UserMutex *>(ev->ptr)->Unlock();
     break;
   case Event::MUTEX_READLOCK:
-    static_cast<Mutex*>(ev->ptr)->ReadLock();
+    static_cast<UserMutex *>(ev->ptr)->ReadLock();
     break;
   case Event::MUTEX_TRYREADLOCK:
-    ev->res = static_cast<Mutex*>(ev->ptr)->TryReadLock();
+    ev->res = static_cast<UserMutex *>(ev->ptr)->TryReadLock();
     break;
   case Event::MUTEX_READUNLOCK:
-    static_cast<Mutex*>(ev->ptr)->ReadUnlock();
+    static_cast<UserMutex *>(ev->ptr)->ReadUnlock();
     break;
   case Event::MEMCPY:
     __interceptor_memcpy(ev->ptr, (void*)ev->arg, ev->arg2);
     break;
   case Event::MEMSET:
     __interceptor_memset(ev->ptr, ev->arg, ev->arg2);
     break;
   default: CHECK(0);
void ScopedThread::Call(void(*pc)()) {
   impl_->send(&event);
 }
 
 void ScopedThread::Return() {
   Event event(Event::RETURN);
   impl_->send(&event);
 }
 
-void ScopedThread::Create(const Mutex &m) {
+void ScopedThread::Create(const UserMutex &m) {
   Event event(Event::MUTEX_CREATE, &m);
   impl_->send(&event);
 }
 
-void ScopedThread::Destroy(const Mutex &m) {
+void ScopedThread::Destroy(const UserMutex &m) {
   Event event(Event::MUTEX_DESTROY, &m);
   impl_->send(&event);
 }
 
-void ScopedThread::Lock(const Mutex &m) {
+void ScopedThread::Lock(const UserMutex &m) {
   Event event(Event::MUTEX_LOCK, &m);
   impl_->send(&event);
 }
 
-bool ScopedThread::TryLock(const Mutex &m) {
+bool ScopedThread::TryLock(const UserMutex &m) {
   Event event(Event::MUTEX_TRYLOCK, &m);
   impl_->send(&event);
   return event.res;
 }
 
-void ScopedThread::Unlock(const Mutex &m) {
+void ScopedThread::Unlock(const UserMutex &m) {
   Event event(Event::MUTEX_UNLOCK, &m);
   impl_->send(&event);
 }
 
-void ScopedThread::ReadLock(const Mutex &m) {
+void ScopedThread::ReadLock(const UserMutex &m) {
   Event event(Event::MUTEX_READLOCK, &m);
   impl_->send(&event);
 }
 
-bool ScopedThread::TryReadLock(const Mutex &m) {
+bool ScopedThread::TryReadLock(const UserMutex &m) {
   Event event(Event::MUTEX_TRYREADLOCK, &m);
   impl_->send(&event);
   return event.res;
 }
 
-void ScopedThread::ReadUnlock(const Mutex &m) {
+void ScopedThread::ReadUnlock(const UserMutex &m) {
   Event event(Event::MUTEX_READUNLOCK, &m);
   impl_->send(&event);
 }
 
 void ScopedThread::Memcpy(void *dst, const void *src, int size,
                           bool expect_race) {
   Event event(Event::MEMCPY, dst, (uptr)src, size);
   if (expect_race)