performance_measurements.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <algorithm>
#include <array>
#include <atomic>
#include <chrono>
#include <concepts>
#include <cstddef>
#include <exception>
#include <functional>
#include <optional>
#include <ranges>
#include <span>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace uni20::performance
{
 
enum class MeasurementLevel
{
  none,
  coarse,
  detailed,
};
 
struct NoMeasurements
{
    static constexpr MeasurementLevel measurement_level = MeasurementLevel::none;
};
 
using Duration = std::chrono::nanoseconds;
 
using WallClock = std::chrono::steady_clock;
 
struct DurationStatistics
{
    std::size_t count = 0;
    Duration total = Duration::zero();
    Duration minimum = Duration::zero();
    Duration maximum = Duration::zero();
 
    [[nodiscard]] constexpr auto mean() const noexcept -> Duration
    {
      return count == 0 ? Duration::zero() : total / static_cast<Duration::rep>(count);
    }
};
 
template <class Event, std::size_t EventCount> class DurationMeasurements {
  public:
    static constexpr MeasurementLevel measurement_level = MeasurementLevel::coarse;
    static constexpr std::size_t event_count = EventCount;
 
    void record_duration(Event event, Duration duration) noexcept
    {
      auto& statistics = values_[event_index(event)];
      if (statistics.count == 0)
      {
        statistics.minimum = duration;
        statistics.maximum = duration;
      }
      else
      {
        statistics.minimum = std::min(statistics.minimum, duration);
        statistics.maximum = std::max(statistics.maximum, duration);
      }
      ++statistics.count;
      statistics.total += duration;
    }
 
    [[nodiscard]] auto operator[](Event event) const noexcept -> DurationStatistics const&
    {
      return values_[event_index(event)];
    }
 
    constexpr void reset() noexcept { values_ = {}; }
 
  private:
    [[nodiscard]] static constexpr auto event_index(Event event) noexcept -> std::size_t
    {
      return static_cast<std::size_t>(event);
    }
 
    std::array<DurationStatistics, EventCount> values_{};
};
 
struct BatchMeasurement
{
    std::size_t requested_items = 0;
    std::size_t started_items = 0;
    std::size_t completed_items = 0;
    std::size_t peak_concurrency = 0;
    Duration wall_duration = Duration::zero();
    Duration total_item_duration = Duration::zero();
    Duration maximum_item_duration = Duration::zero();
    Duration first_item_start_delay = Duration::zero();
    Duration item_start_spread = Duration::zero();
    Duration item_finish_spread = Duration::zero();
    Duration return_after_last_finish = Duration::zero();
};
 
template <class Event, std::size_t EventCount>
class DetailedMeasurements : public DurationMeasurements<Event, EventCount> {
  public:
    static constexpr MeasurementLevel measurement_level = MeasurementLevel::detailed;
 
    void record_batch(Event event, BatchMeasurement measurement)
    {
      batches_[static_cast<std::size_t>(event)].push_back(std::move(measurement));
    }
 
    [[nodiscard]] auto batches(Event event) const noexcept -> std::span<BatchMeasurement const>
    {
      return batches_[static_cast<std::size_t>(event)];
    }
 
    void reset()
    {
      DurationMeasurements<Event, EventCount>::reset();
      batches_ = {};
    }
 
  private:
    std::array<std::vector<BatchMeasurement>, EventCount> batches_{};
};
 
template <class Measurements>
inline constexpr MeasurementLevel measurement_level_v = std::remove_cvref_t<Measurements>::measurement_level;
 
template <class Measurements, class Event>
concept DurationMeasurementPolicy = requires { std::remove_cvref_t<Measurements>::measurement_level; } &&
                                    (measurement_level_v<Measurements> == MeasurementLevel::none ||
                                     requires(Measurements& measurements, Event event, Duration duration) {
                                       { measurements.record_duration(event, duration) } noexcept -> std::same_as<void>;
                                     });
 
template <class Measurements, class Event>
concept BatchMeasurementPolicy = DurationMeasurementPolicy<Measurements, Event> &&
                                 (measurement_level_v<Measurements> != MeasurementLevel::detailed ||
                                  requires(Measurements& measurements, Event event, BatchMeasurement batch) {
                                    { measurements.record_batch(event, std::move(batch)) } -> std::same_as<void>;
                                  });
 
namespace detail
{
 
template <class Measurements, class Event> class DurationGuard {
  public:
    DurationGuard(Measurements& measurements, Event event) noexcept
        : measurements_(measurements), event_(event), start_(WallClock::now())
    {}
 
    DurationGuard(DurationGuard const&) = delete;
    DurationGuard(DurationGuard&&) = delete;
    auto operator=(DurationGuard const&) -> DurationGuard& = delete;
    auto operator=(DurationGuard&&) -> DurationGuard& = delete;
 
    ~DurationGuard() noexcept
    {
      auto const elapsed = std::chrono::duration_cast<Duration>(WallClock::now() - start_);
      measurements_.record_duration(event_, elapsed);
    }
 
  private:
    Measurements& measurements_;
    Event event_;
    WallClock::time_point start_;
};
 
} // namespace detail
 
template <class Measurements, class Event, class Function>
  requires DurationMeasurementPolicy<Measurements, Event> && std::invocable<Function>
decltype(auto) measure_duration(Measurements& measurements, Event event, Function&& function)
{
  if constexpr (measurement_level_v<Measurements> == MeasurementLevel::none)
  {
    static_cast<void>(measurements);
    static_cast<void>(event);
    return std::invoke(std::forward<Function>(function));
  }
  else
  {
    detail::DurationGuard guard(measurements, event);
    return std::invoke(std::forward<Function>(function));
  }
}
 
namespace detail
{
 
struct BatchItemInterval
{
    bool started = false;
    bool completed = false;
    WallClock::time_point start = {};
    WallClock::time_point finish = {};
    std::size_t start_order = 0;
    std::size_t finish_order = 0;
};
 
inline auto summarize_batch(std::span<BatchItemInterval const> items, WallClock::time_point batch_start,
                            WallClock::time_point batch_finish) -> BatchMeasurement
{
  BatchMeasurement result{.requested_items = items.size(),
                          .wall_duration = std::chrono::duration_cast<Duration>(batch_finish - batch_start)};
  using boundary_type = std::pair<std::size_t, int>;
  std::vector<boundary_type> boundaries;
  boundaries.reserve(items.size() * 2);
  std::optional<WallClock::time_point> first_start;
  std::optional<WallClock::time_point> last_start;
  std::optional<WallClock::time_point> first_finish;
  std::optional<WallClock::time_point> last_finish;
  for (auto const& item : items)
  {
    if (!item.started) continue;
    ++result.started_items;
    first_start = first_start ? std::min(*first_start, item.start) : item.start;
    last_start = last_start ? std::max(*last_start, item.start) : item.start;
    if (!item.completed) continue;
    ++result.completed_items;
    first_finish = first_finish ? std::min(*first_finish, item.finish) : item.finish;
    last_finish = last_finish ? std::max(*last_finish, item.finish) : item.finish;
    auto const duration = std::chrono::duration_cast<Duration>(item.finish - item.start);
    result.total_item_duration += duration;
    result.maximum_item_duration = std::max(result.maximum_item_duration, duration);
    boundaries.emplace_back(item.start_order, 1);
    boundaries.emplace_back(item.finish_order, -1);
  }
 
  if (first_start)
  {
    result.first_item_start_delay = std::chrono::duration_cast<Duration>(*first_start - batch_start);
    result.item_start_spread = std::chrono::duration_cast<Duration>(*last_start - *first_start);
  }
  if (first_finish)
  {
    result.item_finish_spread = std::chrono::duration_cast<Duration>(*last_finish - *first_finish);
    result.return_after_last_finish = std::chrono::duration_cast<Duration>(batch_finish - *last_finish);
  }
 
  std::ranges::sort(boundaries, {}, &boundary_type::first);
  std::size_t active = 0;
  for (auto const& [order, delta] : boundaries)
  {
    static_cast<void>(order);
    if (delta < 0)
      --active;
    else
      result.peak_concurrency = std::max(result.peak_concurrency, ++active);
  }
  return result;
}
 
} // namespace detail
 
template <class Measurements, class Event, class Executor, class Function>
  requires BatchMeasurementPolicy<Measurements, Event> && std::invocable<Function&, std::size_t>
void measure_batch(Measurements& measurements, Event event, std::size_t size, Executor&& executor, Function&& function)
{
  if constexpr (measurement_level_v<Measurements> == MeasurementLevel::none)
  {
    static_cast<void>(measurements);
    static_cast<void>(event);
    std::invoke(std::forward<Executor>(executor), function);
  }
  else if constexpr (measurement_level_v<Measurements> == MeasurementLevel::coarse)
  {
    measure_duration(measurements, event, [&] { std::invoke(std::forward<Executor>(executor), function); });
  }
  else
  {
    std::vector<detail::BatchItemInterval> items(size);
    std::atomic_size_t next_boundary_order = 0;
    auto wrapped = [&](std::size_t index) {
      auto& item = items[index];
      item.started = true;
      item.start_order = next_boundary_order.fetch_add(1, std::memory_order_relaxed);
      item.start = WallClock::now();
      try
      {
        std::invoke(function, index);
      }
      catch (...)
      {
        item.finish = WallClock::now();
        item.finish_order = next_boundary_order.fetch_add(1, std::memory_order_relaxed);
        item.completed = true;
        throw;
      }
      item.finish = WallClock::now();
      item.finish_order = next_boundary_order.fetch_add(1, std::memory_order_relaxed);
      item.completed = true;
    };
 
    auto const start = WallClock::now();
    std::exception_ptr failure;
    try
    {
      std::invoke(std::forward<Executor>(executor), wrapped);
    }
    catch (...)
    {
      failure = std::current_exception();
    }
    auto const finish = WallClock::now();
    auto batch = detail::summarize_batch(items, start, finish);
    measurements.record_duration(event, batch.wall_duration);
    measurements.record_batch(event, std::move(batch));
    if (failure) std::rethrow_exception(failure);
  }
}
 
} // namespace uni20::performance