RuntimeProgressTool.h

Go to the documentation of this file.

#ifndef RUNTIME_PROGRESS_TOOL_H
#define RUNTIME_PROGRESS_TOOL_H
 
#define RUNTIME_PROGRESS_TOOL_VERSION "8"
 
#include <chrono>
#include <iostream>
#include <memory>
#include <string>
#include <valarray>
 
#include "../../src/GenericManagingModule.h"
#include "../../src/ModuleFactory.h"
 
template <typename T>
class RuntimeProgressTool : public GenericManagingModule<T>
{
    private:
        static bool m_registered;
        int iteration_interval;
        int total_time_steps;
        std::string m_ini_filepath{"tools/RuntimeProgressTool.ini"};
        std::chrono::time_point<std::chrono::high_resolution_clock> start_time;
        std::chrono::time_point<std::chrono::high_resolution_clock> last_call_time;
 
        void _calculate_iteration_time();
 
    public:
        RuntimeProgressTool(SimulationClassBase<T>* sim);
        bool setup(std::vector<std::shared_ptr<GenericSubmodule<T>>> all_submodules) override;
        bool exec(std::string_view param) override;  // main functionality of the module
 
        bool init() override { return true; };
        bool preTimeStep() override;
        bool postNonLinIter() override { return true; };
        bool postTimeStep() override;
        bool output() override;
 
        void checkProgress();
 
        std::vector<std::string> getChainInsertion() const override
        {
            return this->ini_file_data.getStringVectorParameters("chain_insertion");
        };
 
        static std::shared_ptr<GenericManagingModule<T>> createMethode(SimulationClassBase<T>* sim)
        {
            return std::make_shared<RuntimeProgressTool<T>>(sim);
        };
        static std::string getName() { return "RuntimeProgressTool"; };
        std::string_view getNameLocal() const override { return "RuntimeProgressTool"; };
};
 
// ================= Implementation =================
 
template <typename T>
RuntimeProgressTool<T>::RuntimeProgressTool(SimulationClassBase<T>* sim)
    : GenericManagingModule<T>(sim)
{
    try
    {
        std::string ini_folder_path{
            this->sim->m_simulation_config.getStringParameters("ini_folder_path")};
        this->ini_file_data.loadUserInput(ini_folder_path + m_ini_filepath);
        this->m_generic_submodules = this->ini_file_data.getStringVectorParameters("submodules");
    }
    catch (const BadInput& e)
    {
        std::cerr << "[RuntimeProgressTool]: " << e.what() << '\n';
        throw BadInput(static_cast<std::string>("[RuntimeProgressTool]: ")
                       + static_cast<std::string>(e.what()));
    }
}
 
template <typename T>
bool RuntimeProgressTool<T>::setup(std::vector<std::shared_ptr<GenericSubmodule<T>>> all_submodules)
{
    try
    {
        this->setSubmodules(all_submodules);
        iteration_interval = this->ini_file_data.getDoubleParameters("iteration_interval");
        total_time_steps =
            std::ceil(this->sim->m_simulation_config.getDoubleParameters("time_max")
                      / this->sim->m_simulation_config.getDoubleParameters("time_delta"));
        start_time = std::chrono::high_resolution_clock::now();
        last_call_time = start_time;
    }
    catch (const BadInput& e)
    {
        std::cerr << "[RuntimeProgressTool]: " << e.what() << '\n';
        throw BadInput(static_cast<std::string>("[RuntimeProgressTool]: ")
                       + static_cast<std::string>(e.what()));
    }
    return true;
}
 
template <typename T>
bool RuntimeProgressTool<T>::exec(std::string_view param)
{
    if (param == "InitChain")
    {
        return init();
    }
    if (param == "PreTimeStepChain")
    {
        return preTimeStep();
    }
    if (param == "PostNonLinIterChain")
    {
        return postNonLinIter();
    }
    if (param == "PostTimeStepChain")
    {
        return postTimeStep();
    }
    if (param == "OutputChain")
    {
        return output();
    }
    return false;
}
 
template <typename T>
void RuntimeProgressTool<T>::_calculate_iteration_time()
{
    // Using milliseconds as seconds can too quickly lead to time intervals of 0
    // That's why multiplication by 1000 is done to still get the iterations per seconds.
    std::chrono::time_point current_time{std::chrono::high_resolution_clock::now()};
    std::chrono::duration passed_time_since_start{
        std::chrono::duration_cast<std::chrono::milliseconds>(current_time - start_time)};
    std::chrono::duration passed_time_since_last_call{
        std::chrono::duration_cast<std::chrono::milliseconds>(current_time - last_call_time)};
    // I'm using the ANSI escape code for color here, to highlight that this is a status related
    // message and not outputs or errors. This only works on terminals supporting these escape
    // codes.
    std::cout << "\033[32m[RuntimeProgressTool]: Time steps: " << this->sim->time_step << "/"
              << total_time_steps << "\033[0m\n";
 
    if (passed_time_since_last_call.count() == 0)
    {
        // Time intervall chosen to small for the current simulation.
    }
    else
    {
        std::cout << "\033[32m[RuntimeProgressTool]: Simulation speed of "
                  << (iteration_interval * 1000 / passed_time_since_last_call.count())
                  << " it/s for the last interval. Simulation speed of "
                  << (this->sim->time_step * 1000 / passed_time_since_start.count())
                  << " it/s since start.\033[0m\n";
    }
    last_call_time = current_time;
}
 
template <typename T>
void RuntimeProgressTool<T>::checkProgress()
{
    if (this->sim->time_step % iteration_interval == 0)
    {
        _calculate_iteration_time();
    }
}
 
template <typename T>
bool RuntimeProgressTool<T>::preTimeStep()
{
    if (this->sim->my_rank == 0)
    {
        checkProgress();
    }
    return true;
}
 
template <typename T>
bool RuntimeProgressTool<T>::postTimeStep()
{
    if (this->sim->my_rank == 0)
    {
        checkProgress();
    }
    return true;
}
 
template <typename T>
bool RuntimeProgressTool<T>::output()
{
    if (this->sim->my_rank != 0)
    {
        return true;
    }
    std::chrono::time_point current_time{std::chrono::high_resolution_clock::now()};
    std::chrono::duration passed_time_since_start{
        std::chrono::duration_cast<std::chrono::milliseconds>(current_time - start_time)};
    std::cout << "\033[32m[RuntimeProgress] Total runtime of "
              << (float)(passed_time_since_start.count() / 1000.0)
              << " seconds since start.\033[0m\n";
    return true;
}
 
template <typename T>
bool RuntimeProgressTool<T>::m_registered =
    ModuleFactory<T>::registerModule(getName(), createMethode);
 
#endif  // RUNTIME_PROGRESS_TOOL_H