tf::AsyncTask class

class to create a dependent asynchronous task

A tf::AsyncTask is a lightweight handle that retains shared ownership of a dependent async task created by an executor. This shared ownership ensures that the async task remains alive when adding it to the dependency list of another async task, thus avoiding the classical ABA problem.

// main thread retains shared ownership of async task A
tf::AsyncTask A = executor.silent_dependent_async([](){});

// task A remains alive (i.e., at least one ref count by the main thread) 
// when being added to the dependency list of async task B
tf::AsyncTask B = executor.silent_dependent_async([](){}, A);

Currently, tf::AsyncTask is implemented based on C++ smart pointer std::shared_ptr and is considered cheap to copy or move as long as only a handful of objects own it. When a worker completes an async task, it will remove the task from the executor, decrementing the number of shared owners by one. If that counter reaches zero, the task is destroyed.

Constructors, destructors, conversion operators

AsyncTask() defaulted
constructs an empty task handle
~AsyncTask() defaulted
destroys the managed asynchronous task if this is the last owner
AsyncTask(const AsyncTask& rhs) defaulted
constructs an task that shares ownership of rhs
AsyncTask(AsyncTask&& rhs) defaulted
move-constructs an task from rhs

Public functions

auto operator=(const AsyncTask& rhs) -> AsyncTask& defaulted
shares ownership of the task managed by rhs
auto operator=(AsyncTask&& rhs) -> AsyncTask& defaulted
move-assigns the task from rhs
auto empty() const -> bool
checks if the task stores a non-null shared pointer
void reset()
release the ownership
auto hash_value() const -> size_t
obtains a hash value of the underlying node