ExampleSimulation.hpp

// <Simulation.h> -*- C++ -*-
 
 
#pragma once
 
#include "sparta/app/Simulation.hpp"
#include "sparta/trigger/ExpiringExpressionTrigger.hpp"
 
namespace sparta {
    class Baz;
    class ParameterSet;
}
 
namespace sparta { namespace trigger { class ExpressionTrigger; } }
namespace core_example{ class CPUFactory; }
 
class ExampleSimulator : public sparta::app::Simulation
{
public:
 
    ExampleSimulator(const std::string& topology,
                     sparta::Scheduler & scheduler,
                     uint32_t num_cores=1, uint64_t instruction_limit=0,
                     bool show_factories = false);
 
    // Tear it down
    virtual ~ExampleSimulator();
 
private:
 
    // Setup
 
    void registerStatCalculationFcns_();
 
    void buildTree_() override;
 
    void configureTree_() override;
 
    void bindTree_() override;
 
    void reportGenerationStarted_(const uint64_t &);
    bool report_generation_fired_ = false;
 
    std::unique_ptr<sparta::Baz> dispatch_baz_;
    std::unique_ptr<sparta::Baz> fpu_baz_;
 
    const sparta::CounterBase* findSemanticCounter_(CounterSemantic sem) const override;
 
    // Runtime
 
    class ExampleController : public sparta::app::Simulation::SimulationController
    {
    public:
        explicit ExampleController(const sparta::app::Simulation * sim);
 
    private:
        virtual void pause_    (const sparta::app::Simulation * sim) override;
        virtual void resume_   (const sparta::app::Simulation * sim) override;
        virtual void terminate_(const sparta::app::Simulation * sim) override;
 
        void customEatCallback_();
        void customSleepCallback_();
    };
 
    std::string cpu_topology_;
 
    const uint32_t num_cores_;
 
    const uint64_t instruction_limit_;
 
    std::vector<sparta::TreeNode*> tlb_nodes_;
 
    std::unique_ptr<sparta::NotificationSource<uint64_t>> testing_notification_source_;
    std::unique_ptr<sparta::trigger::ExpressionTrigger> random_number_trigger_;
    void postRandomNumber_();
 
    std::unique_ptr<sparta::SprintfNotificationSource> sprintf_test_notification_source_;
 
    std::unique_ptr<sparta::NotificationSource<uint64_t>> toggle_trigger_notification_source_;
    std::unique_ptr<sparta::trigger::ExpressionTrigger> toggle_notif_trigger_;
    void postToToggleTrigger_();
 
    std::unique_ptr<sparta::NotificationSource<uint64_t>> legacy_warmup_report_starter_;
    std::vector<std::unique_ptr<sparta::trigger::ExpressionTrigger>> core_warmup_listeners_;
    uint32_t num_cores_still_warming_up_ = 0;
    void onLegacyWarmupNotification_();
 
    void onTriggered_(const std::string & msg);
    bool on_triggered_notifier_registered_ = false;
 
    template <typename ParamT>
    sparta::Parameter<ParamT>* getExtensionParameter_(
        sparta::TreeNode* node,
        const std::string& param_name,
        const std::string& ext_name = "");
 
    template <typename ExtensionT = sparta::TreeNode::ExtensionsBase>
    ExtensionT* getExtension_(
        sparta::TreeNode* node,
        const std::string& ext_name = "");
 
    void validateTreeNodeExtensions_();
 
    auto getCPUFactory_() -> core_example::CPUFactory*;
 
    bool show_factories_;
};