Change the findBlock(addr, lat) to accessBlock, which I think has better connotations...

diff --git a/src/mem/cache/cache_impl.hh b/src/mem/cache/cache_impl.hh
index 45faa84ce9212524383c0f69b9bb31e4ec229620..af179ff919d95c421ce0a567b57892aeb53eaec6 100644 (file)
--- a/src/mem/cache/cache_impl.hh
+++ b/src/mem/cache/cache_impl.hh
@@ -269,7 +269,7 @@ Cache<TagStore>::access(PacketPtr pkt, BlkType *&blk,
         return false;
     }
 
-    blk = tags->findBlock(pkt->getAddr(), lat);
+    blk = tags->accessBlock(pkt->getAddr(), lat);
 
     if (prefetchAccess) {
         //We are determining prefetches on access stream, call prefetcher

diff --git a/src/mem/cache/tags/fa_lru.cc b/src/mem/cache/tags/fa_lru.cc
index 8a2f4eb1382d41a2ee31a8cafb90c10f628da222..aeb20aa4dd1f1cc8835e6d22e4fbb0acf6f4852f 100644 (file)
--- a/src/mem/cache/tags/fa_lru.cc
+++ b/src/mem/cache/tags/fa_lru.cc
@@ -155,7 +155,7 @@ FALRU::invalidateBlk(FALRU::BlkType *blk)
 }
 
 FALRUBlk*
-FALRU::findBlock(Addr addr, int &lat, int *inCache)
+FALRU::accessBlock(Addr addr, int &lat, int *inCache)
 {
     accesses++;
     int tmp_in_cache = 0;

diff --git a/src/mem/cache/tags/fa_lru.hh b/src/mem/cache/tags/fa_lru.hh
index 43b3b5832033af3612ea9256d074ec4808cad30d..dfb21c08f2addd221a3059f19814e469e3ccd050 100644 (file)
--- a/src/mem/cache/tags/fa_lru.hh
+++ b/src/mem/cache/tags/fa_lru.hh
@@ -171,15 +171,17 @@ public:
     void invalidateBlk(BlkType *blk);
 
     /**
-     * Find the block in the cache and update the replacement data. Returns
-     * the access latency and the in cache flags 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 and inCache flags as a side effect.
      * @param addr The address to look for.
      * @param asid The address space ID.
      * @param lat The latency of the access.
      * @param inCache The FALRUBlk::inCache flags.
      * @return Pointer to the cache block.
      */
-    FALRUBlk* findBlock(Addr addr, int &lat, int *inCache = 0);
+    FALRUBlk* accessBlock(Addr addr, int &lat, int *inCache = 0);
 
     /**
      * Find the block in the cache, do not update the replacement data.

diff --git a/src/mem/cache/tags/iic.cc b/src/mem/cache/tags/iic.cc
index 31fd87df6d133148017e4884a3a0d8254bcd702b..6abc0facffef4a6269b461b9368727914cc59973 100644 (file)
--- a/src/mem/cache/tags/iic.cc
+++ b/src/mem/cache/tags/iic.cc
@@ -221,7 +221,7 @@ IIC::regStats(const string &name)
 
 
 IICTag*
-IIC::findBlock(Addr addr, int &lat)
+IIC::accessBlock(Addr addr, int &lat)
 {
     Addr tag = extractTag(addr);
     unsigned set = hash(addr);

diff --git a/src/mem/cache/tags/iic.hh b/src/mem/cache/tags/iic.hh
index 0d513cf92a67d1446c517360bf1ee581a652aae2..26f9858c4d15b3db6990e01b429f2552cc4d9a15 100644 (file)
--- a/src/mem/cache/tags/iic.hh
+++ b/src/mem/cache/tags/iic.hh
@@ -410,14 +410,16 @@ class IIC : public BaseTags
     void invalidateBlk(BlkType *blk);
 
     /**
-     * Find the block and update the replacement data. This call also 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 and inCache flags as a side effect.
      * @param addr The address to find.
      * @param asid The address space ID.
      * @param lat The access latency.
      * @return A pointer to the block found, if any.
      */
-    IICTag* findBlock(Addr addr, int &lat);
+    IICTag* accessBlock(Addr addr, int &lat);
 
     /**
      * Find the block, do not update the replacement data.

diff --git a/src/mem/cache/tags/lru.cc b/src/mem/cache/tags/lru.cc
index 2a82202e01a4fde079794bec320852c7d17bc50a..f5cf33696dc566bbff4307f04b75fd33c71638c1 100644 (file)
--- a/src/mem/cache/tags/lru.cc
+++ b/src/mem/cache/tags/lru.cc
@@ -151,7 +151,7 @@ LRU::~LRU()
 }
 
 LRUBlk*
-LRU::findBlock(Addr addr, int &lat)
+LRU::accessBlock(Addr addr, int &lat)
 {
     Addr tag = extractTag(addr);
     unsigned set = extractSet(addr);

diff --git a/src/mem/cache/tags/lru.hh b/src/mem/cache/tags/lru.hh
index 39b547f5791192300063daadfa20eaf38200023d..4f4c495f308335021efba41f54bfdf187c0cd833 100644 (file)
--- a/src/mem/cache/tags/lru.hh
+++ b/src/mem/cache/tags/lru.hh
@@ -160,17 +160,19 @@ public:
     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);
+    LRUBlk* accessBlock(Addr addr, int &lat);
 
     /**
      * 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.