spsc_sema::LightweightSemaphore Class Reference

#include <atomicops.h>

Collaboration diagram for spsc_sema::LightweightSemaphore:

Public Types
typedef std::make_signed< std::size_t >::type	ssize_t

Public Member Functions
AE_NO_TSAN	LightweightSemaphore (ssize_t initialCount=0)
bool	tryWait () AE_NO_TSAN
void	wait () AE_NO_TSAN
bool	wait (std::int64_t timeout_usecs) AE_NO_TSAN
void	signal (ssize_t count=1) AE_NO_TSAN
ssize_t	availableApprox () const AE_NO_TSAN

Private Member Functions
bool	waitWithPartialSpinning (std::int64_t timeout_usecs=-1) AE_NO_TSAN

Private Attributes
weak_atomic< ssize_t >	m_count
Semaphore	m_sema

Detailed Description

Definition at line 564 of file atomicops.h.

Member Typedef Documentation

ssize_t

typedef std::make_signed<std::size_t>::type spsc_sema::LightweightSemaphore::ssize_t

Definition at line 567 of file atomicops.h.

Constructor & Destructor Documentation

LightweightSemaphore()

AE_NO_TSAN spsc_sema::LightweightSemaphore::LightweightSemaphore ( ssize_t  initialCount = 0 )

inline

Definition at line 617 of file atomicops.h.

                                                                  : m_count(initialCount)
        {
            assert(initialCount >= 0);
        }

Member Function Documentation

availableApprox()

ssize_t spsc_sema::LightweightSemaphore::availableApprox ( ) const

inline

Definition at line 654 of file atomicops.h.

        {
          ssize_t count = m_count.load();
          return count > 0 ? count : 0;
        }

References weak_atomic< T >::load(), and m_count.

Here is the call graph for this function:

signal()

void spsc_sema::LightweightSemaphore::signal ( ssize_t  count = 1 )

inline

Definition at line 643 of file atomicops.h.

        {
          assert(count >= 0);
            ssize_t oldCount = m_count.fetch_add_release(count);
            assert(oldCount >= -1);
            if (oldCount < 0)
            {
                m_sema.signal(1);
            }
        }

References weak_atomic< T >::fetch_add_release(), m_count, and m_sema.

Here is the call graph for this function:

tryWait()

bool spsc_sema::LightweightSemaphore::tryWait ( )

inline

Definition at line 622 of file atomicops.h.

        {
            if (m_count.load() > 0)
            {
              m_count.fetch_add_acquire(-1);
              return true;
            }
            return false;
        }

References weak_atomic< T >::fetch_add_acquire(), weak_atomic< T >::load(), and m_count.

Referenced by wait().

Here is the call graph for this function:

Here is the caller graph for this function:

wait() [1/2]

void spsc_sema::LightweightSemaphore::wait ( )

inline

Definition at line 632 of file atomicops.h.

        {
            if (!tryWait())
                waitWithPartialSpinning();
        }

References tryWait(), and waitWithPartialSpinning().

Here is the call graph for this function:

wait() [2/2]

bool spsc_sema::LightweightSemaphore::wait ( std::int64_t  timeout_usecs )

inline

Definition at line 638 of file atomicops.h.

      {
        return tryWait() || waitWithPartialSpinning(timeout_usecs);
      }

References tryWait(), and waitWithPartialSpinning().

Here is the call graph for this function:

waitWithPartialSpinning()

bool spsc_sema::LightweightSemaphore::waitWithPartialSpinning ( std::int64_t  timeout_usecs = -1 )

inlineprivate

Definition at line 573 of file atomicops.h.

        {
            ssize_t oldCount;
            // Is there a better way to set the initial spin count?
            // If we lower it to 1000, testBenaphore becomes 15x slower on my Core i7-5930K Windows PC,
            // as threads start hitting the kernel semaphore.
            int spin = 10000;
            while (--spin >= 0)
            {
                if (m_count.load() > 0)
                {
                    m_count.fetch_add_acquire(-1);
                    return true;
                }
                compiler_fence(memory_order_acquire);     // Prevent the compiler from collapsing the loop.
            }
            oldCount = m_count.fetch_add_acquire(-1);
        if (oldCount > 0)
          return true;
            if (timeout_usecs < 0)
        {
          m_sema.wait();
          return true;
        }
        if (m_sema.timed_wait(timeout_usecs))
          return true;
        // At this point, we've timed out waiting for the semaphore, but the
        // count is still decremented indicating we may still be waiting on
        // it. So we have to re-adjust the count, but only if the semaphore
        // wasn't signaled enough times for us too since then. If it was, we
        // need to release the semaphore too.
        while (true)
        {
          oldCount = m_count.fetch_add_release(1);
          if (oldCount < 0)
            return false;    // successfully restored things to the way they were
          // Oh, the producer thread just signaled the semaphore after all. Try again:
          oldCount = m_count.fetch_add_acquire(-1);
          if (oldCount > 0 && m_sema.try_wait())
            return true;
        }
        }

References compiler_fence(), weak_atomic< T >::fetch_add_acquire(), weak_atomic< T >::fetch_add_release(), weak_atomic< T >::load(), m_count, m_sema, and memory_order_acquire.

Referenced by wait().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_count

weak_atomic<ssize_t> spsc_sema::LightweightSemaphore::m_count

private

Definition at line 570 of file atomicops.h.

Referenced by availableApprox(), signal(), tryWait(), and waitWithPartialSpinning().

m_sema

Semaphore spsc_sema::LightweightSemaphore::m_sema

private

Definition at line 571 of file atomicops.h.

Referenced by signal(), and waitWithPartialSpinning().

---

The documentation for this class was generated from the following file:

• atomicops.h