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

#include "spinlock.hpp"

Public Types
typedef T	value_type

Public Member Functions
constexpr	spinlockbase () noexcept
	spinlockbase (const spinlockbase &)=delete
constexpr	spinlockbase (spinlockbase &&) noexcept
	Atomically move constructs.
	~spinlockbase ()
spinlockbase &	operator= (const spinlockbase &)=delete
spinlockbase &	operator= (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
	If atomic is zero, sets to 1 and returns true, else false.
constexpr bool	try_lock () const noexcept
bool	try_lock (T &expected) noexcept
	If atomic equals expected, sets to 1 and returns true, else false with expected updated to actual value.
void	unlock () noexcept
	Sets the atomic to zero.
constexpr bool	int_yield (size_t) noexcept

Protected Attributes
atomic< T >	v

Member Typedef Documentation

value_type

template<typename T >

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

Constructor & Destructor Documentation

spinlockbase() [1/3]

template<typename T >

constexpr quickcpplib::_xxx::configurable_spinlock::spinlockbase< T >::spinlockbase ( )

inlineconstexprnoexcept

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

spinlockbase() [2/3]

template<typename T >

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

delete

spinlockbase() [3/3]

template<typename T >

constexpr quickcpplib::_xxx::configurable_spinlock::spinlockbase< T >::spinlockbase ( spinlockbase< T > &&  )

inlineconstexprnoexcept

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
    }

~spinlockbase()

template<typename T >

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

inline

    {
#ifdef QUICKCPPLIB_ENABLE_VALGRIND
      if(v.load(memory_order_acquire))
      {
        QUICKCPPLIB_ANNOTATE_RWLOCK_RELEASED(this, true);
      }
#endif
      QUICKCPPLIB_ANNOTATE_RWLOCK_DESTROY(this);
    }

Member Function Documentation

operator=() [1/2]

template<typename T >

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

delete

operator=() [2/2]

template<typename T >

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

delete

load()

template<typename T >

constexpr T quickcpplib::_xxx::configurable_spinlock::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::spinlockbase< T >::store ( T  a, memory_order  o = memory_order_seq_cst  )

inlinenoexcept

Sets the raw atomic.

{ v.store(a, o); }

try_lock() [1/3]

template<typename T >

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

inlinenoexcept

If atomic is zero, sets to 1 and returns true, else false.

    {
#if !QUICKCPPLIB_IN_THREAD_SANITIZER  // no early outs for the sanitizer
#ifdef QUICKCPPLIB_USE_VOLATILE_READ_FOR_AVOIDING_CMPXCHG
      // MSVC's atomics always seq_cst, so use volatile read to create a true acquire
      volatile T *_v = (volatile T *) &v;
      if(*_v)  // Avoid unnecessary cache line invalidation traffic
        return false;
#else
      if(v.load(memory_order_relaxed))  // Avoid unnecessary cache line invalidation traffic
        return false;
#endif
#endif
#if 0 /* Disabled as CMPXCHG seems to have sped up on recent Intel */  // defined(__i386__) || defined(_M_IX86) ||
                                                                       // defined(__x86_64__) || defined(_M_X64)
      // Intel is a lot quicker if you use XCHG instead of CMPXCHG. ARM is definitely not!
      T ret = v.exchange(1, memory_order_acquire);
      if(!ret)
#else
      T expected = 0;
      bool ret = v.compare_exchange_weak(expected, 1, memory_order_acquire, memory_order_relaxed);
      if(ret)
#endif
      {
        QUICKCPPLIB_ANNOTATE_RWLOCK_ACQUIRED(this, true);
        return true;
      }
      else return false;
    }

try_lock() [2/3]

template<typename T >

constexpr bool quickcpplib::_xxx::configurable_spinlock::spinlockbase< T >::try_lock ( ) const

inlineconstexprnoexcept

    {
      return v.load(memory_order_consume) ? false : true;  // Avoid unnecessary cache line invalidation traffic
    }

try_lock() [3/3]

template<typename T >

bool quickcpplib::_xxx::configurable_spinlock::spinlockbase< T >::try_lock ( T &  expected )

inlinenoexcept

If atomic equals expected, sets to 1 and returns true, else false with expected updated to actual value.

    {
      T t(0);
#if !QUICKCPPLIB_IN_THREAD_SANITIZER  // no early outs for the sanitizer
#ifdef QUICKCPPLIB_USE_VOLATILE_READ_FOR_AVOIDING_CMPXCHG
      // MSVC's atomics always seq_cst, so use volatile read to create a true acquire
      volatile T *_v = (volatile T *) &v;
      if((t = *_v))  // Avoid unnecessary cache line invalidation traffic
#else
      t = v.load(memory_order_relaxed);
      if(t)  // Avoid unnecessary cache line invalidation traffic
#endif
      {
        expected = t;
        return false;
      }
#endif
      bool ret = v.compare_exchange_weak(expected, 1, memory_order_acquire, memory_order_relaxed);
      if(ret)
      {
        QUICKCPPLIB_ANNOTATE_RWLOCK_ACQUIRED(this, true);
        return true;
      }
      else
        return false;
    }

unlock()

template<typename T >

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

inlinenoexcept

Sets the atomic to zero.

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

int_yield()

template<typename T >

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

inlineconstexprnoexcept

{ return false; }

Member Data Documentation

v

template<typename T >

atomic<T> quickcpplib::_xxx::configurable_spinlock::spinlockbase< T >::v

protected

---

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

• include/quickcpplib/spinlock.hpp