2 files changed, 22 insertions, 28 deletions

diff --git a/src/mem/cache/tags/fa_lru.cc b/src/mem/cache/tags/fa_lru.cc
index bcf785e27..60998e254 100644
--- a/src/mem/cache/tags/fa_lru.cc
+++ b/src/mem/cache/tags/fa_lru.cc
@@ -107,16 +107,6 @@ FALRU::regStats()
     cacheTracking.regStats(name());
 }
 
-FALRUBlk *
-FALRU::hashLookup(Addr addr) const
-{
-    tagIterator iter = tagHash.find(addr);
-    if (iter != tagHash.end()) {
-        return (*iter).second;
-    }
-    return nullptr;
-}
-
 void
 FALRU::invalidate(CacheBlk *blk)
 {
@@ -129,7 +119,7 @@ FALRU::invalidate(CacheBlk *blk)
     moveToTail((FALRUBlk*)blk);
 
     // Erase block entry in the hash table
-    tagHash.erase(blk->tag);
+    tagHash.erase(std::make_pair(blk->tag, blk->isSecure()));
 }
 
 CacheBlk*
@@ -145,7 +135,7 @@ FALRU::accessBlock(Addr addr, bool is_secure, Cycles &lat,
     CachesMask mask = 0;
     FALRUBlk* blk = static_cast<FALRUBlk*>(findBlock(addr, is_secure));
 
-    if (blk != nullptr) {
+    if (blk && blk->isValid()) {
         // If a cache hit
         lat = accessLatency;
         // Check if the block to be accessed is available. If not,
@@ -175,15 +165,19 @@ FALRU::accessBlock(Addr addr, bool is_secure, Cycles &lat,
 CacheBlk*
 FALRU::findBlock(Addr addr, bool is_secure) const
 {
+    FALRUBlk* blk = nullptr;
+
     Addr tag = extractTag(addr);
-    FALRUBlk* blk = hashLookup(tag);
+    auto iter = tagHash.find(std::make_pair(tag, is_secure));
+    if (iter != tagHash.end()) {
+        blk = (*iter).second;
+    }
 
     if (blk && blk->isValid()) {
         assert(blk->tag == tag);
         assert(blk->isSecure() == is_secure);
-    } else {
-        blk = nullptr;
     }
+
     return blk;
 }
 
@@ -225,7 +219,7 @@ FALRU::insertBlock(const PacketPtr pkt, CacheBlk *blk)
     moveToHead(falruBlk);
 
     // Insert new block in the hash table
-    tagHash[falruBlk->tag] = falruBlk;
+    tagHash[std::make_pair(blk->tag, blk->isSecure())] = falruBlk;
 }
 
 void
@@ -406,7 +400,7 @@ FALRU::CacheTracking::recordAccess(FALRUBlk *blk)
     }
 
     // Record stats for the actual cache too
-    if (blk) {
+    if (blk && blk->isValid()) {
         hits[numTrackedCaches]++;
     } else {
         misses[numTrackedCaches]++;
diff --git a/src/mem/cache/tags/fa_lru.hh b/src/mem/cache/tags/fa_lru.hh
index 35413c253..876219b00 100644
--- a/src/mem/cache/tags/fa_lru.hh
+++ b/src/mem/cache/tags/fa_lru.hh
@@ -111,19 +111,19 @@ class FALRU : public BaseTags
     FALRUBlk *tail;
 
     /** Hash table type mapping addresses to cache block pointers. */
-    typedef std::unordered_map<Addr, FALRUBlk *, std::hash<Addr> > hash_t;
-    /** Iterator into the address hash table. */
-    typedef hash_t::const_iterator tagIterator;
+    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;
 
     /** The address hash table. */
-    hash_t tagHash;
-
-    /**
-     * Find the cache block for the given address.
-     * @param addr The address to find.
-     * @return The cache block of the address, if any.
-     */
-    FALRUBlk * hashLookup(Addr addr) const;
+    TagHash tagHash;
 
     /**
      * Move a cache block to the MRU position.