invocation_context.h

Go to the documentation of this file.

/*
 * Copyright 2021 MusicScience37 (Kenta Kabashima)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#pragma once
 
#include <cstddef>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
#include "stat_bench/bench_impl/threadable_invoker.h"
#include "stat_bench/benchmark_condition.h"
#include "stat_bench/clock/duration.h"
#include "stat_bench/custom_output_name.h"
#include "stat_bench/param/parameter_name.h"
#include "stat_bench/stat/custom_stat_output.h"
 
namespace stat_bench {

class InvocationContext {
public:
    InvocationContext(BenchmarkCondition cond, std::size_t iterations,
        std::size_t samples, std::size_t warming_up_samples)
        : cond_(std::move(cond)),
          iterations_(iterations),
          samples_(samples),
          warming_up_samples_(warming_up_samples) {}
 
    InvocationContext(const InvocationContext&) = delete;
    InvocationContext(InvocationContext&&) = delete;
    auto operator=(const InvocationContext&) = delete;
    auto operator=(InvocationContext&&) = delete;

    ~InvocationContext() = default;

    [[nodiscard]] auto threads() const noexcept -> std::size_t {
        return cond_.threads();
    }

    [[nodiscard]] auto iterations() const noexcept -> std::size_t {
        return iterations_;
    }

    [[nodiscard]] auto samples() const noexcept -> std::size_t {
        return samples_;
    }

    template <typename T>
    [[nodiscard]] auto get_param(const param::ParameterName& param_name) const
        -> const T& {
        return cond_.params().get<T>(param_name);
    }

    template <typename T>
    [[nodiscard]] auto get_param(std::string param_name) const -> const T& {
        return get_param<T>(param::ParameterName(std::move(param_name)));
    }

    [[nodiscard]] auto add_custom_stat(const CustomOutputName& name,
        stat::CustomOutputAnalysisType analysis_type =
            stat::CustomOutputAnalysisType::mean)
        -> std::shared_ptr<stat::CustomStatOutput> {
        auto out =
            std::make_shared<stat::CustomStatOutput>(name, cond_.threads(),
                samples_, warming_up_samples_, iterations_, analysis_type);
        custom_stat_outputs_.push_back(out);
        return out;
    }

    [[nodiscard]] auto add_custom_stat(std::string name,
        stat::CustomOutputAnalysisType analysis_type =
            stat::CustomOutputAnalysisType::mean)
        -> std::shared_ptr<stat::CustomStatOutput> {
        return add_custom_stat(
            CustomOutputName(std::move(name)), analysis_type);
    }

    void add_custom_output(const CustomOutputName& name, double value) {
        custom_outputs_.emplace_back(name, value);
    }

    void add_custom_output(std::string name, double value) {
        add_custom_output(CustomOutputName(std::move(name)), value);
    }

    template <typename Func>
    void measure(const Func& func) {
        durations_ = bench_impl::ThreadableInvoker(
            cond_.threads(), iterations_, samples_, warming_up_samples_)
                         .measure(func);
    }

    [[nodiscard]] auto durations() const noexcept
        -> const std::vector<std::vector<clock::Duration>>& {
        return durations_;
    }

    [[nodiscard]] auto custom_stat_outputs() const noexcept
        -> const std::vector<std::shared_ptr<stat::CustomStatOutput>>& {
        return custom_stat_outputs_;
    }

    [[nodiscard]] auto custom_outputs() const noexcept
        -> const std::vector<std::pair<CustomOutputName, double>>& {
        return custom_outputs_;
    }
 
private:
    BenchmarkCondition cond_;

    std::size_t iterations_;

    std::size_t samples_;

    std::size_t warming_up_samples_;

    std::vector<std::vector<clock::Duration>> durations_{};

    std::vector<std::shared_ptr<stat::CustomStatOutput>> custom_stat_outputs_{};

    std::vector<std::pair<CustomOutputName, double>> custom_outputs_{};
};
 
}  // namespace stat_bench