spatio_temporal_memory_streaming.hh

Go to the documentation of this file.

 
#ifndef __MEM_CACHE_PREFETCH_SPATIO_TEMPORAL_MEMORY_STREAMING_HH__
#define __MEM_CACHE_PREFETCH_SPATIO_TEMPORAL_MEMORY_STREAMING_HH__
 
#include <vector>
 
#include "base/circular_queue.hh"
#include "base/sat_counter.hh"
#include "mem/cache/prefetch/associative_set.hh"
#include "mem/cache/prefetch/queued.hh"
 
namespace gem5
{
 
struct STeMSPrefetcherParams;
 
namespace prefetch
{
 
class STeMS : public Queued
{
    const size_t spatialRegionSize;
    const size_t spatialRegionSizeBits;
    const unsigned int reconstructionEntries;
 
    struct ActiveGenerationTableEntry : public TaggedEntry
    {
        Addr paddress;
        Addr pc;
        unsigned int seqCounter;
 
        struct SequenceEntry
        {
            SatCounter8 counter;
            unsigned int offset;
            unsigned int delta;
            SequenceEntry() : counter(2), offset(0), delta(0)
            {}
        };
        std::vector<SequenceEntry> sequence;
 
        ActiveGenerationTableEntry(int num_positions)
          : TaggedEntry(), paddress(0), pc(0),
            seqCounter(0), sequence(num_positions)
        {
        }
 
        void
        invalidate() override
        {
            TaggedEntry::invalidate();
            paddress = 0;
            pc = 0;
            seqCounter = 0;
            for (auto &seq_entry : sequence) {
                seq_entry.counter.reset();
                seq_entry.offset = 0;
                seq_entry.delta = 0;
            }
        }
 
        void update(ActiveGenerationTableEntry const &e)
        {
            paddress = e.paddress;
            pc = e.pc;
            seqCounter = e.seqCounter;
            sequence = e.sequence;
        }
 
        void addOffset(unsigned int offset) {
            // Search for the offset in the deltas array, if it exist, update
            // the corresponding counter, if not, add the offset to the array
            for (auto &seq_entry : sequence) {
                if (seq_entry.counter > 0) {
                    if (seq_entry.offset == offset) {
                        seq_entry.counter++;
                    }
                } else {
                    // If the counter is 0 it means that this position is not
                    // being used, and we can allocate the new offset here
                    seq_entry.counter++;
                    seq_entry.offset = offset;
                    seq_entry.delta = seqCounter;
                    break;
                }
            }
            seqCounter = 0;
        }
    };
 
    AssociativeSet<ActiveGenerationTableEntry> activeGenerationTable;
    AssociativeCache<ActiveGenerationTableEntry> patternSequenceTable;
 
    struct RegionMissOrderBufferEntry
    {
        Addr srAddress;
        Addr pstAddress;
        unsigned int delta;
    };
 
    CircularQueue<RegionMissOrderBufferEntry> rmob;
 
    bool addDuplicateEntriesToRMOB;
 
    unsigned int lastTriggerCounter;
 
    void checkForActiveGenerationsEnd(const CacheAccessor &cache);
    void addToRMOB(Addr sr_addr, Addr pst_addr, unsigned int delta);
 
    void reconstructSequence(
        CircularQueue<RegionMissOrderBufferEntry>::iterator rmob_it,
        std::vector<AddrPriority> &addresses);
 
  public:
    STeMS(const STeMSPrefetcherParams &p);
    ~STeMS() = default;
 
    void calculatePrefetch(const PrefetchInfo &pfi,
                           std::vector<AddrPriority> &addresses,
                           const CacheAccessor &cache) override;
};
 
} // namespace prefetch
} // namespace gem5
 
#endif//__MEM_CACHE_PREFETCH_SPATIO_TEMPORAL_MEMORY_STREAMING_HH__