Function my_main

examples/benchmark/common.hpp:115–195

template <class Pool, class RunThread>
void my_main(int argc, char** argv, exec::numa_policy policy = exec::get_numa_policy())
{
  int nthreads = static_cast<int>(std::thread::hardware_concurrency());
  if (argc > 1)
  {
    nthreads = std::atoi(argv[1]);
  }
  std::size_t total_scheds = 10'000'000;
#ifndef STDEXEC_NO_MONOTONIC_BUFFER_RESOURCE
  std::vector<std::unique_ptr<char, numa_deleter>> buffers;
#endif
  std::optional<Pool> pool{};
  if constexpr (std::same_as<Pool, exec::static_thread_pool>)
  {
    pool.emplace(nthreads, exec::bwos_params{}, policy);
  }
  else
  {
    pool.emplace(nthreads);
  }
  std::barrier<>           barrier(nthreads + 1);
  std::vector<std::thread> threads;
  std::atomic<bool>        stop{false};
#ifndef STDEXEC_NO_MONOTONIC_BUFFER_RESOURCE
  std::size_t buffer_size = 2000 << 20;
  for (std::size_t i = 0; std::cmp_less(i, nthreads); ++i)
  {
    exec::numa_allocator<char> alloc(policy.thread_index_to_node(i));
    buffers.push_back(std::unique_ptr<char, numa_deleter>{
      alloc.allocate(buffer_size),
      numa_deleter{.size_ = buffer_size, .allocator_ = alloc}
    });
  }
#endif
  for (std::size_t i = 0; std::cmp_less(i, nthreads); ++i)
  {
    threads.emplace_back(RunThread{},
                         std::ref(*pool),
                         total_scheds,
                         i,
                         std::ref(barrier),
#ifndef STDEXEC_NO_MONOTONIC_BUFFER_RESOURCE
                         std::span<char>{buffers[i].get(), buffer_size},
#endif
                         std::ref(stop),
                         policy);
  }
  std::size_t                                        nRuns  = 100;
  std::size_t                                        warmup = 1;
  std::vector<std::chrono::steady_clock::time_point> starts(nRuns);
  std::vector<std::chrono::steady_clock::time_point> ends(nRuns);
  for (std::size_t i = 0; i < nRuns; ++i)
  {
    barrier.arrive_and_wait();
    starts[i] = std::chrono::steady_clock::now();
    barrier.arrive_and_wait();
    ends[i] = std::chrono::steady_clock::now();
    if (i < warmup)