Concurrency

This library provides high level abstractions for implementing algorithms that eases the use of multiple CPU cores while minimizing the contention.

The future implementation differs in several aspects compared to the C++11/14/17 standard futures: It provides continuations and joins, which were just added in a C++17 TS. But more important this futures propagate values through the graph and not futures. This allows an easy way of creating splits. That means a single future can have multiple continuations into different directions.

An other important difference is that the futures support cancellation. So if one is not anymore interested in the result of a future, then one can destroy the future without the need to wait until the future is fulfilled, as it is the case with std::future (and boost::future). An already started future will run until its end, but will not trigger any continuation. So in all these cases, all chained continuations will never be triggered. Additionally the future interface is designed in a way, that one can use build in or custom build executors. This implies too, that the user has to take more care, that all references used inside the task associated with the future must either exist, or their meanwhile absence must be taken into account. (One appropriate mechanism here are weak and shared pointer.)

Since one can create with futures only graphs for single use, this library provides as well channels. With these channels one can build graphs, that can be used for multiple invocations.

Requirements

  • C++17 compliant compiler (clang, gcc 7, Visual Studio 2017)
  • boost 1.60.0 (optional, variant, if they are not available from the compiler and test for executing the UnitTests)

Authors

Sean Parent, Foster Brereton, Felix Petriconi and other contributors.

Examples

</table>
stlab::async async_example.cpp
 Creates a future running on a given executor
await await_example.cpp
 Called on an await-process whenever a new value was received from upstream.
stlab::buffer_size buffer_size_example.cpp
when_all when_all_example.cpp
when_all_void_example.cpp
 Creates a joining future
zip_with zip_with_example.cpp
 Creates a channel that zips multiple channels into a single one
concurrency/serial_queue.hpp serial_queue_example.cpp
 An executor wrapper that causes enqueued tasks to be run serially.
process process_example.cpp
 Describes a process that gets executed whenever a value is passed into the channel
buffer_size buffer_size_example.cpp
 buffer_size constructor
operator() call_operator_example.cpp
 Send a new value into the channel.
operator^ recover_example.cpp
 Creates a recoverable future on the current object.
operator| then_continuation_example.cpp
then_split_example.cpp
 Creates a continuation on the current future.
operator| operator_pipe_example.cpp
 Attaches a new process to the channel.
then then_continuation_example.cpp
then_split_example.cpp
 Creates a continuation on the current future.
operator co_await operator_co_await_example.cpp
 Creates a awaitable object on a given future.
operator| then_continuation_example.cpp
then_split_example.cpp
 Creates a continuation on the current future.
operator^ recover_example.cpp
 Creates a recoverable future on the current object.
stlab::package package_example.cpp
 Create a promise/future pair
recover recover_example.cpp
 Creates a recoverable future on the current object.
then then_continuation_example.cpp
then_split_example.cpp
 Creates a continuation on the current future.
stlab::when_all when_all_example.cpp
when_all_void_example.cpp
 Creates a joining future
stlab::when_any when_any_example.cpp
when_any_void_example.cpp
 Creates a future that continues on the first success of any futures passed
operator| operator_pipe_example.cpp
 Attaches a new process to the channel.
set_ready set_ready_example.cpp
 Sets the receiver ready to receive values.
set_ready set_ready_example.cpp
 Sets the receiver ready to receive values.
stlab::sender::operator() call_operator_example.cpp
 Sends a new value into the channel
stlab::channel channel_example.cpp
 Creates a pair that consists of a sender and a receiver
stlab::serial_queue serial_queue_example.cpp
 An executor wrapper that causes enqueued tasks to be run serially.
stlab::executor executor_example.cpp
 Executor wrapper class
stlab::join zip_with_example.cpp
 Creates a future that joins all passed arguments. This function is deprecated and it will soon be removed. Please use instead of `zip_with`
stlab::merge merge_channel_example.cpp
 Creates a receiver that merges all passed arguments. This function is deprecated and will be removed soon. Please instead `merge_channel`. </td> </tr>
stlab::merge_channel merge_channel_example.cpp
 Creates a channel that merges all passed arguments
stlab::zip zip_example.cpp
 It zips the values in step from all upstream receivers. (The functionality has changed after release 1.2.0!)
stlab::zip_with zip_with_example.cpp
 Creates a channel that zips multiple channels into a single one

stlab — modern, modular C++ algorithms and data structures.

Page owner(s): Last updated: 2023-01-30 20:54:11 +0000