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_simdb {
    class DatabaseTester;
}
 
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::NotificationSource<uint64_t>> toggle_trigger_notification_source_;
    std::unique_ptr<sparta::trigger::ExpressionTrigger> toggle_notif_trigger_;
    void postToToggleTrigger_();
 
    sparta::trigger::ExpiringExpressionTrigger lazy_table_create_trigger_;
    simdb::TableProxy * lazy_table_proxy_ = nullptr;
    void addToStatsSchema_();
    void addToLazySchemaTable_();
 
    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;
 
    void validateTreeNodeExtensions_();
 
    auto getCPUFactory_() -> core_example::CPUFactory*;
 
    bool show_factories_;
 
    /* \brief Flag which enables SimDB-related code to run for
     * interactive performance benchmarks / comparison. False
     * by default so that we don't impact unit testing / smoke
     * testing times for all regression test runs.
     */
    bool simdb_perf_async_ctrl_enabled_ = false;
 
    std::shared_ptr<sparta_simdb::DatabaseTester> simdb_tester_;
};