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/sat_counter.hh"
#include "mem/cache/prefetch/associative_set.hh"
#include "mem/cache/prefetch/queued.hh"

struct STeMSPrefetcherParams;

class STeMSPrefetcher : public QueuedPrefetcher
{
    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;
        bool valid;
    };

    std::vector<RegionMissOrderBufferEntry> rmob;
    unsigned int rmobHead;

    unsigned int lastTriggerCounter;

    void checkForActiveGenerationsEnd();
    void addToRMOB(Addr sr_addr, Addr pst_addr, unsigned int delta);

    void reconstructSequence(unsigned int rmob_idx,
                             std::vector<AddrPriority> &addresses);
  public:
    STeMSPrefetcher(const STeMSPrefetcherParams* p);
    ~STeMSPrefetcher() {}
    void calculatePrefetch(const PrefetchInfo &pfi,
                           std::vector<AddrPriority> &addresses) override;
};

#endif//__MEM_CACHE_PREFETCH_SPATIO_TEMPORAL_MEMORY_STREAMING_HH__