Method operator()

examples/benchmark/static_thread_pool_nested.cpp:23–107

struct RunThread
{
  void operator()(exec::static_thread_pool& pool,
                  std::size_t               total_scheds,
                  std::size_t               tid,
                  std::barrier<>&           barrier,
#ifndef STDEXEC_NO_MONOTONIC_BUFFER_RESOURCE
                  std::span<char> buffer,
#endif
                  std::atomic<bool>& stop,
                  exec::numa_policy  numa)
  {
    int numa_node = numa.thread_index_to_node(tid);
    numa.bind_to_node(numa_node);
    auto                    scheduler = pool.get_scheduler();
    std::mutex              mut;
    std::condition_variable cv;
    while (true)
    {
      barrier.arrive_and_wait();
      if (stop.load())
      {
        break;
      }
#ifndef STDEXEC_NO_MONOTONIC_BUFFER_RESOURCE
      pmr::monotonic_buffer_resource   resource{buffer.data(),
                                              buffer.size(),
                                              pmr::null_memory_resource()};
      pmr::polymorphic_allocator<char> alloc(&resource);
      auto [start, end] = exec::_pool_::even_share(total_scheds, tid, pool.available_parallelism());
      std::size_t              scheds = end - start;
      std::atomic<std::size_t> counter{scheds};
      auto                     env = stdexec::prop{stdexec::get_allocator, alloc};
      stdexec::sync_wait(stdexec::schedule(scheduler)
                         | stdexec::then(
                           [&]
                           {
                             auto nested_scheduler = pool.get_scheduler();
                             while (scheds)
                             {
                               exec::start_detached(stdexec::schedule(nested_scheduler)
                                                      | stdexec::then(
                                                        [&]
                                                        {
                                                          auto prev = counter.fetch_sub(1);
                                                          if (prev == 1)
                                                          {
                                                            std::lock_guard lock{mut};
                                                            cv.notify_one();
                                                          }
                                                        }),
                                                    env);
                               --scheds;
                             }
                           }));
#else
      auto [start, end] = exec::_pool_::even_share(total_scheds, tid, pool.available_parallelism());
      std::size_t              scheds = end - start;
      std::atomic<std::size_t> counter{scheds};
      stdexec::sync_wait(stdexec::schedule(scheduler)