run_context.hpp

Go to the documentation of this file.

 
#pragma once
#include "metadata.hpp"
#include "program.hpp"
#include <functional>
#include <optional>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace uni20
{
struct run_clock_sample
{
    long double monotonic_seconds;
    std::optional<long double> process_cpu_seconds = std::nullopt;
};
 
[[nodiscard]] run_clock_sample system_run_clock();
[[nodiscard]] std::string utc_now();
[[nodiscard]] std::string metadata_line(std::string_view text);
 
enum class run_outcome
{
  success,
  partial,
  failed,
  cancelled
};
[[nodiscard]] std::string_view to_string(run_outcome value);
 
struct run_context_options
{
    std::function<run_clock_sample()> clock = system_run_clock;
    std::function<std::string()> utc = utc_now;
    std::vector<std::string> invocation = {};
};
 
class run_context {
  public:
    explicit run_context(presentation::program_info program, run_context_options options = {});
    run_context(run_context const&) = delete;
    run_context& operator=(run_context const&) = delete;
 
    [[nodiscard]] metadata_document& metadata();
    [[nodiscard]] metadata_document snapshot() const { return metadata_; }
    [[nodiscard]] std::vector<std::string> const& invocation() const { return options_.invocation; }
    [[nodiscard]] presentation::program_info const& program() const { return program_; }
 
    class computation_scope {
      public:
        explicit computation_scope(run_context& owner);
        computation_scope(computation_scope const&) = delete;
        computation_scope& operator=(computation_scope const&) = delete;
        ~computation_scope() noexcept;
        void finish();
 
      private:
        run_context* owner_;
    };
    [[nodiscard]] computation_scope computation() { return computation_scope(*this); }
    template <typename F> decltype(auto) measure(F&& function)
    {
      auto scope = this->computation();
      if constexpr (std::is_void_v<std::invoke_result_t<F>>)
      {
        std::invoke(std::forward<F>(function));
        scope.finish();
      }
      else
      {
        decltype(auto) result = std::invoke(std::forward<F>(function));
        scope.finish();
        return result;
      }
    }
 
    [[nodiscard]] metadata_document const& finish(run_outcome outcome, metadata_document summary = {});
    [[nodiscard]] bool finished() const { return final_.has_value(); }
 
  private:
    void begin_computation();
    void end_computation();
    presentation::program_info program_;
    run_context_options options_;
    metadata_document metadata_;
    run_clock_sample start_;
    std::optional<run_clock_sample> computation_start_;
    std::optional<long double> computation_cpu_ = 0;
    std::optional<metadata_document> final_;
};
 
[[nodiscard]] presentation::report_builder metadata_report(metadata_document const& document, std::string title = {},
                                                           bool detail = false);
} // namespace uni20