{"id":10322,"date":"2024-11-18T09:03:21","date_gmt":"2024-11-18T09:03:21","guid":{"rendered":"https:\/\/www.modernescpp.com\/?p=10322"},"modified":"2025-07-04T16:10:04","modified_gmt":"2025-07-04T16:10:04","slug":"stdexecution","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/stdexecution\/","title":{"rendered":"std::execution"},"content":{"rendered":"\n

std::execution<\/code><\/strong>, previously known as executors or Senders\/Receivers, provides \u201ca Standard C++ framework for managing asynchronous execution on generic execution resources<\/em>\u201c. (P2300R10<\/a>)<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

Side Note<\/h2>\n\n\n\n

Change of plans. My original plan was to present the C++26 library after the core language. However, the implementation status of the library is not good enough. Therefore, I decided to continue with concurrency and std::execution.<\/code> I will present the remaining C++26 features if a compiler implements them.std::execution<\/code><\/p>\n\n\n\n

std::execution<\/code><\/strong> has three key abstractions: schedulers, senders, and receivers, and a set of customizable asynchronous algorithms. My presentation of std::execution<\/code> is based on the proposal P2300R10<\/a>.<\/p>\n\n\n\n

First Experiments<\/h3>\n\n\n\n

I used stdexec <\/a>for my first experiments. This reference implementation from NVIDIA is based on the eighth revision of the proposal. The purpose of this experiment can be found on GitHub.<\/p>\n\n\n\n

    \n
  1. Provide a proof-of-concept implementation of the design proposed in P2300<\/a>.<\/li>\n\n\n\n
  2. Provide early access to developers looking to experiment with the Sender model.<\/li>\n\n\n\n
  3. Collaborate with those interested in participating or contributing to the design of P2300 (contributions welcome!).<\/li>\n<\/ol>\n\n\n\n

    You can try out stdexec<\/a> on godbolt<\/a> with the following program.<\/p>\n\n\n\n

    #include <stdexec\/execution.hpp><\/span>\n#include <exec\/static_thread_pool.hpp><\/span>\n\nint<\/span> main<\/span>()\n{\n    \/\/ Declare a pool of 3 worker threads:<\/span>\n    exec::<\/span>static_thread_pool pool(3<\/span>);\n\n    \/\/ Get a handle to the thread pool:<\/span>\n    auto<\/span> sched =<\/span> pool.get_scheduler();\n\n    \/\/ Describe some work:<\/span>\n    \/\/ Creates 3 sender pipelines that are executed concurrently by passing to `when_all`<\/span>\n    \/\/ Each sender is scheduled on `sched` using `on` and starts with `just(n)` that creates a<\/span>\n    \/\/ Sender that just forwards `n` to the next sender.<\/span>\n    \/\/ After `just(n)`, we chain `then(fun)` which invokes `fun` using the value provided from `just()`<\/span>\n    \/\/ Note: No work actually happens here. Everything is lazy and `work` is just an object that statically<\/span>\n    \/\/ represents the work to later be executed<\/span>\n    auto<\/span> fun =<\/span> [](int<\/span> i) { return<\/span> i*<\/span>i; };\n    auto<\/span> work =<\/span> stdexec::<\/span>when_all(\n        stdexec::<\/span>starts_on(sched, stdexec::<\/span>just(0<\/span>) |<\/span> stdexec::<\/span>then(fun)),\n        stdexec::<\/span>starts_on(sched, stdexec::<\/span>just(1<\/span>) |<\/span> stdexec::<\/span>then(fun)),\n        stdexec::<\/span>starts_on(sched, stdexec::<\/span>just(2<\/span>) |<\/span> stdexec::<\/span>then(fun))\n    );\n\n    \/\/ Launch the work and wait for the result<\/span>\n    auto<\/span> [i, j, k] =<\/span> stdexec::<\/span>sync_wait(std::<\/span>move(work)).value();\n\n    \/\/ Print the results:<\/span>\n    std::<\/span>printf("%d %d %d<\/span>\\n<\/span>"<\/span>, i, j, k);\n}\n<\/pre><\/div>\n\n\n\n
    Let me convert this program into the revision 10 syntax. You can also try it out on godbolt<\/a>.<\/p>\n\n\n\n
    The program begins by including the necessary headers: <exec\/static_thread_pool.hpp><\/code> for creating a thread pool, <stdexec\/execution.hpp><\/code> for execution-related utilities.<\/p>\n\n\n\n
    In the main<\/code> function, a static_thread_pool pool<\/code> is created with 8 threads. The thread pool executes tasks concurrently. The get_scheduler<\/code> member function of the thread pool is called to obtain a scheduler object sched.<\/code> The schedule schedules the tasks on the thread pool.<\/p>\n\n\n\n
    The lambda function fun<\/code> takes an integer i <\/code>as input and returns its square (i * i)<\/code>. This lambda is applied to the input values in the subsequent tasks.<\/p>\n\n\n\n
    The stdexec::when_all<\/code> function creates a task that waits for the completion of multiple sub-tasks. Each sub-task is created using the stdexec::starts_on<\/code> function, which schedules the task on the specified scheduler sched<\/code>. The stdexec::just<\/code> function creates a task that produces a single value (0, 1, or 2), and the stdexec::then<\/code> function is used to apply the fun<\/code> lambda to this value. The resulting task object is named work<\/code>.<\/p>\n\n\n\n
    The stdexec::sync_wait<\/code> function is then called to wait for the completion of the  task synchronously. The std::move<\/code> function transfers ownership of the work<\/code> task to sync_wait<\/code>. The value<\/code> member function is called on the result of sync_wait<\/code> to obtain the values produced by the sub-tasks. These values are unpacked into the variables i<\/code>, j<\/code>, and k<\/code>.<\/p>\n\n\n\n
    Finally, the program prints the values of i<\/code>, j<\/code>, and k<\/code> to the console using std::printf<\/code>. These values represent the squares of 0, 1, and 2, respectively.<\/p>\n\n\n\n
    The following screenshot shows the execution of the program on the Compiler Explorer:<\/p>\n\n\n\n
    \"\"<\/figure>\n\n\n\n
    I wrote at the beginning of this post that std::execution<\/code> has three key abstractions: schedulers, senders, and receivers, and a set of customizable asynchronous algorithms. Let me clarify these abstractions:<\/p>\n\n\n\n
    Execution resources<\/strong><\/p>\n\n\n\n
      \n
    • represent the place of execution<\/li>\n\n\n\n
    • don\u2018t need a representation in code<\/li>\n<\/ul>\n\n\n\n
      Scheduler<\/strong>: sched<\/code><\/p>\n\n\n\n
        \n
      • represent the execution resource<\/li>\n\n\n\n
      • The scheduler concept is defined by a single sender algorithm: schedule<\/code>.<\/li>\n\n\n\n
      • The algorithm schedule returns a sender that will complete on an execution resource determined by the scheduler.<\/li>\n<\/ul>\n\n\n\n
        Sender describes work<\/strong>: when_all, starts_on, just, then<\/code><\/p>\n\n\n\n
          \n
        • send some values if a receiver connected to that sender will eventually receive said values<\/li>\n\n\n\n
        • just <\/code>is a so-called sender factory<\/li>\n<\/ul>\n\n\n\n
          Receiver stops the workflow<\/strong>: sync_wait<\/code><\/p>\n\n\n\n
            \n
          • it supports three channels: value, error, stopped<\/li>\n\n\n\n
          • sync_wait<\/code> it’s a so-called sender consumer<\/li>\n\n\n\n
          • submits the work, blocking the current std::thread<\/code> and returns an optional tuple of values that were sent by the provided sender on its completion of work<\/li>\n<\/ul>\n\n\n\n
            What’s Next?<\/h2>\n\n\n\n
             After this introduction, I will dive deeper into the set of customizable asynchronous algorithms and preset further examples.<\/p>\n\n\n\n






            <\/p>\n\n\n\n
            <\/p>\n","protected":false},"excerpt":{"rendered":"
            std::execution, previously known as executors or Senders\/Receivers, provides \u201ca Standard C++ framework for managing asynchronous execution on generic execution resources\u201c. (P2300R10) Side Note Change of plans. My original plan was to present the C++26 library after the core language. However, the implementation status of the library is not good enough. Therefore, I decided to continue […]<\/p>\n","protected":false},"author":21,"featured_media":10323,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[559],"tags":[561],"class_list":["post-10322","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c26-blog","tag-execution"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/10322","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=10322"}],"version-history":[{"count":26,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/10322\/revisions"}],"predecessor-version":[{"id":10859,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/10322\/revisions\/10859"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/10323"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=10322"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=10322"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=10322"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}