irregular_stream_buffer.hh

Go to the documentation of this file.

 
#ifndef __MEM_CACHE_PREFETCH_IRREGULAR_STREAM_BUFFER_HH__
#define __MEM_CACHE_PREFETCH_IRREGULAR_STREAM_BUFFER_HH__
 
#include "base/cache/associative_cache.hh"
#include "base/callback.hh"
#include "base/sat_counter.hh"
#include "mem/cache/prefetch/queued.hh"
#include "mem/cache/tags/tagged_entry.hh"
 
namespace gem5
{
 
struct IrregularStreamBufferPrefetcherParams;
 
namespace prefetch
{
 
class IrregularStreamBuffer : public Queued
{
    const size_t chunkSize;
    const unsigned prefetchCandidatesPerEntry;
    const unsigned degree;
 
    struct TrainingUnitEntry : public TaggedEntry
    {
        TrainingUnitEntry(TagExtractor ext)
          : TaggedEntry(), lastAddress(0), lastAddressSecure(false)
        {
            registerTagExtractor(ext);
        }
        Addr lastAddress;
        bool lastAddressSecure;
    };
    AssociativeCache<TrainingUnitEntry> trainingUnit;
 
    struct AddressMapping
    {
        Addr address;
        SatCounter8 counter;
        AddressMapping(unsigned bits) : address(0), counter(bits)
        {}
    };
 
    struct AddressMappingEntry : public TaggedEntry
    {
        std::vector<AddressMapping> mappings;
        AddressMappingEntry(size_t num_mappings, unsigned counter_bits,
                            TagExtractor ext)
          : TaggedEntry(), mappings(num_mappings, counter_bits)
        {
            registerTagExtractor(ext);
        }
 
        void
        invalidate() override
        {
            TaggedEntry::invalidate();
            for (auto &entry : mappings) {
                entry.address = 0;
                entry.counter.reset();
            }
        }
    };
 
    AssociativeCache<AddressMappingEntry> psAddressMappingCache;
    AssociativeCache<AddressMappingEntry> spAddressMappingCache;
    uint64_t structuralAddressCounter;
 
    void addStructuralToPhysicalEntry(Addr structuralAddress, bool is_secure,
                                      Addr physical_address);
 
    AddressMapping& getPSMapping(Addr paddr, bool is_secure);
  public:
    IrregularStreamBuffer(const IrregularStreamBufferPrefetcherParams &p);
    ~IrregularStreamBuffer() = default;
 
    void calculatePrefetch(const PrefetchInfo &pfi,
                           std::vector<AddrPriority> &addresses,
                           const CacheAccessor &cache) override;
};
 
} // namespace prefetch
} // namespace gem5
 
#endif//__MEM_CACHE_PREFETCH_IRREGULAR_STREAM_BUFFER_HH__