performance_tracker.hpp

Go to the documentation of this file.

 
#ifndef PLSSVM_DETAIL_PERFORMANCE_TRACKER_HPP_
#define PLSSVM_DETAIL_PERFORMANCE_TRACKER_HPP_
#pragma once
 
#include "plssvm/detail/cmd/parser_predict.hpp"  // plssvm::detail::cmd::parser_predict
#include "plssvm/detail/cmd/parser_scale.hpp"    // plssvm::detail::cmd::parser_scale
#include "plssvm/detail/cmd/parser_train.hpp"    // plssvm::detail::cmd::parser_train
#include "plssvm/detail/type_traits.hpp"         // plssvm::detail::remove_cvref_t
 
#include "fmt/chrono.h"                          // format std::chrono types
#include "fmt/core.h"                            // fmt::format
#include "fmt/ostream.h"                         // format types with an operator<< overload
 
#include <memory>                                // std::shared_ptr
#include <string>                                // std::string
#include <string_view>                           // std::string_view
#include <type_traits>                           // std::false_type, std::true_type
#include <unordered_map>                         // std::unordered_multimap
#include <utility>                               // std::move
 
namespace plssvm::detail {
 
template <typename T>
struct tracking_entry {
    tracking_entry(const std::string_view category, const std::string_view name, T value) :
        entry_category{ category }, entry_name{ name }, entry_value{ std::move(value) } {}
 
    const std::string entry_category{};
    const std::string_view entry_name{};
    const T entry_value{};
};
 
template <typename T>
std::ostream &operator<<(std::ostream &out, const tracking_entry<T> &entry) {
    return out << fmt::format("{}", entry.entry_value);
}
 
namespace impl {
 
template <typename T>
struct is_tracking_entry : std::false_type {};
template <typename T>
struct is_tracking_entry<tracking_entry<T>> : std::true_type {};
 
}  // namespace impl
 
template <typename T>
struct is_tracking_entry : impl::is_tracking_entry<detail::remove_cvref_t<T>> {};
template <typename T>
constexpr bool is_tracking_entry_v = is_tracking_entry<T>::value;
 
class performance_tracker {
  public:
    performance_tracker();
    ~performance_tracker();
 
    template <typename T>
    void add_tracking_entry(const tracking_entry<T> &entry);
    void add_tracking_entry(const tracking_entry<std::string> &entry);
    void add_tracking_entry(const tracking_entry<::plssvm::parameter> &entry);
    void add_tracking_entry(const tracking_entry<cmd::parser_train> &entry);
    void add_tracking_entry(const tracking_entry<cmd::parser_predict> &entry);
    void add_tracking_entry(const tracking_entry<cmd::parser_scale> &entry);
 
    void save(const std::string &filename);
    void save(std::ostream &out);
 
    void pause_tracking() noexcept;
    void resume_tracking() noexcept;
    [[nodiscard]] bool is_tracking() noexcept;
 
    [[nodiscard]] const std::unordered_multimap<std::string, std::string> &get_tracking_entries() noexcept;
 
  private:
    std::unordered_multimap<std::string, std::string> tracking_statistics{};
    bool is_tracking_{ true };
};
 
template <typename T>
void performance_tracker::add_tracking_entry(const tracking_entry<T> &entry) {
    if (is_tracking()) {
        tracking_statistics.emplace(entry.entry_category, fmt::format("{}{}: {}\n", entry.entry_category.empty() ? "" : "  ", entry.entry_name, entry.entry_value));
    }
}
 
extern std::shared_ptr<performance_tracker> global_tracker;
 
#if defined(PLSSVM_PERFORMANCE_TRACKER_ENABLED)
 
    #define PLSSVM_DETAIL_PERFORMANCE_TRACKER_PAUSE() \
        ::plssvm::detail::global_tracker->pause_tracking()
 
    #define PLSSVM_DETAIL_PERFORMANCE_TRACKER_RESUME() \
        ::plssvm::detail::global_tracker->resume_tracking()
 
    #define PLSSVM_DETAIL_PERFORMANCE_TRACKER_SAVE(filename) \
        ::plssvm::detail::global_tracker->save(filename)
 
    #define PLSSVM_DETAIL_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY(entry) \
        ::plssvm::detail::global_tracker->add_tracking_entry(entry);
#else
 
    #define PLSSVM_DETAIL_PERFORMANCE_TRACKER_PAUSE()
    #define PLSSVM_DETAIL_PERFORMANCE_TRACKER_RESUME()
    #define PLSSVM_DETAIL_PERFORMANCE_TRACKER_SAVE(filename)
    #define PLSSVM_DETAIL_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY(entry)
 
#endif
 
}  // namespace plssvm::detail
 
#endif  // PLSSVM_DETAIL_PERFORMANCE_TRACKER_HPP_