We need a system Orchestrator to implement the robot behaviorRobot Behaviors This Coordinator or Task Planner is also the highest level of abstraction of our system, where we focus on WHAT the robot

used when we created them.” - Albert EinsteinSo what is there to Rethink?Rethinking: Task Queues Problem #1 - Task Queues Do Not Scale Well: ● Contention: ○ Even the most meticulously designed lock-free problems: ○ Task starvation ○ Load balancing ○ Forfeits strict FIFO behaviour ○ Increases memory footprint (or requires allocations) ○ Terrible task selection “fairness” Task Thread Thread Thread Task Task Task Task Task Task Task Task Back Front Task Queue Execute Task() Thread Thread PoolRethinking: Task Queues Problem #2 - No Inherent Support For Prioritization: ● Priority queues address this but

in a top-down task graph What is Task Graph-based Programming System (TGPS) Code 4• TGPS encapsulates function calls and their dependencies in a top-down task graph What is Task Graph-based Programming top-down task graph What is Task Graph-based Programming System (TGPS) Code A B C D B A C D 6• TGPS encapsulates function calls and their dependencies in a top-down task graph What is Task Graph-based sched; 2 task_a = sched.emplace([](&){ 3 // Code block A; 4 }); 5 task_b = sched.emplace([](&){ 6 // Code block B; 7 }); 8 task_c = sched.emplace([](&){ 9 // Code block C; 10 }); 11 task_d = sched

unifex::static_thread_pool pool; io_uring_context ctx; unifex::task task = async_main({argv + 1, argc - 1}, pool, ctx); unifex::sync_wait(std::move(task)); return 0; }int main(int argc, char** argv) { unifex::static_thread_pool pool; io_uring_context ctx; unifex::task task = async_main({argv + 1, argc - 1}, pool, ctx); unifex::sync_wait(std::move(task)); return 0; }int main(int argc, char** argv) { unifex::static_thread_pool pool; io_uring_context ctx; unifex::task task = async_main({argv + 1, argc - 1}, pool, ctx); unifex::sync_wait(std::move(task)); return 0; }int main(int argc, char** argv) {

careA typical async framework class Task { ... } represents a unit of background work Task::join() explicit call to suspend the current task until another task completes, and returns its result propagates uncaught exceptions Task::detach() allows the task to run alongside the rest of the programDetached tasks considered harmful // don’t do this void bad(tcp::socket& s) { std::array asio::use_awaitable); }, asio::detached); } No way to figure out task lifetime => no automatic object lifetime managementDetached tasks considered harmful // don’t do

understanding the general behavior only. template struct task; task sum(int a, int b) { int result = a + b; co_return result; } task sum4(int a, int b, int c, int d) { int ab = co_await initial_suspend_awaitable_t initial_suspend_awaitable; final_suspend_awaitable_t final_suspend_awaitable; }; }; task sum(int a, int b) { auto frame = make_unique<__sum_frame>(a, b); decltype(auto) returnObject release())); return returnObject; } template struct task; task sum(int a, int b) { int result = a + b; co_return result; } task sum4(int a, int b, int c, int d) { int ab = co_await

Qualified/Modified Member Data Visibility vs. AccessibilityData Member Initialization 6 Interactive Task: What is the initial value of the three data members i, s, and pi? struct Widget { int i; Default initialization: Calls // the default constructorData Member Initialization 8 Interactive Task: What is the initial value of the three data members i, s, and pi? struct Widget { int i; means of an empty set of braces (value initialization).Data Member Initialization 11 Interactive Task: What is the initial value of the three data members i, s, and pi? struct Widget { Widget()

extern unifex::static_thread_pool low_latency; extern unifex::static_thread_pool workers; unifex::task accept_and_process_requests() { while (true) { auto request = co_await ex::on(low_latency { ex::set_done((R&&) r_); } };42 SENDERS AND COROUTINES43 // This is a coroutine: unifex::task read_socket_async(socket, span); int main() { socket s = /*...*/; char buff[1024]; in a coroutine type trivially. // This is a coroutine: unifex::task read_socket_async(socket, span); unifex::task concurrent_read_async(socket s1, socket s2) { char buff1[1024];

prevent blocking on our event-handling threads. void event_handler(){ auto handle=spawn_background_task(); handle.wait(); // no benefit }Aside: Non-Blocking vs Lock-free In lots of cases, short-term blocking short-lived std::mutex locks) is OK. ⇒ for those cases, Non-Blocking means Not waiting for a lengthy task to run.Aside: Non-Blocking vs Lock-free In lots of cases, short-term blocking (e.g. with short-lived Not waiting for a lengthy task to run. In other cases, Non-Blocking means Obstruction Free — If you suspend all but one thread at any point, that one thread will complete its task. ⇒ for those cases, you

Them - CppCon 2023 8Overview Key concepts • Task • Executor Francesco Zoffoli - Coroutine Patterns and How to Use Them - CppCon 2023 9Overview – Task • Owns the coroutine state • Lazy • Convertible executor Francesco Zoffoli - Coroutine Patterns and How to Use Them - CppCon 2023 10Overview – Task - Lazy Task<> foo() { println(“Hello”); co_await sleep(1); } auto t = foo(); println(“world”); co_await Francesco Zoffoli - Coroutine Patterns and How to Use Them - CppCon 2023 13Overview – Executor Task<> foo() { int a = 42; a -= 10; int bytes = co_await send(a); if (bytes == -1 ) { handle_error();