C++ await Deon Brewis std::future additions: isocpp.org/files/papers/N3721.pdf resumable functions: isocpp.org/files/papers/N3722.pdf

PPL vs. std::future PPL std::future Requires future.then – i.e. N3721 concurrency::task<int> Calc( int x, int y ) resumable { int i = await concurrency::create_task( [=] { return x + y; } ); return i + 42; } std::future<int> Calc( int x, int y ) resumable { int i = await std::async( [=] { return x + y; } ); return i + 42; } Requires future.then – i.e. N3721

Motivation .get(), .then() and await comparison

Simple case .get size_t file_sizes( string file1, string file2 ) { task<file> f1 = open(file1); task<file> f2 = open(file2); return f1.get().size() + f2.get().size(); }

Simple case .get .then size_t file_sizes( string file1, string file2 ) { task<file> f1 = open(file1); task<file> f2 = open(file2); return f1.get().size() + f2.get().size(); } task<size_t> file_sizes( string file1, string file2 ) { task<file> f1 = open(file1); task<file> f2 = open(file2); return f1.then( [f2] (task<file> tr1 ) { f2.then( [tr1] (task<file> tr2) return tr1.get().size() + tr2.get().size(); }) }); }

Simple case .get .then .then + await size_t file_sizes( string file1, string file2 ) { task<file> f1 = open(file1); task<file> f2 = open(file2); return f1.get().size() + f2.get().size(); } task<size_t> file_sizes( string file1, string file2 ) { task<file> f1 = open(file1); task<file> f2 = open(file2); return f1.then( [f2] (task<file> tr1 ) { f2.then( [tr1] (task<file> tr2) return tr1.get().size() + tr2.get().size(); }) }); } .then + await task<size_t> file_sizes( string file1, string file2 ) resumable { task<file> f1 = open(file1); task<file> f2 = open(file2); return (await f1).size() + (await f2).size(); }

Branches and loops ? .get .then string read( string file, string suffix ) { istream fi = open(file).get(); string ret, chunk; while( (chunk = fi.read().get()).size() ) ret += chunk + suffix; return ret; } task<string> read( string file, string suffix ) { return open(file) .then([=](istream fi) { string ret, chunk; while( ?

Branches and loops .get .then string read( string file, string suffix ) { istream fi = open(file).get(); string ret, chunk; while( (chunk = fi.read().get()).size() ) ret += chunk + suffix; return ret; } task<string> read( string file, string suffix ) { return open(file) .then([=](istream fi) { auto ret = make_shared<string>(); auto next = make_shared<std::function<task<string>()>>( [=] { fi.read() .then([=](string chunk) { if( chunk.size() ) { *ret += chunk + suffix; return next(); } return task_from_result(*ret); }); return (*next)();

Branches and loops .get .then .then + await string read( string file, string suffix ) { istream fi = open(file).get(); string ret, chunk; while( (chunk = fi.read().get()).size() ) ret += chunk + suffix; return ret; } task<string> read( string file, string suffix ) { return open(file) .then([=](istream fi) { auto ret = make_shared<string>(); auto next = make_shared<std::function<task<string>()>>( [=] { fi.read() .then([=](string chunk) { if( chunk.size() ) { *ret += chunk + suffix; return next(); } return task_from_result(*ret); }); return (*next)(); .then + await task<string> read( string file, string suffix ) resumable { istream fi = await open(file); string ret, chunk; while( (chunk = await fi.read()).size() ) ret += chunk + suffix; return ret; }

Technical drill-down

Await implementations Iterator-Based Co-routines Rewrite resumable function into a resumable state machine Requires all locals to be hoisted to the heap Resumable Side Stacks Do not rewrite function logic Each resumable function execution has its own “side” stack Side stack lives beyond suspension/resuming until logical completion C# C++ IBC: harder to implement in our current compiler (temp lifetime); also slower for C++ (ctor and dtor calls need to be injected) RSS: A sidestack requires 8k commit (4k + guard page), it reserves 1MB ASLA: for scalability reasons (supporting >1million concurrent resumable functions)

Resumable Side Stack simulation void foo() { task<bool> t = async_bar(); somefunc(); bool b = t.get(); } task<bool> async_bar() resumable do_work(); ... // sync calls await async_work(); // More sync calls return true; task<void> async_work() resumable await create_task( [] { longrunning (); }); return; Thread #1 Thread #2 Main Stack Side Stack Side Stack <blocked> <completed> done! somefunc(); bool b = t.get() t = async_bar() <suspended> foo(); async_work is done! Longrunning is done! <completed> … return task<bool> … <suspended> … … … … … return task<void> … do_work(); More sync calls await async_work(); do_work(); await create_task(); … return true; async_bar(); async_work(); return;

Demo