hebench_report_cpp.h

Go to the documentation of this file.

 
// Copyright (C) 2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
 
#ifndef _HEBench_Harness_Report_CPP_H_0596d40a3cce4b108a81595c50eb286d
#define _HEBench_Harness_Report_CPP_H_0596d40a3cce4b108a81595c50eb286d
 
#include <ratio>
#include <stdexcept>
#include <string>
 
#include "hebench_report_types.h"
 
namespace hebench {
namespace ReportGen {
namespace cpp {
 
//class ReportSummary;
 
class TimingPrefixUtility
{
public:
    enum class TimeUnit
    {
        Default,
        Seconds,
        MilliSeconds,
        Microseconds,
        Nanoseconds
    };
 
    static constexpr TimeUnit getPrefix(char ch_prefix)
    {
        switch (ch_prefix)
        {
        case 0:
            return TimeUnit::Default;
            break;
        case 's':
            return TimeUnit::Seconds;
            break;
        case 'm':
            return TimeUnit::MilliSeconds;
            break;
        case 'u':
            return TimeUnit::Microseconds;
            break;
        case 'n':
            return TimeUnit::Nanoseconds;
            break;
        default:
            throw std::invalid_argument("Unknown prefix.");
            break;
        } // end switch
    }
 
    static constexpr char getPrefix(TimeUnit unit)
    {
        switch (unit)
        {
        case TimeUnit::Default:
            return 0;
            break;
        case TimeUnit::Seconds:
            return 's';
            break;
        case TimeUnit::MilliSeconds:
            return 'm';
            break;
        case TimeUnit::Microseconds:
            return 'u';
            break;
        case TimeUnit::Nanoseconds:
            return 'n';
            break;
        default:
            throw std::invalid_argument("Unknown prefix.");
            break;
        } // end switch
    }
 
    static void setTimingPrefix(TimingPrefixedSeconds &prefix, double seconds, char ch_prefix);
    static void setTimingPrefix(TimingPrefixedSeconds &prefix, double seconds, TimeUnit unit)
    {
        setTimingPrefix(prefix, seconds, getPrefix(unit));
    }
    static void computeTimingPrefix(TimingPrefixedSeconds &prefix, double seconds);
};
 
class TimingReport
{
    friend class ReportSummary;
 
private:
    static constexpr const char *m_private_class_name = "TimingReport";
 
public:
    TimingReport(const TimingReport &) = delete;
 
public:
    TimingReport(const std::string &header = std::string());
    TimingReport(TimingReport &&);
    virtual ~TimingReport();
 
    TimingReport &operator=(TimingReport &&);
 
    void setHeader(const std::string &new_header);
    void appendHeader(const std::string &new_header, bool new_line = true);
    void prependHeader(const std::string &new_header, bool new_line = true);
    std::string getHeader() const;
 
    void setFooter(const std::string &new_footer);
    void appendFooter(const std::string &new_header, bool new_line = true);
    void prependFooter(const std::string &new_header, bool new_line = true);
    std::string getFooter() const;
 
    void addEventType(uint32_t event_type_id, const std::string &event_type_header, bool is_main_event = false);
    bool hasEventType(uint32_t event_type_id) const;
    std::string getEventTypeHeader(uint32_t event_type_id) const;
    uint64_t getEventTypeCount() const;
    uint32_t getEventType(uint64_t index) const;
    uint32_t getMainEventType() const;
 
    // events management
 
    void addEvent(const TimingReportEventC &p_event);
    void getEvent(TimingReportEventC &p_event, uint64_t index) const;
    uint64_t getEventCount() const;
    uint64_t getEventCapacity() const;
    void setEventCapacity(uint64_t new_capacity);
    void clear();
 
    // CSV
 
    void save2CSV(const std::string &filename);
    std::string convert2CSV();
 
    static TimingReport loadReportFromCSV(const std::string &s_csv_content);
    static TimingReport loadReportFromCSVFile(const std::string &filename);
 
    template <class TimeInterval = std::ratio<1, 1>>
    static double computeElapsedWallTime(const TimingReportEventC &event);
    template <class TimeInterval = std::ratio<1, 1>>
    static double computeElapsedCPUTime(const TimingReportEventC &event);
 
private:
    void *m_lib_handle;
};
 
template <class TimeInterval>
double TimingReport::computeElapsedWallTime(const TimingReportEventC &event)
{
    return (std::abs(event.wall_time_end - event.wall_time_start)
            * (event.time_interval_ratio_num * TimeInterval::den))
           / (event.time_interval_ratio_den * TimeInterval::num);
}
 
template <class TimeInterval>
double TimingReport::computeElapsedCPUTime(const TimingReportEventC &event)
{
    return (std::abs(event.cpu_time_end - event.cpu_time_start)
            * (event.time_interval_ratio_num * TimeInterval::den))
           / (event.time_interval_ratio_den * TimeInterval::num);
}
 
//class ReportSummary
//{
//private:
//    static constexpr const char *m_private_class_name = "ReportSummary";
 
//public:
//    ReportSummary(const TimingReport &report);
//};
 
} // namespace cpp
} // namespace ReportGen
} // namespace hebench
 
#endif // defined _HEBench_Harness_Report_CPP_H_0596d40a3cce4b108a81595c50eb286d