// Copyright (c) 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include "base/synchronization/condition_variable.h" #include <errno.h> #include <sys/time.h> #include "base/logging.h" #include "base/synchronization/lock.h" #include "base/threading/thread_restrictions.h" #include "base/time/time.h" namespace base { ConditionVariable::ConditionVariable(Lock* user_lock) : user_mutex_(user_lock->lock_.native_handle()) #if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON) , user_lock_(user_lock) #endif { int rv = 0; // http://crbug.com/293736 // NaCl doesn't support monotonic clock based absolute deadlines. // On older Android platform versions, it's supported through the // non-standard pthread_cond_timedwait_monotonic_np. Newer platform // versions have pthread_condattr_setclock. // Mac can use relative time deadlines. #if !defined(OS_MACOSX) && !defined(OS_NACL) && \ !(defined(OS_ANDROID) && defined(HAVE_PTHREAD_COND_TIMEDWAIT_MONOTONIC)) pthread_condattr_t attrs; rv = pthread_condattr_init(&attrs); DCHECK_EQ(0, rv); pthread_condattr_setclock(&attrs, CLOCK_MONOTONIC); rv = pthread_cond_init(&condition_, &attrs); pthread_condattr_destroy(&attrs); #else rv = pthread_cond_init(&condition_, NULL); #endif DCHECK_EQ(0, rv); } ConditionVariable::~ConditionVariable() { int rv = pthread_cond_destroy(&condition_); DCHECK_EQ(0, rv); } void ConditionVariable::Wait() { base::ThreadRestrictions::AssertWaitAllowed(); #if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON) user_lock_->CheckHeldAndUnmark(); #endif int rv = pthread_cond_wait(&condition_, user_mutex_); DCHECK_EQ(0, rv); #if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON) user_lock_->CheckUnheldAndMark(); #endif } void ConditionVariable::TimedWait(const TimeDelta& max_time) { base::ThreadRestrictions::AssertWaitAllowed(); int64 usecs = max_time.InMicroseconds(); struct timespec relative_time; relative_time.tv_sec = usecs / Time::kMicrosecondsPerSecond; relative_time.tv_nsec = (usecs % Time::kMicrosecondsPerSecond) * Time::kNanosecondsPerMicrosecond; #if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON) user_lock_->CheckHeldAndUnmark(); #endif #if defined(OS_MACOSX) int rv = pthread_cond_timedwait_relative_np( &condition_, user_mutex_, &relative_time); #else // The timeout argument to pthread_cond_timedwait is in absolute time. struct timespec absolute_time; #if defined(OS_NACL) // See comment in constructor for why this is different in NaCl. struct timeval now; gettimeofday(&now, NULL); absolute_time.tv_sec = now.tv_sec; absolute_time.tv_nsec = now.tv_usec * Time::kNanosecondsPerMicrosecond; #else struct timespec now; clock_gettime(CLOCK_MONOTONIC, &now); absolute_time.tv_sec = now.tv_sec; absolute_time.tv_nsec = now.tv_nsec; #endif absolute_time.tv_sec += relative_time.tv_sec; absolute_time.tv_nsec += relative_time.tv_nsec; absolute_time.tv_sec += absolute_time.tv_nsec / Time::kNanosecondsPerSecond; absolute_time.tv_nsec %= Time::kNanosecondsPerSecond; DCHECK_GE(absolute_time.tv_sec, now.tv_sec); // Overflow paranoia #if defined(OS_ANDROID) && defined(HAVE_PTHREAD_COND_TIMEDWAIT_MONOTONIC) int rv = pthread_cond_timedwait_monotonic_np( &condition_, user_mutex_, &absolute_time); #else int rv = pthread_cond_timedwait(&condition_, user_mutex_, &absolute_time); #endif // OS_ANDROID && HAVE_PTHREAD_COND_TIMEDWAIT_MONOTONIC #endif // OS_MACOSX DCHECK(rv == 0 || rv == ETIMEDOUT); #if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON) user_lock_->CheckUnheldAndMark(); #endif } void ConditionVariable::Broadcast() { int rv = pthread_cond_broadcast(&condition_); DCHECK_EQ(0, rv); } void ConditionVariable::Signal() { int rv = pthread_cond_signal(&condition_); DCHECK_EQ(0, rv); } } // namespace base