Source code

Revision control

Other Tools

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "mozilla/Assertions.h"
#include "mozilla/CheckedInt.h"
#include <errno.h>
#include <pthread.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include "mozilla/PlatformConditionVariable.h"
#include "mozilla/PlatformMutex.h"
#include "MutexPlatformData_posix.h"
using mozilla::CheckedInt;
using mozilla::TimeDuration;
static const long NanoSecPerSec = 1000000000;
// Android 32-bit & macOS 10.12 has the clock functions, but not
// pthread_condattr_setclock.
#if defined(HAVE_CLOCK_MONOTONIC) && \
!(defined(__ANDROID__) && !defined(__LP64__)) && !defined(__APPLE__)
# define CV_USE_CLOCK_API
#endif
#ifdef CV_USE_CLOCK_API
// The C++ specification defines std::condition_variable::wait_for in terms of
// std::chrono::steady_clock, which is closest to CLOCK_MONOTONIC.
static const clockid_t WhichClock = CLOCK_MONOTONIC;
// While timevaladd is widely available to work with timevals, the newer
// timespec structure is largely lacking such conveniences. Thankfully, the
// utilities available in MFBT make implementing our own quite easy.
static void moz_timespecadd(struct timespec* lhs, struct timespec* rhs,
struct timespec* result) {
// Add nanoseconds. This may wrap, but not above 2 billion.
MOZ_RELEASE_ASSERT(lhs->tv_nsec < NanoSecPerSec);
MOZ_RELEASE_ASSERT(rhs->tv_nsec < NanoSecPerSec);
result->tv_nsec = lhs->tv_nsec + rhs->tv_nsec;
// Add seconds, checking for overflow in the platform specific time_t type.
CheckedInt<time_t> sec = CheckedInt<time_t>(lhs->tv_sec) + rhs->tv_sec;
// If nanoseconds overflowed, carry the result over into seconds.
if (result->tv_nsec >= NanoSecPerSec) {
MOZ_RELEASE_ASSERT(result->tv_nsec < 2 * NanoSecPerSec);
result->tv_nsec -= NanoSecPerSec;
sec += 1;
}
// Extracting the value asserts that there was no overflow.
MOZ_RELEASE_ASSERT(sec.isValid());
result->tv_sec = sec.value();
}
#endif
struct mozilla::detail::ConditionVariableImpl::PlatformData {
pthread_cond_t ptCond;
};
mozilla::detail::ConditionVariableImpl::ConditionVariableImpl() {
pthread_cond_t* ptCond = &platformData()->ptCond;
#ifdef CV_USE_CLOCK_API
pthread_condattr_t attr;
int r0 = pthread_condattr_init(&attr);
MOZ_RELEASE_ASSERT(!r0);
int r1 = pthread_condattr_setclock(&attr, WhichClock);
MOZ_RELEASE_ASSERT(!r1);
int r2 = pthread_cond_init(ptCond, &attr);
MOZ_RELEASE_ASSERT(!r2);
int r3 = pthread_condattr_destroy(&attr);
MOZ_RELEASE_ASSERT(!r3);
#else
int r = pthread_cond_init(ptCond, NULL);
MOZ_RELEASE_ASSERT(!r);
#endif
}
mozilla::detail::ConditionVariableImpl::~ConditionVariableImpl() {
int r = pthread_cond_destroy(&platformData()->ptCond);
MOZ_RELEASE_ASSERT(r == 0);
}
void mozilla::detail::ConditionVariableImpl::notify_one() {
int r = pthread_cond_signal(&platformData()->ptCond);
MOZ_RELEASE_ASSERT(r == 0);
}
void mozilla::detail::ConditionVariableImpl::notify_all() {
int r = pthread_cond_broadcast(&platformData()->ptCond);
MOZ_RELEASE_ASSERT(r == 0);
}
void mozilla::detail::ConditionVariableImpl::wait(MutexImpl& lock) {
pthread_cond_t* ptCond = &platformData()->ptCond;
pthread_mutex_t* ptMutex = &lock.platformData()->ptMutex;
int r = pthread_cond_wait(ptCond, ptMutex);
MOZ_RELEASE_ASSERT(r == 0);
}
mozilla::CVStatus mozilla::detail::ConditionVariableImpl::wait_for(
MutexImpl& lock, const TimeDuration& a_rel_time) {
if (a_rel_time == TimeDuration::Forever()) {
wait(lock);
return CVStatus::NoTimeout;
}
pthread_cond_t* ptCond = &platformData()->ptCond;
pthread_mutex_t* ptMutex = &lock.platformData()->ptMutex;
int r;
// Clamp to 0, as time_t is unsigned.
TimeDuration rel_time = a_rel_time < TimeDuration::FromSeconds(0)
? TimeDuration::FromSeconds(0)
: a_rel_time;
// Convert the duration to a timespec.
struct timespec rel_ts;
rel_ts.tv_sec = static_cast<time_t>(rel_time.ToSeconds());
rel_ts.tv_nsec =
static_cast<uint64_t>(rel_time.ToMicroseconds() * 1000.0) % NanoSecPerSec;
#ifdef CV_USE_CLOCK_API
struct timespec now_ts;
r = clock_gettime(WhichClock, &now_ts);
MOZ_RELEASE_ASSERT(!r);
struct timespec abs_ts;
moz_timespecadd(&now_ts, &rel_ts, &abs_ts);
r = pthread_cond_timedwait(ptCond, ptMutex, &abs_ts);
#else
// Our non-clock-supporting platforms, OS X and Android, do support waiting
// on a condition variable with a relative timeout.
r = pthread_cond_timedwait_relative_np(ptCond, ptMutex, &rel_ts);
#endif
if (r == 0) {
return CVStatus::NoTimeout;
}
MOZ_RELEASE_ASSERT(r == ETIMEDOUT);
return CVStatus::Timeout;
}
mozilla::detail::ConditionVariableImpl::PlatformData*
mozilla::detail::ConditionVariableImpl::platformData() {
static_assert(sizeof platformData_ >= sizeof(PlatformData),
"platformData_ is too small");
return reinterpret_cast<PlatformData*>(platformData_);
}