signature_path.hh

Go to the documentation of this file.

 
#ifndef __MEM_CACHE_PREFETCH_SIGNATURE_PATH_HH__
#define __MEM_CACHE_PREFETCH_SIGNATURE_PATH_HH__
 
#include "base/cache/associative_cache.hh"
#include "base/sat_counter.hh"
#include "mem/cache/prefetch/queued.hh"
#include "mem/cache/tags/tagged_entry.hh"
#include "mem/packet.hh"
 
namespace gem5
{
 
struct SignaturePathPrefetcherParams;
 
namespace prefetch
{
 
class SignaturePath : public Queued
{
  protected:
    typedef uint16_t signature_t;
    typedef int16_t stride_t;
 
    const unsigned stridesPerPatternEntry;
    const uint8_t signatureShift;
    const signature_t signatureBits;
    const double prefetchConfidenceThreshold;
    const double lookaheadConfidenceThreshold;
 
    struct SignatureEntry : public TaggedEntry
    {
        signature_t signature;
        stride_t lastBlock;
        SignatureEntry(TagExtractor ext)
          : TaggedEntry(), signature(0), lastBlock(0)
        {
            registerTagExtractor(ext);
        }
        SignatureEntry(TagExtractor ext) {…}
    };
    struct SignatureEntry : public TaggedEntry {…};
    AssociativeCache<SignatureEntry> signatureTable;
 
    struct PatternStrideEntry
    {
        stride_t stride;
        SatCounter8 counter;
        PatternStrideEntry(unsigned bits) : stride(0), counter(bits)
        {}
        PatternStrideEntry(unsigned bits) : stride(0), counter(bits) {…}
    };
    struct PatternStrideEntry {…};
    struct PatternEntry : public TaggedEntry
    {
        std::vector<PatternStrideEntry> strideEntries;
        SatCounter8 counter;
        PatternEntry(size_t num_strides, unsigned counter_bits,
                     TagExtractor ext)
          : TaggedEntry(), strideEntries(num_strides, counter_bits),
            counter(counter_bits)
        {
            registerTagExtractor(ext);
        }
        PatternEntry(size_t num_strides, unsigned counter_bits, {…}
 
        void
        invalidate() override
        {
            TaggedEntry::invalidate();
            for (auto &entry : strideEntries) {
                entry.counter.reset();
                entry.stride = 0;
            }
            counter.reset();
        }
        invalidate() override {…}
 
        PatternStrideEntry *findStride(stride_t stride)
        {
            PatternStrideEntry *found_entry = nullptr;
            for (auto &entry : strideEntries) {
                if (entry.stride == stride) {
                    found_entry = &entry;
                    break;
                }
            }
            return found_entry;
        }
        PatternStrideEntry *findStride(stride_t stride) {…}
 
        PatternStrideEntry &getStrideEntry(stride_t stride);
    };
    struct PatternEntry : public TaggedEntry {…};
 
    AssociativeCache<PatternEntry> patternTable;
 
    inline signature_t updateSignature(signature_t sig, stride_t str) const {
        sig <<= signatureShift;
        sig ^= str;
        sig &= mask(signatureBits);
        return sig;
    }
    inline signature_t updateSignature(signature_t sig, stride_t str) const  {…}
 
    void addPrefetch(Addr ppn, stride_t last_block, stride_t delta,
                          double path_confidence, signature_t signature,
                          bool is_secure,
                          std::vector<AddrPriority> &addresses);
 
    SignatureEntry &getSignatureEntry(Addr ppn, bool is_secure, stride_t block,
            bool &miss, stride_t &stride, double &initial_confidence);
    PatternEntry& getPatternEntry(Addr signature);
 
    void updatePatternTable(Addr signature, stride_t stride);
 
    virtual double calculateLookaheadConfidence(PatternEntry const &sig,
            PatternStrideEntry const &lookahead) const;
 
    virtual double calculatePrefetchConfidence(PatternEntry const &sig,
            PatternStrideEntry const &entry) const;
 
    virtual void increasePatternEntryCounter(PatternEntry &pattern_entry,
            PatternStrideEntry &pstride_entry);
 
    virtual void handleSignatureTableMiss(stride_t current_block,
            signature_t &new_signature, double &new_conf,
            stride_t &new_stride);
 
    virtual void auxiliaryPrefetcher(Addr ppn, stride_t current_block,
            bool is_secure, std::vector<AddrPriority> &addresses);
 
    virtual void handlePageCrossingLookahead(signature_t signature,
            stride_t last_offset, stride_t delta, double path_confidence) {
    }
    virtual void handlePageCrossingLookahead(signature_t signature, {…}
 
  public:
    SignaturePath(const SignaturePathPrefetcherParams &p);
    ~SignaturePath() = default;
 
    void calculatePrefetch(const PrefetchInfo &pfi,
                           std::vector<AddrPriority> &addresses,
                           const CacheAccessor &cache) override;
};
class SignaturePath : public Queued {…};
 
} // namespace prefetch
} // namespace gem5
 
#endif//__MEM_CACHE_PREFETCH_SIGNATURE_PATH_HH__