monitor.hh

Go to the documentation of this file.

#ifndef UTOPIA_DATAIO_MONITOR_HH
#define UTOPIA_DATAIO_MONITOR_HH
 
#include <chrono>
#include <iostream>
#include <utility>
#include <vector>
#include <yaml-cpp/yaml.h>
 
#include "../core/string.hh"
#include "cfg_utils.hh"
 
 
namespace Utopia::DataIO
{
 
 
template < class F, class... Args >
struct is_callable
{
    template < class U >
    static auto
    test(U* p)
        -> decltype((*p)(std::declval< Args >()...), void(), std::true_type());
    template < class U >
    static auto
    test(...) -> decltype(std::false_type());
 
    static constexpr bool value = decltype(test< F >(0))::value;
};
 
class MonitorTimer
{
  public:
    // -- Data types uses throughout the monitor timer-- //
 
    using Clock = std::chrono::high_resolution_clock;
 
    using Time = std::chrono::high_resolution_clock::time_point;
 
    using DurationType = std::chrono::duration< double >;
 
  private:
    // -- Member declaration -- //
    const DurationType _emit_interval;
 
    const Time _start_time;
 
    Time _last_emit;
 
  public:
 
    MonitorTimer(const double emit_interval) :
        // Store the emit interval
        _emit_interval(emit_interval),
        // Set the starting time member
        _start_time(Clock::now()),
        // Initialize _last_emit empty, setting it to 1.1.1970, 0:00, meaning
        // that no emit has occurred yet.
        _last_emit(){};
 
 
    bool
    time_has_come() const
    {
        // Calculate the time difference between now and the last emit
        const DurationType duration = Clock::now() - _last_emit;
 
        // If more time than the _emit_interval has passed, return true
        return (duration > _emit_interval);
    }
 
    void
    reset()
    {
        _last_emit = Clock::now();
    }
 
    template < class DurationT = DurationType >
    const DurationT
    get_time_elapsed() const
    {
        return Clock::now() - _start_time;
    }
 
    double
    get_time_elapsed_seconds() const
    {
        return get_time_elapsed< std::chrono::duration< double > >().count();
    }
 
    const DurationType
    get_emit_interval() const
    {
        return _emit_interval;
    }
};
 
 
class MonitorManager
{
  private:
    using Timer = std::shared_ptr< MonitorTimer >;
 
    // -- Members -------------------------------------------------------------
    Timer _timer;
 
    YAML::Node _entries;
 
    bool _emit_enabled;
 
    std::size_t _emit_counter;
 
    const std::string _emit_prefix;
 
    const std::string _emit_suffix;
 
  public:
 
    MonitorManager(const double      emit_interval,
                   const std::string emit_prefix = "!!map ",
                   const std::string emit_suffix = "")
    :
        // Create a new MonitorTimer object
        _timer(std::make_shared< MonitorTimer >(emit_interval)),
        // Create an empty MonitorEntries object for the data to be emitted
        _entries(YAML::Node()),
        // Initialially set the collect data flag to true
        _emit_enabled(true),
        _emit_counter(0),
        _emit_prefix(emit_prefix),
        _emit_suffix(emit_suffix)
    {};
 
    void
    emit_if_enabled()
    {
        if (not _emit_enabled) return;
 
        // Calling recursive_setitem may remove the emitter style, requiring
        // to reset it here each time. This will only set some flags in the
        // to-be-created YAML::Emitter and has negligible performance impact.
        _entries.SetStyle(YAML::EmitterStyle::Flow);
 
        std::cout << _emit_prefix
                  << _entries
                  << _emit_suffix
                  << std::endl;
 
        _emit_counter++;
        _timer->reset();
        _emit_enabled = false;
    }
 
    void
    check_timer()
    {
        if (_timer->time_has_come())
        {
            _emit_enabled = true;
        }
    }
 
    /* This function can be used as a more performative way to checking whether
     * it makes sense to collect monitor entries; it makes only sense to
     * collect entries, if the emission will actually performed in the current
     * time step.
     */
    bool
    emit_enabled() const
    {
        return _emit_enabled;
    }
 
 
    template < typename Value >
    void
    set_entry(const std::string& path,
              const std::string& key,
              const Value        value)
    {
        using _internal::recursive_setitem;
        recursive_setitem(_entries, path + "." + key, value, ".");
    }
 
 
    template < typename Time >
    void
    set_time_entries(const Time time, const Time time_max)
    {
        _entries["time"] = time;
 
        // Add the progress indicator and the elapsed time
        _entries["progress"] = float(time) / float(time_max);
    }
 
    Timer&
    get_timer()
    {
        return _timer;
    }
 
    auto
    get_emit_interval()
    {
        return _timer->get_emit_interval();
    }
 
    auto
    get_emit_counter()
    {
        return _emit_counter;
    }
 
    YAML::Node&
    get_entries()
    {
        return _entries;
    }
};
 
class Monitor
{
  private:
 
    const std::string _name;
 
    std::shared_ptr< MonitorManager > _mtr_mgr;
 
  public:
 
    Monitor(std::shared_ptr< MonitorManager > root_mtr_mgr)
    :
        _name(""),
        _mtr_mgr(root_mtr_mgr){};
 
 
    Monitor(const std::string& name, const Monitor& parent_mtr)
    :
        _name(parent_mtr.get_name() + "." + name),
        _mtr_mgr(parent_mtr.get_monitor_manager()){};
 
 
    template < typename Func >
    void
    set_by_func(const std::string key, Func&& f)
    {
        _mtr_mgr->set_entry(_name, key, f());
    }
 
 
    template < typename Value >
    void
    set_by_value(const std::string key, Value const& v)
    {
        _mtr_mgr->set_entry(_name, key, v);
    }
 
 
    template < typename Arg >
    void
    set_entry(const std::string key, Arg arg)
    {
        if constexpr (is_callable< Arg >::value)
        {
            set_by_func(key, arg);
        }
        else
        {
            set_by_value(key, arg);
        }
    }
 
    std::shared_ptr< MonitorManager >
    get_monitor_manager() const
    {
        return _mtr_mgr;
    }
 
    std::string
    get_name() const
    {
        return _name;
    }
};
 
 
} // namespace Utopia::DataIO
 
#endif // UTOPIA_DATAIO_MONITOR_HH