fesa::Atomic< T > Class Template Reference

#include <Atomic.h>

Inherits noncopyable.

Inherited by fesa::AtomicInteger< T >.

Public Member Functions
	Atomic (T initialValue=0)
	Atomic (char *memory, bool aligned, T initialValue=0, bool ignoreInitialValue=false)
T	load () const
void	store (T value)
bool	compareAndExchange (T &expected, const T desired)

Static Public Member Functions
static void	checkAlignment (const char *pointer)

Static Public Attributes
static const std::size_t	alignment = sizeof(T)
static const std::size_t	unalignedSize = Aligned<T>::unalignedSize

Static Protected Member Functions
static boost::atomic< T > *	alignAndCreate (char *memory, T initialValue, bool ignoreInitialValue=false)
static boost::atomic< T > *	create (char *memory, T initialValue, bool ignoreInitialValue=false)

Protected Attributes
boost::atomic< T > *	value_
bool	mine_

Detailed Description

template<typename T>
class fesa::Atomic< T >

Wrapper class for atomic types. Can either use preexisting memory, or allocate it. All operations on Atomic<T> objects are guaranteed to be atomic. Additionally, all operations on Atomic<T> objects instantiated on preexisting memory are guaranteed to be lock-free. Instantiable with all integral types (bool included) from 8 to 64 bits.

Constructor & Destructor Documentation

template<typename T>

fesa::Atomic< T >::Atomic ( T  initialValue = 0 )

explicit

Allocates and creates an atomic type.

Parameters

initialValue

the initial value

template<typename T>

fesa::Atomic< T >::Atomic	(	char *	memory,
		bool	aligned,
		T	initialValue = 0,
		bool	ignoreInitialValue = false
	)

Creates an atomic type from arbitrary memory. The memory buffer given must satisfy one of these conditions: A. Have a size of sizeof(T) and be aligned properly (for x86 and x64, this means aligned on sizeof(T)) B. Have a size of Atomic<T>::unalignedSize; the alignment doesn't matter then. In case A, the aligned parameter must be true; in case B, it must be false. Additionally, in case A, alignment will be checked and an exception thrown if the pointer is unaligned.

Parameters

memory	pointer to the memory to use
aligned	whether the memory pointer is properly aligned
initialValue	the initial value to give to this object. If not given, object is initialized to 0.
ignoreInitialValue	if true, the atomic created is left uninitialized.

Exceptions

FesaException	if aligned is true, but memory is not properly aligned.
FesaException	if current platform doesn't support lock-free atomic operations on T.

Member Function Documentation

template<typename T>

boost::atomic< T > * fesa::Atomic< T >::alignAndCreate ( char *  memory, T  initialValue, bool  ignoreInitialValue = false  )

staticprotected

Allocates a boost::atomic<T> on the memory pointer given, ensuring proper alignment. The memory pointer must point to a memory buffer of at least Atomic<T>::unalignedSize bytes.

Parameters

memory	pointer to a buffer where the atomic type will be allocated
initialValue	initial value to give to the object
ignoreInitialValue	if true, the atomic created is left uninitialized.

Returns

the newly created boost::atomic<T>

template<typename T >

void fesa::Atomic< T >::checkAlignment ( const char *  pointer )

static

Checks the alignment of pointer and throws if it is not properly aligned for T.

Parameters

pointer

the pointer to check

template<typename T>

bool fesa::Atomic< T >::compareAndExchange ( T &  expected, const T  desired  )

inline

Stores the desired value in the object only if its current value is equal to the expected value. In all cases, writes the previous value to expected.

Parameters

expected	the expected value of the object
desired	the desired value to store in the object

Returns

true in case of success, false otherwise

template<typename T>

boost::atomic< T > * fesa::Atomic< T >::create ( char *  memory, T  initialValue, bool  ignoreInitialValue = false  )

staticprotected

Allocates a boost::atomic<T> on the memory pointer given. The pointer must be properly aligned. Alignment is checked and this function will throw if it is not correct. The size of the buffer pointed to by memory must be at least sizeof(T) bytes.

Parameters

memory	pointer to a buffer where the atomic type will be allocated
initialValue	initial value to give to the object
ignoreInitialValue	if true, the atomic created is left uninitialized.

Returns

the newly created boost::atomic<T>

template<typename T >

T fesa::Atomic< T >::load ( ) const

inline

Returns

the current value of the object.

template<typename T>

void fesa::Atomic< T >::store ( T  value )

inline

Stores the given value in the object.

Parameters

value

the value to store.

Member Data Documentation

template<typename T>

const std::size_t fesa::Atomic< T >::alignment = sizeof(T)

static

Contains the required alignment for T.

template<typename T>

bool fesa::Atomic< T >::mine_

protected

Whether memory was allocated by this object or given as a paremeter to the constructor

template<typename T>

const std::size_t fesa::Atomic< T >::unalignedSize = Aligned<T>::unalignedSize

static

Contains the required unaligned memory size to ensure an aligned T can be allocated.

template<typename T>

boost::atomic<T>* fesa::Atomic< T >::value_

protected

Pointer to the wrapped atomic type

---

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

• Atomic.h
• Atomic.cpp