sbooe.hh

Go to the documentation of this file.

 
#ifndef __MEM_CACHE_PREFETCH_SBOOE_HH__
#define __MEM_CACHE_PREFETCH_SBOOE_HH__
 
#include <unordered_map>
#include <vector>
 
#include "base/circular_queue.hh"
#include "mem/cache/prefetch/queued.hh"
#include "mem/packet.hh"
 
struct SBOOEPrefetcherParams;
 
namespace Prefetcher {
 
class SBOOE : public Queued
{
    private:
 
        const int sequentialPrefetchers;
 
        const unsigned int scoreThreshold;
 
        std::unordered_map<Addr, Tick> demandAddresses;
 
        CircularQueue<Tick> latencyBuffer;
 
        Tick averageAccessLatency;
 
        Tick latencyBufferSum;
 
        struct SandboxEntry {
            Addr line;
            Tick expectedArrivalTick;
            bool valid;
 
            SandboxEntry()
                : valid(false)
            {}
        };
 
        class Sandbox
        {
          private:
            CircularQueue<SandboxEntry> entries;
 
            unsigned int sandboxScore;
 
            unsigned int lateScore;
 
          public:
            const int stride;
 
            Sandbox(unsigned int max_entries, int _stride)
              : entries(max_entries), sandboxScore(0), lateScore(0),
                stride(_stride)
            {
            }
 
            void access(Addr line, Tick tick);
 
            unsigned int score() const { return (sandboxScore - lateScore); }
        };
 
        std::vector<Sandbox> sandboxes;
 
        const Sandbox* bestSandbox;
 
        unsigned int accesses;
 
        bool access(Addr line);
 
        void notifyFill(const PacketPtr& pkt) override;
 
    public:
        SBOOE(const SBOOEPrefetcherParams *p);
 
        void calculatePrefetch(const PrefetchInfo &pfi,
                               std::vector<AddrPriority> &addresses) override;
};
 
} // namespace Prefetcher
 
#endif // __MEM_CACHE_PREFETCH_SBOOE_HH__