| /external/clang/test/Modules/Inputs/thread-safety/ |
| a.h | 1 struct __attribute__((lockable)) mutex { struct
|
| /external/valgrind/memcheck/tests/darwin/ |
| pth-supp.c | 6 pthread_rwlock_t mutex; local
7 pthread_rwlock_init(&mutex, NULL);
|
| /external/libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/ |
| try_lock_until.pass.cpp | 14 // template <class Mutex> class shared_lock;
26 struct mutex struct
39 mutex m;
47 std::shared_lock<mutex> lk(m, std::defer_lock);
|
| try_lock.pass.cpp | 14 // template <class Mutex> class shared_lock;
25 struct mutex struct
35 mutex m;
42 std::shared_lock<mutex> lk(m, std::defer_lock);
|
| try_lock_for.pass.cpp | 14 // template <class Mutex> class shared_lock;
28 struct mutex struct
40 mutex m;
47 std::shared_lock<mutex> lk(m, std::defer_lock);
|
| unlock.pass.cpp | 14 // template <class Mutex> class shared_lock;
25 struct mutex struct
31 mutex m;
38 std::shared_lock<mutex> lk(m);
|
| /external/libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/ |
| try_lock_until.pass.cpp | 12 // <mutex>
14 // template <class Mutex> class unique_lock;
19 #include <mutex>
24 struct mutex struct
37 mutex m;
42 std::unique_lock<mutex> lk(m, std::defer_lock);
|
| try_lock.pass.cpp | 12 // <mutex>
14 // template <class Mutex> class unique_lock;
18 #include <mutex>
23 struct mutex struct
33 mutex m;
37 std::unique_lock<mutex> lk(m, std::defer_lock);
|
| try_lock_for.pass.cpp | 12 // <mutex>
14 // template <class Mutex> class unique_lock;
19 #include <mutex>
26 struct mutex struct
38 mutex m;
42 std::unique_lock<mutex> lk(m, std::defer_lock);
|
| unlock.pass.cpp | 12 // <mutex>
14 // template <class Mutex> class unique_lock;
18 #include <mutex>
23 struct mutex struct
29 mutex m;
33 std::unique_lock<mutex> lk(m);
|
| /external/parameter-framework/asio-1.10.6/include/asio/detail/ |
| mutex.hpp | 2 // detail/mutex.hpp
27 typedef posix_mutex mutex; typedef in namespace:asio::detail
29 typedef std_mutex mutex;
|
| /external/valgrind/drd/tests/ |
| pth_process_shared_mutex.c | 2 * Test program that locks and unlocks a process-shared mutex.
15 pthread_mutex_t mutex; local
20 pthread_mutex_init(&mutex, &attr);
23 pthread_mutex_lock(&mutex);
24 pthread_mutex_unlock(&mutex);
25 pthread_mutex_destroy(&mutex);
|
| trylock.c | 22 pthread_mutex_t mutex; local
63 r = pthread_mutex_init(&mutex, NULL); assert(r == 0);
64 fprintf(stderr, "Locking mutex via pthread_mutex_trylock().\n");
65 r = pthread_mutex_trylock(&mutex); assert(r == 0);
66 r = pthread_mutex_unlock(&mutex); assert(r == 0);
67 fprintf(stderr, "Locking mutex via pthread_mutex_lock().\n");
68 r = pthread_mutex_lock(&mutex); assert(r == 0);
69 r = pthread_mutex_unlock(&mutex); assert(r == 0);
70 fprintf(stderr, "Locking mutex via pthread_mutex_timedlock().\n");
72 r = pthread_mutex_timedlock(&mutex, &abs_timeout); assert(r == 0)
[all...] |
| /external/valgrind/helgrind/tests/ |
| cond_timedwait_invalid.c | 10 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; local
21 assert(pthread_mutex_lock(&mutex)==0);
22 assert(pthread_cond_timedwait(&cond, &mutex, &abstime)==EINVAL);
23 assert(pthread_mutex_unlock(&mutex)==0);
|
| cond_timedwait_test.c | 5 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; local
12 pthread_mutex_lock(&mutex);
13 pthread_cond_timedwait(&cond, &mutex, &now);
14 pthread_mutex_unlock(&mutex);
16 pthread_mutex_destroy(&mutex);
|
| /ndk/sources/cxx-stl/llvm-libc++/libcxx/test/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/ |
| try_lock_until.pass.cpp | 12 // template <class Mutex> class shared_lock;
24 struct mutex struct
37 mutex m;
45 std::shared_lock<mutex> lk(m, std::defer_lock);
|
| /ndk/sources/cxx-stl/llvm-libc++/libcxx/test/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/ |
| try_lock_until.pass.cpp | 10 // <mutex>
12 // template <class Mutex> class unique_lock;
17 #include <mutex>
22 struct mutex struct
35 mutex m;
40 std::unique_lock<mutex> lk(m, std::defer_lock);
|
| /system/bt/service/common/bluetooth/util/ |
| atomic_string.cpp | 26 std::mutex* mutex = const_cast<std::mutex*>(&lock_); local
27 std::lock_guard<std::mutex> lock(*mutex);
32 std::lock_guard<std::mutex> lock(lock_);
|
| /external/compiler-rt/test/tsan/ |
| signal_cond.cc | 12 pthread_mutex_t mutex; variable
22 pthread_mutex_lock(&mutex);
24 pthread_cond_wait(&cond, &mutex);
25 pthread_mutex_unlock(&mutex);
32 pthread_mutex_init(&mutex, 0);
43 pthread_mutex_lock(&mutex);
46 pthread_mutex_unlock(&mutex);
|
| /external/libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/ |
| member_swap.pass.cpp | 14 // template <class Mutex> class shared_lock;
23 struct mutex struct
29 mutex m;
36 std::shared_lock<mutex> lk1(m);
37 std::shared_lock<mutex> lk2;
39 assert(lk1.mutex() == nullptr);
41 assert(lk2.mutex() == &m);
|
| nonmember_swap.pass.cpp | 14 // template <class Mutex> class shared_lock;
16 // template <class Mutex>
17 // void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
24 struct mutex struct
30 mutex m;
37 std::shared_lock<mutex> lk1(m);
38 std::shared_lock<mutex> lk2;
40 assert(lk1.mutex() == nullptr);
42 assert(lk2.mutex() == &m)
[all...] |
| release.pass.cpp | 14 // template <class Mutex> class shared_lock;
23 struct mutex struct
31 int mutex::lock_count = 0;
32 int mutex::unlock_count = 0;
34 mutex m;
41 std::shared_lock<mutex> lk(m);
42 assert(lk.mutex() == &m);
44 assert(mutex::lock_count == 1);
45 assert(mutex::unlock_count == 0);
47 assert(lk.mutex() == nullptr)
[all...] |
| /external/libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/ |
| member_swap.pass.cpp | 12 // <mutex>
14 // template <class Mutex> class unique_lock;
18 #include <mutex>
21 struct mutex struct
27 mutex m;
31 std::unique_lock<mutex> lk1(m);
32 std::unique_lock<mutex> lk2;
34 assert(lk1.mutex() == nullptr);
36 assert(lk2.mutex() == &m);
|
| nonmember_swap.pass.cpp | 12 // <mutex>
14 // template <class Mutex> class unique_lock;
16 // template <class Mutex>
17 // void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y);
19 #include <mutex>
22 struct mutex struct
28 mutex m;
32 std::unique_lock<mutex> lk1(m);
33 std::unique_lock<mutex> lk2
[all...] |
| release.pass.cpp | 12 // <mutex>
14 // template <class Mutex> class unique_lock;
18 #include <mutex>
21 struct mutex struct
29 int mutex::lock_count = 0;
30 int mutex::unlock_count = 0;
32 mutex m;
36 std::unique_lock<mutex> lk(m);
37 assert(lk.mutex() == &m);
39 assert(mutex::lock_count == 1)
[all...] |
