quickcpplib::_xxx::configurable_spinlock::shared_spinlockbase< T > Struct Template Reference

#include "spinlock.hpp"

Public Types
typedef T	value_type

Public Member Functions
constexpr	shared_spinlockbase () noexcept
	shared_spinlockbase (const shared_spinlockbase &)=delete
	shared_spinlockbase (shared_spinlockbase &&) noexcept
	Atomically move constructs.
	~shared_spinlockbase ()
shared_spinlockbase &	operator= (const shared_spinlockbase &)=delete
shared_spinlockbase &	operator= (shared_spinlockbase &&)=delete
constexpr T	load (memory_order o=memory_order_seq_cst) const noexcept
	Returns the raw atomic.
void	store (T a, memory_order o=memory_order_seq_cst) noexcept
	Sets the raw atomic.
bool	try_lock () noexcept
	Tries to lock the spinlock for exclusive access, returning true if successful.
void	unlock () noexcept
	Releases the lock from exclusive access.
bool	try_lock_shared () noexcept
	Tries to lock the spinlock for shared access, returning true if successful.
void	unlock_shared () noexcept
	Releases the lock from shared access.
bool	try_convert_lock_to_shared () noexcept
	Tries to convert an exclusive lock to a shared lock, returning true if successful.
bool	try_convert_lock_to_exclusive () noexcept
	Tries to convert a shared lock to an exclusive lock, returning true if successful.
bool	int_yield (size_t) noexcept

Protected Attributes
atomic< value_type >	_v

Member Typedef Documentation

value_type

template<typename T>

typedef T quickcpplib::_xxx::configurable_spinlock::shared_spinlockbase< T >::value_type

Constructor & Destructor Documentation

shared_spinlockbase() [1/3]

template<typename T>

quickcpplib::_xxx::configurable_spinlock::shared_spinlockbase< T >::shared_spinlockbase ( )

inlineconstexprnoexcept

        : _v(0)
    {
      QUICKCPPLIB_ANNOTATE_RWLOCK_CREATE(this);
#if QUICKCPPLIB_IN_THREAD_SANITIZER
      _v.store(0, memory_order_release);
#endif
    }

shared_spinlockbase() [2/3]

template<typename T>

quickcpplib::_xxx::configurable_spinlock::shared_spinlockbase< T >::shared_spinlockbase ( const shared_spinlockbase< T > & )

delete

shared_spinlockbase() [3/3]

template<typename T>

quickcpplib::_xxx::configurable_spinlock::shared_spinlockbase< T >::shared_spinlockbase ( shared_spinlockbase< T > && )

inlinenoexcept

Atomically move constructs.

        : _v(0)
    {
      QUICKCPPLIB_ANNOTATE_RWLOCK_CREATE(this);
// v.store(o.v.exchange(0, memory_order_acq_rel));
#if QUICKCPPLIB_IN_THREAD_SANITIZER
      _v.store(0, memory_order_release);
#endif
    }

~shared_spinlockbase()

template<typename T>

quickcpplib::_xxx::configurable_spinlock::shared_spinlockbase< T >::~shared_spinlockbase ( )

inline

    {
#ifdef QUICKCPPLIB_ENABLE_VALGRIND
      value_type i = _v.load(memory_order_relaxed);
      if(i == 1)
      {
        QUICKCPPLIB_ANNOTATE_RWLOCK_RELEASED(this, true);
      }
      else if(i != 0)
      {
        QUICKCPPLIB_ANNOTATE_RWLOCK_RELEASED(this, false);
      }
#endif
      QUICKCPPLIB_ANNOTATE_RWLOCK_DESTROY(this);
    }

Member Function Documentation

operator=() [1/2]

template<typename T>

shared_spinlockbase & quickcpplib::_xxx::configurable_spinlock::shared_spinlockbase< T >::operator= ( const shared_spinlockbase< T > & )

delete

operator=() [2/2]

template<typename T>

shared_spinlockbase & quickcpplib::_xxx::configurable_spinlock::shared_spinlockbase< T >::operator= ( shared_spinlockbase< T > && )

delete

load()

template<typename T>

T quickcpplib::_xxx::configurable_spinlock::shared_spinlockbase< T >::load ( memory_order o = memory_order_seq_cst ) const

inlineconstexprnoexcept

Returns the raw atomic.

{ return _v.load(o); }

store()

template<typename T>

void quickcpplib::_xxx::configurable_spinlock::shared_spinlockbase< T >::store ( T a, memory_order o = memory_order_seq_cst )

inlinenoexcept

Sets the raw atomic.

{ _v.store(a, o); }

try_lock()

template<typename T>

bool quickcpplib::_xxx::configurable_spinlock::shared_spinlockbase< T >::try_lock ( )

inlinenoexcept

Tries to lock the spinlock for exclusive access, returning true if successful.

    {
      value_type i = _v.load(memory_order_relaxed), o = i;
      // If locked by anybody, bail out immediately
      if(i)
        return false;
      o = 1;
      if(_v.compare_exchange_weak(i, o, memory_order_acquire, memory_order_relaxed))
      {
        QUICKCPPLIB_ANNOTATE_RWLOCK_ACQUIRED(this, true);
        return true;
      }
      return false;
    }

unlock()

template<typename T>

void quickcpplib::_xxx::configurable_spinlock::shared_spinlockbase< T >::unlock ( )

inlinenoexcept

Releases the lock from exclusive access.

    {
      // assert(_v == 1);
      QUICKCPPLIB_ANNOTATE_RWLOCK_RELEASED(this, true);
      _v.store(0, memory_order_release);
    }

try_lock_shared()

template<typename T>

bool quickcpplib::_xxx::configurable_spinlock::shared_spinlockbase< T >::try_lock_shared ( )

inlinenoexcept

Tries to lock the spinlock for shared access, returning true if successful.

    {
      // OR in the exclusive lock bit
      value_type i = _v.fetch_or(1, memory_order_acquire);
      if(i & 1)
        return false;
      // If not locked, increment reader count and unlock
      i += 2;
      i &= ~1;
      _v.store(i, memory_order_release);
      QUICKCPPLIB_ANNOTATE_RWLOCK_ACQUIRED(this, false);
      return true;
    }

unlock_shared()

template<typename T>

void quickcpplib::_xxx::configurable_spinlock::shared_spinlockbase< T >::unlock_shared ( )

inlinenoexcept

Releases the lock from shared access.

    {
      value_type i;
      for(size_t n = 0;; n++)
      {
        i = _v.fetch_or(1, memory_order_acquire);
        // assert(i > 1);
        if(!(i & 1))
          break;
        // For very heavily contended locks, stop thrashing the cache line
        if(n > 2)
        {
          for(size_t m = 0; m < 15000; m = m + 1)
          {
            volatile int x = 1;
            (void) x;
          }
        }
      }
      QUICKCPPLIB_ANNOTATE_RWLOCK_RELEASED(this, false);
      i -= 2;
      i &= ~1;
      _v.store(i, memory_order_release);
    }

try_convert_lock_to_shared()

template<typename T>

bool quickcpplib::_xxx::configurable_spinlock::shared_spinlockbase< T >::try_convert_lock_to_shared ( )

inlinenoexcept

Tries to convert an exclusive lock to a shared lock, returning true if successful.

    {
      value_type expected = 1;
      return _v.compare_exchange_strong(expected, 2, memory_order_acquire, memory_order_relaxed);
    }

try_convert_lock_to_exclusive()

template<typename T>

bool quickcpplib::_xxx::configurable_spinlock::shared_spinlockbase< T >::try_convert_lock_to_exclusive ( )

inlinenoexcept

Tries to convert a shared lock to an exclusive lock, returning true if successful.

    {
      value_type expected = 2;
      return _v.compare_exchange_strong(expected, 1, memory_order_acquire, memory_order_relaxed);
    }

int_yield()

template<typename T>

bool quickcpplib::_xxx::configurable_spinlock::shared_spinlockbase< T >::int_yield ( size_t )

inlinenoexcept

{ return false; }

Member Data Documentation

_v

template<typename T>

atomic<value_type> quickcpplib::_xxx::configurable_spinlock::shared_spinlockbase< T >::_v

protected

---

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

• include/quickcpplib/spinlock.hpp