| /hardware/qcom/media/msmcobalt/mm-video-v4l2/vidc/vdec/src/ |
| message_queue.c | 73 /* Lock the mutex to protect the critical section */
74 pthread_mutex_lock(&ptr_q->mutex);
86 /* Unlock the mutex to release the critical section */
87 pthread_mutex_unlock(&ptr_q->mutex);
105 /* Lock the mutex to protect the critical section */
106 pthread_mutex_lock(&ptr_q->mutex);
110 /* Unlock the mutex to release the critical section */
111 pthread_mutex_unlock(&ptr_q->mutex);
120 /* Unlock the mutex to release the critical section */
121 pthread_mutex_unlock(&ptr_q->mutex);
[all...] |
| /ndk/sources/cxx-stl/llvm-libc++/libcxx/src/ |
| mutex.cpp | 1 //===------------------------- mutex.cpp ----------------------------------===//
11 #include "mutex"
23 mutex::~mutex()
29 mutex::lock()
33 __throw_system_error(ec, "mutex lock failed");
37 mutex::try_lock() _NOEXCEPT
43 mutex::unlock() _NOEXCEPT
119 lock_guard<mutex> _(__m_);
125 unique_lock<mutex> lk(__m_)
[all...] |
| condition_variable.cpp | 37 condition_variable::wait(unique_lock<mutex>& lk) _NOEXCEPT
41 "condition_variable::wait: mutex not locked");
42 int ec = pthread_cond_wait(&__cv_, lk.mutex()->native_handle());
48 condition_variable::__do_timed_wait(unique_lock<mutex>& lk,
54 "condition_variable::timed wait: mutex not locked");
72 int ec = pthread_cond_timedwait(&__cv_, lk.mutex()->native_handle(), &ts);
78 notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk)
|
| /ndk/sources/cxx-stl/llvm-libc++/libcxx/test/thread/thread.mutex/thread.lock/thread.lock.shared/ |
| types.pass.cpp | 12 // template <class Mutex>
16 // typedef Mutex mutex_type;
26 static_assert((std::is_same<std::shared_lock<std::mutex>::mutex_type,
27 std::mutex>::value), "");
|
| /ndk/sources/cxx-stl/llvm-libc++/libcxx/test/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/ |
| native_handle.pass.cpp | 10 // <mutex>
12 // class mutex;
17 #include <mutex>
22 std::mutex m;
|
| /system/core/include/utils/ |
| Condition.h | 29 #include <utils/Mutex.h>
39 * Condition variables are paired up with mutexes. Lock the mutex,
41 * or unlock the mutex and continue. All threads calling wait() must
42 * use the same mutex for a given Condition.
59 // Wait on the condition variable. Lock the mutex before calling.
60 status_t wait(Mutex& mutex);
62 status_t waitRelative(Mutex& mutex, nsecs_t reltime);
105 inline status_t Condition::wait(Mutex& mutex)
[all...] |
| /system/core/libmemunreachable/ |
| Semaphore.h | 21 #include <mutex>
31 std::unique_lock<std::mutex> lk(m_);
42 std::lock_guard<std::mutex> lk(m_);
51 std::mutex m_;
|
| /art/runtime/base/ |
| mutex.h | 51 // LockLevel is used to impose a lock hierarchy [1] where acquisition of a Mutex at a higher or
140 // Base class for all Mutex implementations
184 // Number of times the Mutex has been contended.
202 // A Mutex is used to achieve mutual exclusion between threads. A Mutex can be used to gain
203 // exclusive access to what it guards. A Mutex can be in one of two states:
212 // * Mutex is not reentrant and so an attempt to ExclusiveLock on the same thread will result in
214 std::ostream& operator<<(std::ostream& os, const Mutex& mu);
215 class LOCKABLE Mutex : public BaseMutex {
217 explicit Mutex(const char* name, LockLevel level = kDefaultMutexLevel, bool recursive = false)
[all...] |
| /external/libcxx/src/ |
| condition_variable.cpp | 39 condition_variable::wait(unique_lock<mutex>& lk) _NOEXCEPT
43 "condition_variable::wait: mutex not locked");
44 int ec = pthread_cond_wait(&__cv_, lk.mutex()->native_handle());
50 condition_variable::__do_timed_wait(unique_lock<mutex>& lk,
56 "condition_variable::timed wait: mutex not locked");
74 int ec = pthread_cond_timedwait(&__cv_, lk.mutex()->native_handle(), &ts);
80 notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk)
|
| /external/libcxx/test/std/thread/thread.condition/thread.condition.condvar/ |
| notify_one.pass.cpp | 19 #include <mutex>
24 std::mutex mut;
32 std::unique_lock<std::mutex> lk(mut);
42 std::unique_lock<std::mutex> lk(mut);
56 std::unique_lock<std::mutex>lk(mut);
63 std::unique_lock<std::mutex>lk(mut);
80 std::unique_lock<std::mutex>lk(mut);
|
| wait.pass.cpp | 16 // void wait(unique_lock<mutex>& lock);
19 #include <mutex>
24 std::mutex mut;
31 std::unique_lock<std::mutex> lk(mut);
42 std::unique_lock<std::mutex>lk(mut);
|
| wait_pred.pass.cpp | 17 // void wait(unique_lock<mutex>& lock, Predicate pred);
20 #include <mutex>
26 std::mutex mut;
42 std::unique_lock<std::mutex> lk(mut);
52 std::unique_lock<std::mutex>lk(mut);
|
| /external/opencv3/3rdparty/openexr/IlmThread/ |
| IlmThreadMutex.cpp | 37 // class Mutex, class Lock -- dummy implementation
51 Mutex::Mutex () {}
52 Mutex::~Mutex () {}
53 void Mutex::lock () const {}
54 void Mutex::unlock () const {}
|
| IlmThreadMutexWin32.cpp | 37 // class Mutex -- implementation for Windows
47 Mutex::Mutex ()
53 Mutex::~Mutex ()
60 Mutex::lock () const
67 Mutex::unlock () const
|
| IlmThreadMutexPosix.cpp | 37 // class Mutex -- implementation for
53 Mutex::Mutex ()
56 Iex::throwErrnoExc ("Cannot initialize mutex (%T).", error);
60 Mutex::~Mutex ()
68 Mutex::lock () const
71 Iex::throwErrnoExc ("Cannot lock mutex (%T).", error);
76 Mutex::unlock () const
79 Iex::throwErrnoExc ("Cannot unlock mutex (%T).", error)
[all...] |
| /frameworks/av/media/libstagefright/ |
| MediaAdapter.cpp | 34 Mutex::Autolock autoLock(mAdapterLock);
40 Mutex::Autolock autoLock(mAdapterLock);
48 Mutex::Autolock autoLock(mAdapterLock);
64 Mutex::Autolock autoLock(mAdapterLock);
69 Mutex::Autolock autoLock(mAdapterLock);
79 Mutex::Autolock autoLock(mAdapterLock);
111 Mutex::Autolock autoLock(mAdapterLock);
|
| /hardware/ti/omap4-aah/security/tf_crypto_sst/ |
| lib_mutex.h | 35 * This libray defines a type of simple non-recursive mutex that can
69 /* Linux: directly use a pthread mutex. */
76 * Initialize a mutex. Note that thie function cannot fail. If there
77 * is not enough resource to initialize the mutex, the implementation
83 * Lock the mutex
88 * Unlock the mutex
93 * Destroy the mutex
|
| /hardware/ti/omap4xxx/security/tf_crypto_sst/ |
| lib_mutex.h | 35 * This libray defines a type of simple non-recursive mutex that can
69 /* Linux: directly use a pthread mutex. */
76 * Initialize a mutex. Note that thie function cannot fail. If there
77 * is not enough resource to initialize the mutex, the implementation
83 * Lock the mutex
88 * Unlock the mutex
93 * Destroy the mutex
|
| /ndk/sources/cxx-stl/llvm-libc++/libcxx/test/thread/thread.condition/thread.condition.condvar/ |
| notify_one.pass.cpp | 17 #include <mutex>
22 std::mutex mut;
30 std::unique_lock<std::mutex> lk(mut);
40 std::unique_lock<std::mutex> lk(mut);
54 std::unique_lock<std::mutex>lk(mut);
61 std::unique_lock<std::mutex>lk(mut);
78 std::unique_lock<std::mutex>lk(mut);
|
| /frameworks/av/services/audiopolicy/service/ |
| AudioPolicyInterfaceImpl.cpp | 49 Mutex::Autolock _l(mLock);
82 Mutex::Autolock _l(mLock);
94 Mutex::Autolock _l(mLock);
114 Mutex::Autolock _l(mLock);
144 Mutex::Autolock _l(mLock);
165 Mutex::Autolock _l(mLock);
190 Mutex::Autolock _l(mLock);
200 Mutex::Autolock _l(mLock);
226 Mutex::Autolock _l(mLock);
236 Mutex::Autolock _l(mLock)
[all...] |
| /packages/apps/Nfc/nxp/jni/ |
| com_android_nfc_list.cpp | 30 if(pthread_mutex_init(&pList->mutex, NULL) == -1)
32 ALOGE("Mutex creation failed (errno=0x%08x)", errno);
46 if(pthread_mutex_destroy(&pList->mutex) == -1)
48 ALOGE("Mutex destruction failed (errno=0x%08x)", errno);
73 pthread_mutex_lock(&pList->mutex);
97 pthread_mutex_unlock(&pList->mutex);
107 pthread_mutex_lock(&pList->mutex);
160 pthread_mutex_unlock(&pList->mutex);
169 pthread_mutex_lock(&pList->mutex);
197 pthread_mutex_unlock(&pList->mutex);
[all...] |
| /art/runtime/ |
| atomic.cc | 18 #include "base/mutex.h"
24 std::vector<Mutex*>* QuasiAtomic::gSwapMutexes = nullptr;
26 Mutex* QuasiAtomic::GetSwapMutex(const volatile int64_t* addr) {
32 gSwapMutexes = new std::vector<Mutex*>;
34 gSwapMutexes->push_back(new Mutex("QuasiAtomic stripe", kSwapMutexesLock));
|
| /build/kati/ |
| thread_pool.cc | 18 #include <mutex>
40 unique_lock<mutex> lock(mu_);
47 unique_lock<mutex> lock(mu_);
64 unique_lock<mutex> lock(mu_);
82 mutex mu_;
|
| /external/dng_sdk/source/ |
| dng_mutex.h | 78 dng_mutex (const dng_mutex &mutex);
80 dng_mutex & operator= (const dng_mutex &mutex);
95 dng_lock_mutex (dng_mutex *mutex);
120 dng_unlock_mutex (dng_mutex *mutex);
149 bool Wait (dng_mutex &mutex, double timeoutSecs = -1.0);
|
| /external/libcxx/test/std/thread/thread.condition/ |
| notify_all_at_thread_exit.pass.cpp | 15 // notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
18 #include <mutex>
24 std::mutex mut;
31 std::unique_lock<std::mutex> lk(mut);
38 std::unique_lock<std::mutex> lk(mut);
|
