benchmark.cpp

#include "benchmark.h"

#include <sys/resource.h>

#include <chrono>
#include <vector>

#include "aggregator.h"
#include "mmap_reader.h"
#include "thread_pool.h"

namespace {

double peak_rss_mb() {
  rusage ru{};
  ::getrusage(RUSAGE_SELF, &ru);
  // ru_maxrss units differ by platform: bytes on macOS, kilobytes on Linux.
#ifdef __APPLE__
  return static_cast<double>(ru.ru_maxrss) / (1024.0 * 1024.0);
#else
  return static_cast<double>(ru.ru_maxrss) / 1024.0;
#endif
}

}  // namespace

BenchmarkResult run_benchmark(const std::string& path, unsigned threads,
                              std::size_t chunk_bytes) {
  if (threads == 0) threads = 1;

  const auto t0 = std::chrono::steady_clock::now();

  MmapReader reader(path);
  std::vector<Chunk> chunks = reader.chunks(chunk_bytes);

  ThreadPool pool(threads);
  for (const Chunk& c : chunks) pool.submit(c);
  pool.close_and_join();
  Report report = merge(pool.stats(), 10);

  const auto t1 = std::chrono::steady_clock::now();
  const double ms = std::chrono::duration<double, std::milli>(t1 - t0).count();
  const double mb = static_cast<double>(reader.size()) / (1024.0 * 1024.0);
  const double sec = ms / 1000.0;

  BenchmarkResult r;
  r.threads = threads;
  r.runtime_ms = ms;
  r.throughput_mb_s = (sec > 0.0) ? mb / sec : 0.0;
  r.peak_rss_mb = peak_rss_mb();
  r.total_requests = report.total_requests;
  return r;
}