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 Sotiris Papatheodorou
 * SPDX-License-Identifier: MIT
 */

/*

 This code is licensed under the MIT License.

 */

#ifndef SE_PERFSTATS_HPP
#define SE_PERFSTATS_HPP

#ifdef __APPLE__
#    include <mach/clock.h>
#    include <mach/mach.h>
#endif


#include <Eigen/Dense>
#include <algorithm>
#include <fstream>
#include <iomanip>
#include <map>
#include <mutex>
#include <numeric>
#include <ostream>
#include <sstream>
#include <string>
#include <vector>

struct PerfStats {
    enum Type {
        BOOL,
        COORDINATES,
        COUNT,
        CURRENT,
        DISTANCE,
        DOUBLE,
        DURATION,
        ENERGY,
        FRAME,
        FREQUENCY,
        INT,
        ITERATION,
        MEMORY,
        ORIENTATION,
        PERCENTAGE,
        POSITION,
        POWER,
        TIME,
        UNDEFINED,
        VOLTAGE
    };

    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_;
        bool
            detailed_; 
        double last_absolute_; 
        std::mutex mutex_;
        Type type_; 
    };

    struct Results {
        double mean;
        double min;
        double max;
        double sum;
    };

    PerfStats();

    PerfStats(const bool include_detailed);

    std::string createHeaderString();

    std::string createDataIterString();

    std::string createDataIterString(const size_t iter);

    std::string createDataString();

    void debug();

    const Stats& get(const std::string& key) const
    {
        return stats_.find(key)->second;
    }

    std::vector<double> getLastData(const std::string& key);

    double getLastDataMerged(const std::string& key);

    double getSampleTime(const std::string& key);

    static double getTime();

    Type getType(const std::string& key);

    void reset();

    void reset(const std::string& key);

    double sample(const std::string& key,
                  const double value,
                  const Type type = COUNT,
                  const bool detailed = false);

    double sampleT_WB(const Eigen::Matrix4f& T_WB, const bool detailed = false);

    double sampleDurationStart(const std::string& key, const bool detailed = false);
    double sampleDurationEnd(const std::string& key);

    void setFilestream(std::ofstream* filestream);

    void includeDetailed(const bool include_detailed)
    {
        if (include_detailed != include_detailed_) {
            filestream_aligned_ = false;
            ostream_aligned_ = false;
        }
        include_detailed_ = include_detailed;
    };

    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);

    std::vector<PerfStats::Type> header_order_ = {
        FRAME,
        ITERATION,
        TIME,
        DURATION,
        MEMORY,
        POSITION,
        ORIENTATION,
        DISTANCE,
        FREQUENCY,
        BOOL,
        POWER,
        ENERGY,
        CURRENT,
        VOLTAGE,
        COUNT,
        INT,
        DOUBLE,
        PERCENTAGE,
        UNDEFINED};         
    bool include_detailed_; 

    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_; 
};

#include "impl/perfstats_impl.hpp"

namespace se {



extern PerfStats perfstats;


} // namespace se

#endif // SE_PERFSTATS_HPP