custom_stat_output.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 <cstdint>
#include <utility>
#include <vector>
 
#include "stat_bench/clock/duration.h"
#include "stat_bench/custom_output_name.h"
#include "stat_bench/stat/calc_stat.h"
#include "stat_bench/stat/statistics.h"
#include "stat_bench/stat_bench_exception.h"
 
namespace stat_bench {
namespace stat {

enum class CustomOutputAnalysisType : std::uint8_t {
    mean,         
    rate_per_sec  
};

class CustomStatOutput {
public:
    CustomStatOutput(CustomOutputName name, std::size_t threads,
        std::size_t samples, std::size_t warming_up_samples,
        std::size_t iterations, CustomOutputAnalysisType analysis_type)
        : name_(std::move(name)),
          threads_(threads),
          samples_(samples),
          warming_up_samples_(warming_up_samples),
          iterations_(iterations),
          analysis_type_(analysis_type) {
        if (samples <= warming_up_samples) {
            throw StatBenchException("Invalid number of samples.");
        }
        data_.reserve(threads_);
        const std::size_t used_samples = samples - warming_up_samples;
        for (std::size_t i = 0; i < threads_; ++i) {
            data_.emplace_back(used_samples, 0.0);
        }
    }

    void add(std::size_t thread_index, std::size_t sample_index, double val) {
        if (sample_index < warming_up_samples_) {
            return;
        }
        data_.at(thread_index).at(sample_index - warming_up_samples_) += val;
    }

    void preprocess(
        const std::vector<std::vector<clock::Duration>>& durations) {
        const std::size_t used_samples = samples_ - warming_up_samples_;
        for (std::size_t i = 0; i < threads_; ++i) {
            for (std::size_t j = 0; j < used_samples; ++j) {
                double& val = data_.at(i).at(j);
 
                switch (analysis_type_) {
                case CustomOutputAnalysisType::mean:
                    val /= static_cast<double>(iterations_);
                    break;
                case CustomOutputAnalysisType::rate_per_sec:
                    val /= durations.at(i).at(j).seconds();
                    break;
                }
            }
        }
    }

    [[nodiscard]] auto stat() const -> Statistics { return calc_stat(data_); }

    [[nodiscard]] auto name() const noexcept -> const CustomOutputName& {
        return name_;
    }

    [[nodiscard]] auto data() const noexcept
        -> const std::vector<std::vector<double>>& {
        return data_;
    }
 
private:
    CustomOutputName name_;

    std::vector<std::vector<double>> data_{};

    std::size_t threads_;

    std::size_t samples_;

    std::size_t warming_up_samples_;

    std::size_t iterations_;

    CustomOutputAnalysisType analysis_type_;
};
 
}  // namespace stat
}  // namespace stat_bench