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"
 
// 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 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();
 
    bool hasTreeNodeExtensions() const;
 
    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_;
    }
 
    const ParameterTree& getExtensionsUnboundParameterTree() const {
        return extensions_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_file_prefix = NoPipelineCollectionStr;
 
    ReportDescVec reports;
 
    class SimDBConfig
    {
    public:
        void setGlobalDatabaseFile(const std::string & db_file)
        {
            global_simdb_file_ = db_file;
        }
 
        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 enableApp(const std::string & app_name, const std::string & db_file, size_t num_instances = 1)
        {
            enabled_apps_[db_file].insert(app_name);
            app_db_files_[app_name].insert(db_file);
            enabled_app_counts_[std::make_pair(app_name, db_file)] = num_instances;
        }
 
        bool appEnabled(const std::string & app_name) const
        {
            return app_db_files_.count(app_name) > 0;
        }
 
        std::vector<std::string> getEnabledApps() const 
        {
            std::vector<std::string> apps;
            for (const auto& [app_name, db_files] : app_db_files_)
            {
                apps.emplace_back(app_name);
            }
            return apps;
        }
 
        size_t getAppInstances(const std::string & app_name, const std::string & db_file) const
        {
            auto key = std::make_pair(app_name, db_file);
            auto it = enabled_app_counts_.find(key);
            if (it == enabled_app_counts_.end()) {
                return 0;
            }
            return it->second;
        }
 
        std::vector<std::string> getAppDatabases(const std::string & app_name) const
        {
            auto it = app_db_files_.find(app_name);
            if (it != app_db_files_.end()) {
                return {it->second.begin(), it->second.end()};
            } else {
                return {};
            }
        }
 
        //Call this once prior to calling Simulation::configure()
        void finalize()
        {
            if (global_simdb_file_.empty())
            {
                return;
            }
 
            //Try to set the global SimDB file.
            //   --simdb-apps test.db app1 --simdb-file out.db
            //       >> send app1 to out.db
            //   --simdb-apps test.db app1 --enable-simdb-reports reports.db --simdb-file out.db
            //       >> send app1 to out.db
            //       >> send 'simdb-reports' (ReportStatsCollector) to out.db
            //   --simdb-apps foo.db app1 --simdb-apps bar.db app1 --simdb-file out.db
            //       >> THROW:
            //       >>>> one instance of app1 was to go to foo.db, the other to bar.db
            //       >>>> if we use only out.db, not clear if there should be two app1
            //            instances or just one
            std::ostringstream errors;
            for (const auto & [app_name, db_files] : app_db_files_) {
                if (db_files.size() > 1) {
                    if (errors.str().empty()) {
                        errors << "Cannot use --simdb-file if any app is sent to two "
                               << "different databases:\n";
                    }
                    errors << "  " << app_name << " is sent to:\n";
                    for (const auto & db_file : db_files) {
                        errors << "    " << db_file << "\n";
                    }
                }
            }
 
            const auto error = errors.str();
            if (!error.empty()) {
                throw SpartaException(error);
            }
 
            for (const auto & [app_name, db_files] : app_db_files_) {
                for (const auto & db_file : db_files) {
                    auto key = std::make_pair(app_name, db_file);
                    const auto num_instances = enabled_app_counts_.at(key);
                    if (db_file != global_simdb_file_) {
                        std::cout << "Redirecting " << num_instances << " instance"
                                  << (num_instances == 1 ? "" : "s") << " of the '"
                                  << app_name << "' app from " << db_file << " to "
                                  << global_simdb_file_ << "\n";
                        enableApp(app_name, global_simdb_file_, num_instances);
                    }
                }
            }
 
            std::vector<std::string> old_db_files;
            for (const auto & [db_file, _] : enabled_apps_) {
                if (db_file != global_simdb_file_) {
                    old_db_files.push_back(db_file);
                }
            }
 
            for (const auto & db_file : old_db_files) {
                enabled_apps_.erase(db_file);
            }
 
            for (auto & [app_name, db_files] : app_db_files_) {
                db_files.clear();
                db_files.insert(global_simdb_file_);
            }
 
            std::vector<std::pair<std::string, std::string>> old_counts_kvps;
            for (const auto & [key, num_instances] : enabled_app_counts_) {
                if (key.second != global_simdb_file_) {
                    old_counts_kvps.push_back(key);
                }
            }
 
            for (const auto & key : old_counts_kvps) {
                enabled_app_counts_.erase(key);
            }
        }
 
        //SQLite3 PRAGMA's to execute on database creation.
        //  "PRAGMA <name> = <val>"
        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 global_simdb_file_;
        std::map<std::string, std::set<std::string>> enabled_apps_;
        std::map<std::string, std::set<std::string>> app_db_files_;
        std::unordered_map<std::pair<std::string, std::string>, size_t> enabled_app_counts_;
        bool legacy_reports_enabled_ = true;
        std::map<std::string, std::string> dbmgr_pragmas_;
    } simdb_config;
 
    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_;
 
    //
};
 
} // namespace app
} // namespace sparta