perfstats.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2011-2013 Gerhard Reitmayr, TU Graz
 * SPDX-FileCopyrightText: 2014 University of Edinburgh, Imperial College, University of Manchester
 * SPDX-FileCopyrightText: 2016-2019 Emanuele Vespa
 * SPDX-FileCopyrightText: 2021 Smart Robotics Lab, Imperial College London, Technical University of Munich
 * SPDX-FileCopyrightText: 2021 Nils Funk
 * SPDX-FileCopyrightText: 2021-2024 Sotiris Papatheodorou
 * SPDX-License-Identifier: MIT
 */
 
#ifndef SE_PERFSTATS_HPP
#define SE_PERFSTATS_HPP
 
#include <Eigen/Geometry>
#include <algorithm>
#include <chrono>
#include <fstream>
#include <iomanip>
#include <map>
#include <mutex>
#include <numeric>
#include <ostream>
#include <sstream>
#include <string>
#include <vector>
 
namespace se {
 
struct PerfStats {
    enum Type {
        BOOL,
        COORDINATES,
        COUNT,
        CURRENT,
        DISTANCE,
        DOUBLE,
        DURATION,
        ENERGY,
        FRAME,
        FREQUENCY,
        INT,
        ITERATION,
        MEMORY,
        ORIENTATION,
        PERCENTAGE,
        POSITION,
        POWER,
        TIME,
        UNDEFINED,
        VOLTAGE,
        VOLUME,
    };
 
    struct Stats {
 
        static double meanIter(const std::vector<double>& iter_data_vec);
 
        static double lastIter(const std::vector<double>& iter_data_vec);
 
        static double minIter(const std::vector<double>& iter_data_vec);
 
        static double maxIter(const std::vector<double>& iter_data_vec);
 
        static double sumIter(const std::vector<double>& iter_data_vec);
 
        static double mergeIter(const std::vector<double>& iter_data_vec, const Type type);
 
 
 
        double meanIter(const size_t iter);
 
        double lastIter(const size_t iter);
 
        double minIter(const size_t iter);
 
        double maxIter(const size_t iter);
 
        double sumIter(const size_t iter);
 
        double mergeIter(const size_t iter);
 
 
 
        double mean() const;
 
        double last() const;
 
        double min() const;
 
        double max() const;
 
        double sum() const;
 
        double merge() const;
 
 
        std::string unitString();
 
        // <iteration/frame, vector of values at iteration/frame>
        std::map<size_t, std::vector<double>> data_;
        double last_absolute_; 
        std::mutex mutex_;
        Type type_; 
    };
 
    struct Results {
        double mean;
        double min;
        double max;
        double sum;
    };
 
    PerfStats();
 
    std::string createHeaderString();
 
    std::string createDataIterString();
 
    std::string createDataIterString(const size_t iter);
 
    std::string createDataString();
 
    const Stats& get(const std::string& key) const
    {
        return stats_.find(key)->second;
    }
 
    double sample(const std::string& key, const double value, const Type type = COUNT);
 
    double sampleT_WB(const Eigen::Isometry3f& T_WB);
 
    double sampleDurationStart(const std::string& key);
 
    double sampleDurationEnd(const std::string& key);
 
    void setFilestream(std::ofstream* filestream);
 
    void setIter(const size_t iter)
    {
        iter_ = iter;
        sample("iteration", iter, ITERATION);
    };
 
    void writeToFilestream();
 
    void writeToOStream(std::ostream& ostream);
 
    void writeSummaryToOStream(std::ostream& ostream, const bool include_iter_data = true);
 
    static double timeNow();
 
    std::vector<PerfStats::Type> header_order_ = {
        FRAME,    ITERATION, TIME, DURATION, MEMORY,     POSITION, ORIENTATION,
        DISTANCE, FREQUENCY, BOOL, POWER,    ENERGY,     CURRENT,  VOLTAGE,
        VOLUME,   COUNT,     INT,  DOUBLE,   PERCENTAGE, UNDEFINED};
 
    int insertion_idx_; 
    size_t iter_;       
    std::map<int, std::string>
        order_; 
    std::map<std::string, Stats> stats_; 
 
    std::ofstream* filestream_;
    bool filestream_aligned_;
    size_t filestream_last_iter_;
    std::streampos filestream_pos_;
 
    bool ostream_aligned_;
    size_t ostream_last_iter_;
};
 
extern PerfStats perfstats;
 
} // namespace se
 
#include "impl/perfstats_impl.hpp"
 
#endif // SE_PERFSTATS_HPP