compiler-rt/test/tsan/deadlock_detector_stress_test.cpp

   1 // RUN: %clangxx_tsan %s -o %t -DLockType=PthreadMutex
   2 // RUN: %deflake %run %t | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-NOT-SECOND
   3 // RUN: %env_tsan_opts=second_deadlock_stack=1 %deflake %run %t | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-SECOND
   4 // RUN: %clangxx_tsan %s -o %t -DLockType=PthreadSpinLock
   5 // RUN: %deflake %run %t | FileCheck %s
   6 // RUN: %clangxx_tsan %s -o %t -DLockType=PthreadRWLock
   7 // RUN: %deflake %run %t | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-RD
   8 // RUN: %clangxx_tsan %s -o %t -DLockType=PthreadRecursiveMutex
   9 // RUN: %deflake %run %t | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-REC
  10 #include "test.h"
  11 #undef NDEBUG
  12 #include <assert.h>
  13 #include <new>
  14
  15 #ifndef LockType
  16 #define LockType PthreadMutex
  17 #endif
  18
  19 // You can optionally pass [test_number [iter_count]] on command line.
  20 static int test_number = -1;
  21 static int iter_count = 100000;
  22
  23 class PthreadMutex {
  24  public:
  25   explicit PthreadMutex(bool recursive = false) {
  26     if (recursive) {
  27       pthread_mutexattr_t attr;
  28       pthread_mutexattr_init(&attr);
  29       pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
  30       assert(0 == pthread_mutex_init(&mu_, &attr));
  31     } else {
  32       assert(0 == pthread_mutex_init(&mu_, 0));
  33     }
  34   }
  35   ~PthreadMutex() {
  36     assert(0 == pthread_mutex_destroy(&mu_));
  37     (void)padding_;
  38   }
  39   static bool supports_read_lock() { return false; }
  40   static bool supports_recursive_lock() { return false; }
  41   void lock() { assert(0 == pthread_mutex_lock(&mu_)); }
  42   void unlock() { assert(0 == pthread_mutex_unlock(&mu_)); }
  43   bool try_lock() { return 0 == pthread_mutex_trylock(&mu_); }
  44   void rdlock() { assert(0); }
  45   void rdunlock() { assert(0); }
  46   bool try_rdlock() { assert(0); }
  47
  48  private:
  49   pthread_mutex_t mu_;
  50   char padding_[64 - sizeof(pthread_mutex_t)];
  51 };
  52
  53 class PthreadRecursiveMutex : public PthreadMutex {
  54  public:
  55   PthreadRecursiveMutex() : PthreadMutex(true) { }
  56   static bool supports_recursive_lock() { return true; }
  57 };
  58
  59 #ifndef __APPLE__
  60 class PthreadSpinLock {
  61  public:
  62   PthreadSpinLock() { assert(0 == pthread_spin_init(&mu_, 0)); }
  63   ~PthreadSpinLock() {
  64     assert(0 == pthread_spin_destroy(&mu_));
  65     (void)padding_;
  66   }
  67   static bool supports_read_lock() { return false; }
  68   static bool supports_recursive_lock() { return false; }
  69   void lock() { assert(0 == pthread_spin_lock(&mu_)); }
  70   void unlock() { assert(0 == pthread_spin_unlock(&mu_)); }
  71   bool try_lock() { return 0 == pthread_spin_trylock(&mu_); }
  72   void rdlock() { assert(0); }
  73   void rdunlock() { assert(0); }
  74   bool try_rdlock() { assert(0); }
  75
  76  private:
  77   pthread_spinlock_t mu_;
  78   char padding_[64 - sizeof(pthread_spinlock_t)];
  79 };
  80 #else
  81 class PthreadSpinLock : public PthreadMutex { };
  82 #endif
  83
  84 class PthreadRWLock {
  85  public:
  86   PthreadRWLock() { assert(0 == pthread_rwlock_init(&mu_, 0)); }
  87   ~PthreadRWLock() {
  88     assert(0 == pthread_rwlock_destroy(&mu_));
  89     (void)padding_;
  90   }
  91   static bool supports_read_lock() { return true; }
  92   static bool supports_recursive_lock() { return false; }
  93   void lock() { assert(0 == pthread_rwlock_wrlock(&mu_)); }
  94   void unlock() { assert(0 == pthread_rwlock_unlock(&mu_)); }
  95   bool try_lock() { return 0 == pthread_rwlock_trywrlock(&mu_); }
  96   void rdlock() { assert(0 == pthread_rwlock_rdlock(&mu_)); }
  97   void rdunlock() { assert(0 == pthread_rwlock_unlock(&mu_)); }
  98   bool try_rdlock() { return 0 == pthread_rwlock_tryrdlock(&mu_); }
  99
 100  private:
 101   pthread_rwlock_t mu_;
 102   char padding_[256 - sizeof(pthread_rwlock_t)];
 103 };
 104
 105 class LockTest {
 106  public:
 107   LockTest() : n_(), locks_() {}
 108   void Init(size_t n) {
 109     n_ = n;
 110     locks_ = new LockType*[n_];
 111     for (size_t i = 0; i < n_; i++)
 112       locks_[i] = new LockType;
 113   }
 114   ~LockTest() {
 115     for (size_t i = 0; i < n_; i++)
 116       delete locks_[i];
 117     delete [] locks_;
 118   }
 119   void L(size_t i) {
 120     assert(i < n_);
 121     locks_[i]->lock();
 122   }
 123
 124   void U(size_t i) {
 125     assert(i < n_);
 126     locks_[i]->unlock();
 127   }
 128
 129   void RL(size_t i) {
 130     assert(i < n_);
 131     locks_[i]->rdlock();
 132   }
 133
 134   void RU(size_t i) {
 135     assert(i < n_);
 136     locks_[i]->rdunlock();
 137   }
 138
 139   void *A(size_t i) {
 140     assert(i < n_);
 141     return locks_[i];
 142   }
 143
 144   bool T(size_t i) {
 145     assert(i < n_);
 146     return locks_[i]->try_lock();
 147   }
 148
 149   // Simple lock order onversion.
 150   void Test1() {
 151     if (test_number > 0 && test_number != 1) return;
 152     fprintf(stderr, "Starting Test1\n");
 153     // CHECK: Starting Test1
 154     Init(5);
 155     print_address("Expecting lock inversion: ", 2, A(0), A(1));
 156     // CHECK: Expecting lock inversion: [[A1:0x[a-f0-9]*]] [[A2:0x[a-f0-9]*]]
 157     Lock_0_1();
 158     Lock_1_0();
 159     // CHECK: WARNING: ThreadSanitizer: lock-order-inversion (potential deadlock)
 160     // CHECK: Cycle in lock order graph: [[M1:M[0-9]+]] ([[A1]]) => [[M2:M[0-9]+]] ([[A2]]) => [[M1]]
 161     // CHECK: Mutex [[M2]] acquired here while holding mutex [[M1]]
 162     // CHECK:   #0 pthread_
 163     // CHECK-SECOND:   Mutex [[M1]] previously acquired by the same thread here:
 164     // CHECK-SECOND:   #0 pthread_
 165     // CHECK-NOT-SECOND:   second_deadlock_stack=1 to get more informative warning message
 166     // CHECK-NOT-SECOND-NOT:   #0 pthread_
 167     // CHECK: Mutex [[M1]] acquired here while holding mutex [[M2]]
 168     // CHECK:   #0 pthread_
 169     // CHECK-SECOND:   Mutex [[M2]] previously acquired by the same thread here:
 170     // CHECK-SECOND:   #0 pthread_
 171     // CHECK-NOT-SECOND-NOT:   #0 pthread_
 172     // CHECK-NOT: WARNING: ThreadSanitizer:
 173   }
 174
 175   // Simple lock order inversion with 3 locks.
 176   void Test2() {
 177     if (test_number > 0 && test_number != 2) return;
 178     fprintf(stderr, "Starting Test2\n");
 179     // CHECK: Starting Test2
 180     Init(5);
 181     print_address("Expecting lock inversion: ", 3, A(0), A(1), A(2));
 182     // CHECK: Expecting lock inversion: [[A1:0x[a-f0-9]*]] [[A2:0x[a-f0-9]*]] [[A3:0x[a-f0-9]*]]
 183     Lock2(0, 1);
 184     Lock2(1, 2);
 185     Lock2(2, 0);
 186     // CHECK: WARNING: ThreadSanitizer: lock-order-inversion (potential deadlock)
 187     // CHECK: Cycle in lock order graph: [[M1:M[0-9]+]] ([[A1]]) => [[M2:M[0-9]+]] ([[A2]]) => [[M3:M[0-9]+]] ([[A3]]) => [[M1]]
 188     // CHECK-NOT: WARNING: ThreadSanitizer:
 189   }
 190
 191   // Lock order inversion with lots of new locks created (but not used)
 192   // between. Since the new locks are not used we should still detect the
 193   // deadlock.
 194   void Test3() {
 195     if (test_number > 0 && test_number != 3) return;
 196     fprintf(stderr, "Starting Test3\n");
 197     // CHECK: Starting Test3
 198     Init(5);
 199     Lock_0_1();
 200     L(2);
 201     CreateAndDestroyManyLocks();
 202     U(2);
 203     Lock_1_0();
 204     // CHECK: WARNING: ThreadSanitizer: lock-order-inversion (potential deadlock)
 205     // CHECK-NOT: WARNING: ThreadSanitizer:
 206   }
 207
 208   // lock l0=>l1; then create and use lots of locks; then lock l1=>l0.
 209   // The deadlock epoch should have changed and we should not report anything.
 210   void Test4() {
 211     if (test_number > 0 && test_number != 4) return;
 212     fprintf(stderr, "Starting Test4\n");
 213     // CHECK: Starting Test4
 214     Init(5);
 215     Lock_0_1();
 216     L(2);
 217     CreateLockUnlockAndDestroyManyLocks();
 218     U(2);
 219     Lock_1_0();
 220     // CHECK-NOT: WARNING: ThreadSanitizer:
 221   }
 222
 223   void Test5() {
 224     if (test_number > 0 && test_number != 5) return;
 225     fprintf(stderr, "Starting Test5\n");
 226     // CHECK: Starting Test5
 227     Init(5);
 228     RunThreads(&LockTest::Lock_0_1<true>, &LockTest::Lock_1_0<true>);
 229     // CHECK: WARNING: ThreadSanitizer: lock-order-inversion
 230     // CHECK: Cycle in lock order graph: [[M1:M[0-9]+]] ({{.*}}) => [[M2:M[0-9]+]] ({{.*}}) => [[M1]]
 231     // CHECK: Mutex [[M2]] acquired here while holding mutex [[M1]] in thread [[T1:T[0-9]+]]
 232     // CHECK: Mutex [[M1]] acquired here while holding mutex [[M2]] in thread [[T2:T[0-9]+]]
 233     // CHECK: Thread [[T1]] {{.*}} created by main thread
 234     // CHECK: Thread [[T2]] {{.*}} created by main thread
 235     // CHECK-NOT: WARNING: ThreadSanitizer:
 236   }
 237
 238   void Test6() {
 239     if (test_number > 0 && test_number != 6) return;
 240     fprintf(stderr, "Starting Test6: 3 threads lock/unlock private mutexes\n");
 241     // CHECK: Starting Test6
 242     Init(100);
 243     // CHECK-NOT: WARNING: ThreadSanitizer:
 244     RunThreads(&LockTest::Lock1_Loop_0, &LockTest::Lock1_Loop_1,
 245                &LockTest::Lock1_Loop_2);
 246   }
 247
 248   void Test7() {
 249     if (test_number > 0 && test_number != 7) return;
 250     fprintf(stderr, "Starting Test7\n");
 251     // CHECK: Starting Test7
 252     Init(10);
 253     L(0); T(1); U(1); U(0);
 254     T(1); L(0); U(1); U(0);
 255     // CHECK-NOT: WARNING: ThreadSanitizer:
 256     fprintf(stderr, "No cycle: 0=>1\n");
 257     // CHECK: No cycle: 0=>1
 258
 259     T(2); L(3); U(3); U(2);
 260     L(3); T(2); U(3); U(2);
 261     // CHECK-NOT: WARNING: ThreadSanitizer:
 262     fprintf(stderr, "No cycle: 2=>3\n");
 263     // CHECK: No cycle: 2=>3
 264
 265     T(4); L(5); U(4); U(5);
 266     L(5); L(4); U(4); U(5);
 267     // CHECK: WARNING: ThreadSanitizer: lock-order-inversion
 268     fprintf(stderr, "Have cycle: 4=>5\n");
 269     // CHECK: Have cycle: 4=>5
 270
 271     L(7); L(6); U(6); U(7);
 272     T(6); L(7); U(6); U(7);
 273     // CHECK: WARNING: ThreadSanitizer: lock-order-inversion
 274     fprintf(stderr, "Have cycle: 6=>7\n");
 275     // CHECK: Have cycle: 6=>7
 276   }
 277
 278   void Test8() {
 279     if (test_number > 0 && test_number != 8) return;
 280     if (!LockType::supports_read_lock()) return;
 281     fprintf(stderr, "Starting Test8\n");
 282     Init(5);
 283     // CHECK-RD: Starting Test8
 284     RL(0); L(1); RU(0); U(1);
 285     L(1); RL(0); RU(0); U(1);
 286     // CHECK-RD: WARNING: ThreadSanitizer: lock-order-inversion
 287     fprintf(stderr, "Have cycle: 0=>1\n");
 288     // CHECK-RD: Have cycle: 0=>1
 289
 290     RL(2); RL(3); RU(2); RU(3);
 291     RL(3); RL(2); RU(2); RU(3);
 292     // CHECK-RD: WARNING: ThreadSanitizer: lock-order-inversion
 293     fprintf(stderr, "Have cycle: 2=>3\n");
 294     // CHECK-RD: Have cycle: 2=>3
 295   }
 296
 297   void Test9() {
 298     if (test_number > 0 && test_number != 9) return;
 299     if (!LockType::supports_recursive_lock()) return;
 300     fprintf(stderr, "Starting Test9\n");
 301     // CHECK-REC: Starting Test9
 302     Init(5);
 303     L(0); L(0); L(0); L(1); U(1); U(0); U(0); U(0);
 304     L(1); L(1); L(1); L(0); U(0); U(1); U(1); U(1);
 305     // CHECK-REC: WARNING: ThreadSanitizer: lock-order-inversion
 306   }
 307
 308   void Test10() {
 309     if (test_number > 0 && test_number != 10) return;
 310     fprintf(stderr, "Starting Test10: 4 threads lock/unlock 4 private mutexes, one under another\n");
 311     // CHECK: Starting Test10
 312     Init(100);
 313     // CHECK-NOT: WARNING: ThreadSanitizer:
 314     RunThreads(&LockTest::Test10_Thread1, &LockTest::Test10_Thread2,
 315                &LockTest::Test10_Thread3, &LockTest::Test10_Thread4);
 316   }
 317   void Test10_Thread1() { Test10_Thread(0); }
 318   void Test10_Thread2() { Test10_Thread(10); }
 319   void Test10_Thread3() { Test10_Thread(20); }
 320   void Test10_Thread4() { Test10_Thread(30); }
 321   void Test10_Thread(size_t m) {
 322     for (int i = 0; i < iter_count; i++) {
 323       L(m + 0);
 324       L(m + 1);
 325       L(m + 2);
 326       L(m + 3);
 327       U(m + 3);
 328       U(m + 2);
 329       U(m + 1);
 330       U(m + 0);
 331     }
 332   }
 333
 334   void Test11() {
 335     if (test_number > 0 && test_number != 11) return;
 336     fprintf(stderr, "Starting Test11: 4 threads lock/unlock 4 private mutexes, all under another private mutex\n");
 337     // CHECK: Starting Test11
 338     Init(500);
 339     // CHECK-NOT: WARNING: ThreadSanitizer:
 340     RunThreads(&LockTest::Test11_Thread1, &LockTest::Test11_Thread2,
 341                &LockTest::Test11_Thread3, &LockTest::Test11_Thread4);
 342   }
 343   void Test11_Thread1() { Test10_Thread(0); }
 344   void Test11_Thread2() { Test10_Thread(10); }
 345   void Test11_Thread3() { Test10_Thread(20); }
 346   void Test11_Thread4() { Test10_Thread(30); }
 347   void Test11_Thread(size_t m) {
 348     for (int i = 0; i < iter_count; i++) {
 349       L(m);
 350       L(m + 100);
 351       U(m + 100);
 352       L(m + 200);
 353       U(m + 200);
 354       L(m + 300);
 355       U(m + 300);
 356       L(m + 400);
 357       U(m + 500);
 358       U(m);
 359     }
 360   }
 361
 362   void Test12() {
 363     if (test_number > 0 && test_number != 12) return;
 364     if (!LockType::supports_read_lock()) return;
 365     fprintf(stderr, "Starting Test12: 4 threads read lock/unlock 4 shared mutexes, one under another\n");
 366     // CHECK-RD: Starting Test12
 367     Init(500);
 368     // CHECK-RD-NOT: WARNING: ThreadSanitizer:
 369     RunThreads(&LockTest::Test12_Thread, &LockTest::Test12_Thread,
 370                &LockTest::Test12_Thread, &LockTest::Test12_Thread);
 371   }
 372   void Test12_Thread() {
 373     for (int i = 0; i < iter_count; i++) {
 374       RL(000);
 375       RL(100);
 376       RL(200);
 377       RL(300);
 378       RU(300);
 379       RU(200);
 380       RU(100);
 381       RU(000);
 382     }
 383   }
 384
 385   void Test13() {
 386     if (test_number > 0 && test_number != 13) return;
 387     if (!LockType::supports_read_lock()) return;
 388     fprintf(stderr, "Starting Test13: 4 threads read lock/unlock 4 shared mutexes, all under another shared mutex\n");
 389     // CHECK-RD: Starting Test13
 390     Init(500);
 391     // CHECK-RD-NOT: WARNING: ThreadSanitizer:
 392     RunThreads(&LockTest::Test13_Thread, &LockTest::Test13_Thread,
 393                &LockTest::Test13_Thread, &LockTest::Test13_Thread);
 394   }
 395   void Test13_Thread() {
 396     for (int i = 0; i < iter_count; i++) {
 397       RL(0);
 398       RL(100);
 399       RU(100);
 400       RL(200);
 401       RU(200);
 402       RL(300);
 403       RU(300);
 404       RL(400);
 405       RU(400);
 406       RU(0);
 407     }
 408   }
 409
 410   void Test14() {
 411     if (test_number > 0 && test_number != 14) return;
 412     fprintf(stderr, "Starting Test14: create lots of locks in 4 threads\n");
 413     Init(10);
 414     // CHECK-RD: Starting Test14
 415     RunThreads(&LockTest::CreateAndDestroyLocksLoop,
 416                &LockTest::CreateAndDestroyLocksLoop,
 417                &LockTest::CreateAndDestroyLocksLoop,
 418                &LockTest::CreateAndDestroyLocksLoop);
 419   }
 420
 421   void Test15() {
 422     if (test_number > 0 && test_number != 15) return;
 423     if (!LockType::supports_read_lock()) return;
 424     fprintf(stderr, "Starting Test15: recursive rlock\n");
 425     // DISABLEDCHECK-RD: Starting Test15
 426     Init(5);
 427     RL(0); RL(0); RU(0); RU(0);  // Recusrive reader lock.
 428     RL(0); RL(0); RL(0); RU(0); RU(0); RU(0);  // Recusrive reader lock.
 429   }
 430
 431   // More detailed output test.
 432   void Test16() {
 433     if (test_number > 0 && test_number != 16) return;
 434     fprintf(stderr, "Starting Test16: detailed output test with two locks\n");
 435     // CHECK: Starting Test16
 436     // CHECK: WARNING: ThreadSanitizer: lock-order-inversion
 437     // CHECK: acquired here while holding mutex
 438     // CHECK: LockTest::Acquire1
 439     // CHECK-NEXT: LockTest::Acquire_0_then_1
 440     // CHECK-SECOND: previously acquired by the same thread here
 441     // CHECK-SECOND: LockTest::Acquire0
 442     // CHECK-SECOND-NEXT: LockTest::Acquire_0_then_1
 443     // CHECK: acquired here while holding mutex
 444     // CHECK: LockTest::Acquire0
 445     // CHECK-NEXT: LockTest::Acquire_1_then_0
 446     // CHECK-SECOND: previously acquired by the same thread here
 447     // CHECK-SECOND: LockTest::Acquire1
 448     // CHECK-SECOND-NEXT: LockTest::Acquire_1_then_0
 449     Init(5);
 450     Acquire_0_then_1();
 451     U(0); U(1);
 452     Acquire_1_then_0();
 453     U(0); U(1);
 454   }
 455
 456   // More detailed output test.
 457   void Test17() {
 458     if (test_number > 0 && test_number != 17) return;
 459     fprintf(stderr, "Starting Test17: detailed output test with three locks\n");
 460     // CHECK: Starting Test17
 461     // CHECK: WARNING: ThreadSanitizer: lock-order-inversion
 462     // CHECK: LockTest::Acquire1
 463     // CHECK-NEXT: LockTest::Acquire_0_then_1
 464     // CHECK: LockTest::Acquire2
 465     // CHECK-NEXT: LockTest::Acquire_1_then_2
 466     // CHECK: LockTest::Acquire0
 467     // CHECK-NEXT: LockTest::Acquire_2_then_0
 468     Init(5);
 469     Acquire_0_then_1();
 470     U(0); U(1);
 471     Acquire_1_then_2();
 472     U(1); U(2);
 473     Acquire_2_then_0();
 474     U(0); U(2);
 475   }
 476
 477   __attribute__((noinline)) void Acquire2() { L(2); }
 478   __attribute__((noinline)) void Acquire1() { L(1); }
 479   __attribute__((noinline)) void Acquire0() { L(0); }
 480   __attribute__((noinline)) void Acquire_1_then_0() { Acquire1(); Acquire0(); }
 481   __attribute__((noinline)) void Acquire_0_then_1() { Acquire0(); Acquire1(); }
 482   __attribute__((noinline)) void Acquire_1_then_2() { Acquire1(); Acquire2(); }
 483   __attribute__((noinline)) void Acquire_2_then_0() { Acquire2(); Acquire0(); }
 484
 485   // This test creates, locks, unlocks and destroys lots of mutexes.
 486   void Test18() {
 487     if (test_number > 0 && test_number != 18) return;
 488     fprintf(stderr, "Starting Test18: create, lock and destroy 4 locks; all in "
 489                     "4 threads in a loop\n");
 490     RunThreads(&LockTest::Test18_Thread, &LockTest::Test18_Thread,
 491                &LockTest::Test18_Thread, &LockTest::Test18_Thread);
 492   }
 493
 494   void Test18_Thread() {
 495     LockType *l = new LockType[4];
 496     for (size_t i = 0; i < iter_count / 100; i++) {
 497       for (int i = 0; i < 4; i++) l[i].lock();
 498       for (int i = 0; i < 4; i++) l[i].unlock();
 499       for (int i = 0; i < 4; i++) l[i].~LockType();
 500       for (int i = 0; i < 4; i++) new ((void*)&l[i]) LockType();
 501     }
 502     delete [] l;
 503   }
 504
 505   void Test19() {
 506     if (test_number > 0 && test_number != 19) return;
 507     fprintf(stderr, "Starting Test19: lots of lock inversions\n");
 508     const int kNumLocks = 45;
 509     Init(kNumLocks);
 510     for (int i = 0; i < kNumLocks; i++) {
 511       for (int j = 0; j < kNumLocks; j++)
 512         L((i + j) % kNumLocks);
 513       for (int j = 0; j < kNumLocks; j++)
 514         U((i + j) % kNumLocks);
 515     }
 516   }
 517
 518  private:
 519   void Lock2(size_t l1, size_t l2) { L(l1); L(l2); U(l2); U(l1); }
 520
 521   template<bool wait = false>
 522   void Lock_0_1() {
 523     Lock2(0, 1);
 524     if (wait)
 525       barrier_wait(&barrier);
 526   }
 527
 528   template<bool wait = false>
 529   void Lock_1_0() {
 530     if (wait)
 531       barrier_wait(&barrier);
 532     Lock2(1, 0);
 533   }
 534
 535   void Lock1_Loop(size_t i, size_t n_iter) {
 536     for (size_t it = 0; it < n_iter; it++) {
 537       // if ((it & (it - 1)) == 0) fprintf(stderr, "%zd", i);
 538       L(i);
 539       U(i);
 540     }
 541     // fprintf(stderr, "\n");
 542   }
 543   void Lock1_Loop_0() { Lock1_Loop(0, iter_count); }
 544   void Lock1_Loop_1() { Lock1_Loop(10, iter_count); }
 545   void Lock1_Loop_2() { Lock1_Loop(20, iter_count); }
 546
 547   void CreateAndDestroyManyLocks() {
 548     LockType *create_many_locks_but_never_acquire =
 549         new LockType[kDeadlockGraphSize];
 550     (void)create_many_locks_but_never_acquire;
 551     delete [] create_many_locks_but_never_acquire;
 552   }
 553
 554   void CreateAndDestroyLocksLoop() {
 555     for (size_t it = 0; it <= iter_count; it++) {
 556       LockType some_locks[10];
 557       (void)some_locks;
 558     }
 559   }
 560
 561   void CreateLockUnlockAndDestroyManyLocks() {
 562     LockType many_locks[kDeadlockGraphSize];
 563     for (size_t i = 0; i < kDeadlockGraphSize; i++) {
 564       many_locks[i].lock();
 565       many_locks[i].unlock();
 566     }
 567   }
 568
 569   // LockTest Member function callback.
 570   struct CB {
 571     void (LockTest::*f)();
 572     LockTest *lt;
 573   };
 574
 575   // Thread function with CB.
 576   static void *Thread(void *param) {
 577     CB *cb = (CB*)param;
 578     (cb->lt->*cb->f)();
 579     return NULL;
 580   }
 581
 582   void RunThreads(void (LockTest::*f1)(), void (LockTest::*f2)(),
 583                   void (LockTest::*f3)() = 0, void (LockTest::*f4)() = 0) {
 584     const int kNumThreads = 4;
 585     pthread_t t[kNumThreads];
 586     CB cb[kNumThreads] = {{f1, this}, {f2, this}, {f3, this}, {f4, this}};
 587     for (int i = 0; i < kNumThreads && cb[i].f; i++)
 588       pthread_create(&t[i], 0, Thread, &cb[i]);
 589     for (int i = 0; i < kNumThreads && cb[i].f; i++)
 590       pthread_join(t[i], 0);
 591   }
 592
 593   static const size_t kDeadlockGraphSize = 4096;
 594   size_t n_;
 595   LockType **locks_;
 596 };
 597
 598 int main(int argc, char **argv) {
 599   barrier_init(&barrier, 2);
 600   if (argc > 1)
 601     test_number = atoi(argv[1]);
 602   if (argc > 2)
 603     iter_count = atoi(argv[2]);
 604   LockTest().Test1();
 605   LockTest().Test2();
 606   LockTest().Test3();
 607   LockTest().Test4();
 608   LockTest().Test5();
 609   LockTest().Test6();
 610   LockTest().Test7();
 611   LockTest().Test8();
 612   LockTest().Test9();
 613   LockTest().Test10();
 614   LockTest().Test11();
 615   LockTest().Test12();
 616   LockTest().Test13();
 617   LockTest().Test14();
 618   LockTest().Test15();
 619   LockTest().Test16();
 620   LockTest().Test17();
 621   LockTest().Test18();
 622   LockTest().Test19();
 623   fprintf(stderr, "ALL-DONE\n");
 624   // CHECK: ALL-DONE
 625 }