simulation.h

Go to the documentation of this file.

/*
  © 2014 Intel Corporation
 
  This software and the related documents are Intel copyrighted materials, and
  your use of them is governed by the express license under which they were
  provided to you ("License"). Unless the License provides otherwise, you may
  not use, modify, copy, publish, distribute, disclose or transmit this software
  or the related documents without Intel's prior written permission.
 
  This software and the related documents are provided as is, with no express or
  implied warranties, other than those that are expressly stated in the License.
*/
 
#ifndef SIMICS_SYSTEMC_SIMULATION_H
#define SIMICS_SYSTEMC_SIMULATION_H
 
#include <systemc>
 
#include <simics/base/iface-call.h>
 
#include <simics/devs/frequency.h>
#include <simics/model-iface/event-delta.h>
#include <simics/model-iface/co-execute.h>
#include <simics/systemc/iface/concurrency_group_interface.h>
#include <simics/systemc/iface/concurrency_mode_interface.h>
#include <simics/systemc/iface/event_delta_interface.h>
#include <simics/systemc/iface/execute_control_interface.h>
#include <simics/systemc/iface/execute_interface.h>
#include <simics/systemc/iface/frequency_interface.h>
#include <simics/systemc/iface/simulation_interface.h>
#include <simics/systemc/internal_interface.h>
#include <simics/systemc/kernel.h>
#include <simics/systemc/simulation_deleter.h>
 
#include <vector>
 
namespace simics {
namespace systemc {
 
class Simulation
    : public iface::SimulationInterface,
      public iface::EventDeltaInterface,
      public iface::ExecuteInterface,
      public iface::FrequencyInterface,
      public iface::ConcurrencyGroupInterface,
      public iface::ConcurrencyModeInterface,
      public iface::ExecuteControlInterface {
  public:
    Simulation(ConfObjectRef o, InternalInterface *internal);
    virtual ~Simulation();
 
    // ExecuteInterface
    void run() override;
    void stop() override;
    void switch_in() override;
    void switch_out() override;
 
    // EventDeltaInterface
    uint64 set_delta(conf_object_t *NOTNULL event_handler_obj,
                     const event_class_t *next_event_ec,
                     uint64 delta) override;
    uint64 get_delta(conf_object_t *NOTNULL event_handler_obj) override;
 
    // FrequencyInterface
    double get() const override;
 
    // ConcurrencyGroupInterface
    std::vector<conf_object_t *> serialized_memory_group(
            unsigned group_index) override;
    std::vector<conf_object_t *> execution_group(unsigned group_index) override;
 
    // ConcurrencyModeInterface
    concurrency_mode_t supported_modes() override;
    concurrency_mode_t current_mode() override;
    void switch_mode(concurrency_mode_t mode) override;
 
    // ExecuteControlInterface
    void message_pending() override;
    void yield_request() override;
 
    // SimulationInterface
    int runDeltaPhase(int count) override;
    bool runSimulation(sc_core::sc_time t) override;
    void stopSimulation() override;
    sc_core::sc_simcontext* context() const override;
    ConfObjectRef simics_object() const override;
 
  protected:
    // methods called from Adapter
    void set_run_next_delta(int count);
    uint64_t get_sc_time_resolution() const {
        return time_resolution_;
    }
    void set_sc_time_resolution(uint64_t time_resolution);
    void set_frequency(double frequency);
    void finalize();
 
    virtual void callHandleEvent();
 
    const std::vector<conf_object_t*>& instances() const;
 
  private:
    int runDeltaPhaseNoStateCheck(int count);
    bool isPausePending();
    bool hasPendingAsyncActivity() const;
    bool runSimulationNoCallHandleEvent(const sc_core::sc_time &t);
 
    static void atSimulationStopped(lang_void *simulation, conf_object_t *obj);
    static std::vector<conf_object_t*> instancesNotInCell(conf_object_t *cell);
    static void onCellChange(lang_void *callback_data, conf_object_t *obj,
                             conf_object_t *old_cell, conf_object_t *new_cell);
 
    // Helper to group all instances in the same TD
    struct InstanceTracker {
        explicit InstanceTracker(conf_object_t *NOTNULL object);
        virtual ~InstanceTracker();
        conf_object_t *object_;
    };
    static std::vector<conf_object_t*> instances_;
 
    class YieldRequest : public sc_core::sc_prim_channel {
      public:
        YieldRequest(conf_object_t *co_execute, const char* name)
            : sc_core::sc_prim_channel(name) {
            INIT_IFACE(&execute_, execute, co_execute);
        }
        void update(void) override {
            if (execute_.obj)
                CALL(execute_, stop)();
        }
        IFACE_OBJ(execute) execute_;
    };
 
    ConfObjectRef simics_object_;
    SimulationDeleter *simulation_deleter_;
    Kernel kernel_;
    uint64 delta_;
    sc_core::sc_time sc_time_when_set_delta_;
    IFACE_OBJ(event_handler) event_handler_;
    concurrency_mode_t concurrency_mode_;
    YieldRequest yield_request_;
    bool break_pending_;
    InternalInterface *internal_;
    InstanceTracker instance_tracker_;
    // The frequency value returned for the FrequencyInterface. It represents
    // the number of Simics cycles that equate to one second in SystemC.
    double frequency_;
    // The SystemC time resolution in number of ps
    uint64_t time_resolution_;
    // True only after sc_start has advanced SC time since the last
    // set_delta call. Allows get_delta to skip the SC context switch in
    // the common case.
    bool sc_time_stamp_changed_ {false};
};
 
}  // namespace systemc
}  // namespace simics
 
#endif