Scheduleable.hpp

Go to the documentation of this file.

 
// <Scheduleable.h> -*- C++ -*-
 
 
#pragma once
 
#include <cinttypes>
 
#include "sparta/simulation/Clock.hpp"
#include "sparta/kernel/SpartaHandler.hpp"
 
namespace sparta
{
    class ScheduleableHandle;
    class Scheduler;
    class Vertex;
 
    class Scheduleable
    {
 
    public:
        typedef uint32_t PrecedenceGroup;
 
        static const PrecedenceGroup INVALID_GROUP;
 
        Scheduleable(const SpartaHandler & consumer_event_handler,
                     Clock::Cycle delay, SchedulingPhase sched_phase,
                     bool is_unique_event = false);
 
        virtual ~Scheduleable() = default;
 
        Scheduleable(const Scheduleable &) = default;
 
        Scheduleable(Scheduleable &&) noexcept = default;
 
        Scheduler * getScheduler(const bool must_exist = true) {
            sparta_assert(scheduler_ || !must_exist);
            return scheduler_;
        }
 
        const Scheduler * getScheduler(const bool must_exist = true) const {
            sparta_assert(scheduler_ || !must_exist);
            return scheduler_;
        }
 
        void setDelay(Clock::Cycle delay) {
            delay_ = delay;
        }
 
        void addDelay(Clock::Cycle delay) {
            delay_ += delay;
        }
 
        Clock::Cycle getDelay() const {
            return delay_;
        }
 
        void setContinuing(bool continuing) {
            continuing_ = continuing;
        }
 
        bool isContinuing() const {
            return continuing_;
        }
 
        const SpartaHandler & getHandler() const {
            return consumer_event_handler_;
        }
 
        SpartaHandler & getHandler() {
            return consumer_event_handler_;
        }
 
        void setHandler(const SpartaHandler & handler) {
            consumer_event_handler_ = handler;
            setLabel(consumer_event_handler_.getName());
        }
 
        void schedule()
        {
            this->schedule(delay_, local_clk_);
        }
 
        void schedule(const Clock * clk)
        {
            schedule(delay_, clk);
        }
 
        void schedule(Clock::Cycle delay)
        {
            schedule(delay, local_clk_);
        }
 
        virtual void scheduleRelativeTick(const Scheduler::Tick rel_tick,
                                          Scheduler * const scheduler)
        {
            sparta_assert(scheduler != nullptr);
            scheduler->scheduleEvent(this, rel_tick, pgid_,
                                     continuing_, is_unique_event_);
        }
 
        void schedule(Clock::Cycle delay, const Clock *clk)
        {
            sparta_assert(clk != nullptr);
            this->scheduleRelativeTick(clk->getTick(delay),
                                       clk->getScheduler());
        }
 
        bool isScheduled() const {
            return scheduler_->isScheduled(this);
        }
 
        bool isOrphan() const;
 
        bool isScheduled(Clock::Cycle rel_cycle) const {
            Scheduler::Tick rel_tick = local_clk_->getTick(rel_cycle);
            return scheduler_->isScheduled(this, rel_tick);
        }
 
        SchedulingPhase getSchedulingPhase() const {
            return sched_phase_;
        }
 
        const char * getLabel() const {
            return label_.c_str();
        }
 
        void setLabel(const char * label);
 
        Vertex * getVertex(){
            return vertex_;
        }
 
        void precedes(Scheduleable & consumer, const std::string & reason = "");
 
        void precedes(Vertex & consumer, const std::string & reason = "") const;
 
        void precedes(Scheduleable * consumer, const std::string & reason = "") {
            this->precedes(*consumer, reason);
        }
 
        void precedes(Vertex * consumer, const std::string & reason = "") const{
            this->precedes(*consumer, reason);
        }
 
        void setGOP(bool gop) {
            is_gop_ = gop;
        }
 
        void setGroupID(const PrecedenceGroup gid) {
            pgid_ = gid;
        }
 
        bool unlink(Scheduleable *w);
 
        PrecedenceGroup getGroupID() const {
            return pgid_;
        }
 
        void cancel() {
            scheduler_->cancelEvent(this);
            eventCancelled_();
        }
 
        void cancel(Clock::Cycle rel_cycle) {
            Scheduler::Tick rel_tick = local_clk_->getTick(rel_cycle);
            scheduler_->cancelEvent(this, rel_tick);
 
            // If the event was scheduled at the given time, it will
            // be cancelled by the Scheduler.  We don't explicitly
            // cancel this here.
        }
 
 
        void setScheduleableClock(const Clock * clk) {
            sparta_assert(clk != nullptr);
            local_clk_ = clk;
            scheduler_ = clk->getScheduler();
        }
 
        void setScheduler(Scheduler * sched){
            scheduler_ = sched;
        }
 
        void setVertex();
 
#ifndef DO_NOT_DOCUMENT
 
        virtual void onSchedulerAssignment_() {
            setupDummyPrecedence_ThisMethodToGoAwayOnceDaveAddsPhaseSupportToDAG();
        }
        void setupDummyPrecedence_ThisMethodToGoAwayOnceDaveAddsPhaseSupportToDAG();
 
#endif
 
    protected:
        SpartaHandler         consumer_event_handler_;
 
        const Clock * local_clk_ = nullptr;
 
        uint32_t getScheduleableHandleCount_() const {
            return scheduleable_handle_count_;
        }
 
        virtual void setGroupID_(const PrecedenceGroup gid) {
            pgid_ = gid;
        }
 
        // Allow the Scheduler to cancel the event
        friend class Scheduler;
 
        virtual void eventCancelled_() {}
 
        class PrecedenceSetup {
        public:
            explicit PrecedenceSetup(Scheduleable * scheduleable) :
                scheduleable_(scheduleable)
            {}
 
            PrecedenceSetup & operator=(Scheduler * scheduler);
 
            Scheduler * operator->() {
                return scheduler_;
            }
 
            const Scheduler * operator->() const {
                return scheduler_;
            }
 
            operator Scheduler*() {
                return scheduler_;
            }
 
            operator const Scheduler*() const {
                return scheduler_;
            }
 
            operator bool() const {
                return scheduler_ != nullptr;
            }
 
            bool equals(const PrecedenceSetup & other) const {
                return scheduler_ == other.scheduler_;
            }
 
        private:
            Scheduleable * scheduleable_ = nullptr;
            Scheduler    * scheduler_ = nullptr;
        };//End class PrecedenceSetup
 
        PrecedenceSetup scheduler_{this};
 
    private:
        friend class DAG;
 
        friend class Unit; // temporary
 
        friend class ScheduleableHandle;
 
        Vertex * vertex_ = nullptr;
 
        std::string label_;
 
        PrecedenceGroup pgid_ = 0;
 
        // TODO: elminate Unit.cpp code that used this.
        bool is_gop_ = false;
 
        mutable uint32_t scheduleable_handle_count_ = 0;
 
        virtual void reclaim_() {}
 
        Clock::Cycle        delay_;
 
        const SchedulingPhase sched_phase_ = SchedulingPhase::Invalid;
 
        bool continuing_ = true;
 
        const bool is_unique_event_ = false;
 
    };//End class Scheduleable
 
 
    class ScheduleableHandle
    {
    private:
        void disconnect_() {
            if(scheduleable_ && --scheduleable_->scheduleable_handle_count_ == 0) {
                scheduleable_->reclaim_();
            }
        }
 
        void connect_() {
            if(scheduleable_) {
                ++scheduleable_->scheduleable_handle_count_;
            }
        }
 
    public:
        ScheduleableHandle() = default;
 
        // Default move
        ScheduleableHandle(ScheduleableHandle &&) = default;
 
        ScheduleableHandle(const ScheduleableHandle & orig)
        {
            disconnect_();
            scheduleable_ = orig.scheduleable_;
            connect_();
        }
 
        ScheduleableHandle(Scheduleable * scheduleable) :
            scheduleable_(scheduleable)
        {
            connect_();
        }
 
        ScheduleableHandle(Scheduleable & scheduleable) :
            scheduleable_(&scheduleable)
        {
            connect_();
        }
 
        ~ScheduleableHandle()
        {
            disconnect_();
        }
 
        Scheduleable * operator->() const {
            return scheduleable_;
        }
 
        bool operator==(const ScheduleableHandle & rhs) const {
            return (scheduleable_ == rhs.scheduleable_);
        }
 
        bool operator!=(const ScheduleableHandle & rhs) const {
            return !(scheduleable_ == rhs.scheduleable_);
        }
 
        ScheduleableHandle & operator=(const ScheduleableHandle & rhs) {
            disconnect_();
            scheduleable_ = rhs.scheduleable_;
            connect_();
            return *this;
        }
 
    private:
        Scheduleable *scheduleable_ = nullptr;
    };//End class ScheduleableHandle
 
 
    // Scheduleable >> Scheduleable
    inline Scheduleable & operator>>(Scheduleable & producer, Scheduleable & consumer)
    {
        sparta_assert(producer.getSchedulingPhase() == consumer.getSchedulingPhase(),
                    "The Producer: " << producer.getLabel() << " scheduling phase is not equal to"
                    " the consumer: " << consumer.getLabel());
        producer.precedes(consumer);
        return consumer;
    }
 
}