… … Stack Traces for Async Code are Unhelpful Threadpool threads: #0 process_file(...) #5 pool.run() #10 __clone … … IO Thread: #0 async_read_some_at(...) #3 ctx Threadpool threads: #0 process_file(...) #5 pool.run() #10 … IO Thread: … #0 async_read_some_at(...) #3 ctx.run() #5 __clone … … Main thread: #0 unifex::sync_wait( … #0 async_read_some_at(...) … #12 unifex::sync_wait(...) #16 main() #19 __libc_start_main() … … Async Stacks are BetterStructured Concurrency Makes Async Stacks Possible

Cheat Sheet - 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 Task18/55 Threads - A straightforward solution std::future spawn_task () { return std:: async( outer_function ); }18/55 Threads - A straightforward solution main() spawn task()18/55 Threads auto data = co_await async_io (...); co_return IoResult :: from_io_data(data ); }24/55 Suspending nested coroutines Async inner_function () { auto data = co_await async_io (...); co_return

demonstrated to justify switchingCallbacks vs coroutines // read length auto len = make_unique(); async_read(socket, buffer(len.get(), sizeof(int32_t)), [len = move(len)](auto ec, size_t len1){ && len1 == sizeof(int32_t)) { // read data auto buf = make_unique(*len); async_read(socket, buffer(buf.get(), *len), [buf = move(buf), len = *len] (auto // read length int32_t len; co_await async_read(s, buffer(&len, sizeof(len)), use_awaitable); // read data auto buf = make_unique(len); co_await async_read(s, buffer(buf.get(), len)

Goals for the Executors proposal 2. Some simple examples, intro to senders 3. The lifecycle of an async operation 4. Under the hood of a concurrent operation 5. Implementing a simple algorithm 6. Senders THE EXECUTORS PROPOSAL The vision: “An asynchronous analog of the STL” • A full suite of standard async algorithms based on real-world requirements: E.g., then, when_all, sync_wait, repeat, stop_when, compute resource (aka, scheduler) • A unit of lazy async work (aka, sender) • A completion handler (aka, receiver) • A small, initial set of generic async algorithms: • E.g., then, when_all, sync_wait,

2023 10Overview – Task - Lazy Task<> foo() { println(“Hello”); co_await sleep(1); } auto t = foo(); println(“world”); co_await move(t); Francesco Zoffoli - Coroutine Patterns and How to Use Them - Them - CppCon 2023 13Overview – Executor Task<> foo() { int a = 42; a -= 10; int bytes = co_await send(a); if (bytes == -1 ) { handle_error(); } } Francesco Zoffoli - Coroutine Patterns and Use Them - CppCon 2023 14Overview – Executor Task<> foo() { int a = 42; a -= 10; int bytes = co_await send(a); if (bytes == -1 ) { handle_error(); } } Francesco Zoffoli - Coroutine Patterns and How

18Why Coroutine • Coroutine is very useful if you have a stove other computing resource! GPU, TPU, async I/O, … CPU A B! C A B! C With multitasking (C++ Coroutine) Multitask Idle GPU CPU GPU gpu_matmul<<<8, 256, 0, stream>>>(matA, matB); 10 while(cudaStreamQuery(stream) != cudaSuccess) { 11 co_await std::suspend_always{}; 12 } 13 cudaStreamDestory(stream); 14 } 2 struct Coro { 3 4 struct > handle; 16 }; 7 co_await std::suspend_always{}; 12 // compiler transform 13 auto&& awaiter = std::suspend_always{}; 14 if(!awaiter.await_ready()) { 15 awaiter.await_suspend(std::coroutine_handle<>

std::jthread std::async(std::launch::async,...) Platform-specific APIsSpawning new threads There are lots of ways to spawn new threads: std::thread std::jthread std::async(std::launch::async,...) Platform-specific II std::async is a bit better: we can check the std::future to see if it is ready. std::vector> pending_threads; void handle_event(Event details){ auto handle=std::async( std::launch::async std::launch::async, [=]{process_event(details);}); pending_threads.push_back( std::move(handle)); }Managing thread handles III Can remove completed tasks by periodically checking: void check_for_done_threads(){

Name 10 © 2023 Intel Corporation and Jeffrey E. Erickson cppcon 2023 10 Keywords • co_await or lhs = co_await • Pause execution of the coroutine until the arg becomes ready • lhs applies only Erickson cppcon 2023 13 How do we get the value back? • In another coroutine uint32_t val = co_await foo(); • From outside a coroutine auto bar = foo(); // starts foo() … //do other things uint32_t un-ready • When coroutine A’s logic is met, it becomes ready and co_returns • Coroutine B’s co_await is then satisfied and Coroutine B continuesIntel Confidential Department or Event Name 16 © 2023

push_back(move(other)); } path.action.push_back(action); path.action_index++; }Async Cleanup Validate that async cleanup function is called once before the object is destroyed in every control flow auto resource = get_resource(); /*...*/ if (condition) { /*...*/ co_await resource.cleanup(); return; } /*...*/ co_await resource.cleanup(); if (true) if (false)Performance Validation • General

C++20) for control-flow asymmetry such as suspended function (e.g., return, co_return, co_yield, co_await)Charley Bay - charleyb123 at gmail dot com The Roles of Symmetry And Orthogonality In Design cppcon compute) • Double-compute (e.g., in iterators, or when using std::range) • Synchronization of async calls or across threads Relationships can be complicatedCharley Bay - charleyb123 at gmail dot com compute) • Double-compute (e.g., in iterators, or when using std::range) • Synchronization of async calls or across threads Orthogonal components exhibiting symmetric correlations • Custom control