Function async_inclusive_scan

test/exec/taskflow/test_taskflow_thread_pool.cpp:33–75

Example adapted from https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2300r5.html#example-async-inclusive-scan

  // Example adapted from
  // https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2300r5.html#example-async-inclusive-scan
  [[nodiscard]]
  auto async_inclusive_scan(STDEXEC::scheduler auto sch,                     // 2
                            std::span<double const> input,                   // 1
                            std::span<double>       output,                  // 1
                            double                  init,                    // 1
                            std::size_t             tile_count) -> STDEXEC::sender auto  // 3
  {
    using namespace STDEXEC;
    std::size_t const tile_size = (input.size() + tile_count - 1) / tile_count;

    std::vector<double> partials(tile_count + 1);
    partials[0] = init;

    return just(std::move(partials)) | continues_on(sch)
         | bulk(ex::par,
                tile_count,
                [=](std::size_t i, std::span<double> partials)
                {
                  auto start      = i * tile_size;
                  auto end        = (std::min) (input.size(), (i + 1) * tile_size);
                  partials[i + 1] = *--std::inclusive_scan(begin(input) + static_cast<long>(start),
                                                           begin(input) + static_cast<long>(end),
                                                           begin(output)
                                                             + static_cast<long>(start));
                })  //
         | then(
             [](std::vector<double>&& partials)
             {
               std::inclusive_scan(begin(partials), end(partials), begin(partials));
               return std::move(partials);
             })  //
         | bulk(ex::par,
                tile_count,
                [=](std::size_t i, std::span<double const> partials)
                {
                  auto start = i * tile_size;
                  auto end   = (std::min) (input.size(), (i + 1) * tile_size);
                  std::for_each(begin(output) + static_cast<long>(start),
                                begin(output) + static_cast<long>(end),
                                [&](double& e) { e = partials[i] + e; });
                })  //
         | then([=](std::vector<double>&&) { return output; });
  }

  TEST_CASE("exec::taskflow::taskflow_thread_pool offers the parallel forward progress guarantee",
            "[taskflow_thread_pool]")