#include <ListLockFree.hpp>
Classes | |
struct | Item |
struct | StorageImpl |
Public Types | |
typedef T | value_t |
Public Member Functions | |
bool | append (value_t item) |
size_t | append (const std::vector< T > &items) |
template<class Function > | |
void | apply (Function func) |
template<class Function > | |
void | apply_and_blank (Function func, value_t blank) |
value_t | back () const |
size_t | capacity () const |
void | clear () |
template<typename Pred > | |
bool | delete_if (Pred pred) |
bool | empty () const |
bool | erase (value_t item) |
bool | erase_and_blank (value_t item, value_t blank) |
template<class Function > | |
value_t | find_if (Function func, value_t blank=value_t()) |
value_t | front () const |
void | grow (size_t items=1) |
ListLockFree (unsigned int lsize, unsigned int threads=ORONUM_OS_MAX_THREADS) | |
void | reserve (size_t lsize) |
void | shrink (size_t items=1) |
size_t | size () const |
~ListLockFree () | |
Public Attributes | |
const unsigned int | MAX_THREADS |
The maximum number of threads. More... | |
Private Types | |
typedef std::vector< value_t > | BufferType |
typedef BufferType::const_iterator | CIterator |
typedef BufferType::iterator | Iterator |
typedef boost::intrusive_ptr< StorageImpl > | Storage |
Private Member Functions | |
size_t | BufNum () const |
Item * | findEmptyBuf (Storage &bufptr) |
Item * | lockAndGetActive (Storage &bufptr) const |
Item * | lockAndGetActive () const |
Item * | lockAndGetBlank (Storage &bufptr) const |
Storage | newStorage (size_t alloc, size_t items, bool init=true) |
bool | pointsTo (Item *p, const Storage &bf) const |
Private Attributes | |
Item *volatile | active |
Item *volatile | blankp |
Storage | bufs |
size_t | required |
A simple lock-free list implementation to append or erase data of type T. If T is a value type, no memory allocation is done during appending or erasing. The maximum number of threads which can access this object is defined by MAX_THREADS.
T | The value type to be stored in the list. If T is a type that does memory allocation or deallocation in copy-constructor or destructor, certain functions of this list will not be real-time. Example : ListLockFree is a list which holds values of type A. |
Definition at line 85 of file ListLockFree.hpp.
|
private |
Definition at line 97 of file ListLockFree.hpp.
|
private |
Definition at line 99 of file ListLockFree.hpp.
|
private |
Definition at line 98 of file ListLockFree.hpp.
|
private |
The intrusive_ptr is far more thread-safe than the shared_ptr for 'reads' during 'assignments'.
Definition at line 126 of file ListLockFree.hpp.
typedef T RTT::internal::ListLockFree< T >::value_t |
Definition at line 95 of file ListLockFree.hpp.
|
inline |
Create a lock-free list wich can store lsize elements.
lsize | the capacity of the list. |
threads | the number of threads which may concurrently read or write this buffer. Defaults to ORONUM_OS_MAX_THREADS, but you may lower this number in case not all threads will read this buffer. A lower number will consume less memory. ' |
Definition at line 164 of file ListLockFree.hpp.
|
inline |
Definition at line 171 of file ListLockFree.hpp.
|
inline |
Append a single value to the list. This function calls the copy-constructor of item and may call the destructor of item
item | the value to write |
Definition at line 344 of file ListLockFree.hpp.
|
inline |
Append a sequence of values to the list.
items | the values to append. |
Definition at line 401 of file ListLockFree.hpp.
|
inline |
Apply a function to the elements of the whole list.
func | The function to apply. |
Definition at line 524 of file ListLockFree.hpp.
|
inline |
Apply a function to the non-blanked elements of the list. If during an apply_and_blank, the erase_and_blank function is called, that element will not be subject to func if not yet processed. You must not call this function concurrently from multiple threads.
func | The function to apply. |
blank | The 'blank' item. Each item of this list will be compared to this item using operator==(), if it matches, it is considered blank, and func is not applied. |
Definition at line 552 of file ListLockFree.hpp.
|
inline |
Returns the last element of the list.
Definition at line 385 of file ListLockFree.hpp.
|
inlineprivate |
Definition at line 150 of file ListLockFree.hpp.
|
inline |
Returns the maximum number of elements this list can hold.
Definition at line 178 of file ListLockFree.hpp.
|
inline |
Clears all elements in the list.
Definition at line 316 of file ListLockFree.hpp.
|
inline |
Erase a value from the list.
function | each elements for which pred returns true are removed |
Definition at line 480 of file ListLockFree.hpp.
|
inline |
Returns true if this list is empty.
Definition at line 206 of file ListLockFree.hpp.
|
inline |
Erase a value from the list.
item | is to be erased from the list. |
Definition at line 438 of file ListLockFree.hpp.
|
inline |
Erase an element from the list and blank it if possible. If during an apply_and_blank, the erase_and_blank function is called, that element will not be subject to func if not yet processed. You may call this function concurrently from multiple threads.
item | The item to erase from the list. |
blank | The 'blank' item to use to blank item from the list. |
Definition at line 597 of file ListLockFree.hpp.
|
inline |
Find an item in the list such that func( item ) == true.
blank | The value to return if not found. |
Definition at line 626 of file ListLockFree.hpp.
|
inlineprivate |
Item returned is guaranteed to point into bufptr. This function calls all destructors of all old elements in the empty buf, by using the std::vector::clear() function. This means that if a destructor of T is not real-time, all functions calling this function are not real-time as well. For example, append() and erase().
Definition at line 649 of file ListLockFree.hpp.
|
inline |
Returns the first element of the list.
Definition at line 373 of file ListLockFree.hpp.
|
inline |
Grow the capacity to contain at least n additional items. This method tries to avoid too much re-allocations, by growing a bit more than required every N invocations and growing nothing in between.
items | The number of items to at least additionally reserve. |
Definition at line 224 of file ListLockFree.hpp.
|
inlineprivate |
Item returned is guaranteed to point into bufptr.
Definition at line 670 of file ListLockFree.hpp.
|
inlineprivate |
Only to be used by reserve() ! Caller must guarantee that active points to valid memory.
Definition at line 698 of file ListLockFree.hpp.
|
inlineprivate |
Get the blank buffer or null if no apply_and_blank operation going on.
Definition at line 716 of file ListLockFree.hpp.
|
inlineprivate |
Definition at line 128 of file ListLockFree.hpp.
|
inlineprivate |
Definition at line 739 of file ListLockFree.hpp.
|
inline |
Reserve a capacity for this list. If you wish to invoke this method concurrently, guard it with a mutex. The other methods may be invoked concurrently with this method.
lsize | the minimal number of items this list will be able to hold. Will not drop below the current capacity() and this method will do nothing if lsize < this->capacity(). @ Not real-time if lsize <= this->capacity(). |
Definition at line 252 of file ListLockFree.hpp.
|
inline |
Shrink the capacity with at most n items. This method does not actually free memory, it just prevents a (number of) subsequent grow() invocations to allocate more memory.
items | The number of items to at most remove from the capacity. |
Definition at line 238 of file ListLockFree.hpp.
|
inline |
Returns the current number of elements in this list.
Definition at line 192 of file ListLockFree.hpp.
|
private |
Definition at line 144 of file ListLockFree.hpp.
|
private |
Definition at line 145 of file ListLockFree.hpp.
|
private |
Definition at line 143 of file ListLockFree.hpp.
const unsigned int RTT::internal::ListLockFree< T >::MAX_THREADS |
The maximum number of threads.
The number of threads which may concurrently access this buffer.
Definition at line 93 of file ListLockFree.hpp.
|
private |
Definition at line 154 of file ListLockFree.hpp.