/* * 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 { // --------------------------------------------------------------------------- // DO NOT USE: please use std::condition_variable instead. /* * 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, nullptr); 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