fa_lru.hh

Go to the documentation of this file.

/*
 * Copyright (c) 2012-2013,2016,2018 ARM Limited
 * All rights reserved.
 *
 * The license below extends only to copyright in the software and shall
 * not be construed as granting a license to any other intellectual
 * property including but not limited to intellectual property relating
 * to a hardware implementation of the functionality of the software
 * licensed hereunder.  You may use the software subject to the license
 * terms below provided that you ensure that this notice is replicated
 * unmodified and in its entirety in all distributions of the software,
 * modified or unmodified, in source code or in binary form.
 *
 * Copyright (c) 2003-2005 The Regents of The University of Michigan
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met: redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer;
 * redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution;
 * neither the name of the copyright holders nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef __MEM_CACHE_TAGS_FA_LRU_HH__
#define __MEM_CACHE_TAGS_FA_LRU_HH__
 
#include <cstdint>
#include <functional>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "base/bitfield.hh"
#include "base/intmath.hh"
#include "base/logging.hh"
#include "base/statistics.hh"
#include "base/types.hh"
#include "mem/cache/cache_blk.hh"
#include "mem/cache/tags/base.hh"
#include "mem/packet.hh"
#include "params/FALRU.hh"
 
// Uncomment to enable sanity checks for the FALRU cache and the
// TrackedCaches class
//#define FALRU_DEBUG
 
class BaseCache;
class ReplaceableEntry;
 
// A bitmask of the caches we are keeping track of. Currently the
// lowest bit is the smallest cache we are tracking, as it is
// specified by the corresponding parameter. The rest of the bits are
// for exponentially growing cache sizes.
typedef uint32_t CachesMask;
 
class FALRUBlk : public CacheBlk
{
  public:
    FALRUBlk() : CacheBlk(), prev(nullptr), next(nullptr), inCachesMask(0) {}
 
    FALRUBlk *prev;
    FALRUBlk *next;
 
    CachesMask inCachesMask;
 
    std::string print() const override;
};
 
class FALRU : public BaseTags
{
  public:
    typedef FALRUBlk BlkType;
 
  protected:
    FALRUBlk *blks;
 
    FALRUBlk *head;
    FALRUBlk *tail;
 
    struct PairHash
    {
        template <class T1, class T2>
        std::size_t operator()(const std::pair<T1, T2> &p) const
        {
            return std::hash<T1>()(p.first) ^ std::hash<T2>()(p.second);
        }
    };
    typedef std::pair<Addr, bool> TagHashKey;
    typedef std::unordered_map<TagHashKey, FALRUBlk *, PairHash> TagHash;
 
    TagHash tagHash;
 
    void moveToHead(FALRUBlk *blk);
 
    void moveToTail(FALRUBlk *blk);
 
  public:
    typedef FALRUParams Params;
 
    FALRU(const Params *p);
    ~FALRU();
 
    void tagsInit() override;
 
    void regStats() override;
 
    void invalidate(CacheBlk *blk) override;
 
    CacheBlk* accessBlock(Addr addr, bool is_secure, Cycles &lat,
                          CachesMask *in_cache_mask);
 
    CacheBlk* accessBlock(Addr addr, bool is_secure, Cycles &lat) override;
 
    CacheBlk* findBlock(Addr addr, bool is_secure) const override;
 
    ReplaceableEntry* findBlockBySetAndWay(int set, int way) const override;
 
    CacheBlk* findVictim(Addr addr, const bool is_secure,
                         const std::size_t size,
                         std::vector<CacheBlk*>& evict_blks) override;
 
    void insertBlock(const PacketPtr pkt, CacheBlk *blk) override;
 
    Addr extractTag(Addr addr) const override
    {
        return blkAlign(addr);
    }
 
    Addr regenerateBlkAddr(const CacheBlk* blk) const override
    {
        return blk->tag;
    }
 
    void forEachBlk(std::function<void(CacheBlk &)> visitor) override {
        for (int i = 0; i < numBlocks; i++) {
            visitor(blks[i]);
        }
    }
 
    bool anyBlk(std::function<bool(CacheBlk &)> visitor) override {
        for (int i = 0; i < numBlocks; i++) {
            if (visitor(blks[i])) {
                return true;
            }
        }
        return false;
    }
 
  private:
    class CacheTracking
    {
      public:
        CacheTracking(unsigned min_size, unsigned max_size,
                      unsigned block_size)
            : blkSize(block_size),
              minTrackedSize(min_size),
              numTrackedCaches(max_size > min_size ?
                               floorLog2(max_size) - floorLog2(min_size) : 0),
              inAllCachesMask(mask(numTrackedCaches)),
              boundaries(numTrackedCaches)
        {
            fatal_if(numTrackedCaches > sizeof(CachesMask) * 8,
                     "Not enough bits (%s) in type CachesMask type to keep "
                     "track of %d caches\n", sizeof(CachesMask),
                     numTrackedCaches);
        }
 
        void init(FALRUBlk *head, FALRUBlk *tail);
 
        void moveBlockToHead(FALRUBlk *blk);
 
        void moveBlockToTail(FALRUBlk *blk);
 
        void recordAccess(FALRUBlk *blk);
 
        void check(const FALRUBlk *head, const FALRUBlk *tail) const;
 
        void regStats(std::string name);
 
      private:
        const unsigned blkSize;
        const unsigned minTrackedSize;
        const int numTrackedCaches;
        const CachesMask inAllCachesMask;
        std::vector<FALRUBlk*> boundaries;
 
      protected:
        Stats::Vector hits;
        Stats::Vector misses;
        Stats::Scalar accesses;
 
    };
    CacheTracking cacheTracking;
};
 
#endif // __MEM_CACHE_TAGS_FA_LRU_HH__