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__