PhasedSingleCycleUniqueEvent.hpp

Go to the documentation of this file.

// <PhasedSingleCycleUniqueEvent.h> -*- C++ -*-
 
 
#pragma once
 
#include <array>
#include <memory>
#include <string>
#include "sparta/simulation/TreeNode.hpp"
#include "sparta/kernel/SpartaHandler.hpp"
#include "sparta/simulation/Clock.hpp"
#include "sparta/kernel/Scheduler.hpp"
#include "sparta/events/EventNode.hpp"
#include "sparta/events/Scheduleable.hpp"
 
namespace sparta
{
 
    class PhasedSingleCycleUniqueEvent : public EventNode
    {
    public:
        PhasedSingleCycleUniqueEvent(TreeNode * event_set,
                                     const std::string & name,
                                     SchedulingPhase sched_phase,
                                     const SpartaHandler & consumer_event_handler) :
            EventNode(event_set, name, sched_phase),
            local_clk_(getClock()),
            fancy_name_(name + "[" + consumer_event_handler.getName() + "]"),
            single_cycle_event_scheduleable_(consumer_event_handler, 1 /*HARD CODED*/, sched_phase)
        {
            single_cycle_event_scheduleable_.setScheduleableClock(getClock());
            single_cycle_event_scheduleable_.setLabel(fancy_name_.c_str());
        }
 
        PhasedSingleCycleUniqueEvent(const PhasedSingleCycleUniqueEvent &) = delete;
 
        PhasedSingleCycleUniqueEvent& operator=(const PhasedSingleCycleUniqueEvent &) = delete;
 
        void setContinuing(bool continuing) {
            single_cycle_event_scheduleable_.setContinuing(continuing);
        }
 
        bool isContinuing() const {
            return single_cycle_event_scheduleable_.isContinuing();
        }
 
        void cancel() {
            single_cycle_event_scheduleable_.cancel();
        }
 
        bool isScheduled() const {
            return single_cycle_event_scheduleable_.isScheduled();
        }
 
        virtual ~PhasedSingleCycleUniqueEvent() = default;
 
        using EventNode::getSchedulingPhase;
 
        void schedule(Clock::Cycle rel_cycle = 0) {
            sparta_assert(rel_cycle < 2,
                        "Cannot schedule sparta::SingleCycleUniqueEvent:'"
                        << getName() << "' in any relative time other than 0 or 1. rel_cycle given: "
                        << rel_cycle);
 
            const auto to_be_scheduled_relative_tick =
                local_clk_->getTick(Clock::Cycle(rel_cycle));
 
            const auto to_be_scheduled_abs_tick =
                local_scheduler_->calcIndexTime(to_be_scheduled_relative_tick);
 
            if(SPARTA_EXPECT_TRUE(next_scheduled_tick_ < to_be_scheduled_abs_tick || is_init_tick_))
            {
#ifndef NDEBUG
                // This is a handy debug assertion to see if
                // SingleCycleUniqueEvent is actually only scheduled once.
                //
                sparta_assert(single_cycle_event_scheduleable_.isScheduled(rel_cycle) == false,
                              "Bummer!  You found a bug in PhasedSingleCycleUniqueEvent.  Please file a GitHub Issue");
#endif
                single_cycle_event_scheduleable_.
                    scheduleRelativeTick(to_be_scheduled_relative_tick, local_scheduler_);
                prev_scheduled_tick_ = next_scheduled_tick_;
                next_scheduled_tick_ = to_be_scheduled_abs_tick;
                is_init_tick_ = false; //only allow one event in tick 0
            }
            else if((to_be_scheduled_abs_tick < next_scheduled_tick_) &&
                    (prev_scheduled_tick_ != to_be_scheduled_abs_tick))
            {
#ifndef NDEBUG
                // This is a handy debug assertion to see if
                // SingleCycleUniqueEvent is actually only scheduled once.
                //
                sparta_assert(single_cycle_event_scheduleable_.isScheduled(rel_cycle) == false,
                              "Bummer!  You found a bug in PhasedSingleCycleUniqueEvent.  Please file a GitHub Issue");
                sparta_assert(prev_scheduled_tick_ < to_be_scheduled_abs_tick,
                              "Bummer!  You found a bug in PhasedSingleCycleUniqueEvent.  Please file a GitHub Issue")
#endif
                single_cycle_event_scheduleable_.
                    scheduleRelativeTick(to_be_scheduled_relative_tick, local_scheduler_);
                prev_scheduled_tick_ = to_be_scheduled_abs_tick;
            }
        }
 
        template<class ScheduleableT>
        void precedes(ScheduleableT & consumer, const std::string & reason = "") {
            single_cycle_event_scheduleable_.precedes(consumer, reason);
        }
 
#ifndef DO_NOT_DOCUMENT
        // Used by EventNode and auto-precedence.  Return the
        // Scheduleable (this)
        Scheduleable & getScheduleable() override {
            return single_cycle_event_scheduleable_;
        }
#endif
 
    private:
        void createResource_() override {
            local_clk_ = getClock();
            local_scheduler_ = local_clk_->getScheduler();
        }
 
        const Clock * local_clk_ = nullptr;
 
        Scheduler * local_scheduler_ = nullptr;
 
        //std::array<Scheduler::Tick, 2> next_scheduled_tick_ = {0, 0};
        Scheduler::Tick next_scheduled_tick_ = 0;
        Scheduler::Tick prev_scheduled_tick_ = 0;
 
        std::string fancy_name_;
 
        Scheduleable single_cycle_event_scheduleable_;
 
        bool is_init_tick_ = true;
    };
 
}