FlushManager.hpp

// <Flush.h> -*- C++ -*-
 
 
#pragma once
 
#include <cinttypes>
#include <string>
 
#include "sparta/simulation/Unit.hpp"
#include "sparta/ports/DataPort.hpp"
 
namespace core_example
{
    class FlushManager : public sparta::Unit
    {
    public:
        typedef uint64_t FlushingCriteria;
        static constexpr char name[] = "flushmanager";
 
        class FlushManagerParameters : public sparta::ParameterSet
        {
        public:
            FlushManagerParameters(sparta::TreeNode* n) :
                sparta::ParameterSet(n)
            { }
 
        };
 
        FlushManager(sparta::TreeNode *rc, const FlushManagerParameters * params) :
            Unit(rc, name),
            out_retire_flush_(getPortSet(), "out_retire_flush", false),
            in_retire_flush_(getPortSet(), "in_retire_flush", 0),
            out_fetch_flush_redirect_(getPortSet(), "out_fetch_flush_redirect", false),
            in_fetch_flush_redirect_(getPortSet(), "in_fetch_flush_redirect", 0)
        {
            (void)params;
            in_retire_flush_.
                registerConsumerHandler(CREATE_SPARTA_HANDLER_WITH_DATA(FlushManager,
                                                                      forwardRetireFlush_,
                                                                      FlushingCriteria));
            in_fetch_flush_redirect_.
                registerConsumerHandler(CREATE_SPARTA_HANDLER_WITH_DATA(FlushManager,
                                                                      forwardFetchRedirectFlush_,
                                                                      uint64_t));
        }
 
    private:
 
        // Flushing criteria
        sparta::DataOutPort<FlushingCriteria> out_retire_flush_;
        sparta::DataInPort <FlushingCriteria> in_retire_flush_;
 
        // Flush redirect for Fetch
        sparta::DataOutPort<uint64_t> out_fetch_flush_redirect_;
        sparta::DataInPort <uint64_t> in_fetch_flush_redirect_;
 
        // Internal method used to forward the flush to the attached
        // listeners
        void forwardRetireFlush_(const FlushingCriteria & flush_data) {
            out_retire_flush_.send(flush_data);
        }
 
        // Internal method used to forward the fetch redirect
        void forwardFetchRedirectFlush_(const uint64_t & flush_data) {
            out_fetch_flush_redirect_.send(flush_data);
        }
    };
}