tools/debugserver/source/PThreadEvent.cpp

   1 //===-- PThreadEvent.cpp ----------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  Created by Greg Clayton on 6/16/07.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "PThreadEvent.h"
  15 #include "errno.h"
  16 #include "DNBLog.h"
  17
  18 PThreadEvent::PThreadEvent(uint32_t bits, uint32_t validBits) :
  19     m_mutex(),
  20     m_set_condition(),
  21     m_reset_condition(),
  22     m_bits(bits),
  23     m_validBits(validBits),
  24     m_reset_ack_mask(0)
  25 {
  26     // DNBLogThreadedIf(LOG_EVENTS, "%p PThreadEvent::%s (0x%8.8x, 0x%8.8x)", this, __FUNCTION__, bits, validBits);
  27 }
  28
  29 PThreadEvent::~PThreadEvent()
  30 {
  31     // DNBLogThreadedIf(LOG_EVENTS, "%p %s", this, __PRETTY_FUNCTION__);
  32 }
  33
  34
  35 uint32_t
  36 PThreadEvent::NewEventBit()
  37 {
  38     // DNBLogThreadedIf(LOG_EVENTS, "%p %s", this, __PRETTY_FUNCTION__);
  39     PTHREAD_MUTEX_LOCKER (locker, m_mutex);
  40     uint32_t mask = 1;
  41     while (mask & m_validBits)
  42         mask <<= 1;
  43     m_validBits |= mask;
  44     return mask;
  45 }
  46
  47 void
  48 PThreadEvent::FreeEventBits(const uint32_t mask)
  49 {
  50     // DNBLogThreadedIf(LOG_EVENTS, "%p PThreadEvent::%s (0x%8.8x)", this, __FUNCTION__, mask);
  51     if (mask)
  52     {
  53         PTHREAD_MUTEX_LOCKER (locker, m_mutex);
  54         m_bits &= ~mask;
  55         m_validBits &= ~mask;
  56     }
  57 }
  58
  59
  60 uint32_t
  61 PThreadEvent::GetEventBits() const
  62 {
  63     // DNBLogThreadedIf(LOG_EVENTS, "%p %s", this, __PRETTY_FUNCTION__);
  64     PTHREAD_MUTEX_LOCKER (locker, m_mutex);
  65     uint32_t bits = m_bits;
  66     return bits;
  67 }
  68
  69 // Replace the event bits with a new bitmask value
  70 void
  71 PThreadEvent::ReplaceEventBits(const uint32_t bits)
  72 {
  73     // DNBLogThreadedIf(LOG_EVENTS, "%p PThreadEvent::%s (0x%8.8x)", this, __FUNCTION__, bits);
  74     PTHREAD_MUTEX_LOCKER (locker, m_mutex);
  75     // Make sure we have some bits and that they aren't already set...
  76     if (m_bits != bits)
  77     {
  78         // Figure out which bits are changing
  79         uint32_t changed_bits = m_bits ^ bits;
  80         // Set the new bit values
  81         m_bits = bits;
  82         // If any new bits are set, then broadcast
  83         if (changed_bits & m_bits)
  84             m_set_condition.Broadcast();
  85     }
  86 }
  87
  88 // Set one or more event bits and broadcast if any new event bits get set
  89 // that weren't already set.
  90
  91 void
  92 PThreadEvent::SetEvents(const uint32_t mask)
  93 {
  94     // DNBLogThreadedIf(LOG_EVENTS, "%p PThreadEvent::%s (0x%8.8x)", this, __FUNCTION__, mask);
  95     // Make sure we have some bits to set
  96     if (mask)
  97     {
  98         PTHREAD_MUTEX_LOCKER (locker, m_mutex);
  99         // Save the old event bit state so we can tell if things change
 100         uint32_t old = m_bits;
 101         // Set the all event bits that are set in 'mask'
 102         m_bits |= mask;
 103         // Broadcast only if any extra bits got set.
 104         if (old != m_bits)
 105             m_set_condition.Broadcast();
 106     }
 107 }
 108
 109 // Reset one or more event bits
 110 void
 111 PThreadEvent::ResetEvents(const uint32_t mask)
 112 {
 113     // DNBLogThreadedIf(LOG_EVENTS, "%p PThreadEvent::%s (0x%8.8x)", this, __FUNCTION__, mask);
 114     if (mask)
 115     {
 116         PTHREAD_MUTEX_LOCKER (locker, m_mutex);
 117
 118         // Save the old event bit state so we can tell if things change
 119         uint32_t old = m_bits;
 120         // Clear the all event bits that are set in 'mask'
 121         m_bits &= ~mask;
 122         // Broadcast only if any extra bits got reset.
 123         if (old != m_bits)
 124             m_reset_condition.Broadcast();
 125     }
 126 }
 127
 128 //----------------------------------------------------------------------
 129 // Wait until 'timeout_abstime' for any events that are set in
 130 // 'mask'. If 'timeout_abstime' is NULL, then wait forever.
 131 //----------------------------------------------------------------------
 132 uint32_t
 133 PThreadEvent::WaitForSetEvents(const uint32_t mask, const struct timespec *timeout_abstime) const
 134 {
 135     // DNBLogThreadedIf(LOG_EVENTS, "%p PThreadEvent::%s (0x%8.8x, %p)", this, __FUNCTION__, mask, timeout_abstime);
 136     int err = 0;
 137     // pthread_cond_timedwait() or pthread_cond_wait() will atomically
 138     // unlock the mutex and wait for the condition to be set. When either
 139     // function returns, they will re-lock the mutex. We use an auto lock/unlock
 140     // class (PThreadMutex::Locker) to allow us to return at any point in this
 141     // function and not have to worry about unlocking the mutex.
 142     PTHREAD_MUTEX_LOCKER (locker, m_mutex);
 143     do
 144     {
 145         // Check our predicate (event bits) in case any are already set
 146         if (mask & m_bits)
 147         {
 148             uint32_t bits_set = mask & m_bits;
 149             // Our PThreadMutex::Locker will automatically unlock our mutex
 150             return bits_set;
 151         }
 152         if (timeout_abstime)
 153         {
 154             // Wait for condition to get broadcast, or for a timeout. If we get
 155             // a timeout we will drop out of the do loop and return false which
 156             // is what we want.
 157             err = ::pthread_cond_timedwait (m_set_condition.Condition(), m_mutex.Mutex(), timeout_abstime);
 158             // Retest our predicate in case of a race condition right at the end
 159             // of the timeout.
 160             if (err == ETIMEDOUT)
 161             {
 162                 uint32_t bits_set = mask & m_bits;
 163                 return bits_set;
 164             }
 165         }
 166         else
 167         {
 168             // Wait for condition to get broadcast. The only error this function
 169             // should return is if
 170             err = ::pthread_cond_wait (m_set_condition.Condition(), m_mutex.Mutex());
 171         }
 172     } while (err == 0);
 173     return 0;
 174 }
 175
 176 //----------------------------------------------------------------------
 177 // Wait until 'timeout_abstime' for any events in 'mask' to reset.
 178 // If 'timeout_abstime' is NULL, then wait forever.
 179 //----------------------------------------------------------------------
 180 uint32_t
 181 PThreadEvent::WaitForEventsToReset(const uint32_t mask, const struct timespec *timeout_abstime) const
 182 {
 183     // DNBLogThreadedIf(LOG_EVENTS, "%p PThreadEvent::%s (0x%8.8x, %p)", this, __FUNCTION__, mask, timeout_abstime);
 184     int err = 0;
 185     // pthread_cond_timedwait() or pthread_cond_wait() will atomically
 186     // unlock the mutex and wait for the condition to be set. When either
 187     // function returns, they will re-lock the mutex. We use an auto lock/unlock
 188     // class (PThreadMutex::Locker) to allow us to return at any point in this
 189     // function and not have to worry about unlocking the mutex.
 190     PTHREAD_MUTEX_LOCKER (locker, m_mutex);
 191     do
 192     {
 193         // Check our predicate (event bits) each time through this do loop
 194         if ((mask & m_bits) == 0)
 195         {
 196             // All the bits requested have been reset, return zero indicating
 197             // which bits from the mask were still set (none of them)
 198             return 0;
 199         }
 200         if (timeout_abstime)
 201         {
 202             // Wait for condition to get broadcast, or for a timeout. If we get
 203             // a timeout we will drop out of the do loop and return false which
 204             // is what we want.
 205             err = ::pthread_cond_timedwait (m_reset_condition.Condition(), m_mutex.Mutex(), timeout_abstime);
 206         }
 207         else
 208         {
 209             // Wait for condition to get broadcast. The only error this function
 210             // should return is if
 211             err = ::pthread_cond_wait (m_reset_condition.Condition(), m_mutex.Mutex());
 212         }
 213     } while (err == 0);
 214     // Return a mask indicating which bits (if any) were still set
 215     return mask & m_bits;
 216 }
 217
 218 uint32_t
 219 PThreadEvent::WaitForResetAck (const uint32_t mask, const struct timespec *timeout_abstime) const
 220 {
 221     if (mask & m_reset_ack_mask)
 222     {
 223         // DNBLogThreadedIf(LOG_EVENTS, "%p PThreadEvent::%s (0x%8.8x, %p)", this, __FUNCTION__, mask, timeout_abstime);
 224         return WaitForEventsToReset (mask & m_reset_ack_mask, timeout_abstime);
 225     }
 226     return 0;
 227 }