Home | History | Annotate | Download | only in utils 
      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