Method operator()

examples/benchmark/static_thread_pool.cpp:23–97

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);
    exec::nodemask mask{};
    mask.set(static_cast<std::size_t>(numa_node));
    auto                    scheduler = pool.get_constrained_scheduler(&mask);
    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};
      while (scheds)
      {
        exec::start_detached(stdexec::schedule(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};
      while (scheds)
      {
        exec::start_detached(stdexec::schedule(scheduler)
                             | stdexec::then(
                               [&]