SysCSpartaSchedulerAdapter.hpp

Go to the documentation of this file.

// <SysCSpartaSchedulerAdapter> -*- C++ -*-
 
 
#pragma once
 
#include <climits>
 
#include "sparta/kernel/Scheduler.hpp"
#include "sparta/events/Event.hpp"
 
// Ignore -Wconversion issues with SysC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
  #include "sysc/kernel/sc_event.h"
  #include "sysc/kernel/sc_time.h"
  #include "sysc/kernel/sc_module.h"
  #include "sysc/communication/sc_clock.h"
#pragma GCC diagnostic pop
 
namespace sparta
{
 
    namespace sparta_sysc_utils {
        inline Clock::Cycle calculateSpartaOffset(const sparta::Clock * sparta_clk,
                                                  sc_core::sc_time::value_type sysc_offset)
        {
 
            //
            // This is a transaction coming from SysC that is on SysC's
            // clock, not Sparta's.  Need to find the same tick cycle on
            // the Sparta clock and align the time for the transaction.
            // The Sparta's scheduler starts at tick 0 like SysC.
            //
            // Another item to note is how the sparta::Scheduler sees
            // time.  If the Scheduler is running, currentTick
            // represents the time events are being fired.  If the
            // Scheduler _is not running_ currentTick represents the
            // tick _after_ the last successful run.  In the case the
            // Scheduler is not running, use elapsedCycles to align
            // the schedulers.
            //
            // For example,
            //   - The Sparta's clock is at 7 ticks
            //   - The SysC clock is at 10 ticks
            //   - The transaction's delay is 1 tick (to be fired at tick 11)
            //
            //   sysc_clock - sparta_clock + sysc_offset = 4 cycles on sparta clock (11)
            //
 
            // Send to memory with the given delay - NS -> clock cycles.
            // The Clock is on the same freq as the memory block
            const auto current_sc_time = sc_core::sc_time_stamp().value();
            const auto sparta_sched = sparta_clk->getScheduler();
            const auto current_tick = sparta_sched->isRunning() ?
                sparta_sched->getCurrentTick() : sparta_sched->getElapsedTicks();
            sparta_assert(current_sc_time >= current_tick);
            const auto final_relative_tick = current_sc_time - current_tick + sysc_offset;
            return final_relative_tick;
        }
    }
 
#define SC_SPARTA_SCHEDULER_NAME  "SysCSpartaSchedulerAdapter"
 
#define SC_SPARTA_STOP_EVENT_NAME "sc_ev_stop_simulation"
 
class SysCSpartaSchedulerAdapter : public sc_core::sc_module
{
 
    // Called by the Scheduler when a new event is scheduled
    void wakeupAdapter_(const Scheduler::Tick&) {
        sc_wake_sparta_.notify();
        sparta_scheduler_->
            deregisterForNotification<Scheduler::Tick,
                                      SysCSpartaSchedulerAdapter,
                                      &SysCSpartaSchedulerAdapter::wakeupAdapter_>(this, "item_scheduled");
    }
 
public:
 
    SC_HAS_PROCESS(SysCSpartaSchedulerAdapter);
 
    SysCSpartaSchedulerAdapter(Scheduler * scheduler) :
        sc_module(sc_core::sc_module_name(SC_SPARTA_SCHEDULER_NAME)),
        sparta_scheduler_(scheduler),
        sc_ev_stop_simulation_(SC_SPARTA_STOP_EVENT_NAME),
        sc_wake_sparta_("sc_ev_wake_sparta")
    {
        SC_THREAD(runScheduler_);
        SC_METHOD(setSystemCSimulationDone);
        dont_initialize();
        sensitive << sc_ev_stop_simulation_;
 
        switch(PS_PER_SECOND/sparta_scheduler_->getFrequency())
        {
        case 1:
            sparta_sc_time_ = sc_core::SC_PS;
            break;
        case 10:
            sparta_sc_time_ = sc_core::SC_NS;
            break;
        case 100:
            sparta_sc_time_ = sc_core::SC_US;
            break;
        default:
            throw sparta::SpartaException("Frequency not supported");
            break;
        }
    }
 
    void run(Scheduler::Tick num_ticks = Scheduler::INDEFINITE)
    {
        double convert_to_sysc_time = std::numeric_limits<double>::max();
        if(num_ticks != Scheduler::INDEFINITE) {
            convert_to_sysc_time = num_ticks;
        }
        sc_core::sc_start(sc_core::sc_time(convert_to_sysc_time, sparta_sc_time_));
    }
 
    void setSystemCSimulationDone() {
        // Only report this once.
        if(!sysc_simulation_done_) {
            std::cout << "SysCSpartaSchedulerAdapter: SystemC reports finished on tick "
                      << sc_core::sc_time_stamp().value() << std::endl;
            sysc_simulation_done_ = true;
        }
    }
 
    void registerSysCFinishQueryEvent(sparta::Scheduleable * sysc_query_event,
                                      const Scheduler::Tick interval)
    {
        sysc_query_event_ = sysc_query_event;
        sysc_query_event_interval_ = interval;
        next_sysc_event_fire_tick_ = sparta_scheduler_->getCurrentTick() + interval;
        sparta_assert(sysc_query_event_->isContinuing() == false,
                          "This event should be non-continuing");
    }
 
    bool wasScStopCalled() const {
        return sc_stop_called_;
    }
 
private:
 
    void runScheduler_()
    {
        // Start simulation -- align the schedulers
        sparta_assert(sparta_scheduler_->nextEventTick() > 0);
 
        // Align the schedulers.  Sparta starts at tick 1
        wait(sc_core::sc_time(double(1), sparta_sc_time_));
 
        do {
            // If the Sparta Scheduler has nothing to do, put it to sleep
            if(sparta_scheduler_->nextEventTick() == Scheduler::INDEFINITE) {
                sparta_scheduler_->registerForNotification<Scheduler::Tick,
                                                           SysCSpartaSchedulerAdapter,
                                                           &SysCSpartaSchedulerAdapter::wakeupAdapter_>(this, "item_scheduled");
                wait(sc_wake_sparta_);
            }
 
            //
            // Wait for SysC to get to the next event time on the
            // Sparta Scheduler, then advance Sparta
            //
            const sc_core::sc_time sysc_time = sc_core::sc_time_stamp();
            if(sparta_scheduler_->nextEventTick() >= sysc_time.value()) {
                // Wait until the sysc scheduled catches up with Sparta
                wait(sc_core::sc_time(double(sparta_scheduler_->nextEventTick() - sysc_time.value()),
                                      sparta_sc_time_));
            }
 
            // Align to the posedge events in systemc
            wait(sc_core::SC_ZERO_TIME);
 
            // If given, schedule the user's SystemC query event to
            // allow the Sparta user to check to see if the SystemC side
            // of simulation is complete.  This query can be as simple
            // as asking the SystemC kernel if there are any events
            // (sc_core::sc_pending_activity()) or asking the SystemC
            // simulator if it's done.
            if(sysc_query_event_ && sparta_scheduler_->getCurrentTick() >= next_sysc_event_fire_tick_)
            {
                next_sysc_event_fire_tick_ = sparta_scheduler_->getCurrentTick() + sysc_query_event_interval_;
                sysc_query_event_->scheduleRelativeTick(1, sparta_scheduler_);
            }
 
            advanceSpartaScheduler_();
 
        } while(!sparta_scheduler_->isFinished() || !sysc_simulation_done_);
 
        // Stop simulation
        sc_core::sc_stop();
        sc_stop_called_ = true;
    }
 
    void advanceSpartaScheduler_()
    {
        const sc_core::sc_time sysc_time = sc_core::sc_time_stamp();
 
        // The SystemC scheduler will always be exactly at the same
        // tick as Sparta when this function is called.  Following
        // this rule allows safe assumptions in scheduling
        // synchronization.
        sparta_assert(sysc_time.value() == sparta_scheduler_->nextEventTick());
        sparta_assert(sparta_scheduler_->nextEventTick() >= sparta_scheduler_->getCurrentTick());
 
        constexpr bool exacting_run = true;
        constexpr bool measure_scheduler_time = false; // no need to do this
        // Run to the next event scheduled and then run that cycle
        sparta_scheduler_->run(sparta_scheduler_->nextEventTick() - sparta_scheduler_->getCurrentTick() + 1,
                               exacting_run, measure_scheduler_time);
 
        // Sparta should now be finished with the cycle at `sysc_time`
        // and be exactly one cycle ahead of it.
        sparta_assert(sysc_time.value() + 1 == sparta_scheduler_->getCurrentTick());
    }
 
    // Local copy of the sparta scheduler
    sparta::Scheduler * sparta_scheduler_ = nullptr;
 
    // Time unit Sparta runs in
    sc_core::sc_time_unit sparta_sc_time_ = sc_core::SC_PS;
 
    // Boolean that tells our runScheduler_ thread to exit -- the rest
    // of the SystemC scheduling is complete
    bool sysc_simulation_done_ = false;
 
    // SystemC event that stops simulation
    sc_core::sc_event sc_ev_stop_simulation_;
    bool sc_stop_called_ = false;
 
    // SystemC event that wakes the Sparta Scheduler
    sc_core::sc_event sc_wake_sparta_;
 
    // Sparta Event (optional) that will be automatically scheduled if
    // the Sparta scheduler is finished and the driver needs to query systemc
    sparta::Scheduleable * sysc_query_event_ = nullptr;
    Scheduler::Tick sysc_query_event_interval_ = 10000;
    Scheduler::Tick next_sysc_event_fire_tick_ = 0;
};
 
}