Simulation.hpp

Go to the documentation of this file.

// <Simulation.h> -*- C++ -*-
 
 
#pragma once
 
#include <vector>
 
#include "sparta/simulation/Resource.hpp"
#include "sparta/simulation/ResourceFactory.hpp"
#include "sparta/simulation/TreeNode.hpp"
#include "sparta/log/Tap.hpp"
#include "sparta/parsers/ConfigParserYAML.hpp"
#include "sparta/simulation/ClockManager.hpp"
#include "sparta/simulation/ParameterTree.hpp"
#include "sparta/report/ReportRepository.hpp"
#include "sparta/app/Backtrace.hpp"
#include "sparta/app/ConfigApplicators.hpp"
#include "sparta/app/ReportDescriptor.hpp"
#include "sparta/app/SimulationConfiguration.hpp"
#include "sparta/control/TemporaryRunController.hpp"
#include "sparta/simulation/State.hpp"
#include "sparta/pipeViewer/InformationWriter.hpp"
 
namespace YP = YAML; // Prevent collision with YAML class in ConfigParser namespace.
 
namespace simdb {
    class AppManager;
    class AppManagers;
    class AppRegistrations;
}
 
namespace sparta {
 
class Clock;
class MemoryProfiler;
class TreeNodeExtensionManager;
 
namespace python {
    class PythonInterpreter;
}
namespace control {
    class TemporaryRunControl;
}
 
namespace trigger {
    class SingleTrigger;
    class CounterTrigger;
    class TimeTrigger;
    class CycleTrigger;
    class Trigger;
} // namespace trigger
 
namespace app {
class LoggingTrigger;
class ConfigApplicator;
class FeatureConfiguration;
 
class Simulation
{
public:
 
    enum CounterSemantic {
        CSEM_INSTRUCTIONS = 0 
    };
 
    Simulation() = delete;
 
    Simulation(const Simulation&) = delete;
 
    Simulation(Simulation&&) = delete;
 
    Simulation& operator=(const Simulation&) = delete;
 
    Simulation(const std::string& sim_name, Scheduler * scheduler);
 
    virtual ~Simulation();
 
    void setFeatureConfig(const FeatureConfiguration * feature_config) {
        feature_config_ = feature_config;
    }
 
    void configure(const int argc,
                   char ** argv,
                   SimulationConfiguration * configuration,
                   const bool use_pyshell = false);
 
    void addReport(const ReportDescriptor & rep);
 
    void installTaps(const log::TapDescVec& taps);
 
    sparta::RootTreeNode* getRoot() noexcept { return &root_; }
 
    sparta::app::MetaTreeNode* getMetaParamRoot() const noexcept { return meta_.get(); }
 
    const sparta::RootTreeNode* getRoot() const noexcept { return &root_; }
 
    sparta::Scheduler * getScheduler() { return scheduler_; }
 
    const sparta::Scheduler * getScheduler() const { return scheduler_; }
 
    simdb::AppManagers* getAppManagers() const { return app_managers_.get(); }
 
    bool usingFinalConfig() const { return using_final_config_; }
 
    bool readyToRun() const { return framework_finalized_; }
 
    sparta::Clock* getRootClock() noexcept { return root_clk_.get(); }
 
    const sparta::Clock* getRootClock() const noexcept { return root_clk_.get(); }
 
    sparta::ClockManager & getClockManager() noexcept { return clk_manager_; }
 
    sparta::ResourceSet* getResourceSet() noexcept { return &res_list_; }
 
    const std::string& getSimName() const noexcept {
        return sim_name_;
    }
 
    SimulationConfiguration * getSimulationConfiguration() const {
        return sim_config_;
    }
 
    const TreeNodeExtensionManager * getExtensionManager(bool must_exist = true) const {
        return root_.getExtensionManager(must_exist);
    }
 
    TreeNodeExtensionManager * getExtensionManager(bool must_exist = true) {
        return root_.getExtensionManager(must_exist);
    }
 
    const FeatureConfiguration * getFeatureConfiguration() const {
        return feature_config_;
    }
 
    ReportConfiguration * getReportConfiguration() const {
        return report_config_.get();
    }
 
 
    // Setup
 
    void buildTree();
 
    void configureTree();
 
    void finalizeTree();
 
 
    void finalizeFramework();
 
 
    // Running
 
    virtual void run(uint64_t run_time);
 
    virtual void runRaw(uint64_t run_time);
 
    virtual void asyncStop();
 
 
    // Post-processing
 
    void dumpDebugContentIfAllowed(std::exception_ptr eptr, bool forcec=false) noexcept;
 
    void saveReports();
 
    void postProcessingLastCall();
 
    const CounterBase* findSemanticCounter(CounterSemantic sem) const {
        sparta_assert(root_.isFinalized(),
                          "Cannot query findSemanticCounter until Simulation is finalized");
        sparta_assert(!root_.isTearingDown(),
                          "Cannot query findSemanticCounter after Simulation has entered teardown");
        return findSemanticCounter_(sem);
    }
 
 
    // Status
 
    bool simulationSuccessful() const { return simulation_successful_; }
 
    uint64_t numFired() { return num_fired_; }
 
    void enablePostRunValidation() {
        validate_post_run_ = true;
    }
    std::string getPipelineCollectionPrefix() const {
        return pipeline_collection_prefix_;
    }
 
    bool usingPyshell() const {
#ifdef SPARTA_PYTHON_SUPPORT
        return pyshell_ != nullptr;
#else
        return false;
#endif
    }
 
    virtual sparta::control::TemporaryRunControl * getRunControlInterface() {
        return rc_.get();
    }
 
    void dumpMetaParameterTable(std::ostream& out) const;
 
 
protected:
 
    class SimulationController
    {
    public:
        virtual ~SimulationController() {}
 
        void pause();
        void resume();
        void terminate();
 
        void invokeNamedEvent(
            const std::string & event_name);
 
        enum class SimulationStatus {
            Idle,
            Paused,
            Simulating,
            Terminated
        };
        SimulationStatus getSimStatus() const {
            return sim_status_;
        }
 
    protected:
        explicit SimulationController(
            const sparta::app::Simulation * sim) :
            sim_(sim)
        {}
 
        void addNamedCallback_(
            const std::string & event_name,
            SpartaHandler callback_method);
 
    private:
        virtual void pause_(const sparta::app::Simulation * sim) {
            (void) sim;
        }
        virtual void resume_(const sparta::app::Simulation * sim) {
            (void) sim;
        }
        virtual void terminate_(const sparta::app::Simulation * sim) {
            (void) sim;
        }
        void verifyFinalized_() const;
 
        const sparta::app::Simulation * sim_ = nullptr;
        std::unordered_map<std::string, SpartaHandler> callbacks_;
        std::set<std::string> invoked_callbacks_;
        SimulationStatus sim_status_ = SimulationStatus::Idle;
 
        friend class sparta::app::Simulation;
    };
 
    void setSimulationController_(
        std::shared_ptr<SimulationController> controller);
 
    void pause_();
 
    void resume_();
 
    void terminate_();
 
    void customEvent_(const std::string & event_name);
 
    void setupControllerTriggers_();
 
    std::shared_ptr<SimulationController> controller_;
 
    std::vector<std::shared_ptr<trigger::ExpressionTrigger>> controller_triggers_;
 
    uint32_t dumpNonDefaultParameters_(TreeNode* root, std::ostream& out);
 
    uint32_t countNonDefaultParameters_(TreeNode* root);
 
    uint32_t reapplyVolatileParameters_(TreeNode* root);
 
    uint32_t reapplyAllParameters_(TreeNode* root);
 
    void addTreeNodeExtensionFactory_(const std::string & extension_name,
                                      std::function<TreeNode::ExtensionsBase*()> factory);
 
    void setTreeNodeExtensionManager_(TreeNodeExtensionManager* mgr);
 
 
    virtual void buildTree_() = 0;
 
    virtual void configureTree_() = 0;
 
    virtual void bindTree_() = 0;
 
    virtual void registerSimDbApps_([[maybe_unused]] simdb::AppRegistrations* app_registrations) {}
 
    virtual void parameterizeSimDbApps_([[maybe_unused]] simdb::AppManager* app_mgr) {}
 
    virtual void postFinalizeFramework_() {}
 
    virtual void onSimDbAppsReady_() {}
 
 
    virtual void runControlLoop_(uint64_t run_time);
 
    virtual void runRaw_(uint64_t run_time);
 
 
    virtual const CounterBase* findSemanticCounter_(CounterSemantic sem) const {
        (void) sem;
        return nullptr;
    }
 
    bool dumpDebugContent_(std::string& filename,
                           const std::string& exception,
                           const std::string& backtrace) noexcept;
 
    void delayedPeventStart_();
    void rootDescendantAdded_(const sparta::TreeNode& node_added);
 
    void attachTapTo_(const log::TapDescriptor& td, sparta::TreeNode* n);
 
    void attachReportTo_(sparta::ReportRepository::DirectoryHandle directoryH,
                         const ReportDescriptor & rd,
                         sparta::TreeNode* n,
                         const std::vector<std::string>& replacements);
 
    void checkAllVirtualParamsRead_(const ParameterTree& pt);
 
    void validateDescriptorCanBeAdded_(
        const ReportDescriptor & rd,
        const bool using_pyshell) const;
 
    void setupReports_(ReportStatsCollector* collector);
 
    ReportDescVec expandReportDescriptor_(const ReportDescriptor & rd) const;
 
    void setupProfilers_();
 
    void setupStreamControllers_();
 
    sparta::ClockManager clk_manager_;
 
    std::shared_ptr<sparta::MemoryProfiler> memory_profiler_;
 
    std::unique_ptr<sparta::ReportRepository> report_repository_;
 
    Backtrace backtrace_;
 
    const std::string sim_name_;
 
    std::vector<std::unique_ptr<sparta::log::Tap>> taps_to_del_;
 
    sparta::ResourceSet res_list_;
 
    Scheduler *const scheduler_;
 
    std::unique_ptr<Report> auto_summary_report_;
 
    std::unique_ptr<sparta::RootTreeNode> clk_root_node_;
 
    Clock::Handle root_clk_;
 
    sparta::RootTreeNode root_;
 
    std::unique_ptr<MetaTreeNode> meta_;
 
    bool framework_finalized_ = false;
 
    std::vector<std::unique_ptr<sparta::TreeNode>> to_delete_;
 
    // The SimulationConfiguration object
    SimulationConfiguration * sim_config_{nullptr};
 
    // The FeatureConfiguration object
    const FeatureConfiguration * feature_config_{nullptr};
 
    // Order matters: Taps should die before any other nodes (or after all other
    // nodes are guaranteed destructed)
 
    sparta::log::Tap warn_to_cerr_; 
 
    std::unique_ptr<sparta::log::Tap> warn_to_file_;
 
    uint64_t num_fired_; 
 
    bool print_dag_ = false; 
 
    bool validate_post_run_ = false;
 
    std::string pipeline_collection_prefix_;
 
    ReportDescriptorCollection rep_descs_;
 
    std::unique_ptr<ReportConfiguration> report_config_;
 
    std::vector<ConfigApplicator*> user_configs_;
 
    bool using_final_config_ = false;
 
    uint64_t pevent_warmup_icount_ = 0;
 
    SpartaHandler pevent_start_handler_;
 
    std::unique_ptr<trigger::CounterTrigger> pevent_start_trigger_;
 
    std::unique_ptr<LoggingTrigger> log_trigger_;
 
    std::unique_ptr<trigger::Trigger> debug_trigger_;
 
    bool simulation_successful_ = true;
 
private:
 
#ifdef SPARTA_PYTHON_SUPPORT
    std::unique_ptr<python::PythonInterpreter> pyshell_;
#endif
 
    sparta::State<sparta::PhasedObject::TreePhase> simulation_state_;
 
    virtual void validateReportDescriptors_(
        const ReportDescriptorCollection & report_descriptors) const
    {
        (void) report_descriptors;
    }
 
    std::unique_ptr<control::TemporaryRunControl> rc_;
 
    void createSimDbApps_();
    int argc_ = 0;
    char** argv_ = nullptr;
 
     std::shared_ptr<simdb::AppManagers> app_managers_;
};
 
} // namespace app
} // namespace sparta