* Declaration of a LRU tag store.
*/
-#ifndef __LRU_HH__
-#define __LRU_HH__
+#ifndef __MEM_CACHE_TAGS_LRU_HH__
+#define __MEM_CACHE_TAGS_LRU_HH__
+#include <cassert>
+#include <cstring>
#include <list>
-#include "mem/cache/cache_blk.hh" // base class
-#include "mem/packet.hh" // for inlined functions
-#include <assert.h>
-#include "mem/cache/tags/base_tags.hh"
+#include "mem/cache/blk.hh"
+#include "mem/cache/tags/base.hh"
+#include "mem/packet.hh"
class BaseCache;
+class CacheSet;
-/**
- * LRU cache block.
- */
-class LRUBlk : public CacheBlk {
- public:
- /** Has this block been touched? Used to aid calculation of warmup time. */
- bool isTouched;
-};
-
-/**
- * An associative set of cache blocks.
- */
-class CacheSet
-{
- public:
- /** The associativity of this set. */
- int assoc;
-
- /** Cache blocks in this set, maintained in LRU order 0 = MRU. */
- LRUBlk **blks;
-
- /**
- * Find a block matching the tag in this set.
- * @param asid The address space ID.
- * @param tag The Tag to find.
- * @return Pointer to the block if found.
- */
- LRUBlk* findBlk(Addr tag) const;
-
- /**
- * Move the given block to the head of the list.
- * @param blk The block to move.
- */
- void moveToHead(LRUBlk *blk);
-};
/**
* A LRU cache tag store.
{
public:
/** Typedef the block type used in this tag store. */
- typedef LRUBlk BlkType;
+ typedef CacheBlk BlkType;
/** Typedef for a list of pointers to the local block class. */
- typedef std::list<LRUBlk*> BlkList;
+ typedef std::list<BlkType*> BlkList;
+
protected:
/** The number of sets in the cache. */
- const int numSets;
+ const unsigned numSets;
/** The number of bytes in a block. */
- const int blkSize;
+ const unsigned blkSize;
/** The associativity of the cache. */
- const int assoc;
+ const unsigned assoc;
/** The hit latency. */
- const int hitLatency;
+ const unsigned hitLatency;
/** The cache sets. */
CacheSet *sets;
/** The cache blocks. */
- LRUBlk *blks;
+ BlkType *blks;
/** The data blocks, 1 per cache block. */
uint8_t *dataBlks;
* @param _assoc The associativity of the cache.
* @param _hit_latency The latency in cycles for a hit.
*/
- LRU(int _numSets, int _blkSize, int _assoc, int _hit_latency);
+ LRU(unsigned _numSets, unsigned _blkSize, unsigned _assoc,
+ unsigned _hit_latency);
/**
* Destructor
* Return the block size.
* @return the block size.
*/
- int getBlockSize()
+ unsigned
+ getBlockSize() const
{
return blkSize;
}
* size.
* @return The block size.
*/
- int getSubBlockSize()
+ unsigned
+ getSubBlockSize() const
{
return blkSize;
}
- /**
- * Search for the address in the cache.
- * @param asid The address space ID.
- * @param addr The address to find.
- * @return True if the address is in the cache.
- */
- bool probe(Addr addr) const;
-
/**
* Invalidate the given block.
* @param blk The block to invalidate.
void invalidateBlk(BlkType *blk);
/**
- * Finds the given address in the cache and update replacement data.
- * Returns the access latency as a side effect.
+ * Access block and update replacement data. May not succeed, in which case
+ * NULL pointer is returned. This has all the implications of a cache
+ * access and should only be used as such. Returns the access latency as a side effect.
* @param addr The address to find.
* @param asid The address space ID.
* @param lat The access latency.
* @return Pointer to the cache block if found.
*/
- LRUBlk* findBlock(Addr addr, int &lat);
+ BlkType* accessBlock(Addr addr, int &lat, int context_src);
/**
* Finds the given address in the cache, do not update replacement data.
+ * i.e. This is a no-side-effect find of a block.
* @param addr The address to find.
* @param asid The address space ID.
* @return Pointer to the cache block if found.
*/
- LRUBlk* findBlock(Addr addr) const;
+ BlkType* findBlock(Addr addr) const;
/**
- * Find a replacement block for the address provided.
- * @param pkt The request to a find a replacement candidate for.
+ * Find a block to evict for the address provided.
+ * @param addr The addr to a find a replacement candidate for.
* @param writebacks List for any writebacks to be performed.
- * @param compress_blocks List of blocks to compress, for adaptive comp.
- * @return The block to place the replacement in.
+ * @return The candidate block.
*/
- LRUBlk* findReplacement(PacketPtr &pkt, PacketList &writebacks,
- BlkList &compress_blocks);
+ BlkType* findVictim(Addr addr, PacketList &writebacks);
/**
- * Generate the tag from the given address.
- * @param addr The address to get the tag from.
- * @return The tag of the address.
+ * Insert the new block into the cache. For LRU this means inserting into
+ * the MRU position of the set.
+ * @param addr The address to update.
+ * @param blk The block to update.
*/
- Addr extractTag(Addr addr) const
- {
- return (addr >> tagShift);
- }
+ void insertBlock(Addr addr, BlkType *blk, int context_src);
- /**
+ /**
* Generate the tag from the given address.
* @param addr The address to get the tag from.
- * @param blk Ignored.
* @return The tag of the address.
*/
- Addr extractTag(Addr addr, LRUBlk *blk) const
+ Addr extractTag(Addr addr) const
{
return (addr >> tagShift);
}
{
return hitLatency;
}
-
- /**
- * Read the data out of the internal storage of the given cache block.
- * @param blk The cache block to read.
- * @param data The buffer to read the data into.
- * @return The cache block's data.
- */
- void readData(LRUBlk *blk, uint8_t *data)
- {
- memcpy(data, blk->data, blk->size);
- }
-
/**
- * Write data into the internal storage of the given cache block. Since in
- * LRU does not store data differently this just needs to update the size.
- * @param blk The cache block to write.
- * @param data The data to write.
- * @param size The number of bytes to write.
- * @param writebacks A list for any writebacks to be performed. May be
- * needed when writing to a compressed block.
+ *iterated through all blocks and clear all locks
+ *Needed to clear all lock tracking at once
*/
- void writeData(LRUBlk *blk, uint8_t *data, int size,
- PacketList & writebacks)
- {
- assert(size <= blkSize);
- blk->size = size;
- }
+ virtual void clearLocks();
/**
* Called at end of simulation to complete average block reference stats.
virtual void cleanupRefs();
};
-#endif
+#endif // __MEM_CACHE_TAGS_LRU_HH__
projects / gem5.git / blobdiff