measurement.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 <utility>
#include <vector>
 
#include "stat_bench/benchmark_condition.h"
#include "stat_bench/benchmark_full_name.h"
#include "stat_bench/clock/duration.h"
#include "stat_bench/custom_output_name.h"
#include "stat_bench/measurer/measurement_type.h"
#include "stat_bench/stat/calc_stat.h"
#include "stat_bench/stat/custom_stat_output.h"
#include "stat_bench/stat/statistics.h"
 
namespace stat_bench {
namespace measurer {

class Measurement {
public:
    Measurement(BenchmarkFullName case_info, BenchmarkCondition cond,
        MeasurementType measurement_type, std::size_t iterations,
        std::size_t 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)
        : case_info_(std::move(case_info)),
          cond_(std::move(cond)),
          measurement_type_(std::move(measurement_type)),
          iterations_(iterations),
          samples_(samples),
          durations_(std::move(durations)),
          durations_stat_(stat::calc_stat(durations_, iterations)),
          custom_stat_outputs_(std::move(custom_stat_outputs)),
          custom_outputs_(std::move(custom_outputs)) {
        custom_stat_.reserve(custom_stat_outputs_.size());
        for (const auto& out : custom_stat_outputs_) {
            out->preprocess(durations_);
            custom_stat_.push_back(out->stat());
        }
    }

    [[nodiscard]] auto case_info() const noexcept -> const BenchmarkFullName& {
        return case_info_;
    }

    [[nodiscard]] auto cond() const noexcept -> const BenchmarkCondition& {
        return cond_;
    }

    [[nodiscard]] auto measurement_type() const noexcept
        -> const MeasurementType& {
        return measurement_type_;
    }

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

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

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

    [[nodiscard]] auto durations_stat() const noexcept
        -> const stat::Statistics& {
        return durations_stat_;
    }

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

    [[nodiscard]] auto custom_stat() const noexcept
        -> const std::vector<stat::Statistics>& {
        return custom_stat_;
    }

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

    BenchmarkCondition cond_;

    MeasurementType measurement_type_;

    std::size_t iterations_;

    std::size_t samples_;

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

    stat::Statistics durations_stat_;

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

    std::vector<stat::Statistics> custom_stat_;

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