Function main

examples/benchmark/fibonacci.cpp:96–146

}

auto main(int argc, char** argv) -> int
{
  if (argc < 5)
  {
    std::cerr << "Usage: example.benchmark.fibonacci cutoff n nruns {tbb|static}" << std::endl;
    return -1;
  }

  // skip 'warmup' iterations for performance measurements
  static constexpr size_t warmup = 1;

  long        cutoff = std::strtol(argv[1], nullptr, 10);
  long        n      = std::strtol(argv[2], nullptr, 10);
  std::size_t nruns  = std::strtoul(argv[3], nullptr, 10);

  if (nruns <= warmup)
  {
    std::cerr << "nruns should be >= " << warmup << std::endl;
    return -1;
  }

  std::variant<exec::tbb::tbb_thread_pool, exec::static_thread_pool> pool;

  if (argv[4] == std::string_view("tbb"))
  {
    pool.emplace<exec::tbb::tbb_thread_pool>(static_cast<int>(std::thread::hardware_concurrency()));
  }
  else
  {
    pool.emplace<exec::static_thread_pool>(std::thread::hardware_concurrency(),
                                           exec::bwos_params{},
                                           exec::get_numa_policy());
  }

  std::vector<unsigned long> times;
  long                       result;
  for (unsigned long i = 0; i < nruns; ++i)
  {
    auto snd = std::visit([&](auto&& pool)
                          { return fib_sender(fib_s{cutoff, n, pool.get_scheduler()}); },
                          pool);

    auto time = measure<std::chrono::milliseconds>(
      [&] { std::tie(result) = stdexec::sync_wait(std::move(snd)).value(); });
    times.push_back(static_cast<unsigned int>(time));
  }

  std::cout << "Avg time: "
            << (std::accumulate(times.begin() + warmup, times.end(), 0u) / (times.size() - warmup))
            << "ms. Result: " << result << std::endl;
}