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. 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 95 inline Condition::Condition() : Condition(PRIVATE) { 96 } 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 } 112 inline Condition::~Condition() { 113 pthread_cond_destroy(&mCond); 114 } 115 inline status_t Condition::wait(Mutex& mutex) { 116 return -pthread_cond_wait(&mCond, &mutex.mMutex); 117 } 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 } 150 inline void Condition::signal() { 151 pthread_cond_signal(&mCond); 152 } 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