to pause the video stream during the talk. 23 REVIEW C++ COROUTINE IN 10 MINS • Core concepts: promise object, coroutine handle • Keywords: co_return, co_await, co_yield(not covered here) • awaitables https://lewissbaker.github.io/2018/09/05/understanding -the-promise-type • User defined type(s) that stores whatever you want/required Promise Object Coroutine Handle • Literally a handle • Two different coroutine_handle<>, coroutine_handle<Promise> • coroutine_handle<>: resume/destroy coroutine, check status(done) • coroutine_handle<Promise>: provide access to the promise object(promise) Useful to know For convenience:

Non-blocking! writer.Close(); thread x thread yfutures/promises: “buffered channel” Promise promise; Channel::Reader reader = channel.Reader(); reader.Read(); // Blocks! Non-blocking! writer.Close(); thread x thread yfutures/promises: “buffered channel” Promise promise; Channel::Reader reader = channel.Reader(); reader.Read(); // Blocks! Close(); thread x thread yfutures/promises: “buffered channel” Promise promise; Future future = promise.Future(); reader.Read(); // Blocks! Channel::Writer writer

} }8/55 The coroutine promise promise type9/55 Cheat Sheet - Promise Type 1 struct ReturnType / std:: coroutine_traits < ReturnType , ...> { 2 struct promise_type { 3 promise_type (T...); // opt. 4 Awaitable 1 struct Awaitable { 2 bool await_ready (); 3 auto await_suspend (std:: coroutine_handle < promise_type >); 4 auto await_resume (); 5 };12/55 Cheat Sheet: Map of Coroutine Land13/55 Get the cheat Async { struct promise_type { /* ... */ }; };34/55 Setting up the Async object template struct Async { struct promise_type { /* ... */ }; std:: coroutine_handle <promise_type > self ;

Coroutines in VGJS – Example void test() { Coro retObj = driver(13); schedule(retObj); //put promise into a VGJS queue, a thread will grab it in its loop if(retObj.ready()) std::cout << "Result " << Coro retObj = driver(13); schedule(retObj); } Coro_promise Coro_promise VGJS Coroutines Coro driver(int i) { co_await promise.initial_suspend(); try { Coro retObj = coroTest(i); coroTest(i); int res = co_await retObj; co_return 0.0f; } catch (...) { promise.unhandled_exception(); } FinalSuspend: co_await promise.final_suspend(); } Coro coroTest(int i) { co_await thread_index_t{

.hpp:220 frame #3 : 0x0000555555571da5 in unifex::_ch::continuation_handlepromise<(anonymous namespace)::word_stats, false>::type>::resume() () at /home/cppcon/cppcon24-async-d () at /hom frame #3 : 0x0000555555571da5 in unifex::_ch::continuation_handlepromise<(a frame #4 : 0x0000555555579f86 in unifex::_task::_sr_thunk_task<(anonymous namespace)::word_s unifex::_seq::_sndrpromise::type:: frame #13: 0x000055555557dc9c in unifex::_await::_sender_task

0 码力 | 131 页 | 907.41 KB | 5 月前

3

before suspending Promise::await_transform() to the rescue Any awaitable is passed through await_transform() We can use it to stash a type-erased pointer to the awaiteeclass Promise { void* awaitee_ await_transform(T&& t) { return Interceptor{this, &t}; } template struct Interceptor { Promise* p; T* t; auto await_suspend(coroutine_handle<> h) { // Stash a type-erased reference (awaitee_) { cancelFn_( awaitee_, coroutine_handle<Promise>:: from_promise(*this)); } } };Destroying the coroutine coroutine_handle::destroy() can only

is a generalized subroutine that can be suspended and resumed. ▪ A coroutine consists of ▪ A promise object to manipulate it from the inside ▪ A handle to resume or destroy it from the outside ▪ State the following { Promise promise; co_await promise.initial_suspend(); try { } catch (...) { promise.unhandled_exception(); } FinalSuspend: co_await promise.final_suspend(); }Coroutine the coroutine activation frame ▪ Promise prom created ▪ Generator gen created ▪ Handle to the promise created and locally stored prom.get_return_object() ▪ Promise initially suspended: prom.initial_suspend()

C++ function requires function itself • But implementing a C++ coroutine requires: - Coroutine - Promise - Awaitable - Coroutine handle CppNow23 talk: An Introduction to C++ Coroutines Through a Thread std::suspend_always{}; 12 } 13 cudaStreamDestory(stream); 14 } 2 struct Coro { 3 4 struct promise_type { 5 std::suspend_always initial_suspend() noexcept { return {}; } 6 std::suspend_always return std::coroutine_handle<promise_type>::from_promise(*this); } 9 void return_void() {} 10 void unhandled_exception() {} 11 }; 12 13 Coro(std::coroutine_handle<promise_type> handle): handle{handle}

placeholder for a value, which is set by a promise. auto future = std::async([]{ return "LazyOrEager"; }); future.get(); Future: receiver get Promise: sender set channelConcurrency Patterns Synchronization state change or asks for the state change. ▪ Push principle: condition variables, future/promise pairs, atomics (C++20), and semaphores (C++20) ▪ Pull principle: not natively supported in C++ C++ ▪ The waiting thread waits with or without a time limit. ▪ Condition variables, and future/promise pairs ▪ The notification is sent to one or all waiting threads. ▪ Shared futures, condition variables

certainly want a mutex plus a condition_variable. If produce/consume happen only once, consider std::promise/std::future, which we aren’t going to talk about in this presentation. It still uses mutex+cv internally wait. ● wait blocks only until the counter becomes zero.Question BreakOne-slide intro to C++11 promise/future std::future f1 = std::async([]() { puts("Hello from thread A!"); return 1; }); are available from threads A and B 46 This slide shows the future side (Frosty). Not shown: the promise side (Pat). std::async creates a new thread on each call. The STL’s async has serious perf caveats