Scheduler.hpp

Go to the documentation of this file.

// <Scheduler> -*- C++ -*-
 
#pragma once
 
#include <ctime>
#include <unistd.h>
#include <boost/timer/timer.hpp>
//#include <boost/algorithm/string/predicate.hpp>
#include <cstdint>
#include <string>
#include <cmath>
#include <vector>
#include <chrono>
#include <mutex>
#include <array>
#include <memory>
#include <algorithm>
#include <limits>
#include <list>
#include <ostream>
 
#include "sparta/utils/Colors.hpp"
#include "sparta/kernel/SpartaHandler.hpp"
#include "sparta/kernel/ObjectAllocator.hpp"
#include "sparta/simulation/RootTreeNode.hpp"
#include "sparta/log/MessageSource.hpp"
#include "sparta/statistics/StatisticDef.hpp"
#include "sparta/statistics/ReadOnlyCounter.hpp"
#include "sparta/statistics/Counter.hpp"
#include "sparta/statistics/StatisticSet.hpp"
#include "sparta/events/SchedulingPhases.hpp"
#include "sparta/utils/ValidValue.hpp"
#include "sparta/statistics/CounterBase.hpp"
#include "sparta/utils/SpartaAssert.hpp"
 
#ifdef SYSTEMC_SUPPORT
#include "sparta/log/NotificationSource.hpp"
#endif
 
namespace sparta {
class GlobalTreeNode;
}  // namespace sparta
 
 
#define PS_PER_SECOND 1000000000000
 
namespace sparta {
    class Scheduler;
    class Clock;
    class DAG;
 
    class Scheduleable;
    class StartupEvent;
    // Forward declaration to support the addition of sparta::GlobalEvent
    template<typename DataT>
    class PhasedPayloadEvent;
    class EventSet;
    class GlobalEventProxy;
}
 
namespace sparta
{
 
class Scheduler : public RootTreeNode
{
public:
 
    typedef uint64_t Tick;
 
private:
 
    struct TickQuantum
    {
        struct ScheduleableGroup {
        public:
            using Scheduleables = std::vector<Scheduleable *>;
 
            void addScheduleable(Scheduleable* sched) {
                if(SPARTA_EXPECT_FALSE(current_idx_ == size_)) {
                    scheduleables_.resize(scheduleables_.size() * 2, nullptr);
                    size_ = scheduleables_.size();
                }
                scheduleables_[current_idx_++] = sched;
            }
 
            size_t size() const {
                return current_idx_;
            }
 
            void clear() {
                current_idx_ = 0;
            }
 
            Scheduleables::const_reference operator[](const size_t index) const {
                sparta_assert(index < current_idx_);
                return scheduleables_[index];
            }
 
            Scheduleables::reference operator[](const size_t index) {
                sparta_assert(index < current_idx_);
                return scheduleables_[index];
            }
 
        private:
            size_t size_        = 16;
            size_t current_idx_ = 0;
            Scheduleables scheduleables_{size_, nullptr}; // start with 16 events.
        };
 
        using ScheduleableGroups = std::vector<ScheduleableGroup>;
 
        TickQuantum(uint32_t num_firing_groups) :
            groups(num_firing_groups)
        { }
 
        void addEvent(uint32_t firing_group, Scheduleable * scheduleable) {
            sparta_assert(firing_group > 0);
            sparta_assert(firing_group < groups.size());
            groups[firing_group].addScheduleable(scheduleable);
            first_group_idx = std::min(first_group_idx, firing_group);
        }
 
        void addEventIfNotScheduled(uint32_t firing_group, Scheduleable * scheduleable) {
            sparta_assert(firing_group > 0);
            sparta_assert(firing_group < groups.size());
            auto & grp = groups[firing_group];
            const auto grp_size = grp.size();
            for(uint32_t idx = 0; idx < grp_size; ++idx) {
                if(grp[idx] == scheduleable) {
                    return;
                }
            }
            grp.addScheduleable(scheduleable);
            first_group_idx = std::min(first_group_idx, firing_group);
        }
 
        Tick               tick = 0; 
        ScheduleableGroups groups;   
        uint32_t first_group_idx = std::numeric_limits<uint32_t>::max(); 
        TickQuantum * next = nullptr;
    };
 
    TickQuantum * current_tick_quantum_ = nullptr;
 
    ObjectAllocator<TickQuantum> tick_quantum_allocator_;
 
    bool watchdogExpired_() const
    {
        bool watchdoc_expired = false;
        if (wdt_period_ticks_ > 0) {
            sparta_assert(current_tick_ >= prev_wdt_tick_);
            uint64_t num_ticks_since_wdt = current_tick_ - prev_wdt_tick_;
            if (num_ticks_since_wdt >= wdt_period_ticks_) {
                watchdoc_expired = true;
            }
        }
        return watchdoc_expired;
    }
 
public:
 
    constexpr Tick calcIndexTime(const Tick rel_time) const {
        return current_tick_ + rel_time;
    }
 
    template <typename DurationT>
    DurationT getRunCpuTime() const
    {
        return std::chrono::duration_cast<DurationT>(std::chrono::nanoseconds(timer_.elapsed().user));
    }
 
    template <typename DurationT>
    DurationT getRunWallTime() const
    {
        return std::chrono::duration_cast<DurationT>(std::chrono::nanoseconds(timer_.elapsed().wall));
    }
 
    static const Tick INDEFINITE;
 
    static constexpr char NODE_NAME[] = "scheduler";
 
    Scheduler();
 
    Scheduler(const std::string& name) :
        Scheduler(name, nullptr)
    {
        // Delegated Constructor
    }
 
    Scheduler(const std::string& name, GlobalTreeNode* search_scope);
 
    ~Scheduler();
 
    void reset();
 
    void registerClock(sparta::Clock *clk);
 
    void deregisterClock(sparta::Clock *clk);
 
 
    void finalize();
 
    DAG * getDAG() const{
        return dag_.get();
    }
 
 
 
 
    void stopRunning() {
        running_ = false;
    }
 
    void clearEvents();
 
    void restartAt(Tick t);
 
    template<class StreamType>
    void printNextCycleEventTree(StreamType & os, uint32_t curr_grp = 0,
                                 uint32_t curr_event = 0, uint32_t future=0) const;
 
    void scheduleEvent(Scheduleable * scheduleable,
                       Tick rel_time,
                       uint32_t dag_group=0,
                       bool continuing=true,
                       bool add_if_not_scheduled=false);
 
    void scheduleAsyncEvent(Scheduleable *sched, Scheduler::Tick delay);
 
    bool isScheduled(const Scheduleable * scheduleable) const;
 
    bool isScheduled(const Scheduleable * scheduleable, Tick rel_time) const;
 
 
    void cancelEvent(const Scheduleable * scheduleable);
 
    void cancelEvent(const Scheduleable * scheduleable, Tick rel_time);
 
    void cancelAsyncEvent(Scheduleable *scheduleable);
 
 
 
    void run(Tick num_ticks=INDEFINITE,
             const bool exacting_run = false,
             const bool measure_run_time = true);
 
    bool isFinished() const {
        return is_finished_;
    }
 
    Tick nextEventTick() const {
        sparta_assert(!isRunning());
        if(current_tick_quantum_ == nullptr) {
            return INDEFINITE;
        }
        return (current_tick_quantum_->tick);
    }
 
 
 
    bool isFinalized() const noexcept override
    {
        return dag_finalized_;
    }
 
    bool isRunning() const noexcept
    {
        return running_;
    }
 
    Tick getCurrentTick() const noexcept
    {
        return current_tick_;
    }
 
    Tick getElapsedTicks() const noexcept
    {
        return elapsed_ticks_;
    }
 
    Tick getSimulatedPicoSeconds() const noexcept
    {
        return current_tick_;
    }
 
    void kickTheDog() noexcept {
        prev_wdt_tick_ = getCurrentTick();
    }
 
    void enableWatchDog(uint64_t watchdog_timeout_ps) {
        // TODO: Handle the case when different callers want different
        // enable/disable behavior
        if (watchdog_timeout_ps == 0) {
            sparta_assert(wdt_period_ticks_ == 0);
        }
 
        // Only increase the period; don't allow it to decrease
        if (wdt_period_ticks_ < watchdog_timeout_ps) {
            // Scheduler ticks are currently pico-seconds, so this is 1:1
            wdt_period_ticks_ = watchdog_timeout_ps;
        }
    }
 
    Tick getNumFired() const noexcept
    {
        return events_fired_;
    }
 
    Tick getNextContinuingEventTime() const noexcept {
        return latest_continuing_event_;
    }
 
    const Scheduleable * getCurrentFiringEvent() const
    {
        if(current_tick_quantum_) {
            if(current_tick_quantum_->groups.size() > current_group_firing_) {
                if(current_tick_quantum_->groups[current_group_firing_].size() > current_event_firing_) {
                    return current_tick_quantum_->groups[current_group_firing_][current_event_firing_];
                }
            }
        }
        return nullptr;
    }
 
    uint32_t getCurrentFiringEventIdx() const {
        return current_event_firing_;
    }
 
    SchedulingPhase getCurrentSchedulingPhase() const {
        return current_scheduling_phase_;
    }
 
 
 
    Tick getFrequency() const {
        return PS_PER_SECOND; // 1tick = 1ps
    }
 
    ReadOnlyCounter& getCurrentTicksROCounter() {
        return ticks_roctr_;
    }
 
    ReadOnlyCounter& getCurrentPicosecondsROCounter() {
        return picoseconds_roctr_;
    }
 
    StatisticDef& getSecondsStatisticDef() {
        return seconds_stat_;
    }
 
    StatisticDef& getCurrentMillisecondsStatisticDef() {
        return milliseconds_stat_;
    }
 
    StatisticDef& getCurrentMicrosecondsStatisticDef() {
        return microseconds_stat_;
    }
 
    StatisticDef& getCurrentNanosecondsStatisticDef() {
        return nanoseconds_stat_;
    }
 
 
private:
 
    // The startup event adds itself to internal structures
    friend class StartupEvent;
 
    void scheduleStartupHandler_(const SpartaHandler & event_del) {
        startup_events_.emplace_back(event_del);
    }
 
    void throwPrecedenceIssue_(const Scheduleable * scheduleable, const uint32_t firing_group) const;
    const char * getScheduleableLabel_(const Scheduleable * sched) const;
 
    TickQuantum* determineTickQuantum_(Tick rel_time);
 
    std::unique_ptr<DAG> dag_;
 
    uint32_t dag_group_count_ = 0;
 
    uint32_t firing_group_count_ = 0;
 
    uint32_t group_zero_ = 0;
 
    bool dag_finalized_ = false;
 
    bool first_tick_ = true;
 
    Tick current_tick_ = 0; //init tick 0
 
    Tick elapsed_ticks_ = 0;
 
    Tick prev_wdt_tick_ = 0;
 
    Tick wdt_period_ticks_ = 0;
 
    bool running_ = false;
 
    std::unique_ptr<Scheduleable> stop_event_;
 
    std::unique_ptr<Scheduleable> cancelled_event_;
    void cancelCallback_() {}
 
    bool is_finished_ = false;
 
    std::vector<SpartaHandler> startup_events_;
 
    std::vector<sparta::Clock*> registered_clocks_;
 
    uint32_t current_group_firing_ = 0;
 
    uint32_t current_event_firing_ = 0;
 
    SchedulingPhase current_scheduling_phase_ = SchedulingPhase::Trigger;
 
    log::MessageSource debug_;
 
    log::MessageSource call_trace_logger_;
 
    std::ostringstream call_trace_stream_;
 
    Tick latest_continuing_event_ = 0;
 
    StatisticSet sset_;
 
    std::unique_ptr<sparta::Clock> scheduler_internal_clk_;
 
    ReadOnlyCounter ticks_roctr_;
    class PicoSecondCounter : public ReadOnlyCounter {
        Scheduler& sched_;
    public:
        PicoSecondCounter(Scheduler& sched,
                          sparta::Clock * clk,
                          StatisticSet* parent);
 
        counter_type get() const override {
            return static_cast<counter_type>(static_cast<double>(sched_.getElapsedTicks()) *
                                             (PS_PER_SECOND / static_cast<double>(sched_.getFrequency()))); // 150000.0
        }
    } picoseconds_roctr_;
 
    StatisticDef seconds_stat_;
 
    StatisticDef milliseconds_stat_;
 
    StatisticDef microseconds_stat_;
 
    StatisticDef nanoseconds_stat_;
 
    StatisticDef user_runtime_stat_;
 
    StatisticDef system_runtime_stat_;
 
    StatisticDef wall_runtime_stat_;
 
    boost::timer::cpu_timer timer_;
 
    uint64_t        events_fired_ = 0;
    ReadOnlyCounter events_fired_cnt_;
 
    uint64_t        user_time_ = 0;
    ReadOnlyCounter user_time_cnt_;
 
    uint64_t        system_time_ = 0;
    ReadOnlyCounter system_time_cnt_;
 
    uint64_t        wall_time_ = 0;
    ReadOnlyCounter wall_time_cnt_;
 
public:
    template<SchedulingPhase sched_phase_T = SchedulingPhase::Update>
    PhasedPayloadEvent<GlobalEventProxy>* getGlobalPhasedPayloadEventPtr() {
        static_assert(static_cast<uint32_t>(sched_phase_T) < NUM_SCHEDULING_PHASES,
                     "Invalid Scheduling Phase is provided!");
 
        return gbl_events_[static_cast<uint32_t>(sched_phase_T)].get();
    }
 
private:
    std::unique_ptr<EventSet> es_uptr_;
 
    std::array<std::unique_ptr<PhasedPayloadEvent<GlobalEventProxy>>,
               NUM_SCHEDULING_PHASES> gbl_events_;
 
    void fireGlobalEvent_(const GlobalEventProxy &);
 
    struct AsyncEventInfo {
        AsyncEventInfo(Scheduleable *sched, Scheduler::Tick tick)
            : sched(sched), tick(tick) { }
 
        AsyncEventInfo(Scheduleable *sched)
            : AsyncEventInfo(sched, 0) { }
 
        bool operator() (const AsyncEventInfo &info)
        {
            return info.sched == sched;
        }
 
        Scheduleable *sched = nullptr;
        Scheduler::Tick tick = 0;
    };
 
    volatile bool async_event_list_empty_hint_ = true;
 
    std::list<AsyncEventInfo> async_event_list_;
 
    std::mutex async_event_list_mutex_;
 
#ifdef SYSTEMC_SUPPORT
    sparta::NotificationSource<Tick> item_scheduled_;
#endif
};
 
 
template<class StreamType>
inline void Scheduler::printNextCycleEventTree(StreamType& os,
                                               uint32_t curr_grp,
                                               uint32_t curr_event,
                                               uint32_t future) const
{
    if(current_tick_quantum_ == nullptr) {
        os << "sparta::Scheduler is empty" << std::endl;
        return;
    }
 
    uint32_t scheduler_map_idx = current_tick_ + future;
    os << "Scheduler's event tree for tick: " << scheduler_map_idx << std::endl;
    if(current_tick_quantum_->tick > scheduler_map_idx) {
        os << "\tNo events for time: '"
           << scheduler_map_idx << "' next event @"
           << current_tick_quantum_->tick << std::endl;
    }
    const TickQuantum::ScheduleableGroups & group_array = current_tick_quantum_->groups;
    for(uint32_t i = curr_grp; i < group_array.size(); ++i)
    {
        std::stringstream output;
        if((i + 1) == group_array.size()) {
            output << "\tGroup[zero]: ";
        }
        else {
            output << "\tGroup[" << i + 1 << "]: ";
        }
        const TickQuantum::ScheduleableGroup & scheduleables = group_array[i];
 
        output << SPARTA_CURRENT_COLOR_GREEN;
        for(uint32_t x = 0; x < scheduleables.size(); ++x)
        {
            if(x) {
                output << ", ";
            }
            if((curr_grp == i) && (curr_event == x)) {
                output << SPARTA_CURRENT_COLOR_BRIGHT_GREEN << getScheduleableLabel_(scheduleables[x]);
            }
            else {
                output << SPARTA_CURRENT_COLOR_GREEN << getScheduleableLabel_(scheduleables[x]);
            }
        }
 
        os << output.str() << SPARTA_CURRENT_COLOR_NORMAL << std::endl;
    }
}
 
 
 
 
}