| /external/libmojo/mojo/edk/system/ |
| waiter.h | 21 // IMPORTANT (all-caps gets your attention, right?): |Waiter| methods are called
22 // under other locks, in particular, |Dispatcher::lock_|s, so |Waiter| methods
25 class MOJO_SYSTEM_IMPL_EXPORT Waiter final : public Awakable {
27 Waiter();
28 ~Waiter();
30 // A |Waiter| can be used multiple times; |Init()| should be called before
60 // Wake the waiter up with the given result and context (or no-op if it's been
74 DISALLOW_COPY_AND_ASSIGN(Waiter);
|
| waiter.cc | 5 #include "mojo/edk/system/waiter.h"
17 Waiter::Waiter()
27 Waiter::~Waiter() {
30 void Waiter::Init() {
41 MojoResult Waiter::Wait(MojoDeadline deadline, uintptr_t* context) {
87 bool Waiter::Awake(MojoResult result, uintptr_t context) {
|
| waiter_test_utils.h | 15 #include "mojo/edk/system/waiter.h"
22 // This is a very simple thread that has a |Waiter|, on which it waits
24 // |Waiter| on creation, but the caller must start the thread with |Start()|. It
33 // awakable_list.Add(thread.waiter(), ...);
35 // ... some stuff to wake the waiter ...
36 // awakable_list.Remove(thread.waiter());
41 // |Waiter::Init()|, |AddAwakable()|, and |RemoveAwakable()| are done in the
42 // main (test) thread, not the waiter thread (as would actually happen in real
53 Waiter* waiter() { return &waiter_; function in class:mojo::edk::test::SimpleWaiterThread
[all...] |
| wait_set_dispatcher.h | 51 class Waiter;
94 // Waiter used to wait on dispatchers.
95 std::unique_ptr<Waiter> waiter_;
|
| wait_set_dispatcher.cc | 18 class WaitSetDispatcher::Waiter final : public Awakable {
20 explicit Waiter(WaitSetDispatcher* dispatcher) : dispatcher_(dispatcher) {}
21 ~Waiter() {}
42 : waiter_(new WaitSetDispatcher::Waiter(this)) {}
|
| wait_set_dispatcher_unittest.cc | 20 #include "mojo/edk/system/waiter.h"
135 Waiter w;
199 Waiter w;
268 Waiter w;
343 Waiter mp_w;
402 Waiter w;
421 Waiter w;
468 Waiter w;
|
| waiter_unittest.cc | 10 #include "mojo/edk/system/waiter.h"
57 Waiter* waiter() { return &waiter_; } function in class:mojo::edk::__anon25170::WaitingThread
80 Waiter waiter_; // Thread-safe.
102 thread.waiter()->Awake(MOJO_RESULT_OK, 1);
112 thread.waiter()->Awake(MOJO_RESULT_CANCELLED, 2);
125 thread.waiter()->Awake(1, 3);
138 thread.waiter()->Awake(2, 4);
163 thread.waiter()->Awake(MOJO_RESULT_OK, 5);
173 thread.waiter()->Awake(MOJO_RESULT_CANCELLED, 6)
212 Waiter waiter; local
[all...] |
| core.cc | 37 #include "mojo/edk/system/waiter.h"
1129 Waiter waiter; local
[all...] |
| /external/libchrome/base/synchronization/ |
| waitable_event.h | 125 class Waiter {
127 // Signal the waiter to wake up.
129 // Consider the case of a Waiter which is in multiple WaitableEvent's
131 // signaled at the same time. Now, each will wake only the first waiter in
134 // to dequeue the waiter from the other wait-list in time), two auto-resets
135 // will have happened, but only one waiter has been signaled!
137 // Because of this, a Waiter may "reject" a wake by returning false. In
149 virtual ~Waiter() {}
171 bool Dequeue(Waiter* waiter, void* tag)
[all...] |
| waitable_event_posix.cc | 25 // waiter is either an async wait, in which case we have a Task and the
35 // firing a waiter and so we can store that pointer to find out which event
85 // This is a synchronous waiter. The thread is waiting on the given condition
88 class SyncWaiter : public WaitableEvent::Waiter {
277 // enqueued our waiter in them all.
322 // The locks of the WaitableEvents have been taken in order and the Waiter has
326 // None of the WaitableEvent locks are held. The Waiter has not been enqueued
333 Waiter* waiter) {
345 // No events signaled. All locks acquired. Enqueue the Waiter on all of the
[all...] |
| waitable_event_watcher_posix.cc | 58 // This is an asynchronous waiter which posts a task to a SequencedTaskRunner
61 class AsyncWaiter : public WaitableEvent::Waiter {
178 // We have no kernel. This means that we never enqueued a Waiter on an
197 // fired, freed and the memory reused for a different Waiter which was
198 // enqueued in the same wait-list. We would think that that waiter was our
205 // still exists. So if we find a waiter with the correct pointer value, and
208 // Case 2: the waiter hasn't been signaled yet; it was still on the wait
210 // have been enqueued with the MessageLoop because the waiter was never
217 // Case 3: the waiter isn't on the wait-list, thus it was signaled. It may not
219 // task on the SequencedTaskRunner, but to delete it instead. The Waiter
[all...] |
| /external/eigen/unsupported/Eigen/CXX11/src/ThreadPool/ |
| EventCount.h | 22 // EventCount::Waiter& w = waiters[my_index];
45 // operations it is guaranteed than either waiter will see predicate change
47 // the waiter, or both. But it can't happen that both threads don't see each
51 class Waiter;
53 EventCount(MaxSizeVector<Waiter>& waiters) : waiters_(waiters) {
66 // and call either CancelWait or CommitWait passing the same Waiter object.
67 void Prewait(Waiter* w) {
73 void CommitWait(Waiter* w) {
74 w->state = Waiter::kNotSignaled;
75 // Modification epoch of this waiter
[all...] |
| SimpleThreadPool.h | 64 Waiter* w = waiters_.back();
91 Waiter w;
124 struct Waiter {
139 MaxSizeVector<Waiter*> waiters_; // Stack of waiting threads.
|
| NonBlockingThreadPool.h | 128 MaxSizeVector<EventCount::Waiter> waiters_;
141 EventCount::Waiter* waiter = &waiters_[thread_id]; local
160 if (!WaitForWork(waiter, &t)) {
195 bool WaitForWork(EventCount::Waiter* waiter, Task* t) {
199 ec_.Prewait(waiter);
203 ec_.CancelWait(waiter);
212 ec_.CancelWait(waiter);
232 ec_.CommitWait(waiter);
[all...] |
| /libcore/luni/src/test/java/libcore/java/lang/ |
| OldAndroidMonitorTest.java | 110 static class Waiter extends Thread {
115 public Waiter(Object lock, CountDownLatch cdl) {
145 final Waiter waiter = new Waiter(lock, cdl); local
147 waiter.start();
149 // Wait for the "waiter" to start and acquire |lock| for the first time.
156 // Interrupt |waiter| after we acquire |lock|. This ensures that |waiter| is
159 waiter.interrupt()
[all...] |
| /packages/apps/Camera2/src/com/android/camera/one/v2/sharedimagereader/ticketpool/ |
| FiniteTicketPool.java | 57 private class Waiter {
61 private Waiter(int ticketsRequested, Condition condition) {
78 private final LinkedList<Waiter> mWaiters;
103 Waiter nextWaiter = mWaiters.peekFirst();
125 Waiter thisWaiter = new Waiter(tickets, mLock.newCondition());
195 for (Waiter waiter : mWaiters) {
196 waiter.getCondition().signal();
|
| ReservableTicketPool.java | 52 private static class Waiter {
56 private Waiter(Condition doneCondition, int requestedTicketCount) {
128 private final ArrayDeque<Waiter> mTicketWaiters;
307 Waiter thisWaiter = new Waiter(mLock.newCondition(), tickets);
362 Waiter nextWaiter = mTicketWaiters.peek();
381 List<Waiter> toRemove = new ArrayList<>();
382 for (Waiter waiter : mTicketWaiters) {
383 if (waiter.getRequestedTicketCount() > mCapacity)
[all...] |
| /external/glide/library/src/main/java/com/bumptech/glide/request/ |
| RequestFutureTarget.java | 39 private static final Waiter DEFAULT_WAITER = new Waiter();
46 private final Waiter waiter; field in class:RequestFutureTarget
62 RequestFutureTarget(Handler mainHandler, int width, int height, boolean assertBackgroundThread, Waiter waiter) {
67 this.waiter = waiter;
83 waiter.notifyAll(this);
172 waiter.notifyAll(this)
[all...] |
| /external/eigen/unsupported/test/ |
| cxx11_eventcount.cpp | 28 MaxSizeVector<EventCount::Waiter> waiters(1);
31 EventCount::Waiter& w = waiters[0];
85 MaxSizeVector<EventCount::Waiter> waiters(kThreads);
109 EventCount::Waiter& w = waiters[i];
|
| /external/valgrind/drd/tests/ |
| tsan_unittest.cpp | 366 // Waiter: Waker:
380 usleep(100000); // Make sure the waiter blocks.
389 void Waiter() {
402 Waiter();
415 // Waiter: Waker:
428 usleep(100000); // Make sure the waiter blocks.
432 COND = 1; // We are done! Tell the Waiter.
435 void Waiter() {
447 Waiter();
487 // test05: FP. Synchronization via CondVar, but waiter does not block. {{{
[all...] |
| /system/libhidl/transport/ |
| ServiceManagement.cpp | 509 struct Waiter : IServiceNotification {
510 Waiter(const std::string& interface, const std::string& instanceName,
545 ~Waiter() {
548 << "Waiter still registered for notifications, call done() before dropping ref!";
592 // the corresponding service before blocking on the waiter; otherwise, you might run
594 // here, and subsequently calling waiter->wait() will block forever.
600 // done() must be called before dropping the last strong ref to the Waiter, to make
628 sp<Waiter> waiter = new Waiter(interface, instanceName, defaultServiceManager1_1()) local
[all...] |
| /prebuilts/tools/common/m2/repository/com/koushikdutta/async/androidasync/2.1.3/ |
| androidasync-2.1.3.jar | |
| /prebuilts/tools/common/m2/repository/com/jayway/android/robotium/robotium-solo/5.5.3/ |
| robotium-solo-5.5.3.jar | |
| /prebuilts/misc/common/android-support-test/espresso/ |
| espresso_web_release_no_deps.jar | |
| /prebuilts/tools/common/m2/repository/com/github/bumptech/glide/glide/3.6.1/ |
| glide-3.6.1.jar | |
