indirect_memory.hh

Go to the documentation of this file.

#ifndef __MEM_CACHE_PREFETCH_INDIRECT_MEMORY_HH__
#define __MEM_CACHE_PREFETCH_INDIRECT_MEMORY_HH__

#include <vector>

#include "base/sat_counter.hh"
#include "mem/cache/prefetch/associative_set.hh"
#include "mem/cache/prefetch/queued.hh"

struct IndirectMemoryPrefetcherParams;

namespace Prefetcher {

class IndirectMemory : public Queued
{
    const unsigned int maxPrefetchDistance;
    const std::vector<int> shiftValues;
    const unsigned int prefetchThreshold;
    const int streamCounterThreshold;
    const int streamingDistance;

    struct PrefetchTableEntry : public TaggedEntry
    {
        /* Stream table fields */

        Addr address;
        bool secure;
        unsigned int streamCounter;

        /* Indirect table fields */

        bool enabled;
        int64_t index;
        Addr baseAddr;
        int shift;
        SatCounter indirectCounter;
        bool increasedIndirectCounter;

        PrefetchTableEntry(unsigned indirect_counter_bits)
            : TaggedEntry(), address(0), secure(false), streamCounter(0),
              enabled(false), index(0), baseAddr(0), shift(0),
              indirectCounter(indirect_counter_bits),
              increasedIndirectCounter(false)
        {}

        void
        invalidate() override
        {
            TaggedEntry::invalidate();
            address = 0;
            secure = false;
            streamCounter = 0;
            enabled = false;
            index = 0;
            baseAddr = 0;
            shift = 0;
            indirectCounter.reset();
            increasedIndirectCounter = false;
        }
    };
    AssociativeSet<PrefetchTableEntry> prefetchTable;

    struct IndirectPatternDetectorEntry : public TaggedEntry
    {
        int64_t idx1;
        int64_t idx2;
        bool secondIndexSet;
        int numMisses;
        std::vector<std::vector<Addr>> baseAddr;

        IndirectPatternDetectorEntry(unsigned int num_addresses,
                                     unsigned int num_shifts)
          : TaggedEntry(), idx1(0), idx2(0), secondIndexSet(false),
            numMisses(0),
            baseAddr(num_addresses, std::vector<Addr>(num_shifts))
        {
        }

        void
        invalidate() override
        {
            TaggedEntry::invalidate();
            idx1 = 0;
            idx2 = 0;
            secondIndexSet = false;
            numMisses = 0;
        }
    };
    AssociativeSet<IndirectPatternDetectorEntry> ipd;

    IndirectPatternDetectorEntry *ipdEntryTrackingMisses;

    const ByteOrder byteOrder;

    void allocateOrUpdateIPDEntry(const PrefetchTableEntry *pt_entry,
                                  int64_t index);
    void trackMissIndex1(Addr miss_addr);

    void trackMissIndex2(Addr miss_addr);

    void checkAccessMatchOnActiveEntries(Addr addr);

  public:
    IndirectMemory(const IndirectMemoryPrefetcherParams *p);
    ~IndirectMemory() = default;

    void calculatePrefetch(const PrefetchInfo &pfi,
                           std::vector<AddrPriority> &addresses) override;
};

} // namespace Prefetcher

#endif//__MEM_CACHE_PREFETCH_INDIRECT_MEMORY_HH__