bop.hh

Go to the documentation of this file.

 
#ifndef __MEM_CACHE_PREFETCH_BOP_HH__
#define __MEM_CACHE_PREFETCH_BOP_HH__
 
#include <queue>
 
#include "mem/cache/prefetch/queued.hh"
#include "mem/packet.hh"
 
namespace gem5
{
 
struct BOPPrefetcherParams;
 
namespace prefetch
{
 
class BOP : public Queued
{
    private:
 
        enum RRWay
        {
            Left,
            Right
        };
        enum RRWay {…};
 
        const unsigned int scoreMax;
        const unsigned int roundMax;
        const unsigned int badScore;
        const unsigned int rrEntries;
        const unsigned int tagMask;
        const bool         delayQueueEnabled;
        const unsigned int delayQueueSize;
        const unsigned int delayTicks;
 
        std::vector<Addr> rrLeft;
        std::vector<Addr> rrRight;
 
        typedef std::pair<int16_t, uint8_t> OffsetListEntry;
        std::vector<OffsetListEntry> offsetsList;
 
        struct DelayQueueEntry
        {
            Addr baseAddr;
            Tick processTick;
 
            DelayQueueEntry(Addr x, Tick t) : baseAddr(x), processTick(t)
            {}
            DelayQueueEntry(Addr x, Tick t) : baseAddr(x), processTick(t) {…}
        };
        struct DelayQueueEntry {…};
 
        std::deque<DelayQueueEntry> delayQueue;
 
        void delayQueueEventWrapper();
        EventFunctionWrapper delayQueueEvent;
 
        bool issuePrefetchRequests;
        Addr bestOffset;
        Addr phaseBestOffset;
        std::vector<OffsetListEntry>::iterator offsetsListIterator;
        unsigned int bestScore;
        unsigned int round;
 
        unsigned int index(Addr addr, unsigned int way) const;
 
        void insertIntoRR(Addr addr, Addr addr_tag, unsigned int way);
 
        void insertIntoDelayQueue(Addr addr);
 
        void resetScores();
 
        Addr tag(Addr addr) const;
 
        bool testRR(Addr) const;
 
        void bestOffsetLearning(Addr);
 
        void notifyFill(const CacheAccessProbeArg &arg) override;
 
    public:
        unsigned int degree;
 
        BOP(const BOPPrefetcherParams &p);
        ~BOP() = default;
 
        void calculatePrefetch(const PrefetchInfo &pfi,
                               std::vector<AddrPriority> &addresses,
                               const CacheAccessor &cache) override;
};
class BOP : public Queued {…};
 
} // namespace prefetch
} // namespace gem5
 
#endif /* __MEM_CACHE_PREFETCH_BOP_HH__ */