Scoreboard.hpp

Go to the documentation of this file.

// <Scoreboard.hpp> -*- C++ -*-
 
#pragma once
 
#include <vector>
#include <cinttypes>
#include <string>
#include <map>
#include <list>
 
#include "sparta/simulation/ParameterSet.hpp"
#include "sparta/simulation/Unit.hpp"
#include "sparta/simulation/TreeNode.hpp"
#include "sparta/events/PayloadEvent.hpp"
 
namespace sparta
{
    class ScoreboardView;
 
    class Scoreboard : public sparta::Unit
    {
    public:
        using UnitID = uint32_t;
        using InstID = uint64_t;
 
        static constexpr UnitID INVALID_UNIT_ID   = std::numeric_limits<UnitID>::max();
        static constexpr uint32_t INVALID_LATENCY = static_cast<uint32_t>(-1);
        static constexpr uint32_t MAX_REGISTERS   = 512;
 
        using RegisterBitMask = std::bitset<MAX_REGISTERS>;
 
        static const char name[];
 
        class ScoreboardParameters : public sparta::ParameterSet
        {
        public:
            using LatencyMatrixParameterType = std::vector<std::vector<std::string>>;
 
            explicit ScoreboardParameters(sparta::TreeNode * n);
 
            //
            // Example table:
            //
            // [  # FROM
            //    #  |
            //    #  V
            //    [""     ,"ALU0", "ALU1",   "LSU",   "FPU"], # <- TO
            //    ["ALU0",    "0",    "1",     "1",     "3"],
            //    ["ALU1",    "1",    "0",     "1",     "3"],
            //    ["LSU",     "1",    "1",     "0",     "1"],
            //    ["FPU",     "3",    "3",     "1",     "0"]
            // ]
            //
            PARAMETER(LatencyMatrixParameterType, latency_matrix, {},
                      "The forwarding latency matrix.  See the Scoreboard test for format example")
        };
 
        Scoreboard(sparta::TreeNode * container, const ScoreboardParameters * params);
 
        void set(const RegisterBitMask & bits);
 
        void set(const RegisterBitMask & bits, UnitID producer);
 
        void clearBits(const RegisterBitMask & bits);
 
        UnitID registerView(const std::string & producer_name,
                            ScoreboardView * view);
 
        bool isSet(const RegisterBitMask & bits) const;
 
    private:
 
        // Allow the ScoreboardView to access the above structure
        friend class ScoreboardView;
 
        // 0 means the register is not ready.
        RegisterBitMask global_reg_ready_mask_{0xffffffff}; 
 
        // Setting up the forwarding matrix based on integer lookups
        using ForwardingLatency          = uint32_t;
        using ForwardingLatencyConsumers = std::vector<ForwardingLatency>;
        using ForwardingLatencyProducers = std::vector<ForwardingLatencyConsumers>;
 
        // A vector of producers, with each producing row having a list of consumers
        ForwardingLatencyProducers forwarding_latencies_;
 
        // Units found in the latency table, first column, second row onward
        using UnitToIDMap = std::map<std::string, uint32_t>;
        UnitToIDMap unit_name_to_id_;
 
        // UnitID to the ScoreboardViews
        // Single unit can have multiple ScorboardViews
        using UnitIDToSBVs = std::vector<std::vector<ScoreboardView *>>;
        UnitIDToSBVs unit_id_to_scoreboard_views_;
 
        // Producer UnitID to consumer ScoreboardViews
        using ConsumerSBV = std::tuple<ScoreboardView *, ForwardingLatency>;
        using ConsumerSBVs = std::vector<ConsumerSBV>;
        using ProducerToConsumerSBVs = std::vector<ConsumerSBVs>;
        ProducerToConsumerSBVs producer_to_consumer_scoreboard_views_;
 
        // Unit ID count
        uint32_t unit_id_ = 0;
 
        // Structure to hold a forwarded scoreboard update
        struct ScoreboardUpdate {
            RegisterBitMask bits;
            UnitID    producer;
        };
 
        // PayloadEvent used to deliver the Scoreboard contents to the views
        struct ScoreboardViewUpdate
        {
            ScoreboardUpdate first;
            ScoreboardView *second;
            bool is_canceled;
        };
        sparta::PayloadEvent<ScoreboardViewUpdate, sparta::SchedulingPhase::Update> scoreboard_view_updates_;
        void deliverScoreboardUpdate_(const ScoreboardViewUpdate &);
    };
 
    class ScoreboardView
    {
    public:
        using ReadinessCallback = std::function<void(const Scoreboard::RegisterBitMask&)>;
 
        ScoreboardView(const std::string & unit_name,
                       const std::string & scoreboard_type,
                       sparta::TreeNode * node);
 
        void registerReadyCallback(const Scoreboard::RegisterBitMask & bits,
                                   const Scoreboard::InstID inst_id,
                                   const ReadinessCallback & callback);
 
        void clearCallbacks(const Scoreboard::InstID inst_id);
 
        bool isSet(const Scoreboard::RegisterBitMask & bits) const
        {
            return bits == (local_ready_mask_ & bits);
        }
 
        void setReady(const Scoreboard::RegisterBitMask & bits);
 
        std::string getType() const {
            return scoreboard_type_;
        }
 
        std::string getName() const {
            return unit_name_;
        }
 
    private:
 
        // Make the Scoreboard a friend to clear bits in the view
        friend Scoreboard;
 
        void receiveScoreboardUpdate_(const Scoreboard::RegisterBitMask & bits,
                                      const Scoreboard::UnitID producer);
 
        // Find a Scoreboard that matches this view in the node hierarchy
        Scoreboard::UnitID findMasterScoreboard_(const std::string & unit_name,
                                                 const std::string & scoreboard_type,
                                                 sparta::TreeNode * parent);
 
        void clearBits_(const Scoreboard::RegisterBitMask & bits);
 
        Scoreboard::RegisterBitMask local_ready_mask_{0xffffffff};  
 
        Scoreboard * master_scoreboard_ = nullptr;
 
        struct CallbackData
        {
            CallbackData(const Scoreboard::RegisterBitMask & bv,
                         const Scoreboard::InstID iid,
                         const ReadinessCallback & cb,
                         sparta::Clock::Cycle cyc) :
                needed_bits(bv), inst_id(iid), callback(cb), registered_time(cyc)
 
            {}
 
            CallbackData(CallbackData&&) = default;
 
            const Scoreboard::RegisterBitMask needed_bits;
            const Scoreboard::InstID          inst_id;
            ReadinessCallback                 callback;
            sparta::Clock::Cycle              registered_time;
        };
 
        using ReadinessCallbacks = std::list<CallbackData>;
        ReadinessCallbacks ready_callbacks_;
 
        const sparta::Clock    * clock_;
        const std::string        unit_name_;
        const Scoreboard::UnitID unit_id_;
        const std::string scoreboard_type_;
    };
 
    // This override (implementation in Scoreboard.cpp) will provide a
    // friendlier scoreboard output
    extern std::string printBitSet(const Scoreboard::RegisterBitMask & bits);
}