| //===-- 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; | |
| } |