SimulationConfiguration.hpp

Go to the documentation of this file.

// <SimulationConfiguration> -*- C++ -*-
 
 
#pragma once
 
#include <cstdint>
#include <vector>
#include <set>
#include <string>
#include <memory>
#include <list>
#include <ostream>
#include <type_traits>
#include <utility>
 
#include "sparta/sparta.hpp"
#include "sparta/simulation/ParameterTree.hpp"
#include "sparta/app/MetaTreeNode.hpp"
#include "sparta/log/Tap.hpp"
#include "sparta/app/ConfigApplicators.hpp"
#include "sparta/utils/StringUtils.hpp"
#include "sparta/app/ReportDescriptor.hpp"
#include "sparta/utils/SpartaAssert.hpp"
 
namespace sparta {
namespace app {
 
constexpr char NoPipelineCollectionStr[] = "NOPREFIX_";
 
class DefaultValues
{
public:
    std::vector<std::string> arch_search_dirs = {""};
 
    std::string arch_arg_default = "";
 
    bool non_empty_arch_arg_required = false;
 
    std::string run_time_clock = "";
 
    std::string inst_counter = "";
 
    std::list<ParameterTemplate> other_meta_params = {};
 
    std::string auto_summary_default = "off";
 
    enum class RetiredInstPathStrictness {
        Strict, Relaxed
    };
    enum class RetiredInstPathStrictness {…};
    std::pair<std::string, RetiredInstPathStrictness> path_to_retired_inst_counter =
        std::make_pair("rob.stats.total_number_retired",
                       RetiredInstPathStrictness::Relaxed);
};
class DefaultValues {…};
 
class SimulationConfiguration
{
private:
 
    const DefaultValues defaults_;
 
public:
 
    SimulationConfiguration(const DefaultValues & defaults = DefaultValues());
 
    void processParameter(const std::string & pattern, const std::string & value,
                          bool optional = false);
 
    void processConfigFile(const std::string & pattern, const std::string & filename,
                           bool is_final = false);
 
    void processArch(const std::string & pattern,
                     const std::string & filename);
 
    void enableLogging(const std::string & pattern,
                       const std::string & category,
                       const std::string & destination);
 
    bool hasFinalConfig() const { return !final_config_file_.empty(); }
 
    void processExtensionFile(const std::string & filename);
 
    void setStateTrackingFile(const std::string & filename);
 
    const std::string& getStateTrackingFilename() const;
 
    void addControlFile(const std::string & filename);
 
    const std::set<std::string> & getControlFiles() const;
 
    void addRunMetadata(const std::string & name,
                        const std::string & value);
 
    const std::vector<std::pair<std::string, std::string>> & getRunMetadata() const;
 
    std::string stringizeRunMetadata() const;
 
    std::string getFinalConfigFile() const { return final_config_file_; }
 
    void setMemoryUsageDefFile(const std::string & def_file);
 
    const std::string & getMemoryUsageDefFile() const;
 
    void generateStatsMapping();
 
    bool shouldGenerateStatsMapping() const;
 
    void disablePrettyPrintReports(const std::string & format);
 
    const std::set<std::string> & getDisabledPrettyPrintFormats() const;
 
    void omitStatsWithValueZeroForReportFormat(const std::string & format);
 
    const std::set<utils::lowercase_string> &
        getReportFormatsWhoOmitStatsWithValueZero() const;
 
    void copyTreeNodeExtensionsFromArchAndConfigPTrees();
 
    ParameterTree& getUnboundParameterTree() { return ptree_; }
 
    const ParameterTree& getUnboundParameterTree() const { return ptree_; }
 
    ParameterTree& getArchUnboundParameterTree() { return arch_ptree_; }
 
    const ParameterTree& getArchUnboundParameterTree() const { return arch_ptree_; }
 
    ParameterTree& getExtensionsUnboundParameterTree() {
        return extensions_ptree_;
    }
    ParameterTree& getExtensionsUnboundParameterTree() {…}
 
    const ParameterTree& getExtensionsUnboundParameterTree() const {
        return extensions_ptree_;
    }
    const ParameterTree& getExtensionsUnboundParameterTree() const  {…}
 
    bool archFileProvided() const { return arch_applicator_ != nullptr; }
 
    void printArchConfigurations(std::ostream & os) const {
        if(archFileProvided()) {
            os << arch_applicator_->stringize();
        }
        else {
            os << "<not provided>";
        }
    }
    void printArchConfigurations(std::ostream & os) const  {…}
 
    void addArchSearchPath(const std::string & dir) {
        arch_search_paths_.emplace(arch_search_paths_.begin(), dir);
    }
    void addArchSearchPath(const std::string & dir) {…}
 
    const std::vector<std::string> &getArchSearchPath() const {
        return arch_search_paths_;
    }
    const std::vector<std::string> &getArchSearchPath() const  {…}
 
    void addConfigSearchPath(const std::string & dir) {
        config_search_paths_.emplace(config_search_paths_.begin(), dir);
    }
    void addConfigSearchPath(const std::string & dir) {…}
 
    const std::vector<std::string> & getConfigSearchPath() const {
        return config_search_paths_;
    }
    const std::vector<std::string> & getConfigSearchPath() const  {…}
 
    void addReportDefnSearchPath(const std::string & dir) {
        report_defn_search_paths_.emplace(report_defn_search_paths_.begin(), dir);
    }
    void addReportDefnSearchPath(const std::string & dir) {…}
 
    const std::vector<std::string> & getReportDefnSearchPaths() const {
        return report_defn_search_paths_;
    }
    const std::vector<std::string> & getReportDefnSearchPaths() const  {…}
 
    void printGenericConfigurations(std::ostream & os) const {
        for(auto & cp : config_applicators_) {
            os << "    " << cp->stringize() << '\n';
        }
    }
    void printGenericConfigurations(std::ostream & os) const  {…}
 
    enum class SignalMode
    {
        DISABLE_BACKTRACE_SIGNALS,
        ENABLE_BACKTRACE_SIGNALS
    };
    enum class SignalMode {…};
 
    enum class PostRunDebugDumpPolicy {
        DEBUG_DUMP_ALWAYS = 0, 
        DEBUG_DUMP_NEVER  = 1, 
        DEBUG_DUMP_ERROR  = 2, 
        DEBUG_DUMP_MAX    = 3  
    };
    enum class PostRunDebugDumpPolicy {…};
 
    enum class PostRunDebugDumpOptions {
        DEBUG_DUMP_EVERYTHING,
        DEBUG_DUMP_NOTHING,
        DEBUG_DUMP_BACKTRACE_ONLY
    };
    enum class PostRunDebugDumpOptions {…};
 
    enum class AutoSummaryState {
        AUTO_SUMMARY_OFF     = 0, 
        AUTO_SUMMARY_NORMAL  = 1, 
        AUTO_SUMMARY_VERBOSE = 2, 
        AUTO_SUMMARY_MAX     = 3  
    };
    enum class AutoSummaryState {…};
 
    enum class TriggerSource {
        TRIGGER_ON_NONE = 0,
        TRIGGER_ON_CYCLE,
        TRIGGER_ON_INSTRUCTION,
        TRIGGER_ON_ROI
    };
    enum class TriggerSource {…};
 
    bool warn_stderr = true;
 
    bool verbose_cfg = false;
 
    bool verbose_report_triggers = false;
 
    bool debug_sim = false;
 
    bool report_on_error = true;
 
    SignalMode signal_mode{SignalMode::ENABLE_BACKTRACE_SIGNALS};
 
    AutoSummaryState auto_summary_state{AutoSummaryState::AUTO_SUMMARY_OFF};
 
    PostRunDebugDumpPolicy debug_dump_policy{PostRunDebugDumpPolicy::DEBUG_DUMP_NEVER};
 
    PostRunDebugDumpOptions debug_dump_options{PostRunDebugDumpOptions::DEBUG_DUMP_EVERYTHING};
 
    std::string dump_debug_filename{"error-dump.dbg"};
 
    uint64_t trigger_on_value = 0;
 
    TriggerSource trigger_on_type{TriggerSource::TRIGGER_ON_NONE};
 
    std::string trigger_clock;
 
    bool validate_post_run = false;
 
    std::string warnings_file{""};
 
    bool show_dag = false;
 
    bool suppress_unread_parameter_warnings = false;
 
    std::string pipeline_collection_file_prefix = NoPipelineCollectionStr;
 
    ReportDescVec reports;
 
    bool scheduler_exacting_run = false;
 
    bool scheduler_measure_run_time = true;
 
    std::string parsed_path_to_retired_inst_counter_;
    std::pair<std::string, app::DefaultValues::RetiredInstPathStrictness> path_to_retired_inst_counter =
        std::make_pair(defaults_.path_to_retired_inst_counter.first,
                       app::DefaultValues::RetiredInstPathStrictness::Relaxed);
 
    const DefaultValues & getDefaults() const { return defaults_; }
 
    const log::TapDescVec & getTaps() const { return taps_; }
 
    void setConsumed() const { is_consumed_ = true; }
 
private:
 
    mutable bool is_consumed_ = false;
 
    // Simulation configuration, your -c, -p, --arch flags from Command line
 
    std::string final_config_file_ = "";
 
    std::string memory_usage_def_file_;
 
    bool generate_stats_mapping_ = false;
 
    std::set<std::string> disabled_pretty_print_report_formats_;
 
    std::set<utils::lowercase_string> zero_values_omitted_report_formats_;
 
    ParameterTree arch_ptree_;
 
    ParameterTree ptree_;
 
    ParameterTree extensions_ptree_;
 
    std::vector<std::string> arch_search_paths_;
 
    std::vector<std::string> config_search_paths_ = {"./"};
 
    std::vector<std::string> report_defn_search_paths_;
 
    std::set<std::string> simulation_control_filenames_;
 
    std::vector<std::pair<std::string, std::string>> run_metadata_;
 
    std::unique_ptr<ArchNodeConfigFileApplicator> arch_applicator_;
 
    ConfigVec     config_applicators_;
 
    //
 
    // Simulation logging
    log::TapDescVec taps_;
 
    std::string state_tracking_file_;
 
    //
};
class SimulationConfiguration {…};
 
} // namespace app
} // namespace sparta