CommandLineSimulator.hpp

Go to the documentation of this file.

// <CommandLineSimulator> -*- C++ -*-
 
 
#pragma once
 
#include <boost/program_options.hpp>
#include <boost/program_options/cmdline.hpp>
#include <boost/program_options/errors.hpp>
#include <boost/program_options/options_description.hpp>
#include <boost/program_options/positional_options.hpp>
#include <boost/program_options/variables_map.hpp>
#include <cstdint>
#include <vector>
#include <set>
#include <memory>
#include <string>
#include <unordered_map>
 
#include "sparta/report/Report.hpp"
#include "sparta/app/Simulation.hpp"
#include "sparta/app/MultiDetailOptions.hpp"
#include "sparta/app/AppTriggers.hpp"
#include "sparta/app/SimulationConfiguration.hpp"
#include "sparta/app/FeatureConfiguration.hpp"
#include "sparta/trigger/Trigger.hpp"
#include "sparta/trigger/Triggerable.hpp"
#include "sparta/pevents/PeventTrigger.hpp"
#include "sparta/pevents/PeventController.hpp"
#include "sparta/kernel/Scheduler.hpp"
#include "sparta/app/ReportDescriptor.hpp"
 
namespace boost::program_options {
template <class charT> class basic_parsed_options;
}  // namespace boost::program_options
 
namespace sparta::app {
class Simulation;
}  // namespace sparta::app
 
namespace sparta::trigger {
class Trigger;
class Triggerable;
}  // namespace sparta::trigger
 
namespace po = boost::program_options;
namespace pocls = boost::program_options::command_line_style;
 
namespace sparta {
class InformationWriter;
 
namespace app {
 
const constexpr char DefaultHeartbeat[]        = "0";
 
 
class CommandLineSimulator
{
public:
 
    static DefaultValues DEFAULTS;
 
    CommandLineSimulator() = delete;
 
    CommandLineSimulator(const std::string& usage,
                         const DefaultValues& defs=DEFAULTS);
 
    virtual ~CommandLineSimulator();
 
    bool isParsed() const {
        return is_parsed_;
    }
 
    bool isSetup() const {
        return is_setup_;
    }
 
    const std::string& getUsage() const { return usage_; }
 
    const MultiDetailOptions& getSpartaOptions() const {
        return sparta_opts_;
    }
 
    MultiDetailOptions& getApplicationOptions() {
        return app_opts_;
    }
 
    MultiDetailOptions& getAdvancedOptions() {
        return advanced_opts_;
    }
 
    po::positional_options_description& getPositionalOptions() {
        return positional_opts_;
    }
 
    const po::variables_map& getVariablesMap() const {
        return vm_;
    }
 
    bool parse(int argc,
               char** argv,
               int& err_code);
 
    int parse(int argc,
              char** argv);
 
    void populateSimulation(Simulation* sim);
 
    void runSimulator(Simulation* sim);
 
    void runSimulator(Simulation* sim, uint64_t ticks);
 
    void postProcess(Simulation* sim);
 
    bool isRuntimeFinite() const {
 
        bool retval = (run_time_cycles_ != sparta::Scheduler::INDEFINITE) ||
                      (run_time_ticks_  != sparta::Scheduler::INDEFINITE);
        return retval;
    }
 
    SimulationConfiguration &getSimulationConfiguration() {
        return sim_config_;
    }
 
    const SimulationConfiguration &getSimulationConfiguration() const {
        return sim_config_;
    }
 
protected:
 
    void populateSimulation_(Simulation* sim);
 
    void runSimulator_(Simulation* sim, uint64_t ticks);
 
    void postProcess_(Simulation* sim);
 
    virtual void postParse_(po::basic_parsed_options<char>& opts) {
        (void) opts;
    }
 
    SimulationConfiguration sim_config_;
 
    FeatureConfiguration feature_config_;
 
    const std::string usage_;
 
    int argc_ = 0;
 
    char **argv_ = nullptr;
 
    ReportDescVec reports_;
 
    std::vector<std::string> report_descriptor_def_files_;
 
    app::ReportYamlReplacements report_yaml_placeholder_replacements_;
 
    std::unordered_map<std::string, app::ReportYamlReplacements>
        report_specific_yaml_placeholder_replacements_;
 
    bool is_parsed_ = false;
 
    bool is_setup_ = false;
 
    uint64_t run_time_cycles_ = sparta::Scheduler::INDEFINITE;
    uint64_t run_time_ticks_  = sparta::Scheduler::INDEFINITE;
 
    bool no_run_mode_ = false;
 
    std::string final_config_file_;
 
    std::string read_final_config_ = "";
    uint32_t config_applicators_used_ = 0;
 
    std::string power_config_file_;
 
    std::string final_config_file_verbose_;
 
    bool no_show_config_ = false;
 
    bool show_tree_ = false;
 
    bool show_parameters_ = false;
 
    bool show_ports_ = false;
 
    bool show_counters_ = false;
 
    bool show_clocks_ = false;
 
    bool show_pevents_ = false;
    bool show_notifications_ = false;
 
    bool show_loggers_ = false;
 
    bool show_hidden_ = false;
 
    bool disable_colors_ = false;
 
    std::string dump_debug_type_{"error"};
 
    std::string debug_dump_options_{"all"};
 
    std::unique_ptr<sparta::trigger::Triggerable> pipeline_collection_triggerable_;
    std::unique_ptr<sparta::trigger::Trigger>     pipeline_trigger_;
    std::unique_ptr<sparta::InformationWriter>    info_out_;
 
    std::string pipeline_heartbeat_ = DefaultHeartbeat;
 
    std::set<std::string> pipeline_enabled_node_names_;
 
    std::unique_ptr<sparta::trigger::Triggerable> pevent_trigger_;
 
    pevents::PeventCollectorController pevent_controller_;
    bool run_pevents_ = false;
 
    std::string runtime_clock_;
 
    std::string auto_summary_;
 
    std::string help_topic_;
 
private:
 
    bool use_pyshell_ = false;
 
    void printUsageHelp_() const;
 
    void printOptionsHelp_(uint32_t level) const;
 
    void showVerboseHelp_() const;
 
    void showBriefHelp_() const;
 
    void showHelpTopics_() const;
 
    bool openALFAndFindPipelineNodes_(const std::string & alf_filename);
 
    MultiDetailOptions sparta_opts_;
 
    MultiDetailOptions param_opts_;
 
    MultiDetailOptions debug_opts_;
 
    MultiDetailOptions run_time_opts_;
 
    MultiDetailOptions pipeout_opts_;
 
    MultiDetailOptions log_opts_;
 
    MultiDetailOptions report_opts_;
 
    MultiDetailOptions simdb_opts_;
 
    MultiDetailOptions simdb_internal_opts_;
 
    MultiDetailOptions app_opts_;
 
    MultiDetailOptions feature_opts_;
 
    MultiDetailOptions advanced_opts_;
 
    po::options_description all_opts_;
 
    po::positional_options_description positional_opts_;
 
    po::variables_map vm_;
 
    std::vector<std::string> unrecognized_opts_;
 
    std::unique_ptr<trigger::Trigger> debug_trigger_;
 
};
 
    } // namespace app
} // namespace sparta