Lines Matching refs:MU
365 // 3. MU.Lock() a. write(GLOB)
366 // b. MU.Lock()
369 // 4. while(COND) / e. MU.Unlock()
370 // CV.Wait(MU) <---/
371 // 5. MU.Unlock()
373 Mutex MU;
379 MU.Lock();
382 MU.Unlock();
390 MU.Lock();
392 CV.Wait(&MU);
393 MU.Unlock();
415 // b. MU.Lock()
417 // /--- d. MU.Unlock()
418 // 3. MU.LockWhen(COND==1) <---/
419 // 4. MU.Unlock()
421 Mutex MU;
427 MU.Lock();
429 MU.Unlock(); // calls ANNOTATE_CONDVAR_SIGNAL;
436 MU.LockWhen(Condition(&ArgIsOne, &COND)); // calls ANNOTATE_CONDVAR_WAIT
437 MU.Unlock(); // Waker is done!
495 // 3. MU.Lock() a. write(GLOB)
496 // b. MU.Lock()
499 // 4. while(COND) e. MU.Unlock()
500 // CV.Wait(MU) <<< not called
501 // 5. MU.Unlock()
503 Mutex MU;
507 MU.Lock();
510 MU.Unlock();
519 MU.Lock();
521 CV.Wait(&MU);
522 MU.Unlock();
545 // 3. MU.Lock() a. write(GLOB)
546 // b. MU.Lock()
549 // 4. while(COND) / e. MU.Unlock()
550 // CV.Wait(MU) <<< not called /
551 // 6. ANNOTATE_CONDVAR_WAIT(CV, MU) <----/
552 // 5. MU.Unlock()
555 Mutex MU;
559 MU.Lock();
562 MU.Unlock();
571 MU.Lock();
573 CV.Wait(&MU);
574 ANNOTATE_CONDVAR_LOCK_WAIT(&CV, &MU);
576 MU.Unlock();
600 // b. MU.Lock()
602 // /--- d. MU.Unlock calls ANNOTATE_CONDVAR_SIGNAL
603 // 3. MU.LockWhen(COND==1) <---/
604 // 4. MU.Unlock()
607 Mutex MU;
610 MU.Lock();
612 MU.Unlock(); // calls ANNOTATE_CONDVAR_SIGNAL;
620 MU.LockWhen(Condition(&ArgIsTrue, &COND)); // calls ANNOTATE_CONDVAR_WAIT
621 MU.Unlock(); // Signaller is done!
736 // 2. MU.Lock() b. MU.Lock()
738 // CV.Wait(&MU) <-------/ d. MU.Unlock()
739 // 4. MU.Unlock()
744 Mutex MU;
749 MU.Lock();
752 MU.Unlock();
761 MU.Lock();
763 CV.Wait(&MU);
765 MU.Unlock();
788 // First, we write to GLOB under MU, then we synchronize via PCQ,
792 // 1. MU.Lock() a. MU.Lock()
793 // 2. write(GLOB) <---- MU ----> b. write(GLOB)
794 // 3. MU.Unlock() c. MU.Unlock()
799 Mutex MU;
802 MU.Lock();
804 MU.Unlock();
810 MU.Lock();
812 MU.Unlock();
837 // 1. MU.Lock() a. MU.Lock()
838 // 2. write(GLOB) <---------- MU ----------> b. write(GLOB)
839 // 3. MU.Unlock() c. MU.Unlock()
840 // 4. MU.Lock() .
843 // 7. MU.Unlock() \ .
844 // \----> d. MU.LockWhen(COND == 1)
845 // e. MU.Unlock()
847 Mutex MU;
850 MU.Lock();
852 MU.Unlock();
854 MU.Lock();
856 ANNOTATE_CONDVAR_SIGNAL(&MU);
857 MU.Unlock();
861 MU.Lock();
863 MU.Unlock();
865 MU.LockWhen(Condition(&ArgIsOne, &COND));
866 MU.Unlock();
930 // 2. MU.Lock()
932 // 4. ANNOTATE_CONDVAR_SIGNAL ------------> a. MU.LockWhen(COND == 1)
933 // 5. MU.Unlock() b. MU.Unlock()
937 Mutex MU;
942 MU.Lock();
944 ANNOTATE_CONDVAR_SIGNAL(&MU);
945 MU.Unlock();
949 MU.LockWhen(Condition(&ArgIsOne, &COND));
950 MU.Unlock();
970 // 1. MU.Lock() a. MU.Lock()
971 // 2. write(GLOB) <------------ MU ----------> b. write(GLOB)
972 // 3. MU.Unlock() c. MU.Unlock()
989 Mutex MU;
993 MU.Lock();
995 MU.Unlock();
1023 Mutex MU;
1027 MU.Lock();
1029 MU.Unlock();
1056 Mutex MU;
1063 MU.Lock();
1065 MU.Unlock(); // calls ANNOTATE_CONDVAR_SIGNAL;
1073 MU.Lock();
1074 MU.Await(Condition(&ArgIsOne, &COND)); // calls ANNOTATE_CONDVAR_WAIT
1075 MU.Unlock(); // Waker is done!
1091 Mutex MU;
1096 MU.Lock();
1098 MU.Unlock(); // calls ANNOTATE_CONDVAR_SIGNAL;
1106 MU.Lock();
1107 CHECK(MU.AwaitWithTimeout(Condition(&ArgIsOne, &COND), INT_MAX));
1108 MU.Unlock();
1123 Mutex MU;
1135 MU.Lock();
1136 CHECK(!MU.AwaitWithTimeout(Condition(&ArgIsOne, &COND), 100));
1137 MU.Unlock();
1155 Mutex MU;
1166 CHECK(!MU.LockWhenWithTimeout(Condition(&ArgIsOne, &COND), 100));
1167 MU.Unlock();
1184 Mutex MU;
1198 MU.Lock();
1200 CV.WaitWithTimeout(&MU, ms_left_to_wait);
1203 MU.Unlock();
1221 Mutex MU;
1225 if (MU.TryLock()) {
1227 MU.Unlock();
1238 if (MU.ReaderTryLock()) {
1240 MU.ReaderUnlock();
1250 MU.ReaderLock();
1252 MU.ReaderUnlock();
1259 MU.Lock();
1261 MU.Unlock();
1283 Mutex MU;
1290 MU.Lock();
1292 MU.Unlock(); // calls ANNOTATE_CONDVAR_SIGNAL;
1299 MU.ReaderLockWhen(Condition(&ArgIsOne, &COND));
1300 MU.ReaderUnlock();
1315 Mutex MU;
1323 MU.Lock();
1325 MU.Unlock(); // calls ANNOTATE_CONDVAR_SIGNAL;
1332 CHECK(MU.ReaderLockWhenWithTimeout(Condition(&ArgIsOne, &COND), INT_MAX));
1333 MU.ReaderUnlock();
1348 Mutex MU;
1360 CHECK(!MU.ReaderLockWhenWithTimeout(Condition(&ArgIsOne, &COND), 100));
1361 MU.ReaderUnlock();
1380 SpinLock MU;
1382 MU.Lock();
1384 MU.Unlock();
1403 // 1. MU.Lock() A. MU.Lock()
1405 // 3. MU.Unlock() C. MU.Unlock()
1407 // 5. MU.Lock() \-------> a. Q.Get() / E. MU.Lock()
1409 // 7. MU.Unlock() (sleep) G. MU.Unlock()
1413 Mutex MU;
1416 MU.Lock();
1418 MU.Unlock();
1422 MU.Lock();
1424 MU.Unlock();
1449 Mutex MU;
1453 MU.Lock();
1455 MU.Unlock();
1460 MU.Lock();
1462 MU.Unlock();
1619 // \---> a. MU.Lock() \--> A. sleep(long enough)
1621 // /---- c. MU.Unlock()
1623 // B. MU.Lock()
1625 // /------------ D. MU.Unlock()
1634 Mutex MU;
1637 MU.Lock();
1639 MU.Unlock();
1644 MU.Lock();
1646 MU.Unlock();
1682 Mutex MU;
1685 MU.Lock();
1687 MU.Unlock();
1818 // 1. MU.Lock(); A. MU.Lock()
1820 // 3. MU.Unlock() C. MU.Unlock()
1823 // 6. MU.Lock() b. Q.Get() <---------/ F. MU.Lock()
1825 // 8. MU.Unlock() H. MU.Unlock()
1832 Mutex MU, MU1;
1835 MU.Lock();
1837 MU.Unlock();
1842 MU.Lock();
1844 MU.Unlock();
1871 Mutex MU;
1874 // 1. MU.Lock()
1876 // 3. MU.Unlock()
1877 // a. MU.Lock()
1879 // c. MU.Unlock();
1882 MU.Lock();
1884 MU.Unlock();
1888 MU.Lock();
1890 MU.Unlock();
1929 Mutex MU, MU1, MU2;
1983 Mutex MU;
1986 MU.Lock();
1988 MU.Unlock();
2035 Mutex MU, MU1, MU2;
2103 Mutex MU;
2108 MU.Lock();
2111 MU.Unlock();
2113 MU.Lock();
2115 CV.Wait(&MU);
2116 ANNOTATE_CONDVAR_LOCK_WAIT(&CV, &MU);
2117 MU.Unlock();
2125 MU.Lock();
2127 CV.Wait(&MU);
2128 ANNOTATE_CONDVAR_LOCK_WAIT(&CV, &MU);
2129 MU.Unlock();
2133 MU.Lock();
2136 MU.Unlock();
2190 // 3. MU.Lock() \--> a. Q.Get()
2192 // 5. MU.Unlock()
2193 // b. MU.Lock()
2195 // d. MU.Unlock();
2197 Mutex MU;
2202 MU.Lock();
2204 MU.Unlock();
2209 MU.Lock();
2211 MU.Unlock();
2231 // 3. MU.Lock() \--> a. Q.Get()
2233 // 5. MU.Unlock()
2234 // b. MU.Lock()
2236 // d. MU.Unlock();
2238 Mutex MU;
2243 MU.Lock();
2245 MU.Unlock();
2250 MU.Lock();
2252 MU.Unlock();
2270 // 2. MU.Lock()
2272 // 4. MU.Unlock() (sleep)
2273 // a. MU.Lock()
2275 // c. MU.Unlock();
2277 Mutex MU;
2280 MU.Lock();
2282 MU.Unlock();
2286 MU.Lock();
2288 MU.Unlock();
2293 MU.Lock();
2295 MU.Unlock();
2314 // 2. MU.Lock()
2315 // 3. MU.Unlock() (sleep)
2316 // a. MU.Lock()
2317 // b. MU.Unlock();
2320 Mutex MU;
2323 MU.Lock();
2324 MU.Unlock();
2328 MU.Lock();
2329 MU.Unlock();
2430 Mutex MU;
2436 // 3. MU.Lock() a. write(GLOB)
2437 // b. MU.Lock()
2440 // 4. while(COND != 1) / e. MU.Unlock()
2441 // CV.Wait(MU) <---/
2442 // 5. MU.Unlock()
2443 // 6. write(GLOB) f. MU.Lock()
2445 // h. MU.Unlock()
2453 MU.Lock();
2456 MU.Unlock();
2459 MU.Lock();
2461 MU.Unlock();
2470 MU.Lock();
2472 CV.Wait(&MU);
2473 ANNOTATE_CONDVAR_LOCK_WAIT(&CV, &MU);
2474 MU.Unlock();
2493 Mutex MU;
2501 // 2. MU.Lock()
2503 // CV.Wait(MU)<-\ .
2504 // 4. MU.Unlock() \ .
2506 // \ b. MU.Lock()
2509 // e. MU.Unlock()
2513 // g. MU.Lock()
2516 // j. MU.Unlock()
2524 MU.Lock();
2527 MU.Unlock();
2533 MU.Lock();
2536 MU.Unlock();
2545 MU.Lock();
2547 CV.Wait(&MU);
2548 MU.Unlock();
2568 Mutex MU;
2576 // b. MU.Lock()
2579 // e. MU.Unlock()
2581 // 2. MU.Lock()
2583 // CV.Wait(MU)<-\ .
2584 // 4. MU.Unlock() \ f. write(GLOB)
2586 // \ g. MU.Lock()
2589 // j. MU.Unlock()
2595 MU.Lock();
2598 MU.Unlock();
2604 MU.Lock();
2607 MU.Unlock();
2617 MU.Lock();
2619 CV.Wait(&MU);
2620 MU.Unlock();
2750 Mutex MU;
2754 MU.Lock();
2759 if (!MU.TryLock()) {
2760 MU.Unlock();
2764 MU.Unlock();
2919 Mutex MU;
2925 MU.Lock();
2928 MU.Unlock();
2930 MU.Lock();
2932 CV.Wait(&MU);
2933 ANNOTATE_CONDVAR_LOCK_WAIT(&CV, &MU);
2934 MU.Unlock();
2942 MU.Lock();
2945 MU.Unlock();
2947 MU.Lock();
2949 CV.Wait(&MU);
2950 ANNOTATE_CONDVAR_LOCK_WAIT(&CV, &MU);
2951 MU.Unlock();
2970 Mutex MU;
2975 // We annotate the code so that MU is treated as in pure happens-before detector.
2979 ANNOTATE_MUTEX_IS_USED_AS_CONDVAR(&MU);
2980 MU.Lock();
2985 MU.Unlock();
2991 MU.Lock();
2997 MU.Unlock();
3124 // 1. MU.Lock()
3126 // 3. MU.Unlock() (sleep)
3127 // a. MU.Lock()
3129 // c. MU.Unlock()
3136 Mutex MU;
3140 MU.Lock();
3142 MU.Unlock();
3147 MU.Lock();
3149 MU.Unlock();
3179 Mutex MU;
3183 MU.Lock();
3186 MU.Unlock();
3192 MU.Lock();
3195 MU.Unlock();
3199 MU.Lock();
3200 while (C1 != 1) CV.Wait(&MU);
3202 MU.Unlock();
3207 MU.Lock();
3208 while (C2 != 1) CV.Wait(&MU);
3210 MU.Unlock();
3235 Mutex MU;
3239 MU.Lock();
3242 MU.Unlock();
3247 MU.Lock();
3250 MU.Unlock();
3254 MU.Lock();
3255 while (C1 != 1) CV.Wait(&MU);
3257 MU.Unlock();
3261 MU.Lock();
3262 while (C2 != 1) CV.Wait(&MU);
3264 MU.Unlock();
3281 // test68: TP. Writes are protected by MU, reads are not. {{{1
3291 Mutex MU, MU1;
3295 MU.Lock();
3297 MU.Unlock();
3344 Mutex MU, MU1;
3348 MU.Lock();
3350 MU.Unlock();
3464 Mutex MU;
3467 MU.Lock();
3469 MU.Unlock();
3555 Mutex MU;
3558 MU.Lock();
3560 MU.Unlock();
3627 Mutex MU;
3631 MU.Lock();
3632 MU.Unlock();
3698 // if MU is not annotated
3711 MU.Lock();
3714 MU.Unlock();
3718 MU.Lock();
3725 MU.Unlock();
3735 ANNOTATE_MUTEX_IS_USED_AS_CONDVAR(&MU);
3751 static Mutex MU; // protects ref_
3754 Mutex RefCountedClass::MU;
3782 // test77: TN. Ref counting, MU is annotated. {{{1
3785 // same as test76, but RefCountedClass::MU is annotated.
3844 Mutex MU;
3852 MU.Lock();
3855 MU.Unlock();
3860 MU.Lock();
3861 MAP[1]++; // Just update MAP under MU.
3862 MU.Unlock();
3869 ANNOTATE_MUTEX_IS_USED_AS_CONDVAR(&MU);
4024 Mutex MU;
4036 MU.Lock(); // this is NOT a synchronization,
4037 MU.Unlock(); // it just helps foo[i] to become visible in Reader.
4064 Mutex MU;
4073 MU.Lock(); // Not a synchronization!
4074 MU.Unlock();
4396 Mutex MU;
4399 MU.Lock();
4404 MU.Unlock();
4411 MU.Lock();
4413 MU.Unlock();
4443 Mutex MU, MU1, MU2;
4506 Mutex MU, MU1, MU2;
4580 Mutex MU, MU2;
4588 MU.Lock();
4591 MU.Unlock();
4603 MU.Lock();
4605 CV.Wait(&MU);
4606 MU.Unlock();
4633 Mutex MU, MU2;
4642 MU.Lock();
4645 MU.Unlock();
4656 MU.Lock();
4658 CV.Wait(&MU);
4659 MU.Unlock();
4723 Mutex MU;
4892 Mutex MU;
4900 MU.Lock();
4904 MU.Unlock();
4909 MU.Lock();
4913 MU.Unlock();
4917 MU.Lock();
4919 CV.Wait(&MU);
4921 MU.Unlock();
4923 MU.Lock();
4925 CV.Wait(&MU);
4927 MU.Unlock();
4947 Mutex MU;
4987 Mutex MU[N_MUTEXES];
5000 MU[m].Lock();
5006 MU[m].Unlock();
5458 Mutex MU[kNumLocks];
5463 if (i & (1 << j)) MU[j].Lock();
5466 if (i & (1 << j)) MU[j].Unlock();
6090 Mutex MU;
6097 MU.ReaderLockWhen(Condition(WeirdCondition, ¶m));
6098 MU.ReaderUnlock();
6104 MU.Lock();
6106 MU.Unlock(); // calls ANNOTATE_CONDVAR_SIGNAL;
6764 Mutex MU;
6766 void Worker2() { MU.Lock(); GLOB=1; MU.Unlock();}
6783 Mutex MU;
6788 MU.Lock(); CHECK(STR->length() >= 4); MU.Unlock();
6798 MU.Lock(); CHECK(STR->length() >= 4); MU.Unlock();
6803 MU.Lock(); *STR += " + a very very long string"; MU.Unlock();
7347 Mutex MU;
7352 MU.Lock();
7354 MU.Unlock();
7545 Mutex MU;
7549 MU.Lock();
7551 MU.Unlock();