C++11 Multithreading - Futures

Introduction
Motivation
Asynchronous Return Object:
• future<T>
Asynchronous Provider Objects:
• async<F, Args…>
• packaged_task<R, Args…>
• promise<T>
Continuation passing style
Q&A

[C++03, 1.9.6]
• The observable behavior of the abstract machine is
its sequence of reads and writes to volatile data and
calls to library I/O functions.
 [C++11, 1.10.1]:
• A thread of execution (also known as a thread) is a
single flow of control within a program... The
execution of the entire program consists of an
execution of all of its threads...

 [C++11, 30.1.1]:
• The following subclauses describe components
to create and manage threads (1.10), perform
mutual exclusion, and communicate
conditions and values between threads…
Subclause Header
Threads <thread>
Mutual exclusion <mutex>
Condition variables <condition_variable>
Futures <future>

Having independent time consuming tasks:
// ...
device target_device;
target_device.initialize(); // <- time consuming
configuration_storage db;
configuration config;
db.load(config); // <- time consuming
target_device.configure(config);

Execute time consuming tasks
simultaneously, naive approach:
// ...
thread loader([&db, &config]{ db.load(config); });
// <- run loading config in a separate thread
target_device.initialize();
// <- continue device initialization in current thread
loader.join();
// <- assume loading done at this point

Execute time consuming tasks
simultaneously, thread pool approach:
class async_exec_service {
public:
void exec(function<void()> f);
};
// ...
async_exec_service exec_service;
// ...
exec_service.exec([&db, &config]{ db.load(config); });
// <- run loading config in the thread pool
// <- continue device initialization in current thread
// hmmm... are we ready for proceed ???

 Execute time consuming tasks simultaneously, thread
pool approach with synchronization:
class async_exec_service { public: void exec(function<void()> f); };
// ...
// ...
unique_ptr<configuration> config;
mutex config_guard;
condition_variable config_cv;
exec_service.exec([&]{
unique_lock<mutex> lock(config_guard);
config.reset(new configuration);
db.load(*config);
config_cv.notify_one();
}); // <- run loading config in the thread pool
target_device.initialize(); // continue device initialization in current thread
{ // wait for configuration loading done
unique_lock<mutex> lock(config_guard);
config_cv.wait(lock, [&]{ return (config != nullptr); });
}
// we are ready for proceed
target_device.configure(*config);

The Standard Library provides a unified
solution communicate data between
threads:
• shared state object – privately held object with a
placeholder for result and some auxiliary data;
• asynchronous return object – reads result from
a shared state;
• asynchronous provider - provides shared state
object with a value.

SharedState – internal shared state;
future – asynchronous return object;
Setter – asynchronous provider object:
• async
• packaged_task
• promise

 Execute time consuming tasks simultaneously, using
future<T>:
public:
template <typename _Function>
auto exec(_Function&& f) -> future<decltype(f())>
{ /*...*/ }
};
// ...
future<configuration> config = exec_service.exec([&db]{
db.load(config);
return config;
});
target_device.configure(config.get());
// wait for result and proceed

valid() – tests if the future has a shared
state;
get() – retrieves value, wait if needed;
wait()/wait_for(delay)/wait_until(time) –
waits the future to be populated with result;
share() – makes shared_future from this
future; invalidates this future object.

shares its shared state object between
several asynchronous return objects:
the main purpose – signal the result is
ready to multiple waiting threads

Runs a function in a separate thread and
set its result to future:
• step back to naive approach:
future<configuration> config = async([&db]{
db.load(config);
return config;
}); // run loading config in a separate thread
// continue device initialization in current thread

template< class Function, class... Args>
result_type async(Function&& f, Args&&... args);
template< class Function, class... Args >
result_type async(launch policy, Function&& f, Args&&... args);
async launch policy:
 launch::async – launch a new thread for execution;
 launch::deferred – defers the execution until the
returned future value accessed; performs execution in
current thread;
 launch::async|launch::deferred – used by default,
allows the implementation to choose one.

future<configuration> config = async([&db]{
db.load(config);
return config;
}); // run loading config in a separate thread
if (!target_device.initialize()) {
return; // what will happen to config here ???
}
 [3.6.8/5]:
• … If the implementation chooses the launch::async policy,
- a call to a waiting function on an asynchronous return object that shares
the shared state created by this async call shall block until the
associated thread has completed, as if joined;
…

 provides better control over execution;
 does not execute threads itself;
 provides a wrapper on a function or a callable object for
store returned value/exception in a future.
packaged_task<configuration ()> load_config([&db] {
db.load(config);
return config;
});
future<configuration> config = load_config.get_future();
// just get future<> for future :)
load_config(); // loading config goes here

 Implementation for async_exec_service:
queue<function<void ()>> _exec_queue;
// worker threads will take functions from _exec_queue
// ...
void enqueue(function<void ()> task) {/* put task to _exec_queue */}
public:
{
typedef decltype(f()) _Result;
shared_ptr<packaged_task<_Result()>> task =
make_shared<packaged_task<_Result()>>(f);
function<void()> task_wrapper = [task]{(*task)();};
enqueue(task_wrapper);
return task->get_future();
}
// ...
};

 provides the highest level of control over the shared
state;
 does not require a function or callable object for populate
shared state;
 requires executing thread explicitly set value/exception to
shared state.

 Yet another implementation for async_exec_service:
queue<function<void ()>> _exec_queue;
// worker threads will take functions from _exec_queue
// ...
void enqueue(function<void ()> task) {/* put task to _exec_queue */}
public:
{
typedef decltype(f()) _Result;
shared_ptr<promise<_Result>> result =
make_shared<promise<_Result>>();
function<void()> task_wrapper = [result, f]{
try {
result->set_value(f());
} catch (...) {
result->set_exception(current_exception());
}
}
enqueue(task_wrapper);
return result->get_future();
}
};

Currently is not a part of C++ Standard
Going to be included in C++17 (N3857)
Already available in boost

 compose two futures by declaring one to be the
continuation of another:
future<void> configure = async([&db]{
db.load(config);
return config;
}).then([&target_device](future<configuration> config){
// JUST FOR EXAMPLE:
// config is ready at this point,
// but it doesn’t mean we could already configure the device
});

 wait a number of futures for at least one to be
ready:
future<bool> tasks[] = {
async([&target_device]{ return target_device.initialize(); }),
async([&db, &config]{ db.load(config); return true; }),
};
future<vector<future<bool>>> anyone = when_any(begin(tasks), end(tasks));
future<bool> anyone_completed = anyone.then(
[](future<vector<future<bool>>> lst) {
// JUST FOR EXAMPLE
for (future<bool>& f: lst) {
if (f.is_ready())
return f.get(); // won't block here
}
});

 wait for a number of futures to be ready:
future<bool> init_device = async([&target_device]{
return target_device.initialize();
});
future<configuration> load_config = async([&db]{
db.load(config);
return config;
});
future<tuple<future<bool>, future<configuration>>> init_all =
when_all(init_device, load_config);
future<bool> device_ready = init_all.then(
[&target_device](tuple<future<bool>, future<configuration>> params){
bool hw_ok = get<0>().get();
if (!hw_ok) return false;
configuration config = get<1>().get();
return true;
}
);

C++11 Multithreading - Futures

Related slideshows

More Related Content

What's hot

What's hot (20)

Similar to C++11 Multithreading - Futures

Similar to C++11 Multithreading - Futures (20)

More from GlobalLogic Ukraine

More from GlobalLogic Ukraine (20)

Recently uploaded

Recently uploaded (20)

C++11 Multithreading - Futures