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 "base/cache/associative_cache.hh"
#include "mem/cache/prefetch/queued.hh"
#include "mem/cache/tags/tagged_entry.hh"
#include "mem/packet.hh"
#include "sim/clocked_object.hh"
 
namespace gem5
{
 
struct AccessMapPatternMatchingParams;
struct AMPMPrefetcherParams;
 
namespace prefetch
{
 
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, TagExtractor ext)
          : TaggedEntry(), states(num_entries, AM_INIT)
        {
            registerTagExtractor(ext);
        }
 
        void
        invalidate() override
        {
            TaggedEntry::invalidate();
            for (auto &entry : states) {
                entry = AM_INIT;
            }
        }
    };
    AssociativeCache<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() = default;
 
    void startup() override;
    void calculatePrefetch(const Base::PrefetchInfo &pfi,
        std::vector<Queued::AddrPriority> &addresses,
        const CacheAccessor &cache);
};
 
class AMPM : public Queued
{
    AccessMapPatternMatching &ampm;
  public:
    AMPM(const AMPMPrefetcherParams &p);
    ~AMPM() = default;
 
    void calculatePrefetch(const PrefetchInfo &pfi,
                           std::vector<AddrPriority> &addresses,
                           const CacheAccessor &cache) override;
};
 
} // namespace prefetch
} // namespace gem5
 
#endif//__MEM_CACHE_PREFETCH_ACCESS_MAP_PATTERN_MATCHING_HH__