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"
 
struct STeMSPrefetcherParams;
 
namespace Prefetcher {
 
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 {
            SatCounter 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;
    AssociativeSet<ActiveGenerationTableEntry> patternSequenceTable;
 
    struct RegionMissOrderBufferEntry {
        Addr srAddress;
        Addr pstAddress;
        unsigned int delta;
    };
 
    CircularQueue<RegionMissOrderBufferEntry> rmob;
 
    unsigned int lastTriggerCounter;
 
    void checkForActiveGenerationsEnd();
    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) override;
};
 
} // namespace Prefetcher
 
#endif//__MEM_CACHE_PREFETCH_SPATIO_TEMPORAL_MEMORY_STREAMING_HH__