//===-- PThreadEvent.cpp ----------------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // Created by Greg Clayton on 6/16/07. // //===----------------------------------------------------------------------===// #include "PThreadEvent.h" #include "errno.h" #include "DNBLog.h" PThreadEvent::PThreadEvent(uint32_t bits, uint32_t validBits) : m_mutex(), m_set_condition(), m_reset_condition(), m_bits(bits), m_validBits(validBits), m_reset_ack_mask(0) { // DNBLogThreadedIf(LOG_EVENTS, "%p PThreadEvent::%s (0x%8.8x, 0x%8.8x)", this, __FUNCTION__, bits, validBits); } PThreadEvent::~PThreadEvent() { // DNBLogThreadedIf(LOG_EVENTS, "%p %s", this, __PRETTY_FUNCTION__); } uint32_t PThreadEvent::NewEventBit() { // DNBLogThreadedIf(LOG_EVENTS, "%p %s", this, __PRETTY_FUNCTION__); PTHREAD_MUTEX_LOCKER (locker, m_mutex); uint32_t mask = 1; while (mask & m_validBits) mask <<= 1; m_validBits |= mask; return mask; } void PThreadEvent::FreeEventBits(const uint32_t mask) { // DNBLogThreadedIf(LOG_EVENTS, "%p PThreadEvent::%s (0x%8.8x)", this, __FUNCTION__, mask); if (mask) { PTHREAD_MUTEX_LOCKER (locker, m_mutex); m_bits &= ~mask; m_validBits &= ~mask; } } uint32_t PThreadEvent::GetEventBits() const { // DNBLogThreadedIf(LOG_EVENTS, "%p %s", this, __PRETTY_FUNCTION__); PTHREAD_MUTEX_LOCKER (locker, m_mutex); uint32_t bits = m_bits; return bits; } // Replace the event bits with a new bitmask value void PThreadEvent::ReplaceEventBits(const uint32_t bits) { // DNBLogThreadedIf(LOG_EVENTS, "%p PThreadEvent::%s (0x%8.8x)", this, __FUNCTION__, bits); PTHREAD_MUTEX_LOCKER (locker, m_mutex); // Make sure we have some bits and that they aren't already set... if (m_bits != bits) { // Figure out which bits are changing uint32_t changed_bits = m_bits ^ bits; // Set the new bit values m_bits = bits; // If any new bits are set, then broadcast if (changed_bits & m_bits) m_set_condition.Broadcast(); } } // Set one or more event bits and broadcast if any new event bits get set // that weren't already set. void PThreadEvent::SetEvents(const uint32_t mask) { // DNBLogThreadedIf(LOG_EVENTS, "%p PThreadEvent::%s (0x%8.8x)", this, __FUNCTION__, mask); // Make sure we have some bits to set if (mask) { PTHREAD_MUTEX_LOCKER (locker, m_mutex); // Save the old event bit state so we can tell if things change uint32_t old = m_bits; // Set the all event bits that are set in 'mask' m_bits |= mask; // Broadcast only if any extra bits got set. if (old != m_bits) m_set_condition.Broadcast(); } } // Reset one or more event bits void PThreadEvent::ResetEvents(const uint32_t mask) { // DNBLogThreadedIf(LOG_EVENTS, "%p PThreadEvent::%s (0x%8.8x)", this, __FUNCTION__, mask); if (mask) { PTHREAD_MUTEX_LOCKER (locker, m_mutex); // Save the old event bit state so we can tell if things change uint32_t old = m_bits; // Clear the all event bits that are set in 'mask' m_bits &= ~mask; // Broadcast only if any extra bits got reset. if (old != m_bits) m_reset_condition.Broadcast(); } } //---------------------------------------------------------------------- // Wait until 'timeout_abstime' for any events that are set in // 'mask'. If 'timeout_abstime' is NULL, then wait forever. //---------------------------------------------------------------------- uint32_t PThreadEvent::WaitForSetEvents(const uint32_t mask, const struct timespec *timeout_abstime) const { // DNBLogThreadedIf(LOG_EVENTS, "%p PThreadEvent::%s (0x%8.8x, %p)", this, __FUNCTION__, mask, timeout_abstime); int err = 0; // pthread_cond_timedwait() or pthread_cond_wait() will atomically // unlock the mutex and wait for the condition to be set. When either // function returns, they will re-lock the mutex. We use an auto lock/unlock // class (PThreadMutex::Locker) to allow us to return at any point in this // function and not have to worry about unlocking the mutex. PTHREAD_MUTEX_LOCKER (locker, m_mutex); do { // Check our predicate (event bits) in case any are already set if (mask & m_bits) { uint32_t bits_set = mask & m_bits; // Our PThreadMutex::Locker will automatically unlock our mutex return bits_set; } if (timeout_abstime) { // Wait for condition to get broadcast, or for a timeout. If we get // a timeout we will drop out of the do loop and return false which // is what we want. err = ::pthread_cond_timedwait (m_set_condition.Condition(), m_mutex.Mutex(), timeout_abstime); // Retest our predicate in case of a race condition right at the end // of the timeout. if (err == ETIMEDOUT) { uint32_t bits_set = mask & m_bits; return bits_set; } } else { // Wait for condition to get broadcast. The only error this function // should return is if err = ::pthread_cond_wait (m_set_condition.Condition(), m_mutex.Mutex()); } } while (err == 0); return 0; } //---------------------------------------------------------------------- // Wait until 'timeout_abstime' for any events in 'mask' to reset. // If 'timeout_abstime' is NULL, then wait forever. //---------------------------------------------------------------------- uint32_t PThreadEvent::WaitForEventsToReset(const uint32_t mask, const struct timespec *timeout_abstime) const { // DNBLogThreadedIf(LOG_EVENTS, "%p PThreadEvent::%s (0x%8.8x, %p)", this, __FUNCTION__, mask, timeout_abstime); int err = 0; // pthread_cond_timedwait() or pthread_cond_wait() will atomically // unlock the mutex and wait for the condition to be set. When either // function returns, they will re-lock the mutex. We use an auto lock/unlock // class (PThreadMutex::Locker) to allow us to return at any point in this // function and not have to worry about unlocking the mutex. PTHREAD_MUTEX_LOCKER (locker, m_mutex); do { // Check our predicate (event bits) each time through this do loop if ((mask & m_bits) == 0) { // All the bits requested have been reset, return zero indicating // which bits from the mask were still set (none of them) return 0; } if (timeout_abstime) { // Wait for condition to get broadcast, or for a timeout. If we get // a timeout we will drop out of the do loop and return false which // is what we want. err = ::pthread_cond_timedwait (m_reset_condition.Condition(), m_mutex.Mutex(), timeout_abstime); } else { // Wait for condition to get broadcast. The only error this function // should return is if err = ::pthread_cond_wait (m_reset_condition.Condition(), m_mutex.Mutex()); } } while (err == 0); // Return a mask indicating which bits (if any) were still set return mask & m_bits; } uint32_t PThreadEvent::WaitForResetAck (const uint32_t mask, const struct timespec *timeout_abstime) const { if (mask & m_reset_ack_mask) { // DNBLogThreadedIf(LOG_EVENTS, "%p PThreadEvent::%s (0x%8.8x, %p)", this, __FUNCTION__, mask, timeout_abstime); return WaitForEventsToReset (mask & m_reset_ack_mask, timeout_abstime); } return 0; }