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"
#include "sparta/utils/Utils.hpp"
#include "sparta/extensions/TreeNodeExtensionManager.hpp"
 
// Reuse hash<pair<string,string>>
#include "sparta/report/format/DetailInfoData.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
    };
    std::pair<std::string, RetiredInstPathStrictness> path_to_retired_inst_counter =
        std::make_pair("rob.stats.total_number_retired",
                       RetiredInstPathStrictness::Relaxed);
};
 
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 processExtensionFile(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 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_; }
 
    bool archFileProvided() const { return arch_applicator_ != nullptr; }
 
    void printArchConfigurations(std::ostream & os) const {
        if(archFileProvided()) {
            os << arch_applicator_->stringize();
        }
        else {
            os << "<not provided>";
        }
    }
 
    void addArchSearchPath(const std::string & dir) {
        arch_search_paths_.emplace(arch_search_paths_.begin(), dir);
    }
 
    const std::vector<std::string> &getArchSearchPath() const {
        return arch_search_paths_;
    }
 
    void addConfigSearchPath(const std::string & dir) {
        config_search_paths_.emplace(config_search_paths_.begin(), dir);
    }
 
    const std::vector<std::string> & getConfigSearchPath() const {
        return config_search_paths_;
    }
 
    void addReportDefnSearchPath(const std::string & dir) {
        report_defn_search_paths_.emplace(report_defn_search_paths_.begin(), dir);
    }
 
    const std::vector<std::string> & getReportDefnSearchPaths() const {
        return report_defn_search_paths_;
    }
 
    void printGenericConfigurations(std::ostream & os) const {
        for(auto & cp : config_applicators_) {
            os << "    " << cp->stringize() << '\n';
        }
    }
 
    enum class SignalMode
    {
        DISABLE_BACKTRACE_SIGNALS,
        ENABLE_BACKTRACE_SIGNALS
    };
 
    enum class PostRunDebugDumpPolicy {
        DEBUG_DUMP_ALWAYS = 0, 
        DEBUG_DUMP_NEVER  = 1, 
        DEBUG_DUMP_ERROR  = 2, 
        DEBUG_DUMP_MAX    = 3  
    };
 
    enum class PostRunDebugDumpOptions {
        DEBUG_DUMP_EVERYTHING,
        DEBUG_DUMP_NOTHING,
        DEBUG_DUMP_BACKTRACE_ONLY
    };
 
    enum class AutoSummaryState {
        AUTO_SUMMARY_OFF     = 0, 
        AUTO_SUMMARY_NORMAL  = 1, 
        AUTO_SUMMARY_VERBOSE = 2, 
        AUTO_SUMMARY_MAX     = 3  
    };
 
    enum class TriggerSource {
        TRIGGER_ON_NONE = 0,
        TRIGGER_ON_CYCLE,
        TRIGGER_ON_INSTRUCTION,
        TRIGGER_ON_ROI
    };
 
    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_filepath = NoPipelineCollectionStr;
 
    utils::ValidValue<size_t> pipeline_collection_heartbeat;
 
    ReportDescVec reports;
 
    class SimDBConfig
    {
    public:
        void setSimExecutable(const std::string & exe_name)
        {
            sim_exec_db_filename_ = exe_name + ".db";
        }
 
        void enableApp(const std::string & app_name)
        {
            sparta_assert(!appEnabled(app_name));
            sparta_assert(!sim_exec_db_filename_.empty());
 
            enabled_apps_.insert(app_name);
            setAppCount(app_name, 1);
            setAppDatabase(app_name, sim_exec_db_filename_);
        }
 
        bool appEnabled(const std::string & app_name) const
        {
            return enabled_apps_.count(app_name) > 0;
        }
 
        std::vector<std::string> getEnabledApps() const
        {
            return {enabled_apps_.begin(), enabled_apps_.end()};
        }
 
        void setAppCount(const std::string & app_name, size_t count)
        {
            sparta_assert(count > 0);
            sparta_assert(appEnabled(app_name));
            concrete_app_counts_[app_name] = count;
            inferred_app_counts_.erase(app_name);
        }
 
        void inferAppCountFromTreePattern(const std::string & app_name, const std::string & pattern)
        {
            sparta_assert(!pattern.empty());
            sparta_assert(appEnabled(app_name));
            concrete_app_counts_.erase(app_name);
            inferred_app_counts_[app_name] = pattern;
        }
 
        std::string getTreePatternForInferredAppCount(const std::string & app_name) const
        {
            if (!appEnabled(app_name)) {
                throw SpartaException("App '") << app_name << "' is not enabled.";
            }
 
            auto it = inferred_app_counts_.find(app_name);
            if (it != inferred_app_counts_.end()) {
                return it->second;
            }
            return "";
        }
 
        size_t getAppCount(const std::string & app_name) const
        {
            if (!appEnabled(app_name)) {
                return 0;
            }
 
            auto it = concrete_app_counts_.find(app_name);
            if (it == concrete_app_counts_.end()) {
                throw SpartaException("We do not know the app count yet. Has the tree been built?");
            }
            return it->second;
        }
 
        void setAppDatabase(const std::string & app_name, const std::string & db_file)
        {
            sparta_assert(appEnabled(app_name));
            app_databases_[app_name] = db_file;
        }
 
        std::string getAppDatabase(const std::string & app_name) const
        {
            sparta_assert(appEnabled(app_name));
            return app_databases_.at(app_name);
        }
 
        void reuseDatabase(const std::string & db_file)
        {
            reused_db_files_.insert(db_file);
        }
 
        bool shouldOverwriteDatabase(const std::string & db_file) const
        {
            return reused_db_files_.count(db_file) == 0;
        }
 
        void disableLegacyReports()
        {
            if (!appEnabled("simdb-reports")) {
                throw SpartaException()
                    << "Cannot disable legacy reports when simdb-reports app is not enabled";
            }
            legacy_reports_enabled_ = false;
        }
 
        bool legacyReportsEnabled() const
        {
            return legacy_reports_enabled_;
        }
 
        void enableVerboseMode(bool enable = true)
        {
            verbose_ = enable;
        }
 
        bool verboseMode() const
        {
            return verbose_;
        }
 
        void addPragmaOnOpen(const std::string& name, const std::string& val)
        {
            dbmgr_pragmas_[name] = val;
        }
 
        std::vector<std::pair<std::string, std::string>> getPragmas() const
        {
            std::vector<std::pair<std::string, std::string>> pragmas;
            for (const auto & [name, val] : dbmgr_pragmas_)
            {
                pragmas.emplace_back(name, val);
            }
            return pragmas;
        }
 
    private:
        std::string sim_exec_db_filename_;
        std::set<std::string> enabled_apps_;
        std::map<std::string, size_t> concrete_app_counts_;
        std::map<std::string, std::string> inferred_app_counts_;
        std::map<std::string, std::string> app_databases_;
        std::set<std::string> reused_db_files_;
        std::map<std::string, std::string> dbmgr_pragmas_;
        bool legacy_reports_enabled_ = true;
        bool verbose_ = false;
    } simdb_config;
 
    TreeNodeExtensionManager extension_mgr;
 
    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_;
 
    enum ExtensionsOrderOfOps : uint32_t
    {
        FROM_ARCH_YAML_WITH_WILDCARDS = 0,
        FROM_CONFIG_YAML_OR_PARAM_WITH_WILDCARDS,
        FROM_EXT_YAML_WITH_WILDCARDS,
        FROM_ARCH_YAML_WITHOUT_WILDCARDS,
        FROM_CONFIG_YAML_OR_PARAM_WITHOUT_WILDCARDS,
        FROM_EXT_YAML_WITHOUT_WILDCARDS,
        __N
    };
 
    std::array<ParameterTree, ExtensionsOrderOfOps::__N> extension_ptrees_;
 
    static void extractPTreeExtensions_(
        const ParameterTree & source_ptree,
        ParameterTree & no_extensions,
        ParameterTree & only_extensions);
 
    static void splitExtensionPTree_(
        const ParameterTree & source_ptree,
        ParameterTree & wildcard_extensions,
        ParameterTree & concrete_extensions);
 
    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_;
 
    //
};
 
} // namespace app
} // namespace sparta