| /* |
| * Copyright (C) 2007 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #ifndef _LIBS_UTILS_CONDITION_H |
| #define _LIBS_UTILS_CONDITION_H |
| |
| #include <limits.h> |
| #include <stdint.h> |
| #include <sys/types.h> |
| #include <time.h> |
| |
| #if !defined(_WIN32) |
| # include <pthread.h> |
| #endif |
| |
| #include <utils/Errors.h> |
| #include <utils/Mutex.h> |
| #include <utils/Timers.h> |
| |
| // --------------------------------------------------------------------------- |
| namespace android { |
| // --------------------------------------------------------------------------- |
| |
| /* |
| * Condition variable class. The implementation is system-dependent. |
| * |
| * Condition variables are paired up with mutexes. Lock the mutex, |
| * call wait(), then either re-wait() if things aren't quite what you want, |
| * or unlock the mutex and continue. All threads calling wait() must |
| * use the same mutex for a given Condition. |
| * |
| * On Android and Apple platforms, these are implemented as a simple wrapper |
| * around pthread condition variables. Care must be taken to abide by |
| * the pthreads semantics, in particular, a boolean predicate must |
| * be re-evaluated after a wake-up, as spurious wake-ups may happen. |
| */ |
| class Condition { |
| public: |
| enum { |
| PRIVATE = 0, |
| SHARED = 1 |
| }; |
| |
| enum WakeUpType { |
| WAKE_UP_ONE = 0, |
| WAKE_UP_ALL = 1 |
| }; |
| |
| Condition(); |
| explicit Condition(int type); |
| ~Condition(); |
| // Wait on the condition variable. Lock the mutex before calling. |
| // Note that spurious wake-ups may happen. |
| status_t wait(Mutex& mutex); |
| // same with relative timeout |
| status_t waitRelative(Mutex& mutex, nsecs_t reltime); |
| // Signal the condition variable, allowing one thread to continue. |
| void signal(); |
| // Signal the condition variable, allowing one or all threads to continue. |
| void signal(WakeUpType type) { |
| if (type == WAKE_UP_ONE) { |
| signal(); |
| } else { |
| broadcast(); |
| } |
| } |
| // Signal the condition variable, allowing all threads to continue. |
| void broadcast(); |
| |
| private: |
| #if !defined(_WIN32) |
| pthread_cond_t mCond; |
| #else |
| void* mState; |
| #endif |
| }; |
| |
| // --------------------------------------------------------------------------- |
| |
| #if !defined(_WIN32) |
| |
| inline Condition::Condition() : Condition(PRIVATE) { |
| } |
| inline Condition::Condition(int type) { |
| pthread_condattr_t attr; |
| pthread_condattr_init(&attr); |
| #if defined(__linux__) |
| pthread_condattr_setclock(&attr, CLOCK_MONOTONIC); |
| #endif |
| |
| if (type == SHARED) { |
| pthread_condattr_setpshared(&attr, PTHREAD_PROCESS_SHARED); |
| } |
| |
| pthread_cond_init(&mCond, &attr); |
| pthread_condattr_destroy(&attr); |
| |
| } |
| inline Condition::~Condition() { |
| pthread_cond_destroy(&mCond); |
| } |
| inline status_t Condition::wait(Mutex& mutex) { |
| return -pthread_cond_wait(&mCond, &mutex.mMutex); |
| } |
| inline status_t Condition::waitRelative(Mutex& mutex, nsecs_t reltime) { |
| struct timespec ts; |
| #if defined(__linux__) |
| clock_gettime(CLOCK_MONOTONIC, &ts); |
| #else // __APPLE__ |
| // Apple doesn't support POSIX clocks. |
| struct timeval t; |
| gettimeofday(&t, NULL); |
| ts.tv_sec = t.tv_sec; |
| ts.tv_nsec = t.tv_usec*1000; |
| #endif |
| |
| // On 32-bit devices, tv_sec is 32-bit, but `reltime` is 64-bit. |
| int64_t reltime_sec = reltime/1000000000; |
| |
| ts.tv_nsec += static_cast<long>(reltime%1000000000); |
| if (reltime_sec < INT64_MAX && ts.tv_nsec >= 1000000000) { |
| ts.tv_nsec -= 1000000000; |
| ++reltime_sec; |
| } |
| |
| int64_t time_sec = ts.tv_sec; |
| if (time_sec > INT64_MAX - reltime_sec) { |
| time_sec = INT64_MAX; |
| } else { |
| time_sec += reltime_sec; |
| } |
| |
| ts.tv_sec = (time_sec > LONG_MAX) ? LONG_MAX : static_cast<long>(time_sec); |
| |
| return -pthread_cond_timedwait(&mCond, &mutex.mMutex, &ts); |
| } |
| inline void Condition::signal() { |
| pthread_cond_signal(&mCond); |
| } |
| inline void Condition::broadcast() { |
| pthread_cond_broadcast(&mCond); |
| } |
| |
| #endif // !defined(_WIN32) |
| |
| // --------------------------------------------------------------------------- |
| }; // namespace android |
| // --------------------------------------------------------------------------- |
| |
| #endif // _LIBS_UTILS_CONDITON_H |