time_tracer.hpp

// Copyright (c) Sleipnir contributors
 
#pragma once
 
#include <array>
#include <chrono>
#include <concepts>
#include <cstddef>
#include <span>
#include <string_view>
#include <type_traits>
#include <utility>
 
namespace slp {
 
class SetupTimeTracer {
 public:
  SetupTimeTracer() = default;
 
  explicit SetupTimeTracer(bool enabled) : m_enabled{enabled} {}
 
  void start() {
#ifndef SLEIPNIR_DISABLE_DIAGNOSTICS
    if (m_enabled) {
      m_setup_start_time = std::chrono::steady_clock::now();
    }
#endif
  }
 
  void stop() {
#ifndef SLEIPNIR_DISABLE_DIAGNOSTICS
    if (m_enabled) {
      m_setup_duration = std::chrono::steady_clock::now() - m_setup_start_time;
    }
#endif
  }
 
  const std::chrono::duration<double>& duration() const {
    return m_setup_duration;
  }
 
 private:
  [[maybe_unused]]
  bool m_enabled = true;
  std::chrono::steady_clock::time_point m_setup_start_time;
  std::chrono::duration<double> m_setup_duration{0.0};
};
 
class SolveTimeTracer {
 public:
  SolveTimeTracer() = default;
 
  explicit SolveTimeTracer(bool enabled) : m_enabled{enabled} {}
 
  void start() {
#ifndef SLEIPNIR_DISABLE_DIAGNOSTICS
    if (m_enabled) {
      m_current_solve_start_time = std::chrono::steady_clock::now();
    }
#endif
  }
 
  void stop() {
#ifndef SLEIPNIR_DISABLE_DIAGNOSTICS
    if (m_enabled) {
      m_current_solve_duration =
          std::chrono::steady_clock::now() - m_current_solve_start_time;
      m_total_solve_duration += m_current_solve_duration;
 
      ++m_num_solves;
      m_average_solve_duration =
          (m_num_solves - 1.0) / m_num_solves * m_average_solve_duration +
          1.0 / m_num_solves * m_current_solve_duration;
    }
#endif
  }
 
  int num_solves() const { return m_num_solves; }
 
  const std::chrono::duration<double>& current_duration() const {
    return m_current_solve_duration;
  }
 
  const std::chrono::duration<double>& average_duration() const {
    return m_average_solve_duration;
  }
 
  const std::chrono::duration<double>& total_duration() const {
    return m_total_solve_duration;
  }
 
 private:
  [[maybe_unused]]
  bool m_enabled = true;
  std::chrono::steady_clock::time_point m_current_solve_start_time;
  std::chrono::duration<double> m_current_solve_duration{0.0};
  std::chrono::duration<double> m_total_solve_duration{0.0};
 
  int m_num_solves = 0;
  std::chrono::duration<double> m_average_solve_duration{0.0};
};
 
template <typename T>
concept TimeTracer =
    std::same_as<T, SetupTimeTracer> || std::same_as<T, SolveTimeTracer>;
 
template <TimeTracer Tracer>
class ScopedTimeTracer {
 public:
  explicit ScopedTimeTracer(Tracer& tracer) noexcept : m_tracer{&tracer} {
    m_tracer->start();
  }
 
  ~ScopedTimeTracer() {
    if (m_active) {
      m_tracer->stop();
    }
  }
 
  ScopedTimeTracer(ScopedTimeTracer&& rhs) noexcept
      : m_tracer{rhs.m_tracer}, m_active{rhs.m_active} {
    rhs.m_active = false;
  }
 
  ScopedTimeTracer(const ScopedTimeTracer&) = delete;
  ScopedTimeTracer& operator=(const ScopedTimeTracer&) = delete;
 
  void stop() {
    if (m_active) {
      m_tracer->stop();
      m_active = false;
    }
  }
 
  const std::chrono::duration<double>& current_duration() const {
    return m_tracer->current_duration();
  }
 
 private:
  Tracer* m_tracer;
  bool m_active = true;
};
 
template <TimeTracer Tracer>
class PhaseTimeTracer {
 public:
  explicit PhaseTimeTracer(Tracer& tracer) noexcept : m_tracer{&tracer} {
    m_tracer->start();
  }
 
  ~PhaseTimeTracer() { stop(); }
 
  PhaseTimeTracer(const PhaseTimeTracer&) = delete;
  PhaseTimeTracer& operator=(const PhaseTimeTracer&) = delete;
 
  void next(Tracer& tracer) {
    stop();
    m_tracer = &tracer;
    m_tracer->start();
  }
 
  void stop() {
    if (m_tracer != nullptr) {
      m_tracer->stop();
      m_tracer = nullptr;
    }
  }
 
 private:
  Tracer* m_tracer;
};
 
template <TimeTracer Tracer, typename F>
auto traced(Tracer& tracer, const F& f) {
  return [&tracer, &f]<typename... Args>(Args&&... args) -> decltype(auto) {
    ScopedTimeTracer scoped_tracer{tracer};
    return f(std::forward<Args>(args)...);
  };
}
 
template <typename ID>
  requires std::is_enum_v<ID>
struct TimeTraceEntry {
  ID id;
 
  std::string_view name;
 
  int depth;
};
 
namespace detail {
 
template <typename ID, size_t N>
consteval bool is_valid_time_trace(
    const std::array<TimeTraceEntry<ID>, N>& entries) {
  if (N == 0 || entries[0].depth != 0) {
    return false;
  }
 
  for (size_t i = 1; i < N; ++i) {
    // Each entry after the root must have a larger ID than the previous entry
    if (std::to_underlying(entries[i].id) <=
        std::to_underlying(entries[i - 1].id)) {
      return false;
    }
 
    // Each entry after the root must be a descendant of the root
    if (entries[i].depth < 1) {
      return false;
    }
 
    // Each entry must be at most one level deeper than the previous entry, so
    // it's either the previous entry's child, its sibling, or a sibling of one
    // of its ancestors
    if (entries[i].depth > entries[i - 1].depth + 1) {
      return false;
    }
  }
 
  return true;
}
 
void tracer_id_is_not_in_time_trace();
 
}  // namespace detail
 
template <const auto& Entries>
  requires(detail::is_valid_time_trace(Entries))
class TimeTracerIndex {
 public:
  using ID = decltype(Entries[0].id);
 
  // NOLINTNEXTLINE (google-explicit-constructor)
  consteval TimeTracerIndex(ID id) {
    for (size_t i = 0; i < Entries.size(); ++i) {
      if (Entries[i].id == id) {
        m_index = i;
        return;
      }
    }
 
    detail::tracer_id_is_not_in_time_trace();
  }
 
  constexpr size_t value() const { return m_index; }
 
 private:
  size_t m_index = 0;
};
 
template <TimeTracer Tracer, const auto& Entries>
  requires(detail::is_valid_time_trace(Entries))
class TimeTracerTree {
 public:
  using ID = typename TimeTracerIndex<Entries>::ID;
 
  explicit TimeTracerTree(bool enabled) { m_tracers.fill(Tracer{enabled}); }
 
  Tracer& operator[](TimeTracerIndex<Entries> index) {
    return m_tracers[index.value()];
  }
 
  Tracer& root() { return m_tracers[0]; }
 
  static constexpr std::span<const TimeTraceEntry<ID>, Entries.size()>
  entries() {
    return Entries;
  }
 
  std::span<const Tracer, Entries.size()> tracers() const { return m_tracers; }
 
 private:
  std::array<Tracer, Entries.size()> m_tracers;
};
 
}  // namespace slp