| /external/curl/tests/data/ |
| D | test1554 | 22 -> Mutex lock
23 <- Mutex unlock
24 -> Mutex lock
25 <- Mutex unlock
26 -> Mutex lock
27 <- Mutex unlock
28 -> Mutex lock
29 <- Mutex unlock
30 -> Mutex lock
31 <- Mutex unlock
[all …]
|
| /external/guava/android/guava/src/com/google/common/collect/ |
| D | Synchronized.java | 47 * backing collection and the mutex are serializable.
49 * <p>If {@code null} is passed as the {@code mutex} parameter to any of this class's top-level
50 * methods or inner class constructors, the created object uses itself as the synchronization mutex.
63 final Object mutex; field in Synchronized.SynchronizedObject
65 SynchronizedObject(Object delegate, @NullableDecl Object mutex) { in SynchronizedObject() argument
67 this.mutex = (mutex == null) ? this : mutex; in SynchronizedObject()
78 synchronized (mutex) { in toString()
90 synchronized (mutex) { in writeObject()
100 Collection<E> collection, @NullableDecl Object mutex) { in collection() argument
101 return new SynchronizedCollection<E>(collection, mutex); in collection()
[all …]
|
| /external/guava/guava/src/com/google/common/collect/ |
| D | Synchronized.java | 55 * backing collection and the mutex are serializable.
57 * <p>If {@code null} is passed as the {@code mutex} parameter to any of this class's top-level
58 * methods or inner class constructors, the created object uses itself as the synchronization mutex.
71 final Object mutex; field in Synchronized.SynchronizedObject
73 SynchronizedObject(Object delegate, @Nullable Object mutex) { in SynchronizedObject() argument
75 this.mutex = (mutex == null) ? this : mutex; in SynchronizedObject()
86 synchronized (mutex) { in toString()
98 synchronized (mutex) { in writeObject()
107 private static <E> Collection<E> collection(Collection<E> collection, @Nullable Object mutex) { in collection() argument
108 return new SynchronizedCollection<E>(collection, mutex); in collection()
[all …]
|
| /external/kotlinx.coroutines/kotlinx-coroutines-core/common/test/sync/ |
| D | MutexTest.kt | 13 val mutex = Mutex() in <lambda>() constant
17 mutex.lock() // suspends in <lambda>()
19 mutex.unlock() in <lambda>()
23 mutex.lock() // locked in <lambda>()
27 mutex.unlock() in <lambda>()
35 val mutex = Mutex() in tryLockTest() constant
36 assertFalse(mutex.isLocked) in tryLockTest()
37 assertTrue(mutex.tryLock()) in tryLockTest()
38 assertTrue(mutex.isLocked) in tryLockTest()
39 assertFalse(mutex.tryLock()) in tryLockTest()
[all …]
|
| /external/rust/crates/grpcio-sys/grpc/third_party/re2/util/ |
| D | mutex.h | 9 * A simple mutex wrapper, supporting locks and read-write locks.
36 #include <mutex>
37 typedef std::mutex MutexType;
42 class Mutex {
44 inline Mutex();
45 inline ~Mutex();
53 inline void ReaderUnlock(); // Release a read share of this Mutex
60 // Catch the error of writing Mutex when intending MutexLock.
61 Mutex(Mutex *ignored);
63 Mutex(const Mutex&) = delete;
[all …]
|
| /external/llvm-project/clang/test/SemaCXX/ |
| D | warn-thread-safety-analysis.cpp | 11 class LOCKABLE Mutex { class
26 const Mutex& operator!() const { return *this; } in operator !()
34 MutexLock(Mutex *mu) EXCLUSIVE_LOCK_FUNCTION(mu);
35 MutexLock(Mutex *mu, bool adopt) EXCLUSIVE_LOCKS_REQUIRED(mu);
41 ReaderMutexLock(Mutex *mu) SHARED_LOCK_FUNCTION(mu);
42 ReaderMutexLock(Mutex *mu, bool adopt) SHARED_LOCKS_REQUIRED(mu);
48 ReleasableMutexLock(Mutex *mu) EXCLUSIVE_LOCK_FUNCTION(mu);
56 DoubleMutexLock(Mutex *mu1, Mutex *mu2) EXCLUSIVE_LOCK_FUNCTION(mu1, mu2);
126 Mutex sls_mu;
128 Mutex sls_mu2 __attribute__((acquired_after(sls_mu)));
[all …]
|
| /external/gflags/src/ |
| D | mutex.h | 32 // A simple mutex wrapper, supporting locks and read-write locks.
40 // problems when we have multiple versions of Mutex in each shared object.
64 // function that tries to acquire this mutex -- but that all happens
65 // before this mutex's constructor has run. (This can happen even if
66 // the mutex and the function that uses the mutex are in the same .cc
67 // file.) Basically, because Mutex does non-trivial work in its
71 // The solution used here is to pair the actual mutex primitive with a
72 // bool that is set to true when the mutex is dynamically initialized.
73 // (Before that it's false.) Then we modify all mutex routines to
75 // it to true (which happens after the Mutex constructor has run.)
[all …]
|
| /external/rust/crates/tokio/src/sync/ |
| D | mutex.rs | 11 /// An asynchronous `Mutex`-like type.
13 /// This type acts similarly to [`std::sync::Mutex`], with two major
17 /// # Which kind of mutex should you use?
20 /// [`Mutex`][std] from the standard library in asynchronous code.
22 /// The feature that the async mutex offers over the blocking mutex is the
24 /// mutex more expensive than the blocking mutex, so the blocking mutex should
26 /// async mutex is to provide shared mutable access to IO resources such as a
27 /// database connection. If the value behind the mutex is just data, it's
28 /// usually appropriate to use a blocking mutex such as the one in the standard
31 /// Note that, although the compiler will not prevent the std `Mutex` from holding
[all …]
|
| /external/clang/test/SemaCXX/ |
| D | warn-thread-safety-analysis.cpp | 30 class LOCKABLE Mutex { class
40 const Mutex& operator!() const { return *this; } in operator !()
48 MutexLock(Mutex *mu) EXCLUSIVE_LOCK_FUNCTION(mu);
49 MutexLock(Mutex *mu, bool adopt) EXCLUSIVE_LOCKS_REQUIRED(mu);
55 ReaderMutexLock(Mutex *mu) SHARED_LOCK_FUNCTION(mu);
56 ReaderMutexLock(Mutex *mu, bool adopt) SHARED_LOCKS_REQUIRED(mu);
62 ReleasableMutexLock(Mutex *mu) EXCLUSIVE_LOCK_FUNCTION(mu);
70 DoubleMutexLock(Mutex *mu1, Mutex *mu2)
141 Mutex sls_mu;
143 Mutex sls_mu2 __attribute__((acquired_after(sls_mu)));
[all …]
|
| /external/pigweed/pw_sync/ |
| D | mutex_facade_test.cc | 18 #include "pw_sync/mutex.h"
26 void pw_sync_Mutex_CallLock(pw_sync_Mutex* mutex);
27 bool pw_sync_Mutex_CallTryLock(pw_sync_Mutex* mutex);
28 void pw_sync_Mutex_CallUnlock(pw_sync_Mutex* mutex);
34 TEST(Mutex, LockUnlock) { in TEST() argument
35 pw::sync::Mutex mutex; in TEST() local
36 mutex.lock(); in TEST()
38 // EXPECT_FALSE(mutex.try_lock()); in TEST()
39 mutex.unlock(); in TEST()
42 Mutex static_mutex;
[all …]
|
| D | timed_mutex_facade_test.cc | 30 void pw_sync_TimedMutex_CallLock(pw_sync_TimedMutex* mutex);
31 bool pw_sync_TimedMutex_CallTryLock(pw_sync_TimedMutex* mutex);
33 pw_sync_TimedMutex* mutex, pw_chrono_SystemClock_Duration for_at_least);
35 pw_sync_TimedMutex* mutex, pw_chrono_SystemClock_TimePoint until_at_least);
36 void pw_sync_TimedMutex_CallUnlock(pw_sync_TimedMutex* mutex);
51 pw::sync::TimedMutex mutex; in TEST() local
52 mutex.lock(); in TEST()
54 // EXPECT_FALSE(mutex.try_lock()); in TEST()
55 mutex.unlock(); in TEST()
67 pw::sync::TimedMutex mutex; in TEST() local
[all …]
|
| /external/rust/crates/futures-util/src/lock/ |
| D | mutex.rs | 9 use std::sync::Mutex as StdMutex;
12 /// A futures-aware mutex.
16 /// This mutex provides no fairness guarantees. Tasks may not acquire the mutex
20 pub struct Mutex<T: ?Sized> { struct
26 impl<T: ?Sized> fmt::Debug for Mutex<T> { argument
29 f.debug_struct("Mutex") in fmt()
36 impl<T> From<T> for Mutex<T> { implementation
42 impl<T: Default> Default for Mutex<T> { implementation
73 impl<T> Mutex<T> { impl
74 /// Creates a new futures-aware mutex.
[all …]
|
| /external/angle/third_party/abseil-cpp/absl/synchronization/ |
| D | mutex.h | 16 // mutex.h
19 // This header file defines a `Mutex` -- a mutually exclusive lock -- and the
21 // shared resources. A mutex is used to prevent multiple threads from accessing
24 // Unlike a `std::mutex`, the Abseil `Mutex` provides the following additional
26 // * Conditional predicates intrinsic to the `Mutex` object
32 // MutexLock - An RAII wrapper to acquire and release a `Mutex` for exclusive/
36 // - An RAII wrapper to acquire and release a `Mutex` for shared/read
43 // In addition to simple mutex locks, this file also defines ways to perform
47 // depends on state protected by the `Mutex` to become true.
54 // Mutexes and mutex behavior can be quite complicated. The information within
[all …]
|
| /external/openscreen/third_party/abseil/src/absl/synchronization/ |
| D | mutex.h | 16 // mutex.h
19 // This header file defines a `Mutex` -- a mutually exclusive lock -- and the
21 // shared resources. A mutex is used to prevent multiple threads from accessing
24 // Unlike a `std::mutex`, the Abseil `Mutex` provides the following additional
26 // * Conditional predicates intrinsic to the `Mutex` object
32 // MutexLock - An RAII wrapper to acquire and release a `Mutex` for exclusive/
36 // - An RAII wrapper to acquire and release a `Mutex` for shared/read
43 // In addition to simple mutex locks, this file also defines ways to perform
47 // depends on state protected by the `Mutex` to become true.
54 // Mutexes and mutex behavior can be quite complicated. The information within
[all …]
|
| /external/libtextclassifier/abseil-cpp/absl/synchronization/ |
| D | mutex.h | 16 // mutex.h
19 // This header file defines a `Mutex` -- a mutually exclusive lock -- and the
21 // shared resources. A mutex is used to prevent multiple threads from accessing
24 // Unlike a `std::mutex`, the Abseil `Mutex` provides the following additional
26 // * Conditional predicates intrinsic to the `Mutex` object
32 // MutexLock - An RAII wrapper to acquire and release a `Mutex` for exclusive/
35 // - An RAII wrapper to acquire and release a `Mutex` for shared/read
42 // In addition to simple mutex locks, this file also defines ways to perform
46 // depends on state protected by the `Mutex` to become true.
53 // Mutexes and mutex behavior can be quite complicated. The information within
[all …]
|
| /external/rust/crates/grpcio-sys/grpc/third_party/abseil-cpp/absl/synchronization/ |
| D | mutex.h | 16 // mutex.h
19 // This header file defines a `Mutex` -- a mutually exclusive lock -- and the
21 // shared resources. A mutex is used to prevent multiple threads from accessing
24 // Unlike a `std::mutex`, the Abseil `Mutex` provides the following additional
26 // * Conditional predicates intrinsic to the `Mutex` object
32 // MutexLock - An RAII wrapper to acquire and release a `Mutex` for exclusive/
35 // - An RAII wrapper to acquire and release a `Mutex` for shared/read
42 // In addition to simple mutex locks, this file also defines ways to perform
46 // depends on state protected by the `Mutex` to become true.
53 // Mutexes and mutex behavior can be quite complicated. The information within
[all …]
|
| /external/abseil-cpp/absl/synchronization/ |
| D | mutex.h | 16 // mutex.h
19 // This header file defines a `Mutex` -- a mutually exclusive lock -- and the
21 // shared resources. A mutex is used to prevent multiple threads from accessing
24 // Unlike a `std::mutex`, the Abseil `Mutex` provides the following additional
26 // * Conditional predicates intrinsic to the `Mutex` object
32 // MutexLock - An RAII wrapper to acquire and release a `Mutex` for exclusive/
35 // - An RAII wrapper to acquire and release a `Mutex` for shared/read
42 // In addition to simple mutex locks, this file also defines ways to perform
46 // depends on state protected by the `Mutex` to become true.
53 // Mutexes and mutex behavior can be quite complicated. The information within
[all …]
|
| /external/webrtc/third_party/abseil-cpp/absl/synchronization/ |
| D | mutex.h | 16 // mutex.h
19 // This header file defines a `Mutex` -- a mutually exclusive lock -- and the
21 // shared resources. A mutex is used to prevent multiple threads from accessing
24 // Unlike a `std::mutex`, the Abseil `Mutex` provides the following additional
26 // * Conditional predicates intrinsic to the `Mutex` object
32 // MutexLock - An RAII wrapper to acquire and release a `Mutex` for exclusive/
35 // - An RAII wrapper to acquire and release a `Mutex` for shared/read
42 // In addition to simple mutex locks, this file also defines ways to perform
46 // depends on state protected by the `Mutex` to become true.
53 // Mutexes and mutex behavior can be quite complicated. The information within
[all …]
|
| /external/rust/crates/parking_lot/src/ |
| D | mutex.rs | 13 /// This mutex will block threads waiting for the lock to become available. The
14 /// mutex can also be statically initialized or created via a `new`
15 /// constructor. Each mutex has a type parameter which represents the data that
18 /// ever accessed when the mutex is locked.
23 /// quickly acquires and releases the same mutex in succession, which can starve
24 /// other threads waiting to acquire the mutex. While this improves throughput
26 /// a mutex it has just released, this can starve other threads.
28 /// This mutex uses [eventual fairness](https://trac.webkit.org/changeset/203350)
31 /// which will force the lock to go to the next thread waiting for the mutex.
38 /// unlocking a mutex instead of simply dropping the `MutexGuard`.
[all …]
|
| /external/rust/crates/lock_api/src/ |
| D | mutex.rs | 20 /// Basic operations for a mutex.
22 /// Types implementing this trait can be used by `Mutex` to form a safe and
23 /// fully-functioning mutex type.
27 /// Implementations of this trait must ensure that the mutex is actually
28 /// exclusive: a lock can't be acquired while the mutex is already locked.
30 /// Initial value for an unlocked mutex.
40 /// Acquires this mutex, blocking the current thread until it is able to do so.
43 /// Attempts to acquire this mutex without blocking. Returns `true`
47 /// Unlocks this mutex.
51 /// This method may only be called if the mutex is held in the current context, i.e. it must
[all …]
|
| /external/jemalloc_new/include/jemalloc/internal/ |
| D | mutex.h | 10 /* Can only acquire one mutex of a given witness rank at a time. */
25 * bouncing: the data is not touched by the mutex holder
27 * contenders. Having it before the mutex itself could
106 WITNESS_INITIALIZER("mutex", WITNESS_RANK_OMIT)}
110 WITNESS_INITIALIZER("mutex", WITNESS_RANK_OMIT)}
114 WITNESS_INITIALIZER("mutex", WITNESS_RANK_OMIT)}
119 WITNESS_INITIALIZER("mutex", WITNESS_RANK_OMIT)}
129 bool malloc_mutex_init(malloc_mutex_t *mutex, const char *name,
131 void malloc_mutex_prefork(tsdn_t *tsdn, malloc_mutex_t *mutex);
132 void malloc_mutex_postfork_parent(tsdn_t *tsdn, malloc_mutex_t *mutex);
[all …]
|
| /external/ltp/testcases/open_posix_testsuite/conformance/interfaces/pthread_mutex_setprioceiling/ |
| D | assertions.xml | 3 …The pthread_mutex_getprioceiling() function shall return the current priority ceiling of the mutex.
4 …tion shall attempt to lock the mutex as if by a call to pthread_mutex_lock(), except that the proc…
5 …iii. On acquiring the mutex it shall change the mutex's priority ceiling and then release the mute…
14 The protocol attribute of mutex is PTHREAD_PRIO_NONE.
18 …The mutex could not be acquired because the maximum number of recursive locks for mutex has been e…
20 The mutex type is PTHREAD_MUTEX_ERRORCHECK and the current thread already owns the mutex.
22 …mutex was created with the protocol attribute having the value PTHREAD_PRIO_PROTECT and the callin…
24 The mutex is a robust mutex and the state protected by the mutex is not recoverable.
26 …The mutex is a robust mutex and the process containing the previous owning thread terminated while…
35 …The mutex is a robust mutex and the previous owning thread terminated while holding the mutex lock…
|
| /external/libcups/cups/ |
| D | thread.c | 47 _cups_mutex_t *mutex, /* I - Mutex */ in _cupsCondWait() argument
65 pthread_cond_timedwait(cond, mutex, &abstime); in _cupsCondWait()
68 pthread_cond_wait(cond, mutex); in _cupsCondWait()
73 * '_cupsMutexInit()' - Initialize a mutex.
77 _cupsMutexInit(_cups_mutex_t *mutex) /* I - Mutex */ in _cupsMutexInit() argument
79 pthread_mutex_init(mutex, NULL); in _cupsMutexInit()
84 * '_cupsMutexLock()' - Lock a mutex.
88 _cupsMutexLock(_cups_mutex_t *mutex) /* I - Mutex */ in _cupsMutexLock() argument
90 pthread_mutex_lock(mutex); in _cupsMutexLock()
95 * '_cupsMutexUnlock()' - Unlock a mutex.
[all …]
|
| /external/bcc/tools/ |
| D | deadlock_detector_example.txt | 5 a mutex wait directed graph, and then looks for a cycle in this graph. This
14 program will dump the cycle of mutexes, dump the stack traces where each mutex
21 Since this traces all mutex lock and unlock events and all thread creation
32 For recursive mutexes, lock() is called multiple times on the same mutex.
33 However, there is no way to determine if a mutex is a recursive mutex
34 after the mutex has been created. As a result, this tool will not find
35 potential deadlocks that involve only one mutex.
43 …Mutex M0 (main::static_mutex3 0x0000000000473c60) => Mutex M1 (0x00007fff6d738400) => Mutex M2 (gl…
45 Mutex M1 (0x00007fff6d738400) acquired here while holding Mutex M0 (main::static_mutex3 0x000000000…
47 @ 0000000000406dd0 std::mutex::lock()
[all …]
|
| /external/guava/android/guava-tests/test/com/google/common/collect/ |
| D | SynchronizedNavigableMapTest.java | 48 TestMap<K, V> inner = new TestMap<>(innermost, mutex); in create()
49 NavigableMap<K, V> outer = Synchronized.navigableMap(inner, mutex); in create()
55 private final Object mutex; field in SynchronizedNavigableMapTest.TestEntry
57 TestEntry(Entry<K, V> delegate, Object mutex) { in TestEntry() argument
59 this.mutex = mutex; in TestEntry()
69 assertTrue(Thread.holdsLock(mutex)); in equals()
75 assertTrue(Thread.holdsLock(mutex)); in getKey()
81 assertTrue(Thread.holdsLock(mutex)); in getValue()
87 assertTrue(Thread.holdsLock(mutex)); in hashCode()
93 assertTrue(Thread.holdsLock(mutex)); in setValue()
[all …]
|