density
C++11 library for paged memory management, function queues, heterogeneous queues and lifo memory management
|
#include <conc_function_queue.h>
Public Types | |
template<typename ELEMENT_COMPLETE_TYPE > | |
using | put_transaction = typename UnderlyingQueue::template put_transaction< ELEMENT_COMPLETE_TYPE > |
template<typename ELEMENT_COMPLETE_TYPE > | |
using | reentrant_put_transaction = typename UnderlyingQueue::template reentrant_put_transaction< ELEMENT_COMPLETE_TYPE > |
using | consume_operation = typename UnderlyingQueue::consume_operation |
using | reentrant_consume_operation = typename UnderlyingQueue::reentrant_consume_operation |
Public Member Functions | |
conc_function_queue () noexcept=default | |
conc_function_queue (conc_function_queue &&i_source) noexcept=default | |
conc_function_queue & | operator= (conc_function_queue &&i_source) noexcept=default |
~conc_function_queue () | |
template<typename ELEMENT_COMPLETE_TYPE > | |
void | push (ELEMENT_COMPLETE_TYPE &&i_source) |
template<typename ELEMENT_COMPLETE_TYPE , typename... CONSTRUCTION_PARAMS> | |
void | emplace (CONSTRUCTION_PARAMS &&...i_construction_params) |
template<typename ELEMENT_TYPE > | |
put_transaction< typename std::decay< ELEMENT_TYPE >::type > | start_push (ELEMENT_TYPE &&i_source) |
template<typename ELEMENT_TYPE , typename... CONSTRUCTION_PARAMS> | |
put_transaction< ELEMENT_TYPE > | start_emplace (CONSTRUCTION_PARAMS &&...i_construction_params) |
template<typename ELEMENT_COMPLETE_TYPE > | |
void | reentrant_push (ELEMENT_COMPLETE_TYPE &&i_source) |
template<typename ELEMENT_COMPLETE_TYPE , typename... CONSTRUCTION_PARAMS> | |
void | reentrant_emplace (CONSTRUCTION_PARAMS &&...i_construction_params) |
template<typename ELEMENT_TYPE > | |
reentrant_put_transaction< typename std::decay< ELEMENT_TYPE >::type > | start_reentrant_push (ELEMENT_TYPE &&i_source) |
template<typename ELEMENT_TYPE , typename... CONSTRUCTION_PARAMS> | |
reentrant_put_transaction< ELEMENT_TYPE > | start_reentrant_emplace (CONSTRUCTION_PARAMS &&...i_construction_params) |
std::conditional< std::is_void< RET_VAL >::value, bool, optional< RET_VAL > >::type | try_consume (PARAMS...i_params) |
std::conditional< std::is_void< RET_VAL >::value, bool, optional< RET_VAL > >::type | try_consume (consume_operation &i_consume, PARAMS...i_params) |
std::conditional< std::is_void< RET_VAL >::value, bool, optional< RET_VAL > >::type | try_reentrant_consume (PARAMS...i_params) |
std::conditional< std::is_void< RET_VAL >::value, bool, optional< RET_VAL > >::type | try_reentrant_consume (reentrant_consume_operation &i_consume, PARAMS...i_params) |
template<function_type_erasure ERASURE_ = ERASURE, typename std::enable_if< ERASURE_!=function_manual_clear >::type * = nullptr> | |
void | clear () noexcept |
bool | empty () noexcept |
Static Public Attributes | |
static constexpr bool | concurrent_puts = true |
static constexpr bool | concurrent_consumes = true |
static constexpr bool | concurrent_put_consumes = true |
static constexpr bool | is_seq_cst = true |
Friends | |
void | swap (conc_function_queue &i_first, conc_function_queue &i_second) noexcept |
Thread-safe heterogeneous FIFO pseudo-container specialized to hold callable objects. conc_function_queue is an adaptor for conc_heter_queue.
CALLABLE | Signature required to the callable objects. Must be in the form RET_VAL (PARAMS...) |
ALLOCATOR_TYPE | Allocator type to be used. This type must satisfy the requirements of both UntypedAllocator and PagedAllocator. The default is density::default_allocator. |
ERASURE | Type erasure to use the callable objects. Must be a member of density::function_type_erasure. |
conc_function_queue is basically a function_queue protected from data-races by a mutex. Non-reentrant operations (put or consumes) lock the mutex only once. Reentrant operations lock the mutex once when starting, and a second time to commit or cancel. Anyway in the middle of the operation the queue is not locked, and it can be used by the same thread or by other threads.
reentrant_put_transaction::commit
, reentrant_put_transaction::cancel
, reentrant_consume_operation::commit
and reentrant_consume_operation::cancel
are all noexcept functions that lock a mutex in a controlled context (no reentrancy, no callbacks, no possibility of deadlocks). The lock of the mutex should never throw in this context, but if for some reasons it does, the runtime will call std::terminate.
If ERASURE == function_manual_clear, conc_function_queue is not able to destroy the callable objects without invoking them. This produces a performance benefit, but:
Implementation note: If ERASURE == function_manual_clear, a runtime type associated with a value is actually a pointer to a function that invokes and destroys the callable object. In this case the size of a value is a pair of pointers, plus the capture (if any).
If ERASURE == function_standard_erasure the runtime type has an additional pointer to a function that destroys the callable object without invoking it.
Thread safeness: Put and consumes can be executed concurrently.
Exception safeness: Any function of conc_function_queue is noexcept or provides the strong exception guarantee.
using put_transaction = typename UnderlyingQueue::template put_transaction<ELEMENT_COMPLETE_TYPE> |
Alias to conc_heter_queue::put_transaction.
using reentrant_put_transaction = typename UnderlyingQueue::template reentrant_put_transaction<ELEMENT_COMPLETE_TYPE> |
using consume_operation = typename UnderlyingQueue::consume_operation |
Alias to lf_heter_queue::consume_operation.
using reentrant_consume_operation = typename UnderlyingQueue::reentrant_consume_operation |
|
defaultnoexcept |
Default constructor.
|
defaultnoexcept |
Move constructor.
|
inline |
Destructor
|
defaultnoexcept |
Move assignment.
|
inline |
Adds at the end of the queue a callable object.
See conc_heter_queue::push for a detailed description.
|
inline |
Adds at the end of the queue a callable object of type ELEMENT_COMPLETE_TYPE
, in-place-constructing it from a perfect forwarded parameter pack.
Note: the template argument ELEMENT_COMPLETE_TYPE
can't be deduced from the parameters so it must explicitly specified.
See conc_heter_queue::emplace for a detailed description.
|
inline |
Begins a transaction that appends an element of type ELEMENT_TYPE
, copy-constructing or move-constructing it from the source.
See conc_heter_queue::start_push for a detailed description.
Examples
|
inline |
Begins a transaction that appends an element of a type ELEMENT_TYPE
, in-place-constructing it from a perfect forwarded parameter pack.
See conc_heter_queue::start_emplace for a detailed description.
Examples
|
inline |
Adds at the end of the queue a callable object.
See conc_heter_queue::reentrant_push for a detailed description.
|
inline |
Adds at the end of the queue a callable object of type ELEMENT_COMPLETE_TYPE
, in-place-constructing it from a perfect forwarded parameter pack.
Note: the template argument ELEMENT_COMPLETE_TYPE
can't be deduced from the parameters so it must explicitly specified.
See conc_heter_queue::reentrant_emplace for a detailed description.
|
inline |
Begins a transaction that appends an element of type ELEMENT_TYPE
, copy-constructing or move-constructing it from the source.
See conc_heter_queue::start_reentrant_push for a detailed description.
Examples
|
inline |
Begins a transaction that appends an element of a type ELEMENT_TYPE
, in-place-constructing it from a perfect forwarded parameter pack.
See conc_heter_queue::start_reentrant_emplace for a detailed description.
Examples
|
inline |
If the queue is not empty, invokes the first function object of the queue and then deletes it from the queue. Otherwise no operation is performed.
i_params... | parameters to be forwarded to the function object |
This function is not reentrant: if the callable object accesses in any way this queue, the behavior is undefined. Use conc_function_queue::try_reentrant_consume if you are not sure about what the callable object may do.
Throws: unspecified
Exception guarantee: strong (in case of exception the function has no observable effects).
|
inline |
If the queue is not empty, invokes the first function object of the queue and then deletes it from the queue. Otherwise no operation is performed. The consume operation is performed using the provided consume_operation object.
i_consume | object to use for the consume operation |
i_params... | parameters to be forwarded to the function object |
This function is not reentrant: if the callable object accesses in any way this queue, the behavior is undefined. Use conc_function_queue::try_reentrant_consume if you are not sure about what the callable object may do.
Throws: unspecified
Exception guarantee: strong (in case of exception the function has no observable effects).
|
inline |
If the queue is not empty, invokes the first function object of the queue and then deletes it from the queue. Otherwise no operation is performed.
i_params... | parameters to be forwarded to the function object |
This function is reentrant: the callable object can access in any way this queue.
Throws: unspecified
Exception guarantee: strong (in case of exception the function has no observable effects).
|
inline |
If the queue is not empty, invokes the first function object of the queue and then deletes it from the queue. Otherwise no operation is performed. The consume operation is performed using the provided consume_operation object.
i_consume | object to use for the consume operation |
i_params... | parameters to be forwarded to the function object |
This function is reentrant: the callable object can access in any way this queue.
Throws: unspecified
Exception guarantee: strong (in case of exception the function has no observable effects).
|
inlinenoexcept |
Deletes all the callable objects in the queue. This function is disabled at compile-time if ERASURE is function_manual_clear.
Effects on iterators : all the iterators are invalidated
Throws: nothing
Complexity: linear.
|
inlinenoexcept |
Returns whether this container is empty
|
friend |
Swaps two function queues.
|
static |
Whether multiple threads can do put operations on the same queue without any further synchronization.
|
static |
Whether multiple threads can do consume operations on the same queue without any further synchronization.
|
static |
Whether puts and consumes can be done concurrently without any further synchronization. In any case unsynchronized concurrency is constrained by concurrent_puts and concurrent_consumes.
|
static |
Whether this queue is sequential consistent.