AtomicPtr< T > Class Template Reference

#include <atomictypes.h>

Detailed Description

template<typename T>
class maxon::AtomicPtr< T >

Atomic pointer template.

= Relaxed Ordering : Relaxed ordering means that stores to or loads from a memory location can be reordered by the CPU which means that other threads may observe a completely different order of loads and stores than what your thread seems to do.

= Acquire-Release Ordering : If another thread has released a store on a memory location it is guaranteed that after a load with acquire memory order all following loads will see the (relaxed) stores that preceded the release. Furthermore subsequent loads or stores will not be speculatively executed before this load.

= Sequentially Consistent Ordering : As the name implies operations with this ordering appear in the same order to other threads. This comes at the cost of relatively expensive synchronization between the CPU cores.

By default all memory accesses in C++ are relaxed, any write or read to a variable can be reordered by the CPU. Please note that even if your target CPU does not change the order of memory accesses the C compiler may do so. x86 style CPUs adhere to acquire-release ordering for most memory accesses as long as you don't make use of SSE/AVX. This means that multi threaded code without atomic variables appears to run just fine as long as the compiler doesn't reorder accesses. Of course this code might fail miserably on other platforms (e.g. ARM) or when a new compiler performs optimizations. Therefore you should use AtomicInt

Public Types

using ValueType = T *
 

Public Member Functions

MAXON_IMPLICIT AtomicPtr (T *newValue=(T *) nullptr)
 
T * Get () const
 
void Set (T *newValue)
 
T * Load () const
 
void Store (T *newValue)
 
T * LoadRelaxed () const
 
void StoreRelaxed (T *newValue)
 
T * LoadAcquire () const
 
void StoreRelease (T *newValue)
 
T * LoadConsume () const
 
Bool TryCompareAndSwap (T *newValue, T *compare)
 
T * Swap (T *newValue)
 

Static Public Member Functions

static T * LoadAcquire (T *volatile *v)
 
static void StoreRelease (T *volatile *v, T *newValue)
 
static T * LoadConsume (T *volatile *v)
 
static Bool TryCompareAndSwap (T *volatile *dst, T *newValue, T *compare)
 
static T * Swap (T *volatile *dst, T *newValue)
 

Private Member Functions

 MAXON_DISALLOW_COPY_AND_ASSIGN (AtomicPtr)
 

Private Attributes

T *volatile _ptr
 

Member Typedef Documentation

◆ ValueType

using ValueType = T*

Constructor & Destructor Documentation

◆ AtomicPtr()

MAXON_IMPLICIT AtomicPtr ( T *  newValue = (T*) nullptr)

Member Function Documentation

◆ MAXON_DISALLOW_COPY_AND_ASSIGN()

MAXON_DISALLOW_COPY_AND_ASSIGN ( AtomicPtr< T >  )
private

◆ Get()

T* Get ( void  ) const

Default routine to get an atomic value. It is identical to Load() with sequentially consistent memory order. Other routines might deliver improved performance.

Returns
Read memory location content.

◆ Set()

void Set ( T *  newValue)

Default routine to set an atomic value. It is identical to Store() with sequentially consistent memory order. Other routines might deliver improved performance.

Parameters
[in]newValueValue to be stored.

◆ Load()

T* Load ( ) const

Atomic load with sequentially consistent memory order.

Returns
Read memory location content.

◆ Store()

void Store ( T *  newValue)

Atomic store with sequentially consistent memory order.

Parameters
[in]newValueValue to be stored.

◆ LoadRelaxed()

T* LoadRelaxed ( ) const

Atomic load with relaxed memory order. This load is completely unordered (might be prefetched). You should only use it within the same thread when guarded with preceding acquire load or a fence. Fences are implicitly created by TryCompareAndSwap, Swap, SwapAdd, SwapIncrement, SwapDecrement and by locks.

Returns
Read memory location content.

◆ StoreRelaxed()

void StoreRelaxed ( T *  newValue)

Atomic store with relaxed memory order. This store is completely unordered. You should only use it within the same thread when guarded by a following release store or a fence.

Parameters
[in]newValueValue to be stored.

◆ LoadAcquire() [1/2]

T* LoadAcquire ( ) const

Atomic load with acquire memory order. If another thread has released a store on this location it is guaranteed that after a load with acquire memory order all following loads will see the (relaxed) stores that preceded the release. Furthermore subsequent loads or stores will not be speculatively executed before this load. This is equivalent to a relaxed load followed by a MemoryFenceAcquire().

Returns
Read memory location content.

◆ StoreRelease() [1/2]

void StoreRelease ( T *  newValue)

Atomic store with release memory order. As soon as another thread reads on this location using LoadAcquire() and obtains the stored value it is guaranteed that all prior (relaxed) stores are visible to it. This is equivalent to a MemoryFenceRelease() followed by a relaxed store.

Parameters
[in]newValueValue to be stored.

◆ LoadConsume() [1/2]

T* LoadConsume ( ) const

Atomic load with consume memory order. If another thread has released a store on this location it is guaranteed that after a load with consume memory order that reads the value stored direct dependencies are synchronized (e.g. if the value is a pointer to a structure you can safely access the elements of the structure that have been written before the release). This means that unrelated loads following this method might be reordered by the compiler or the CPU and can be executed before it. For most CPU architectures this the same instruction as an ordinary load which implies no performance penalty compared to a load with relaxed memory order.

Returns
Read memory location content.

◆ TryCompareAndSwap() [1/2]

Bool TryCompareAndSwap ( T *  newValue,
T *  compare 
)

Atomic compare and swap with sequentially consistent memory order. If the previous memory location value equals compare newValue is written to the memory location and true is returned. If the memory location contained a different value it is not changed and false will be returned. If the value is exchanged this call enforces a sequentially consistent memory order which means that it might require potentially expensive synchronization between the CPUs.

Parameters
[in]newValueValue to be stored if memory location contains compare.
[in]compareValue to compare with memory location.
Returns
True if the memory value was exchanged.

◆ Swap() [1/2]

T* Swap ( T *  newValue)

Atomic swap with sequentially consistent memory order. Exchanges the value of the memory location with newValue and returns the previous value. This call enforces a sequentially consistent memory order which means that it might require potentially expensive synchronization between the CPUs.

Parameters
[in]newValueValue to be stored.
Returns
Previous value of the memory location.

◆ LoadAcquire() [2/2]

static T* LoadAcquire ( T *volatile *  v)
static

Atomic load with acquire memory order. If another thread has released a store on this location it is guaranteed that after a load with acquire memory order all following loads will see the (relaxed) stores that preceded the release. Furthermore subsequent loads or stores will not be speculatively executed before this load. This is equivalent to a relaxed load followed by a MemoryFenceAcquire().

Parameters
[in]vMemory location.
Returns
Read memory location content.

◆ StoreRelease() [2/2]

static void StoreRelease ( T *volatile *  v,
T *  newValue 
)
static

Atomic store with release memory order. As soon as another thread reads on this location using LoadAcquire() and obtains the stored value it is guaranteed that all prior (relaxed) stores are visible to it. This is equivalent to a MemoryFenceRelease() followed by a relaxed store.

Parameters
[in]vMemory location.
[in]newValueValue to be stored.

◆ LoadConsume() [2/2]

static T* LoadConsume ( T *volatile *  v)
static

Atomic load with consume memory order. If another thread has released a store on this location it is guaranteed that after a load with consume memory order that reads the value stored direct dependencies are synchronized (e.g. if the value is a pointer to a structure you can safely access the elements of the structure that have been written before the release). This means that unrelated loads following this method might be reordered by the compiler or the CPU and can be executed before it. For most CPU architectures this the same instruction as an ordinary load which implies no performance penalty compared to a load with relaxed memory order.

Parameters
[in]vMemory location.
Returns
Read memory location content.

◆ TryCompareAndSwap() [2/2]

static Bool TryCompareAndSwap ( T *volatile *  dst,
T *  newValue,
T *  compare 
)
static

Atomic compare and swap with sequentially consistent memory order. If the previous memory location value equals compare newValue is written to the memory location and true is returned. If the memory location contained a different value it is not changed and false will be returned. If the value is exchanged this call enforces a sequentially consistent memory order which means that it might require potentially expensive synchronization between the CPUs.

Parameters
[in]dstPointer to the memory location.
[in]newValueValue to be stored if memory location contains compare.
[in]compareValue to compare with memory location.
Returns
True if the memory value was exchanged.

◆ Swap() [2/2]

static T* Swap ( T *volatile *  dst,
T *  newValue 
)
static

Atomic swap with sequentially consistent memory order. Exchanges the value of the memory location with newValue and returns the previous value. This call enforces a sequentially consistent memory order which means that it might require potentially expensive synchronization between the CPUs.

Parameters
[in]dstPointer to the memory location.
[in]newValueValue to be stored.
Returns
Previous value of the memory location.

Member Data Documentation

◆ _ptr

T* volatile _ptr
private