SimulationInfo.hpp

Go to the documentation of this file.

// <SimulationInfo.h> -*- C++ -*-
 
 
#pragma once
 
#include <errno.h>
#include <cstdint>
#include <unistd.h>
#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <sstream>
#include <cstring>
#include <stack>
#include <fstream>
#include <map>
#include <memory>
#include <utility>
 
#include "sparta/utils/TimeManager.hpp"
#include "sparta/utils/ValidValue.hpp"
#include "sparta/utils/StringUtils.hpp"
#include "sparta/utils/SpartaAssert.hpp"
#include "sparta/utils/SpartaException.hpp"
 
#include "simdb/schema/DatabaseTypedefs.hpp"
namespace simdb { class ObjectManager; }
 
namespace sparta
{
 
class LineStringStream
{
    std::vector<std::string> lines_; 
    std::stringstream stream_; 
 
public:
 
    typedef std::ostream& (*manip_t)(std::ostream&);
 
    LineStringStream() = default;
 
    template <class T>
    LineStringStream& operator<<(const T& t) {
        stream_ << t;
        return *this;
    }
 
    LineStringStream& operator<<(manip_t f) {
        if(f == static_cast<manip_t>(std::endl)){
            addNewLine();
        }else{
            f(stream_);
        }
        return *this;
    }
 
    void addNewLine(){
        lines_.push_back(stream_.str());
        stream_.str(""); // Clear
    }
 
    std::vector<std::string> getLines() const {
        std::vector<std::string> result = lines_; // Copy
        result.push_back(stream_.str());
        return result;
    }
}; // class LineStringStream
 
class SimulationInfo
{
    std::string sim_name_;           
    std::string command_line_;       
    std::string working_dir_;        
    std::string executable_;         
    std::string simulator_version_;  
    std::string reproduction_info_;  
    std::string start_time_;         
    std::string sparta_version_;       
    std::vector<std::string> other_; 
 
    utils::ValidValue<std::string>  db_elapsed_time_;
 
    static std::stack<SimulationInfo*> sim_inst_stack_;
 
    static SimulationInfo sim_inst_; 
 
public:
 
    const std::string& sim_name;
 
    const std::string& command_line;
 
    const std::string& working_dir;
 
    const std::string& executable;
 
    const std::string& simulator_version;
 
    static const char sparta_version[];
 
    const std::string& reproduction_info;
 
    const std::string& start_time;
 
    const std::vector<std::string>& other;
 
    static SimulationInfo& getInstance() {
        if (sim_inst_stack_.empty()) {
            return sim_inst_;
        }
        return *sim_inst_stack_.top();
    }
 
    ~SimulationInfo() {
        if (!sim_inst_stack_.empty()) {
            sim_inst_stack_.pop();
        }
    }
 
    SimulationInfo() :
        start_time_(TimeManager::getTimeManager().getLocalTime()),
        sim_name(sim_name_),
        command_line(command_line_),
        working_dir(working_dir_),
        executable(executable_),
        simulator_version(simulator_version_),
        reproduction_info(reproduction_info_),
        start_time(start_time_),
        other(other_)
    {;}
 
    SimulationInfo(const SimulationInfo& rhp) :
        SimulationInfo()
    {
        sim_name_ = rhp.sim_name_;
        command_line_ = rhp.command_line_;
        working_dir_ = rhp.working_dir_;
        executable_ = rhp.executable_;
        simulator_version_ = rhp.simulator_version_;
        reproduction_info_ = rhp.reproduction_info_;
        other_ = rhp.other_;
    }
 
    SimulationInfo(SimulationInfo&&) = delete;
 
    SimulationInfo& operator=(const SimulationInfo& rhp) {
        sim_name_ = rhp.sim_name_;
        command_line_ = rhp.command_line_;
        working_dir_ = rhp.working_dir_;
        executable_ = rhp.executable_;
        simulator_version_ = rhp.simulator_version_;
        reproduction_info_ = rhp.reproduction_info_;
        start_time_ = rhp.start_time_;
        other_ = rhp.other_;
 
        return *this;
    }
 
    SimulationInfo(const std::string& _sim_name,
                   const std::string& _command_line,
                   const std::string& _working_dir,
                   const std::string& _executable,
                   const std::string& _simulator_version,
                   const std::string& _reproduction_info,
                   const std::vector<std::string> & _other) :
        SimulationInfo()
    {
        sim_name_ = _sim_name;
        command_line_ = _command_line;
        working_dir_ = _working_dir;
        executable_  = _executable;
        simulator_version_ = _simulator_version;
        reproduction_info_ = _reproduction_info;
        other_ = _other;
    }
 
    SimulationInfo(const std::string& _sim_name,
                   int argc,
                   char** argv,
                   const std::string& _simulator_version,
                   const std::string& _reproduction_info,
                   const std::vector<std::string> & _other) :
        SimulationInfo()
    {
        sim_name_ = _sim_name;
        setCommandLine(argc, argv);
        simulator_version_ = _simulator_version;
        reproduction_info_ = _reproduction_info;
        other_ = _other;
 
        const uint32_t PATH_SIZE = 2048;
        char tmp[PATH_SIZE];
        if (getcwd(tmp, PATH_SIZE) != nullptr) {
            working_dir_ = tmp;
        } else {
            std::stringstream ss;
            ss << "<error " << errno << " determining working directory>";
            working_dir_ = ss.str();
        }
    }
 
    SimulationInfo(const simdb::ObjectManager & sim_db,
                   const simdb::DatabaseID obj_mgr_db_id,
                   const simdb::DatabaseID report_node_id = 0);
    SimulationInfo(std::ifstream & json_fin,
                   std::map<std::string, std::string> * json_kvpairs = nullptr);
 
    std::string getSpartaVersion() const {
        if (sparta_version_.empty()) {
            return SimulationInfo::sparta_version;
        }
        return sparta_version_;
    }
 
    void setCommandLine(int argc, char** argv) {
        if(argc > 0){
            executable_ = argv[0];
        }
        std::stringstream cmdln;
        for(int i = 0; i < argc; ++i){
            if(i > 0){
                cmdln << " ";
            }
            size_t arglen = strlen(argv[i]);
            if(arglen == 0
               || memchr(argv[i], ' ', arglen) != nullptr
               || memchr(argv[i], '\t', arglen) != nullptr
               || memchr(argv[i], '\n', arglen) != nullptr){
                cmdln << '"' << argv[i] << '"';
            }else{
                cmdln << argv[i];
            }
        }
        command_line_ = cmdln.str();
    }
 
    void setCommandLine(const std::string& cmdline) {
        command_line_ = cmdline;
    }
 
    void addOtherInfo(const std::string& _other){
        other_.push_back(_other);
    }
 
    template <typename StreamType=std::ostream>
    void write(StreamType& o,
               const std::string& line_start="# ",
               const std::string& line_end="\n",
               bool show_field_names=true) const {
 
        auto pairs = getHeaderPairs();
        for(auto p : pairs){
            o << line_start;
            if(show_field_names){
                o << std::left << std::setw(10) << (p.first + ":");
            }
            o << p.second << line_end;
        }
 
        if(other.size() > 0){
            o << line_start << "Other:" << line_end;
            for(const std::string& oi : other){
                o << line_start << "  " << oi << line_end;
            }
        }
    }
 
    template <typename ...Args>
    std::string stringize(const Args& ...args) const {
        std::stringstream ss;
        write(ss, args...);
        return ss.str();
    }
 
    template <typename ...Args>
    std::vector<std::string> stringizeToLines(const Args& ...args) const {
        LineStringStream ss;
        write(ss, args...);
        return ss.getLines();
    }
 
    std::vector<std::pair<std::string, std::string>> getHeaderPairs() const {
        std::vector<std::pair<std::string, std::string>> result;
        result.emplace_back("Name", sim_name);
        result.emplace_back("Cmdline", command_line);
        result.emplace_back("Exe", executable);
        result.emplace_back("SimulatorVersion", simulator_version);
        result.emplace_back("Repro", reproduction_info);
        result.emplace_back("Start", start_time);
 
        //SimDB-recreated SimulationInfo objects have their
        //elapsed time values stored in the database directly.
        if (db_elapsed_time_.isValid()) {
            result.emplace_back("Elapsed", db_elapsed_time_.getValue());
        }
 
        //Normal use of the SimulationInfo::getInstance() singleton,
        //which is used during live SPARTA simulations, computes the
        //elapsed time value via the TimeManager.
        else {
            std::stringstream timestr;
            timestr << TimeManager::getTimeManager().getSecondsElapsed() << 's';
            result.emplace_back("Elapsed", timestr.str());
        }
 
        last_captured_elapsed_time_ = result.back().second;
        return result;
    }
 
    const utils::ValidValue<std::string> & getLastCapturedElapsedTime() const {
        return last_captured_elapsed_time_;
    }
 
private:
    mutable utils::ValidValue<std::string> last_captured_elapsed_time_;
 
}; // class SimulationInfo
 
inline std::ostream& operator<<(std::ostream& o, const SimulationInfo& info) {
    info.write(o);
    return o;
}
 
} // namespace sparta