Rename.hpp

// <Rename.h> -*- C++ -*-
 
 
#pragma once
 
#include <string>
 
#include "sparta/ports/DataPort.hpp"
#include "sparta/events/UniqueEvent.hpp"
#include "sparta/simulation/Unit.hpp"
#include "sparta/simulation/TreeNode.hpp"
#include "sparta/simulation/ParameterSet.hpp"
#include "CoreTypes.hpp"
#include "FlushManager.hpp"
 
namespace core_example
{
 
    class Rename : public sparta::Unit
    {
    public:
        class RenameParameterSet : public sparta::ParameterSet
        {
        public:
            RenameParameterSet(sparta::TreeNode* n) :
                sparta::ParameterSet(n)
            { }
 
            PARAMETER(uint32_t, num_to_rename,       4, "Number of instructions to rename")
            PARAMETER(uint32_t, rename_queue_depth, 10, "Number of instructions queued for rename")
        };
 
        Rename(sparta::TreeNode * node,
               const RenameParameterSet * p);
 
        static const char name[];
 
    private:
        InstQueue                     uop_queue_;
        sparta::DataInPort<InstGroup>   in_uop_queue_append_       {&unit_port_set_, "in_uop_queue_append", 1};
        sparta::DataOutPort<uint32_t>   out_uop_queue_credits_     {&unit_port_set_, "out_uop_queue_credits"};
        sparta::DataOutPort<InstGroup>  out_dispatch_queue_write_  {&unit_port_set_, "out_dispatch_queue_write"};
        sparta::DataInPort<uint32_t>    in_dispatch_queue_credits_ {&unit_port_set_, "in_dispatch_queue_credits", sparta::SchedulingPhase::Tick, 0};
 
        // For flush
        sparta::DataInPort<FlushManager::FlushingCriteria> in_reorder_flush_
             {&unit_port_set_, "in_reorder_flush", sparta::SchedulingPhase::Flush, 1};
 
        sparta::UniqueEvent<> ev_rename_insts_ {&unit_event_set_, "rename_insts", CREATE_SPARTA_HANDLER(Rename, renameInstructions_)};
 
        const uint32_t num_to_rename_per_cycle_;
        uint32_t credits_dispatch_ = 0;
        bool stop_checking_db_access_ = false;
 
        void sendInitialCredits_();
 
        void creditsDispatchQueue_(const uint32_t &);
 
        void decodedInstructions_(const InstGroup &);
 
        void renameInstructions_();
 
        void handleFlush_(const FlushManager::FlushingCriteria & criteria);
 
    };
}