access_map_pattern_matching.hh

Go to the documentation of this file.

#ifndef __MEM_CACHE_PREFETCH_ACCESS_MAP_PATTERN_MATCHING_HH__
#define __MEM_CACHE_PREFETCH_ACCESS_MAP_PATTERN_MATCHING_HH__

#include "mem/cache/prefetch/associative_set.hh"
#include "mem/cache/prefetch/queued.hh"
#include "mem/packet.hh"
#include "sim/clocked_object.hh"

struct AccessMapPatternMatchingParams;

class AccessMapPatternMatching : public ClockedObject
{
    const unsigned blkSize;
    const unsigned limitStride;
    const unsigned startDegree;
    const uint64_t hotZoneSize;
    const double highCoverageThreshold;
    const double lowCoverageThreshold;
    const double highAccuracyThreshold;
    const double lowAccuracyThreshold;
    const double highCacheHitThreshold;
    const double lowCacheHitThreshold;
    const Cycles epochCycles;
    const Tick offChipMemoryLatency;

    enum AccessMapState
    {
        AM_INIT,
        AM_PREFETCH,
        AM_ACCESS,
        AM_INVALID
    };

    struct AccessMapEntry : public TaggedEntry
    {
        std::vector<AccessMapState> states;

        AccessMapEntry(size_t num_entries)
          : TaggedEntry(), states(num_entries, AM_INIT)
        {
        }

        void
        invalidate() override
        {
            TaggedEntry::invalidate();
            for (auto &entry : states) {
                entry = AM_INIT;
            }
        }
    };
    AssociativeSet<AccessMapEntry> accessMapTable;

    uint64_t numGoodPrefetches;
    uint64_t numTotalPrefetches;
    uint64_t numRawCacheMisses;
    uint64_t numRawCacheHits;
    unsigned degree;
    unsigned usefulDegree;

    inline bool checkCandidate(std::vector<AccessMapState> const &states,
                        Addr current, int stride) const
    {
        enum AccessMapState tgt   = states[current - stride];
        enum AccessMapState s     = states[current + stride];
        enum AccessMapState s2    = states[current + 2 * stride];
        enum AccessMapState s2_p1 = states[current + 2 * stride + 1];
        return (tgt != AM_INVALID &&
                ((s == AM_ACCESS && s2 == AM_ACCESS) ||
                (s == AM_ACCESS && s2_p1 == AM_ACCESS)));
    }

    AccessMapEntry *getAccessMapEntry(Addr am_addr, bool is_secure);

    void setEntryState(AccessMapEntry &entry, Addr block,
        enum AccessMapState state);

    void processEpochEvent();
    EventFunctionWrapper epochEvent;

  public:
    AccessMapPatternMatching(const AccessMapPatternMatchingParams* p);
    ~AccessMapPatternMatching()
    {}
    void startup() override;
    void calculatePrefetch(const BasePrefetcher::PrefetchInfo &pfi,
        std::vector<QueuedPrefetcher::AddrPriority> &addresses);
};

struct AMPMPrefetcherParams;

class AMPMPrefetcher : public QueuedPrefetcher
{
    AccessMapPatternMatching &ampm;
  public:
    AMPMPrefetcher(const AMPMPrefetcherParams* p);
    ~AMPMPrefetcher()
    {}
    void calculatePrefetch(const PrefetchInfo &pfi,
                           std::vector<AddrPriority> &addresses) override;
};
#endif//__MEM_CACHE_PREFETCH_ACCESS_MAP_PATTERN_MATCHING_HH__