Adding Support: Configurable Cache Replacement Policies (#230)

Building on
[Issue#61](#61),
this merge request proposes to add configurable cache-replacement
policies to Olympia.

---------

Signed-off-by: Isaac David <61389980+orion160@users.noreply.github.com>
Signed-off-by: Govardhan <saigov14@gmail.com>
Co-authored-by: Isaac David <61389980+orion160@users.noreply.github.com>
Co-authored-by: Kathlene Magnus <kathlene.hurt@gmail.com>
Co-authored-by: jeffnye-gh <112903691+jeffnye-gh@users.noreply.github.com>
Co-authored-by: jeff <jeffnye-gh@github.com>

Author: 5 people

.github/actions/build/entrypoint.sh

@@ -48,7 +48,7 @@ if [ $? -ne 0 ]; then
     echo "ERROR: Cmake for olympia failed"
     exit 1
 fi
-make -j$NUM_CORES regress
+make -j$NUM_CORES VERBOSE=1 regress
 BUILD_OLYMPIA=$?
 if [ ${BUILD_OLYMPIA} -ne 0 ]; then
     echo "ERROR: build/regress of olympia FAILED!!!"

.github/workflows/macos-build.yml

@@ -38,7 +38,7 @@ jobs:
         with:
           repository: sparcians/map
           path: map
-          ref: map_v2.0.13
+          ref: map_v2.0.21
 
       # Setup Conda and build environment
       - name: Grab Python v3.8

.github/workflows/ubuntu-build.yml

@@ -38,7 +38,7 @@ jobs:
         with:
           repository: sparcians/map
           path: map
-          ref: map_v2.0.13
+          ref: map_v2.0.21
 
       # Setup Conda and build environment
       - name: Grab Python v3.8

CONTRIBUTORS.md

@@ -12,4 +12,7 @@ The following people from multiple organizations have contributed to this projec
 * (Condor Computing)[https://condorcomputing.com]
   * (Jeff Nye)[https://github.com/jeffnye-gh]
 
+* (InCore Semiconductors)[https://incoresemi.com/]
+  * (Sai Govardhan)[https://github.com/govardhnn]
+
 List is incomplete and more contributor names/organizations to be added. 

core/CacheFuncModel.hpp

@@ -1,4 +1,3 @@
-
 #pragma once
 
 #include "sparta/utils/SpartaAssert.hpp"
@@ -8,6 +7,7 @@
 #include "cache/ReplacementIF.hpp"
 #include "cache/preload/PreloadableIF.hpp"
 #include "cache/preload/PreloadableNode.hpp"
+#include "ReplacementFactory.hpp"
 
 using namespace std::placeholders;
 namespace olympia
@@ -39,7 +39,6 @@ namespace olympia
             BasicCacheItem::operator=(rhs);
             line_size_ = rhs.line_size_;
             valid_ = rhs.valid_;
-
             return *this;
         }
 
@@ -91,28 +90,37 @@ namespace olympia
     }; // class SimpleCacheLine
 
     class CacheFuncModel : public sparta::cache::SimpleCache2<SimpleCacheLine>,
-                      public sparta::TreeNode,
-                      public sparta::cache::PreloadableIF,
-                      public sparta::cache::PreloadDumpableIF
-
+                          public sparta::TreeNode,
+                          public sparta::cache::PreloadableIF,
+                          public sparta::cache::PreloadDumpableIF
     {
     public:
         using Handle = std::shared_ptr<CacheFuncModel>;
+        
+        // Constructor for the cache functional model
+        // @param parent The parent tree node
+        // @param cache_size_kb Size of the cache in KB
+        // @param line_size Cache line size in bytes
+        // @param replacement_policy Name of the replacement policy to use
+        // @param associativity Number of ways in the cache
         CacheFuncModel(sparta::TreeNode* parent,
-                  uint64_t cache_size_kb,
-                  uint64_t line_size,
-                  const sparta::cache::ReplacementIF& rep) :
-            sparta::cache::SimpleCache2<SimpleCacheLine> (cache_size_kb,
-                                                        line_size,
-                                                        line_size,
-                                                        SimpleCacheLine(line_size),
-                                                        rep),
+                      uint64_t cache_size_kb,
+                      uint64_t line_size,
+                      const std::string& replacement_policy,
+                      uint32_t associativity) :
+            sparta::cache::SimpleCache2<SimpleCacheLine>(
+                cache_size_kb,
+                line_size,
+                line_size,
+                SimpleCacheLine(line_size),
+                *ReplacementFactory::selectReplacementPolicy(replacement_policy, associativity)),
             sparta::TreeNode(parent, "l1cache", "Simple L1 DCache"),
             sparta::cache::PreloadableIF(),
             sparta::cache::PreloadDumpableIF(),
             preloadable_(this, std::bind(&CacheFuncModel::preloadPkt_, this, _1),
-                         std::bind(&CacheFuncModel::preloadDump_, this, _1))
+                        std::bind(&CacheFuncModel::preloadDump_, this, _1))
         {}
+
     private:
         /**
          * Implement a preload by just doing a fill to the va in the packet.
@@ -132,7 +140,6 @@ namespace olympia
                 sparta_assert(getLine(va) != nullptr);
             }
             return true;
-
         }
 
         void preloadDump_(sparta::cache::PreloadEmitter& emitter) const override
@@ -160,6 +167,7 @@ namespace olympia
             emitter << sparta::cache::PreloadEmitter::EndSeq;
             emitter << sparta::cache::PreloadEmitter::EndMap;
         }
+
         //! Provide a preloadable node that hangs off and just returns
         //! the preloadPkt call to us.
         sparta::cache::PreloadableNode preloadable_;

core/ReplacementFactory.hpp

@@ -0,0 +1,49 @@
+#pragma once
+
+#include "cache/ReplacementIF.hpp"
+#include "cache/TreePLRUReplacement.hpp"
+#include "cache/LRUReplacement.hpp"
+#include <memory>
+#include <string>
+#include <stdexcept>
+
+namespace olympia
+{
+    /**
+     * @brief Factory class for creating cache replacement policies
+     * 
+     * Creates and returns Sparta replacement policies based on the policy name.
+     * Currently supports:
+     * - "TreePLRU" (Tree-based Pseudo-LRU)
+     * - "LRU" (Least Recently Used)
+     * - "MRU" (Most Recently Used - implemented using LRU's infrastructure)
+     */
+    class ReplacementFactory {
+    public:
+        /**
+         * @brief Create a replacement policy instance
+         * @param policy_name Name of the policy to create ("TreePLRU", "LRU", or "MRU")
+         * @param num_ways Number of ways in the cache set
+         * @return Unique pointer to the created replacement policy
+         * @throws std::invalid_argument if policy name is not recognized
+         */
+        static std::unique_ptr<sparta::cache::ReplacementIF> selectReplacementPolicy(
+            const std::string& policy_name, 
+            uint32_t num_ways) 
+        {
+            if (policy_name == "TreePLRU") {
+                return std::unique_ptr<sparta::cache::ReplacementIF>(
+                    new sparta::cache::TreePLRUReplacement(num_ways));
+            }
+            else if (policy_name == "LRU" || policy_name == "MRU") {
+                // Both LRU and MRU use the same LRUReplacement class
+                // The difference is in how the cache controller uses touchLRU/touchMRU
+                return std::unique_ptr<sparta::cache::ReplacementIF>(
+                    new sparta::cache::LRUReplacement(num_ways));
+            }
+            
+            throw std::invalid_argument("Unknown replacement policy: " + policy_name + 
+                ". Supported policies are: TreePLRU, LRU, MRU");
+        }
+    };
+} // namespace olympia

core/fetch/ICache.cpp

@@ -37,12 +37,9 @@ namespace olympia {
         const uint32_t l1_line_size = p->l1_line_size;
         const uint32_t l1_size_kb = p->l1_size_kb;
         const uint32_t l1_associativity = p->l1_associativity;
-        std::unique_ptr<sparta::cache::ReplacementIF> repl(new sparta::cache::TreePLRUReplacement
-                                                                   (l1_associativity));
-        l1_cache_.reset(new CacheFuncModel(getContainer(), l1_size_kb, l1_line_size, *repl));
+        const std::string& replacement_policy = p->replacement_policy;
+        l1_cache_.reset(new CacheFuncModel(getContainer(), l1_size_kb, l1_line_size, replacement_policy, l1_associativity));
         sparta::StartupEvent(node, CREATE_SPARTA_HANDLER(ICache, sendInitialCredits_));
-
-
     }
 
     void ICache::sendInitialCredits_()

core/fetch/ICache.hpp

@@ -44,6 +44,7 @@ namespace olympia
             PARAMETER(uint32_t, l1_line_size, 64, "IL1 line size (power of 2)")
             PARAMETER(uint32_t, l1_size_kb, 32, "Size of IL1 in KB (power of 2)")
             PARAMETER(uint32_t, l1_associativity, 8, "IL1 associativity (power of 2)")
+            PARAMETER(std::string, replacement_policy, "TreePLRU", "IL1 cache replacement policy")
             PARAMETER(uint32_t, cache_latency, 1, "Assumed latency of the memory system")
             PARAMETER(bool, l1_always_hit, false, "IL1 will always hit")
         };

core/lsu/DCache.cpp

@@ -52,9 +52,7 @@ namespace olympia
         const uint32_t l1_line_size = p->l1_line_size;
         const uint32_t l1_size_kb = p->l1_size_kb;
         const uint32_t l1_associativity = p->l1_associativity;
-        std::unique_ptr<sparta::cache::ReplacementIF> repl(
-            new sparta::cache::TreePLRUReplacement(l1_associativity));
-        l1_cache_.reset(new CacheFuncModel(getContainer(), l1_size_kb, l1_line_size, *repl));
+        l1_cache_.reset(new CacheFuncModel(getContainer(), l1_size_kb, l1_line_size, p->replacement_policy, l1_associativity));
         addr_decoder_ = l1_cache_->getAddrDecoder();
     }
 

core/lsu/DCache.hpp

@@ -29,6 +29,7 @@ namespace olympia
             PARAMETER(uint32_t, l1_associativity, 8, "DL1 associativity (power of 2)")
             PARAMETER(bool, l1_always_hit, false, "DL1 will always hit")
             PARAMETER(uint32_t, mshr_entries, 8, "Number of MSHR Entries")
+            PARAMETER(std::string, replacement_policy, "TreePLRU", "Cache Replacement Policy")
         };
 
         static const char name[];