PhasedUniqueEvent.hpp

Go to the documentation of this file.

// <PhasedUniqueEvent.h> -*- C++ -*-
 
 
#pragma once
 
#include <set>
#include <memory>
#include "sparta/events/EventNode.hpp"
#include "sparta/events/Scheduleable.hpp"
 
namespace sparta
{
 
    class PhasedUniqueEvent : public EventNode, public Scheduleable
    {
    public:
        PhasedUniqueEvent(TreeNode * event_set,
                          const std::string & name,
                          SchedulingPhase sched_phase,
                          const SpartaHandler & consumer_event_handler,
                          Clock::Cycle delay = 0) :
            EventNode(event_set, name, sched_phase),
            Scheduleable(CREATE_SPARTA_HANDLER(PhasedUniqueEvent, deliverEvent_), delay, sched_phase, true),
            pue_consumer_event_handler_(consumer_event_handler),
            fancy_name_(name + "[" + consumer_event_handler.getName() + "]")
        {
            Scheduleable::local_clk_ = getClock();
            Scheduleable::scheduler_ = determineScheduler(local_clk_);
            setLabel(fancy_name_.c_str());
        }
 
        PhasedUniqueEvent(const PhasedUniqueEvent &) = delete;
 
        PhasedUniqueEvent& operator=(const PhasedUniqueEvent &) = delete;
 
        Scheduler * getScheduler(const bool must_exist = true) {
            return Scheduleable::getScheduler(must_exist);
        }
 
        const Scheduler * getScheduler(const bool must_exist = true) const {
            return Scheduleable::getScheduler(must_exist);
        }
 
        virtual ~PhasedUniqueEvent() {}
 
        using EventNode::getSchedulingPhase;
 
        using Scheduleable::schedule;
 
        void scheduleRelativeTick(sparta::Scheduler::Tick rel_tick,
                                  sparta::Scheduler * scheduler) override final
        {
            sparta_assert(scheduler_);
            sparta_assert(last_tick_called_ != (scheduler->getCurrentTick() + rel_tick),
                        "PhasedUniqueEvent (UniqueEvent) '" << getName()
                        << "' was already scheduled and fired this cycle."
                        "\t\nAre you missing a precedence rule?");
 
            Scheduleable::scheduleRelativeTick(rel_tick, scheduler);
        }
 
#ifndef DO_NOT_DOCUMENT
        // Used by EventNode and auto-precedence.  Return the
        // Scheduleable (this)
        Scheduleable & getScheduleable() override {
            return *this;
        }
#endif
 
    private:
 
        void deliverEvent_() {
            // I don't like this, but since there are a couple of
            // legal ways to create the PhasedUniqueEvent (one includes the
            // lack of a clock), I cannot remember the time...
            if(SPARTA_EXPECT_TRUE(local_clk_ != nullptr)) {
                last_tick_called_ = local_clk_->getScheduler()->getCurrentTick();
            }
            pue_consumer_event_handler_();
        }
 
        void createResource_() override {
            Scheduleable::local_clk_ = getClock();
            Scheduleable::scheduler_ = determineScheduler(local_clk_);
        }
 
        SpartaHandler pue_consumer_event_handler_;
 
        Scheduler::Tick last_tick_called_ = Scheduler::Tick(-1);
 
        std::string fancy_name_;
    };
 
}