Skip to content

Library for statically building execution graphs.

License

Notifications You must be signed in to change notification settings

ofats/task_graph

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

25 Commits
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

Advanced future

An std::future powerfull addition that enables then and contraction operations.

Usage examples

Suppose we want to execute some task right after finish of some other task. We can do it very simply:

my_async([] { std::cout << "First message" << std::endl; })
    .then([] { std::cout << "Second message" << std::endl; }).get();

But what if we want to forward result of one task as an argument to another? As easy as pie:

auto result = my_async([](auto a, auto b) { return very_heavy_calculation(a, b) }, num1, num2)
                  .then([](auto a, auto b) { return another_calculation(a, b); }, num3);
return result.get();

You can see, that for the call to lambda inside .then() we specialized only one argument - the second one. The first one would be forwarded from return value of lambda inside my_async() call.

And what if we want to make some dependent task that is represented as a sync for (as an example) 3 other tasks? We can use contraction() function to do so:

return contraction([](auto a, auto b, auto c) { return dependent_calculation(a, b, c); },
           [] { return first_very_heavy_calculation(); },
           [] { return second_maybe_not_so_heavy_calculation(); },
           [] { return third_independent_calculation(); }).get();

New features are in progress. Enjoy!

Releases

No releases published

Packages

No packages published