1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "base/synchronization/condition_variable.h" 6 7 #include <errno.h> 8 #include <sys/time.h> 9 10 #include "base/logging.h" 11 #include "base/synchronization/lock.h" 12 #include "base/threading/thread_restrictions.h" 13 #include "base/time/time.h" 14 15 namespace base { 16 17 ConditionVariable::ConditionVariable(Lock* user_lock) 18 : user_mutex_(user_lock->lock_.native_handle()) 19 #if !defined(NDEBUG) 20 , user_lock_(user_lock) 21 #endif 22 { 23 int rv = 0; 24 // http://crbug.com/293736 25 // NaCl doesn't support monotonic clock based absolute deadlines. 26 // Android supports it through the non-standard 27 // pthread_cond_timedwait_monotonic_np. 28 // Mac can use relative time deadlines. 29 #if !defined(OS_MACOSX) && !defined(OS_NACL) && !defined(OS_ANDROID) 30 pthread_condattr_t attrs; 31 rv = pthread_condattr_init(&attrs); 32 DCHECK_EQ(0, rv); 33 pthread_condattr_setclock(&attrs, CLOCK_MONOTONIC); 34 rv = pthread_cond_init(&condition_, &attrs); 35 pthread_condattr_destroy(&attrs); 36 #else 37 rv = pthread_cond_init(&condition_, NULL); 38 #endif 39 DCHECK_EQ(0, rv); 40 } 41 42 ConditionVariable::~ConditionVariable() { 43 int rv = pthread_cond_destroy(&condition_); 44 DCHECK_EQ(0, rv); 45 } 46 47 void ConditionVariable::Wait() { 48 base::ThreadRestrictions::AssertWaitAllowed(); 49 #if !defined(NDEBUG) 50 user_lock_->CheckHeldAndUnmark(); 51 #endif 52 int rv = pthread_cond_wait(&condition_, user_mutex_); 53 DCHECK_EQ(0, rv); 54 #if !defined(NDEBUG) 55 user_lock_->CheckUnheldAndMark(); 56 #endif 57 } 58 59 void ConditionVariable::TimedWait(const TimeDelta& max_time) { 60 base::ThreadRestrictions::AssertWaitAllowed(); 61 int64 usecs = max_time.InMicroseconds(); 62 struct timespec relative_time; 63 relative_time.tv_sec = usecs / Time::kMicrosecondsPerSecond; 64 relative_time.tv_nsec = 65 (usecs % Time::kMicrosecondsPerSecond) * Time::kNanosecondsPerMicrosecond; 66 67 #if !defined(NDEBUG) 68 user_lock_->CheckHeldAndUnmark(); 69 #endif 70 71 #if defined(OS_MACOSX) 72 int rv = pthread_cond_timedwait_relative_np( 73 &condition_, user_mutex_, &relative_time); 74 #else 75 // The timeout argument to pthread_cond_timedwait is in absolute time. 76 struct timespec absolute_time; 77 #if defined(OS_NACL) 78 // See comment in constructor for why this is different in NaCl. 79 struct timeval now; 80 gettimeofday(&now, NULL); 81 absolute_time.tv_sec = now.tv_sec; 82 absolute_time.tv_nsec = now.tv_usec * Time::kNanosecondsPerMicrosecond; 83 #else 84 struct timespec now; 85 clock_gettime(CLOCK_MONOTONIC, &now); 86 absolute_time.tv_sec = now.tv_sec; 87 absolute_time.tv_nsec = now.tv_nsec; 88 #endif 89 90 absolute_time.tv_sec += relative_time.tv_sec; 91 absolute_time.tv_nsec += relative_time.tv_nsec; 92 absolute_time.tv_sec += absolute_time.tv_nsec / Time::kNanosecondsPerSecond; 93 absolute_time.tv_nsec %= Time::kNanosecondsPerSecond; 94 DCHECK_GE(absolute_time.tv_sec, now.tv_sec); // Overflow paranoia 95 96 #if defined(OS_ANDROID) 97 int rv = pthread_cond_timedwait_monotonic_np( 98 &condition_, user_mutex_, &absolute_time); 99 #else 100 int rv = pthread_cond_timedwait(&condition_, user_mutex_, &absolute_time); 101 #endif // OS_ANDROID 102 #endif // OS_MACOSX 103 104 DCHECK(rv == 0 || rv == ETIMEDOUT); 105 #if !defined(NDEBUG) 106 user_lock_->CheckUnheldAndMark(); 107 #endif 108 } 109 110 void ConditionVariable::Broadcast() { 111 int rv = pthread_cond_broadcast(&condition_); 112 DCHECK_EQ(0, rv); 113 } 114 115 void ConditionVariable::Signal() { 116 int rv = pthread_cond_signal(&condition_); 117 DCHECK_EQ(0, rv); 118 } 119 120 } // namespace base 121
