Lines Matching refs:mu
125 // 3. MU.Lock() a. write(GLOB)
126 // b. MU.Lock()
129 // 4. while(COND) / e. MU.Unlock()
130 // CV.Wait(MU) <---/
131 // 5. MU.Unlock()
133 Mutex MU;
139 MU.Lock();
142 MU.Unlock();
150 MU.Lock();
152 CV.Wait(&MU);
153 MU.Unlock();
175 // b. MU.Lock()
177 // /--- d. MU.Unlock()
178 // 3. MU.LockWhen(COND==1) <---/
179 // 4. MU.Unlock()
181 Mutex MU;
187 MU.Lock();
189 MU.Unlock(); // calls ANNOTATE_CONDVAR_SIGNAL;
196 MU.LockWhen(Condition(&ArgIsOne, &COND)); // calls ANNOTATE_CONDVAR_WAIT
197 MU.Unlock(); // Waker is done!
255 // 3. MU.Lock() a. write(GLOB)
256 // b. MU.Lock()
259 // 4. while(COND) e. MU.Unlock()
260 // CV.Wait(MU) <<< not called
261 // 5. MU.Unlock()
263 Mutex MU;
267 MU.Lock();
270 MU.Unlock();
275 MU.Lock();
277 CV.Wait(&MU);
278 MU.Unlock();
303 // 3. MU.Lock() a. write(GLOB)
304 // b. MU.Lock()
307 // 4. while(COND) / e. MU.Unlock()
308 // CV.Wait(MU) <<< not called /
309 // 6. ANNOTATE_CONDVAR_WAIT(CV, MU) <----/
310 // 5. MU.Unlock()
313 Mutex MU;
317 MU.Lock();
320 MU.Unlock();
329 MU.Lock();
331 CV.Wait(&MU);
332 ANNOTATE_CONDVAR_LOCK_WAIT(&CV, &MU);
334 MU.Unlock();
358 // b. MU.Lock()
360 // /--- d. MU.Unlock calls ANNOTATE_CONDVAR_SIGNAL
361 // 3. MU.LockWhen(COND==1) <---/
362 // 4. MU.Unlock()
365 Mutex MU;
368 MU.Lock();
370 MU.Unlock(); // calls ANNOTATE_CONDVAR_SIGNAL;
378 MU.LockWhen(Condition(&ArgIsTrue, &COND)); // calls ANNOTATE_CONDVAR_WAIT
379 MU.Unlock(); // Signaller is done!
492 // First, we write to GLOB under MU, then we synchronize via PCQ,
496 // 1. MU.Lock() a. MU.Lock()
497 // 2. write(GLOB) <---- MU ----> b. write(GLOB)
498 // 3. MU.Unlock() c. MU.Unlock()
503 Mutex MU;
506 MU.Lock();
508 MU.Unlock();
514 MU.Lock();
516 MU.Unlock();
541 // 1. MU.Lock() a. MU.Lock()
542 // 2. write(GLOB) <---------- MU ----------> b. write(GLOB)
543 // 3. MU.Unlock() c. MU.Unlock()
544 // 4. MU.Lock() .
547 // 7. MU.Unlock() \ .
548 // \----> d. MU.LockWhen(COND == 1)
549 // e. MU.Unlock()
551 Mutex MU;
554 MU.Lock();
556 MU.Unlock();
558 MU.Lock();
560 ANNOTATE_CONDVAR_SIGNAL(&MU);
561 MU.Unlock();
565 MU.Lock();
567 MU.Unlock();
569 MU.LockWhen(Condition(&ArgIsOne, &COND));
570 MU.Unlock();
634 // 2. MU.Lock()
636 // 4. ANNOTATE_CONDVAR_SIGNAL ------------> a. MU.LockWhen(COND == 1)
637 // 5. MU.Unlock() b. MU.Unlock()
641 Mutex MU;
646 MU.Lock();
648 ANNOTATE_CONDVAR_SIGNAL(&MU);
649 MU.Unlock();
653 MU.LockWhen(Condition(&ArgIsOne, &COND));
654 MU.Unlock();
674 // 1. MU.Lock() a. MU.Lock()
675 // 2. write(GLOB) <------------ MU ----------> b. write(GLOB)
676 // 3. MU.Unlock() c. MU.Unlock()
693 Mutex MU;
697 MU.Lock();
699 MU.Unlock();
727 Mutex MU;
731 MU.Lock();
733 MU.Unlock();
759 Mutex MU;
766 MU.Lock();
768 MU.Unlock(); // calls ANNOTATE_CONDVAR_SIGNAL;
776 MU.Lock();
777 MU.Await(Condition(&ArgIsOne, &COND)); // calls ANNOTATE_CONDVAR_WAIT
778 MU.Unlock(); // Waker is done!
794 Mutex MU;
799 MU.Lock();
801 MU.Unlock(); // calls ANNOTATE_CONDVAR_SIGNAL;
809 MU.Lock();
810 CHECK(MU.AwaitWithTimeout(Condition(&ArgIsOne, &COND), INT_MAX));
811 MU.Unlock();
826 Mutex MU;
833 MU.Lock();
834 CHECK(!MU.AwaitWithTimeout(Condition(&ArgIsOne, &COND), 100));
835 MU.Unlock();
855 Mutex MU;
861 CHECK(!MU.LockWhenWithTimeout(Condition(&ArgIsOne, &COND), 100));
862 MU.Unlock();
881 Mutex MU;
890 MU.Lock();
892 CV.WaitWithTimeout(&MU, ms_left_to_wait);
895 MU.Unlock();
915 Mutex MU;
919 if (MU.TryLock()) {
921 MU.Unlock();
932 if (MU.ReaderTryLock()) {
934 MU.ReaderUnlock();
944 MU.ReaderLock();
946 MU.ReaderUnlock();
953 MU.Lock();
955 MU.Unlock();
977 Mutex MU;
984 MU.Lock();
986 MU.Unlock(); // calls ANNOTATE_CONDVAR_SIGNAL;
993 MU.ReaderLockWhen(Condition(&ArgIsOne, &COND));
994 MU.ReaderUnlock();
1009 Mutex MU;
1017 MU.Lock();
1019 MU.Unlock(); // calls ANNOTATE_CONDVAR_SIGNAL;
1026 CHECK(MU.ReaderLockWhenWithTimeout(Condition(&ArgIsOne, &COND), INT_MAX));
1027 MU.ReaderUnlock();
1042 Mutex MU;
1050 CHECK(!MU.ReaderLockWhenWithTimeout(Condition(&ArgIsOne, &COND), 100));
1051 MU.ReaderUnlock();
1072 SpinLock MU;
1074 MU.Lock();
1076 MU.Unlock();
1095 // 1. MU.Lock() A. MU.Lock()
1097 // 3. MU.Unlock() C. MU.Unlock()
1099 // 5. MU.Lock() \-------> a. Q.Get() / E. MU.Lock()
1101 // 7. MU.Unlock() (sleep) G. MU.Unlock()
1105 Mutex MU;
1108 MU.Lock();
1110 MU.Unlock();
1114 MU.Lock();
1116 MU.Unlock();
1141 Mutex MU;
1145 MU.Lock();
1147 MU.Unlock();
1152 MU.Lock();
1154 MU.Unlock();
1309 // \---> a. MU.Lock() \--> A. sleep(long enough)
1311 // /---- c. MU.Unlock()
1313 // B. MU.Lock()
1315 // /------------ D. MU.Unlock()
1324 Mutex MU;
1327 MU.Lock();
1329 MU.Unlock();
1334 MU.Lock();
1336 MU.Unlock();
1372 Mutex MU;
1375 MU.Lock();
1377 MU.Unlock();
1508 // 1. MU.Lock(); A. MU.Lock()
1510 // 3. MU.Unlock() C. MU.Unlock()
1513 // 6. MU.Lock() b. Q.Get() <---------/ F. MU.Lock()
1515 // 8. MU.Unlock() H. MU.Unlock()
1522 Mutex MU, MU1;
1525 MU.Lock();
1527 MU.Unlock();
1532 MU.Lock();
1534 MU.Unlock();
1561 Mutex MU;
1564 // 1. MU.Lock()
1566 // 3. MU.Unlock()
1567 // a. MU.Lock()
1569 // c. MU.Unlock();
1572 MU.Lock();
1574 MU.Unlock();
1578 MU.Lock();
1580 MU.Unlock();
1619 Mutex MU, MU1, MU2;
1672 Mutex MU;
1675 MU.Lock();
1677 MU.Unlock();
1722 Mutex MU, MU1, MU2;
1790 Mutex MU;
1795 MU.Lock();
1798 MU.Unlock();
1800 MU.Lock();
1802 CV.Wait(&MU);
1803 ANNOTATE_CONDVAR_LOCK_WAIT(&CV, &MU);
1804 MU.Unlock();
1812 MU.Lock();
1814 CV.Wait(&MU);
1815 ANNOTATE_CONDVAR_LOCK_WAIT(&CV, &MU);
1816 MU.Unlock();
1820 MU.Lock();
1823 MU.Unlock();
1877 // 3. MU.Lock() \--> a. Q.Get()
1879 // 5. MU.Unlock()
1880 // b. MU.Lock()
1882 // d. MU.Unlock();
1884 Mutex MU;
1889 MU.Lock();
1891 MU.Unlock();
1896 MU.Lock();
1898 MU.Unlock();
1918 // 3. MU.Lock() \--> a. Q.Get()
1920 // 5. MU.Unlock()
1921 // b. MU.Lock()
1923 // d. MU.Unlock();
1925 Mutex MU;
1930 MU.Lock();
1932 MU.Unlock();
1937 MU.Lock();
1939 MU.Unlock();
1957 // 2. MU.Lock()
1959 // 4. MU.Unlock() (sleep)
1960 // a. MU.Lock()
1962 // c. MU.Unlock();
1964 Mutex MU;
1967 MU.Lock();
1969 MU.Unlock();
1973 MU.Lock();
1975 MU.Unlock();
1980 MU.Lock();
1982 MU.Unlock();
2001 // 2. MU.Lock()
2002 // 3. MU.Unlock() (sleep)
2003 // a. MU.Lock()
2004 // b. MU.Unlock();
2007 Mutex MU;
2010 MU.Lock();
2011 MU.Unlock();
2015 MU.Lock();
2016 MU.Unlock();
2114 Mutex MU;
2120 // 3. MU.Lock() a. write(GLOB)
2121 // b. MU.Lock()
2124 // 4. while(COND != 1) / e. MU.Unlock()
2125 // CV.Wait(MU) <---/
2126 // 5. MU.Unlock()
2127 // 6. write(GLOB) f. MU.Lock()
2129 // h. MU.Unlock()
2137 MU.Lock();
2140 MU.Unlock();
2143 MU.Lock();
2145 MU.Unlock();
2149 MU.Lock();
2151 CV.Wait(&MU);
2152 ANNOTATE_CONDVAR_LOCK_WAIT(&CV, &MU);
2153 MU.Unlock();
2174 Mutex MU;
2182 // 2. MU.Lock()
2184 // CV.Wait(MU)<-\ .
2185 // 4. MU.Unlock() \ .
2187 // \ b. MU.Lock()
2190 // e. MU.Unlock()
2194 // g. MU.Lock()
2197 // j. MU.Unlock()
2204 MU.Lock();
2207 MU.Unlock();
2213 MU.Lock();
2216 MU.Unlock();
2220 MU.Lock();
2223 CV.Wait(&MU);
2224 MU.Unlock();
2245 Mutex MU;
2254 // b. MU.Lock()
2257 // e. MU.Unlock()
2259 // 2. MU.Lock()
2261 // CV.Wait(MU)<-\ .
2262 // 4. MU.Unlock() \ f. write(GLOB)
2264 // \ g. MU.Lock()
2267 // j. MU.Unlock()
2273 MU.Lock();
2276 MU.Unlock();
2283 MU.Lock();
2286 MU.Unlock();
2292 MU.Lock();
2295 CV.Wait(&MU);
2296 MU.Unlock();
2426 Mutex MU;
2430 MU.Lock();
2435 if (!MU.TryLock()) {
2436 MU.Unlock();
2440 MU.Unlock();
2595 Mutex MU;
2601 MU.Lock();
2604 MU.Unlock();
2606 MU.Lock();
2608 CV.Wait(&MU);
2609 ANNOTATE_CONDVAR_LOCK_WAIT(&CV, &MU);
2610 MU.Unlock();
2618 MU.Lock();
2621 MU.Unlock();
2623 MU.Lock();
2625 CV.Wait(&MU);
2626 ANNOTATE_CONDVAR_LOCK_WAIT(&CV, &MU);
2627 MU.Unlock();
2646 Mutex MU;
2651 // We annotate the code so that MU is treated as in pure happens-before detector.
2655 ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(&MU);
2656 MU.Lock();
2661 MU.Unlock();
2667 MU.Lock();
2673 MU.Unlock();
2799 // 1. MU.Lock()
2801 // 3. MU.Unlock() (sleep)
2802 // a. MU.Lock()
2804 // c. MU.Unlock()
2811 Mutex MU;
2815 MU.Lock();
2817 MU.Unlock();
2822 MU.Lock();
2824 MU.Unlock();
2853 Mutex MU;
2857 MU.Lock();
2860 MU.Unlock();
2866 MU.Lock();
2869 MU
2873 MU.Lock();
2874 while (C1 != 1) CV.Wait(&MU);
2876 MU.Unlock();
2881 MU.Lock();
2882 while (C2 != 1) CV.Wait(&MU);
2884 MU.Unlock();
2909 Mutex MU;
2913 MU.Lock();
2916 MU.Unlock();
2921 MU.Lock();
2924 MU.Unlock();
2928 MU.Lock();
2929 while (C1 != 1) CV.Wait(&MU);
2931 MU.Unlock();
2935 MU.Lock();
2936 while (C2 != 1) CV.Wait(&MU);
2938 MU.Unlock();
2954 // test68: TP. Writes are protected by MU, reads are not. {{{1
2964 Mutex MU, MU1;
2968 MU.Lock();
2970 MU.Unlock();
3016 Mutex MU, MU1;
3020 MU.Lock();
3022 MU.Unlock();
3344 Mutex MU;
3347 MU.Lock();
3349 MU.Unlock();
3417 Mutex MU;
3420 MU.Lock();
3422 MU.Unlock();
3489 Mutex MU;
3492 MU.Lock();
3493 MU.Unlock();
3510 // if MU is not annotated
3523 MU.Lock();
3526 MU.Unlock();
3530 MU.Lock();
3537 MU.Unlock();
3547 ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(&MU);
3562 static Mutex MU
3565 Mutex RefCountedClass::MU;
3593 // test77: TN. Ref counting, MU is annotated. {{{1
3596 // same as test76, but RefCountedClass::MU is annotated.
3655 Mutex MU;
3663 MU.Lock();
3666 MU.Unlock();
3671 MU.Lock();
3672 MAP[1]++; // Just update MAP under MU.
3673 MU.Unlock();
3680 ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(&MU);
3835 Mutex MU;
3847 MU.Lock(); // this is NOT a synchronization,
3848 MU.Unlock(); // it just helps foo[i] to become visible in Reader.
3875 Mutex MU;
3884 MU.Lock(); // Not a synchronization!
3885 MU.Unlock();
3971 Mutex mu;
3989 mu.LockWhen(Condition(&ArgIsTrue, &flag_stopped));
3990 mu.Unlock();
4013 mu.Lock();
4015 mu.Unlock();
4258 Mutex MU;
4263 MU.Lock();
4269 MU.Unlock();
4277 MU.Lock();
4279 MU.Unlock();
4308 Mutex MU, MU1, MU2;
4370 Mutex MU, MU1, MU2;
4444 Mutex MU, MU2;
4454 MU.Lock();
4457 MU.Unlock();
4472 MU.Lock();
4475 CV.Wait(&MU);
4476 MU.Unlock();
4503 Mutex MU, MU2;
4512 MU.Lock();
4515 MU.Unlock();
4526 MU.Lock();
4528 CV.Wait(&MU);
4529 MU.Unlock();
4626 Mutex mu;
4630 mu.LockWhenWithTimeout(Condition(&ArgIsTrue, &GLOB), 5);
4632 mu.Unlock();
4639 mu.Lock();
4640 mu.Unlock();
4698 Mutex MU;
4706 MU.Lock();
4710 MU.Unlock();
4715 MU.Lock();
4719 MU.Unlock();
4723 MU.Lock();
4725 CV.Wait(&MU);
4727 MU.Unlock();
4729 MU.Lock();
4731 CV.Wait(&MU);
4733 MU.Unlock();
4753 Mutex MU;
4797 Mutex MU[N_MUTEXES];
4810 MU[m].Lock();
4816 MU[m].Unlock();
4998 Mutex mu;
5009 mu.LockWhen(Condition(&ArgIsTrue, &COND));
5010 mu.Unlock();
5030 mu.Lock();
5032 mu.Unlock();
5048 Mutex mu;
5049 bool ready = false; // under mu
5050 int beg, end; // under mu
5059 mu.Lock();
5063 mu.Unlock();
5087 mu.Lock();
5091 mu.Unlock();
5128 Mutex MU[kNumLocks];
5133 if (i & (1 << j)) MU[j].Lock();
5136 if (i & (1 << j)) MU[j].Unlock();
5327 static Mutex mu;
5332 MutexLock lock(&mu);
5378 Mutex mu;
5386 MutexLock lock(&mu);
5573 Mutex mu;
5575 mu.Lock();
5580 mu.Unlock();
5593 Mutex mu;
5597 mu.Lock();
5599 mu.Unlock();
5616 Mutex MU;
5623 MU.ReaderLockWhen(Condition(WeirdCondition, ¶m));
5624 MU.ReaderUnlock();
5630 MU.Lock();
5632 MU.Unlock(); // calls ANNOTATE_CONDVAR_SIGNAL;
5785 Mutex mu;
5796 // much simpler to apply pure-happens-before mode to the mutex mu.
5799 MutexLock lock(&mu);
5808 MutexLock lock(&mu);
5817 // ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(&mu);
6123 Mutex mu;
6129 mu.Lock();
6132 mu.Unlock();
6136 mu.Lock();
6138 cv.Wait(&mu);
6139 ANNOTATE_CONDVAR_LOCK_WAIT(&cv, &mu);
6141 mu.Unlock();
6146 mu.Lock();
6148 mu.Unlock();
6883 static Mutex mu;
6884 static vector<int> *vec; // GUARDED_BY(mu);
6893 MutexLock lock(&mu);
6898 MutexLock lock(&mu);
6904 MutexLock lock(&mu);
6916 // 2. Call ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(&mu)
6930 mu.LockWhen(Condition(NoElementsLeft, vec));
6931 mu.Unlock();
7013 Mutex MU;
7018 MU.Lock();
7020 MU.Unlock();
7170 Mutex mu[N_MUTEXES];
7181 Mutex *m = & mu[mutex_id];
7214 Mutex MU;
7218 MU.Lock();
7220 MU.Unlock();
7332 Mutex * mu = new Mutex();
7333 mu_list.push_back(mu);
7334 mu->Lock();
7337 Mutex * mu = mu_list[i];
7338 mu->Unlock();
7339 delete mu;
7406 Mutex mu[N_MUTEXES];
7414 mu[m].Lock();
7421 mu[m].Unlock();
7566 Mutex mu;
7571 mu.Lock();
7572 mu.Unlock();
7578 mu.Lock();
7579 mu.Unlock();
7584 ANNOTATE_NOT_HAPPENS_BEFORE_MUTEX(&mu);
