quickcpplib::_xxx::configurable_spinlock::spinlock< T, spinpolicy2, spinpolicy3, spinpolicy4 > Class Template Reference

A non-FIFO policy configurable spin lock meeting the Mutex concept providing the fastest possible spin lock. More...

#include "spinlock.hpp"

Inheritance diagram for quickcpplib::_xxx::configurable_spinlock::spinlock< T, spinpolicy2, spinpolicy3, spinpolicy4 >:

Public Member Functions
constexpr	spinlock ()
	spinlock (const spinlock &)=delete
constexpr	spinlock (spinlock &&o) noexcept
void	lock () noexcept
bool	lock (T only_if_not_this) noexcept
	Locks if the atomic is not the supplied value, else returning false.

Detailed Description

template<typename T, template< class > class spinpolicy2 = spins_to_loop<125>::policy, template< class > class spinpolicy3 = spins_to_yield<250>::policy, template< class > class spinpolicy4 = spins_to_sleep::policy>
class quickcpplib::_xxx::configurable_spinlock::spinlock< T, spinpolicy2, spinpolicy3, spinpolicy4 >

A non-FIFO policy configurable spin lock meeting the Mutex concept providing the fastest possible spin lock.

Template Parameters

T	An integral type capable of atomic usage

sizeof(spinlock<T>) == sizeof(T). Suitable for usage in shared memory.

Meets the requirements of BasicLockable and Lockable. Provides a get() and set() for the type used for the spin lock. Suitable for limited usage in constexpr.

Warning

spinlock<bool> which might seem obvious is usually slower than spinlock<uintptr_t> on most architectures.

So why reinvent the wheel?

1. Policy configurable spin.
2. Implemented in pure C++ 11 atomics so the thread sanitiser works as expected.
3. Multistate locks are possible instead of just 0|1.
4. I don't much care for doing writes during the spin which a lot of other spinlocks do. It generates an unnecessary amount of cache line invalidation traffic. Better to spin-read and only write when the read suggests you might have a chance.
5. This spin lock can use a pointer to memory as the spin lock at the cost of some performance. It uses the bottom bit as the locked flag. See locked_ptr<T>.

Constructor & Destructor Documentation

spinlock() [1/3]

template<typename T , template< class > class spinpolicy2 = spins_to_loop<125>::policy, template< class > class spinpolicy3 = spins_to_yield<250>::policy, template< class > class spinpolicy4 = spins_to_sleep::policy>

constexpr quickcpplib::_xxx::configurable_spinlock::spinlock< T, spinpolicy2, spinpolicy3, spinpolicy4 >::spinlock ( )

inlineconstexpr

{}

spinlock() [2/3]

template<typename T , template< class > class spinpolicy2 = spins_to_loop<125>::policy, template< class > class spinpolicy3 = spins_to_yield<250>::policy, template< class > class spinpolicy4 = spins_to_sleep::policy>

quickcpplib::_xxx::configurable_spinlock::spinlock< T, spinpolicy2, spinpolicy3, spinpolicy4 >::spinlock ( const spinlock< T, spinpolicy2, spinpolicy3, spinpolicy4 > &  )

delete

spinlock() [3/3]

template<typename T , template< class > class spinpolicy2 = spins_to_loop<125>::policy, template< class > class spinpolicy3 = spins_to_yield<250>::policy, template< class > class spinpolicy4 = spins_to_sleep::policy>

constexpr quickcpplib::_xxx::configurable_spinlock::spinlock< T, spinpolicy2, spinpolicy3, spinpolicy4 >::spinlock ( spinlock< T, spinpolicy2, spinpolicy3, spinpolicy4 > &&  o )

inlineconstexprnoexcept

        : parenttype(std::move(o))
    {
    }

Member Function Documentation

lock() [1/2]

template<typename T , template< class > class spinpolicy2 = spins_to_loop<125>::policy, template< class > class spinpolicy3 = spins_to_yield<250>::policy, template< class > class spinpolicy4 = spins_to_sleep::policy>

void quickcpplib::_xxx::configurable_spinlock::spinlock< T, spinpolicy2, spinpolicy3, spinpolicy4 >::lock ( )

inlinenoexcept

    {
      for(size_t n = 0;; n++)
      {
        if(parenttype::try_lock())
          return;
        parenttype::int_yield(n);
      }
    }

lock() [2/2]

template<typename T , template< class > class spinpolicy2 = spins_to_loop<125>::policy, template< class > class spinpolicy3 = spins_to_yield<250>::policy, template< class > class spinpolicy4 = spins_to_sleep::policy>

bool quickcpplib::_xxx::configurable_spinlock::spinlock< T, spinpolicy2, spinpolicy3, spinpolicy4 >::lock ( T  only_if_not_this )

inlinenoexcept

Locks if the atomic is not the supplied value, else returning false.

    {
      for(size_t n = 0;; n++)
      {
        T expected = 0;
        if(parenttype::try_lock(expected))
          return true;
        if(expected == only_if_not_this)
          return false;
        parenttype::int_yield(n);
      }
    }

---

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

• include/quickcpplib/spinlock.hpp