1 /*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #ifndef _LIBS_UTILS_CONDITION_H
18 #define _LIBS_UTILS_CONDITION_H
19
20 #include <limits.h>
21 #include <stdint.h>
22 #include <sys/types.h>
23 #include <time.h>
24
25 #if !defined(_WIN32)
26 # include <pthread.h>
27 #endif
28
29 #include <utils/Errors.h>
30 #include <utils/Mutex.h>
31 #include <utils/Timers.h>
32
33 // ---------------------------------------------------------------------------
34 namespace android {
35 // ---------------------------------------------------------------------------
36
37 /*
38 * Condition variable class. The implementation is system-dependent.
39 *
40 * Condition variables are paired up with mutexes. Lock the mutex,
41 * call wait(), then either re-wait() if things aren't quite what you want,
42 * or unlock the mutex and continue. All threads calling wait() must
43 * use the same mutex for a given Condition.
44 *
45 * On Android and Apple platforms, these are implemented as a simple wrapper
46 * around pthread condition variables. Care must be taken to abide by
47 * the pthreads semantics, in particular, a boolean predicate must
48 * be re-evaluated after a wake-up, as spurious wake-ups may happen.
49 */
50 class Condition {
51 public:
52 enum {
53 PRIVATE = 0,
54 SHARED = 1
55 };
56
57 enum WakeUpType {
58 WAKE_UP_ONE = 0,
59 WAKE_UP_ALL = 1
60 };
61
62 Condition();
63 explicit Condition(int type);
64 ~Condition();
65 // Wait on the condition variable. Lock the mutex before calling.
66 // Note that spurious wake-ups may happen.
67 status_t wait(Mutex& mutex);
68 // same with relative timeout
69 status_t waitRelative(Mutex& mutex, nsecs_t reltime);
70 // Signal the condition variable, allowing one thread to continue.
71 void signal();
72 // Signal the condition variable, allowing one or all threads to continue.
signal(WakeUpType type)73 void signal(WakeUpType type) {
74 if (type == WAKE_UP_ONE) {
75 signal();
76 } else {
77 broadcast();
78 }
79 }
80 // Signal the condition variable, allowing all threads to continue.
81 void broadcast();
82
83 private:
84 #if !defined(_WIN32)
85 pthread_cond_t mCond;
86 #else
87 void* mState;
88 #endif
89 };
90
91 // ---------------------------------------------------------------------------
92
93 #if !defined(_WIN32)
94
Condition()95 inline Condition::Condition() : Condition(PRIVATE) {
96 }
Condition(int type)97 inline Condition::Condition(int type) {
98 pthread_condattr_t attr;
99 pthread_condattr_init(&attr);
100 #if defined(__linux__)
101 pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
102 #endif
103
104 if (type == SHARED) {
105 pthread_condattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
106 }
107
108 pthread_cond_init(&mCond, &attr);
109 pthread_condattr_destroy(&attr);
110
111 }
~Condition()112 inline Condition::~Condition() {
113 pthread_cond_destroy(&mCond);
114 }
wait(Mutex & mutex)115 inline status_t Condition::wait(Mutex& mutex) {
116 return -pthread_cond_wait(&mCond, &mutex.mMutex);
117 }
waitRelative(Mutex & mutex,nsecs_t reltime)118 inline status_t Condition::waitRelative(Mutex& mutex, nsecs_t reltime) {
119 struct timespec ts;
120 #if defined(__linux__)
121 clock_gettime(CLOCK_MONOTONIC, &ts);
122 #else // __APPLE__
123 // Apple doesn't support POSIX clocks.
124 struct timeval t;
125 gettimeofday(&t, NULL);
126 ts.tv_sec = t.tv_sec;
127 ts.tv_nsec = t.tv_usec*1000;
128 #endif
129
130 // On 32-bit devices, tv_sec is 32-bit, but `reltime` is 64-bit.
131 int64_t reltime_sec = reltime/1000000000;
132
133 ts.tv_nsec += static_cast<long>(reltime%1000000000);
134 if (reltime_sec < INT64_MAX && ts.tv_nsec >= 1000000000) {
135 ts.tv_nsec -= 1000000000;
136 ++reltime_sec;
137 }
138
139 int64_t time_sec = ts.tv_sec;
140 if (time_sec > INT64_MAX - reltime_sec) {
141 time_sec = INT64_MAX;
142 } else {
143 time_sec += reltime_sec;
144 }
145
146 ts.tv_sec = (time_sec > LONG_MAX) ? LONG_MAX : static_cast<long>(time_sec);
147
148 return -pthread_cond_timedwait(&mCond, &mutex.mMutex, &ts);
149 }
signal()150 inline void Condition::signal() {
151 pthread_cond_signal(&mCond);
152 }
broadcast()153 inline void Condition::broadcast() {
154 pthread_cond_broadcast(&mCond);
155 }
156
157 #endif // !defined(_WIN32)
158
159 // ---------------------------------------------------------------------------
160 }; // namespace android
161 // ---------------------------------------------------------------------------
162
163 #endif // _LIBS_UTILS_CONDITON_H
164