mem-cache: Create ReplacementPolicy namespace
authorDaniel R. Carvalho <odanrc@yahoo.com.br>
Sat, 28 Dec 2019 22:38:21 +0000 (23:38 +0100)
committerDaniel Carvalho <odanrc@yahoo.com.br>
Mon, 12 Oct 2020 22:04:54 +0000 (22:04 +0000)
Encapsulate the replacement policy classes in their own namespace.

As a side effect these classes have been renamed to drop the RP
suffix in the C++ code.

Change-Id: Ibb65dfb584a1413492fcf11833cf91a859cbff4e
Signed-off-by: Daniel R. Carvalho <odanrc@yahoo.com.br>
Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/35795
Reviewed-by: Nikos Nikoleris <nikos.nikoleris@arm.com>
Maintainer: Nikos Nikoleris <nikos.nikoleris@arm.com>
Tested-by: kokoro <noreply+kokoro@google.com>
30 files changed:
src/mem/cache/prefetch/associative_set.hh
src/mem/cache/prefetch/associative_set_impl.hh
src/mem/cache/prefetch/stride.hh
src/mem/cache/replacement_policies/ReplacementPolicies.py
src/mem/cache/replacement_policies/base.hh
src/mem/cache/replacement_policies/bip_rp.cc
src/mem/cache/replacement_policies/bip_rp.hh
src/mem/cache/replacement_policies/brrip_rp.cc
src/mem/cache/replacement_policies/brrip_rp.hh
src/mem/cache/replacement_policies/fifo_rp.cc
src/mem/cache/replacement_policies/fifo_rp.hh
src/mem/cache/replacement_policies/lfu_rp.cc
src/mem/cache/replacement_policies/lfu_rp.hh
src/mem/cache/replacement_policies/lru_rp.cc
src/mem/cache/replacement_policies/lru_rp.hh
src/mem/cache/replacement_policies/mru_rp.cc
src/mem/cache/replacement_policies/mru_rp.hh
src/mem/cache/replacement_policies/random_rp.cc
src/mem/cache/replacement_policies/random_rp.hh
src/mem/cache/replacement_policies/replaceable_entry.hh
src/mem/cache/replacement_policies/second_chance_rp.cc
src/mem/cache/replacement_policies/second_chance_rp.hh
src/mem/cache/replacement_policies/tree_plru_rp.cc
src/mem/cache/replacement_policies/tree_plru_rp.hh
src/mem/cache/replacement_policies/weighted_lru_rp.cc
src/mem/cache/replacement_policies/weighted_lru_rp.hh
src/mem/cache/tags/base_set_assoc.hh
src/mem/cache/tags/sector_tags.hh
src/mem/ruby/structures/CacheMemory.cc
src/mem/ruby/structures/CacheMemory.hh

index 32bfb837372af699794688806cdd201909916c08..9fc7b98764e2855ce583ed9f12b750cfa9fb551a 100644 (file)
@@ -54,7 +54,7 @@ class AssociativeSet {
     /** Pointer to the indexing policy */
     BaseIndexingPolicy* const indexingPolicy;
     /** Pointer to the replacement policy */
-    BaseReplacementPolicy* const replacementPolicy;
+    ReplacementPolicy::Base* const replacementPolicy;
     /** Vector containing the entries of the container */
     std::vector<Entry> entries;
 
@@ -66,11 +66,10 @@ class AssociativeSet {
      *   of sets can be calculated dividing this balue by the 'assoc' value
      * @param idx_policy indexing policy
      * @param rpl_policy replacement policy
-     * @param initial value of the elements of the set
+     * @param init_val initial value of the elements of the set
      */
     AssociativeSet(int assoc, int num_entries, BaseIndexingPolicy *idx_policy,
-                   BaseReplacementPolicy *rpl_policy, Entry const &init_value =
-                   Entry());
+        ReplacementPolicy::Base *rpl_policy, Entry const &init_val = Entry());
 
     /**
      * Find an entry within the set
index f8316add290b0311bda1661c63891cb3acc84557..4b16dbb3322faa65ddedcb788326f025bdbe4a46 100644 (file)
@@ -34,7 +34,7 @@
 
 template<class Entry>
 AssociativeSet<Entry>::AssociativeSet(int assoc, int num_entries,
-        BaseIndexingPolicy *idx_policy, BaseReplacementPolicy *rpl_policy,
+        BaseIndexingPolicy *idx_policy, ReplacementPolicy::Base *rpl_policy,
         Entry const &init_value)
   : associativity(assoc), numEntries(num_entries), indexingPolicy(idx_policy),
     replacementPolicy(rpl_policy), entries(numEntries, init_value)
index 13215c340a955de7a9263a89b330eb71626a74e2..57179fdb5f808604cf7e980a8edbcce888d614a1 100644 (file)
@@ -61,7 +61,9 @@
 #include "params/StridePrefetcherHashedSetAssociative.hh"
 
 class BaseIndexingPolicy;
-class BaseReplacementPolicy;
+namespace ReplacementPolicy {
+    class Base;
+}
 struct StridePrefetcherParams;
 
 namespace Prefetcher {
@@ -107,11 +109,11 @@ class Stride : public Queued
         const int numEntries;
 
         BaseIndexingPolicy* const indexingPolicy;
-        BaseReplacementPolicy* const replacementPolicy;
+        ReplacementPolicy::Base* const replacementPolicy;
 
         PCTableInfo(int assoc, int num_entries,
             BaseIndexingPolicy* indexing_policy,
-            BaseReplacementPolicy* replacement_policy)
+            ReplacementPolicy::Base* replacement_policy)
           : assoc(assoc), numEntries(num_entries),
             indexingPolicy(indexing_policy),
             replacementPolicy(replacement_policy)
index 53ee589adcd92056d68e13bb9381ce86618052d5..06a49095a4f9c8f37a47ce268c9f2ce6098153ac 100644 (file)
@@ -1,4 +1,4 @@
-# Copyright (c) 2018 Inria
+# Copyright (c) 2018-2020 Inria
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
@@ -31,31 +31,32 @@ from m5.SimObject import SimObject
 class BaseReplacementPolicy(SimObject):
     type = 'BaseReplacementPolicy'
     abstract = True
+    cxx_class = 'ReplacementPolicy::Base'
     cxx_header = "mem/cache/replacement_policies/base.hh"
 
 class FIFORP(BaseReplacementPolicy):
     type = 'FIFORP'
-    cxx_class = 'FIFORP'
+    cxx_class = 'ReplacementPolicy::FIFO'
     cxx_header = "mem/cache/replacement_policies/fifo_rp.hh"
 
 class SecondChanceRP(FIFORP):
     type = 'SecondChanceRP'
-    cxx_class = 'SecondChanceRP'
+    cxx_class = 'ReplacementPolicy::SecondChance'
     cxx_header = "mem/cache/replacement_policies/second_chance_rp.hh"
 
 class LFURP(BaseReplacementPolicy):
     type = 'LFURP'
-    cxx_class = 'LFURP'
+    cxx_class = 'ReplacementPolicy::LFU'
     cxx_header = "mem/cache/replacement_policies/lfu_rp.hh"
 
 class LRURP(BaseReplacementPolicy):
     type = 'LRURP'
-    cxx_class = 'LRURP'
+    cxx_class = 'ReplacementPolicy::LRU'
     cxx_header = "mem/cache/replacement_policies/lru_rp.hh"
 
 class BIPRP(LRURP):
     type = 'BIPRP'
-    cxx_class = 'BIPRP'
+    cxx_class = 'ReplacementPolicy::BIP'
     cxx_header = "mem/cache/replacement_policies/bip_rp.hh"
     btp = Param.Percent(3, "Percentage of blocks to be inserted as MRU")
 
@@ -64,17 +65,17 @@ class LIPRP(BIPRP):
 
 class MRURP(BaseReplacementPolicy):
     type = 'MRURP'
-    cxx_class = 'MRURP'
+    cxx_class = 'ReplacementPolicy::MRU'
     cxx_header = "mem/cache/replacement_policies/mru_rp.hh"
 
 class RandomRP(BaseReplacementPolicy):
     type = 'RandomRP'
-    cxx_class = 'RandomRP'
+    cxx_class = 'ReplacementPolicy::Random'
     cxx_header = "mem/cache/replacement_policies/random_rp.hh"
 
 class BRRIPRP(BaseReplacementPolicy):
     type = 'BRRIPRP'
-    cxx_class = 'BRRIPRP'
+    cxx_class = 'ReplacementPolicy::BRRIP'
     cxx_header = "mem/cache/replacement_policies/brrip_rp.hh"
     num_bits = Param.Int(2, "Number of bits per RRPV")
     hit_priority = Param.Bool(False,
@@ -91,11 +92,11 @@ class NRURP(BRRIPRP):
 
 class TreePLRURP(BaseReplacementPolicy):
     type = 'TreePLRURP'
-    cxx_class = 'TreePLRURP'
+    cxx_class = 'ReplacementPolicy::TreePLRU'
     cxx_header = "mem/cache/replacement_policies/tree_plru_rp.hh"
     num_leaves = Param.Int(Parent.assoc, "Number of leaves in each tree")
 
 class WeightedLRURP(BaseReplacementPolicy):
     type = "WeightedLRURP"
-    cxx_class = "WeightedLRUPolicy"
+    cxx_class = "ReplacementPolicy::WeightedLRU"
     cxx_header = "mem/cache/replacement_policies/weighted_lru_rp.hh"
index 001961f6a85eb498f4f75af27973a905019c6c81..f00ab67d5e0f04ed30dedfde5134ae23c86a0237 100644 (file)
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018 Inria
+ * Copyright (c) 2018-2020 Inria
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  */
 typedef std::vector<ReplaceableEntry*> ReplacementCandidates;
 
+namespace ReplacementPolicy {
+
 /**
  * A common base class of cache replacement policy objects.
  */
-class BaseReplacementPolicy : public SimObject
+class Base : public SimObject
 {
   public:
-    /**
-      * Convenience typedef.
-      */
     typedef BaseReplacementPolicyParams Params;
-
-    /**
-     * Construct and initiliaze this replacement policy.
-     */
-    BaseReplacementPolicy(const Params *p) : SimObject(p) {}
-
-    /**
-     * Destructor.
-     */
-    virtual ~BaseReplacementPolicy() {}
+    Base(const Params *p) : SimObject(p) {}
+    virtual ~Base() = default;
 
     /**
      * Invalidate replacement data to set it as the next probable victim.
@@ -102,4 +93,6 @@ class BaseReplacementPolicy : public SimObject
     virtual std::shared_ptr<ReplacementData> instantiateEntry() = 0;
 };
 
+} // namespace ReplacementPolicy
+
 #endif // __MEM_CACHE_REPLACEMENT_POLICIES_BASE_HH__
index d65d21427f05daf557c6d1312f71496a8d47a66f..0086136d59559d046ad34ad062f4db1fdecc0cef 100644 (file)
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018 Inria
+ * Copyright (c) 2018-2020 Inria
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 #include "params/BIPRP.hh"
 #include "sim/core.hh"
 
-BIPRP::BIPRP(const Params *p)
-    : LRURP(p), btp(p->btp)
+namespace ReplacementPolicy {
+
+BIP::BIP(const Params *p)
+  : LRU(p), btp(p->btp)
 {
 }
 
 void
-BIPRP::reset(const std::shared_ptr<ReplacementData>& replacement_data) const
+BIP::reset(const std::shared_ptr<ReplacementData>& replacement_data) const
 {
     std::shared_ptr<LRUReplData> casted_replacement_data =
         std::static_pointer_cast<LRUReplData>(replacement_data);
@@ -54,8 +56,10 @@ BIPRP::reset(const std::shared_ptr<ReplacementData>& replacement_data) const
     }
 }
 
-BIPRP*
+} // namespace ReplacementPolicy
+
+ReplacementPolicy::BIP*
 BIPRPParams::create()
 {
-    return new BIPRP(this);
+    return new ReplacementPolicy::BIP(this);
 }
index af26ba5a2aedd2f30679f98a074b619c2762b529..9d91f8fc83d723daadec50505165539c75b3dff5 100644 (file)
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018 Inria
+ * Copyright (c) 2018-2020 Inria
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -46,7 +46,9 @@
 
 struct BIPRPParams;
 
-class BIPRP : public LRURP
+namespace ReplacementPolicy {
+
+class BIP : public LRU
 {
   protected:
     /**
@@ -56,18 +58,9 @@ class BIPRP : public LRURP
     const unsigned btp;
 
   public:
-    /** Convenience typedef. */
     typedef BIPRPParams Params;
-
-    /**
-     * Construct and initiliaze this replacement policy.
-     */
-    BIPRP(const Params *p);
-
-    /**
-     * Destructor.
-     */
-    ~BIPRP() {}
+    BIP(const Params *p);
+    ~BIP() = default;
 
     /**
      * Reset replacement data for an entry. Used when an entry is inserted.
@@ -80,4 +73,6 @@ class BIPRP : public LRURP
                                                                      override;
 };
 
+} // namespace ReplacementPolicy
+
 #endif // __MEM_CACHE_REPLACEMENT_POLICIES_BIP_RP_HH__
index 897b19e12941977481c371892b4a46cd4f8cab92..fca1cc190d55c524f8722eea18a6403a11d1a1d0 100644 (file)
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018 Inria
+ * Copyright (c) 2018-2020 Inria
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 #include "base/random.hh"
 #include "params/BRRIPRP.hh"
 
-BRRIPRP::BRRIPRP(const Params *p)
-    : BaseReplacementPolicy(p),
-      numRRPVBits(p->num_bits), hitPriority(p->hit_priority), btp(p->btp)
+namespace ReplacementPolicy {
+
+BRRIP::BRRIP(const Params *p)
+  : Base(p), numRRPVBits(p->num_bits), hitPriority(p->hit_priority),
+    btp(p->btp)
 {
     fatal_if(numRRPVBits <= 0, "There should be at least one bit per RRPV.\n");
 }
 
 void
-BRRIPRP::invalidate(const std::shared_ptr<ReplacementData>& replacement_data)
+BRRIP::invalidate(const std::shared_ptr<ReplacementData>& replacement_data)
 const
 {
     std::shared_ptr<BRRIPReplData> casted_replacement_data =
@@ -54,7 +56,7 @@ const
 }
 
 void
-BRRIPRP::touch(const std::shared_ptr<ReplacementData>& replacement_data) const
+BRRIP::touch(const std::shared_ptr<ReplacementData>& replacement_data) const
 {
     std::shared_ptr<BRRIPReplData> casted_replacement_data =
         std::static_pointer_cast<BRRIPReplData>(replacement_data);
@@ -70,7 +72,7 @@ BRRIPRP::touch(const std::shared_ptr<ReplacementData>& replacement_data) const
 }
 
 void
-BRRIPRP::reset(const std::shared_ptr<ReplacementData>& replacement_data) const
+BRRIP::reset(const std::shared_ptr<ReplacementData>& replacement_data) const
 {
     std::shared_ptr<BRRIPReplData> casted_replacement_data =
         std::static_pointer_cast<BRRIPReplData>(replacement_data);
@@ -88,7 +90,7 @@ BRRIPRP::reset(const std::shared_ptr<ReplacementData>& replacement_data) const
 }
 
 ReplaceableEntry*
-BRRIPRP::getVictim(const ReplacementCandidates& candidates) const
+BRRIP::getVictim(const ReplacementCandidates& candidates) const
 {
     // There must be at least one replacement candidate
     assert(candidates.size() > 0);
@@ -137,13 +139,15 @@ BRRIPRP::getVictim(const ReplacementCandidates& candidates) const
 }
 
 std::shared_ptr<ReplacementData>
-BRRIPRP::instantiateEntry()
+BRRIP::instantiateEntry()
 {
     return std::shared_ptr<ReplacementData>(new BRRIPReplData(numRRPVBits));
 }
 
-BRRIPRP*
+} // namespace ReplacementPolicy
+
+ReplacementPolicy::BRRIP*
 BRRIPRPParams::create()
 {
-    return new BRRIPRP(this);
+    return new ReplacementPolicy::BRRIP(this);
 }
index 6510978ee615f1f4c73bbd982134b7dc14b426ef..c84e9d596abb4757d356f25b5e67d3d1d0903d0e 100644 (file)
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018 Inria
+ * Copyright (c) 2018-2020 Inria
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -57,7 +57,9 @@
 
 struct BRRIPRPParams;
 
-class BRRIPRP : public BaseReplacementPolicy
+namespace ReplacementPolicy {
+
+class BRRIP : public Base
 {
   protected:
     /** BRRIP-specific implementation of replacement data. */
@@ -106,18 +108,9 @@ class BRRIPRP : public BaseReplacementPolicy
     const unsigned btp;
 
   public:
-    /** Convenience typedef. */
     typedef BRRIPRPParams Params;
-
-    /**
-     * Construct and initiliaze this replacement policy.
-     */
-    BRRIPRP(const Params *p);
-
-    /**
-     * Destructor.
-     */
-    ~BRRIPRP() {}
+    BRRIP(const Params *p);
+    ~BRRIP() = default;
 
     /**
      * Invalidate replacement data to set it as the next probable victim.
@@ -162,4 +155,6 @@ class BRRIPRP : public BaseReplacementPolicy
     std::shared_ptr<ReplacementData> instantiateEntry() override;
 };
 
+} // namespace ReplacementPolicy
+
 #endif // __MEM_CACHE_REPLACEMENT_POLICIES_BRRIP_RP_HH__
index 0998a82e64b87a2574857dbd0ff3f71d7c36a45c..2371d76590d641c196c576ec6e1ff544bc2ea6fb 100644 (file)
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018 Inria
+ * Copyright (c) 2018-2020 Inria
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 #include "params/FIFORP.hh"
 #include "sim/core.hh"
 
-FIFORP::FIFORP(const Params *p)
-    : BaseReplacementPolicy(p)
+namespace ReplacementPolicy {
+
+FIFO::FIFO(const Params *p)
+  : Base(p)
 {
 }
 
 void
-FIFORP::invalidate(const std::shared_ptr<ReplacementData>& replacement_data)
+FIFO::invalidate(const std::shared_ptr<ReplacementData>& replacement_data)
 const
 {
     // Reset insertion tick
@@ -49,13 +51,13 @@ const
 }
 
 void
-FIFORP::touch(const std::shared_ptr<ReplacementData>& replacement_data) const
+FIFO::touch(const std::shared_ptr<ReplacementData>& replacement_data) const
 {
     // A touch does not modify the insertion tick
 }
 
 void
-FIFORP::reset(const std::shared_ptr<ReplacementData>& replacement_data) const
+FIFO::reset(const std::shared_ptr<ReplacementData>& replacement_data) const
 {
     // Set insertion tick
     std::static_pointer_cast<FIFOReplData>(
@@ -63,7 +65,7 @@ FIFORP::reset(const std::shared_ptr<ReplacementData>& replacement_data) const
 }
 
 ReplaceableEntry*
-FIFORP::getVictim(const ReplacementCandidates& candidates) const
+FIFO::getVictim(const ReplacementCandidates& candidates) const
 {
     // There must be at least one replacement candidate
     assert(candidates.size() > 0);
@@ -84,13 +86,15 @@ FIFORP::getVictim(const ReplacementCandidates& candidates) const
 }
 
 std::shared_ptr<ReplacementData>
-FIFORP::instantiateEntry()
+FIFO::instantiateEntry()
 {
     return std::shared_ptr<ReplacementData>(new FIFOReplData());
 }
 
-FIFORP*
+} // namespace ReplacementPolicy
+
+ReplacementPolicy::FIFO*
 FIFORPParams::create()
 {
-    return new FIFORP(this);
+    return new ReplacementPolicy::FIFO(this);
 }
index a3478e2fd597ebb12bd7437a7f9dc8ac4e663cfc..03a4aec10085762bfb6c8f302e28150ac1a2a09b 100644 (file)
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018 Inria
+ * Copyright (c) 2018-2020 Inria
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -41,7 +41,9 @@
 
 struct FIFORPParams;
 
-class FIFORP : public BaseReplacementPolicy
+namespace ReplacementPolicy {
+
+class FIFO : public Base
 {
   protected:
     /** FIFO-specific implementation of replacement data. */
@@ -57,18 +59,9 @@ class FIFORP : public BaseReplacementPolicy
     };
 
   public:
-    /** Convenience typedef. */
     typedef FIFORPParams Params;
-
-    /**
-     * Construct and initiliaze this replacement policy.
-     */
-    FIFORP(const Params *p);
-
-    /**
-     * Destructor.
-     */
-    ~FIFORP() {}
+    FIFO(const Params *p);
+    ~FIFO() = default;
 
     /**
      * Invalidate replacement data to set it as the next probable victim.
@@ -114,4 +107,6 @@ class FIFORP : public BaseReplacementPolicy
     std::shared_ptr<ReplacementData> instantiateEntry() override;
 };
 
+} // namespace ReplacementPolicy
+
 #endif // __MEM_CACHE_REPLACEMENT_POLICIES_FIFO_RP_HH__
index 734994e1b0812c5d71a4f004d71cfdc1040befce..0f3b242492aa9a2efa24506ecfecce9aa6ae2fdb 100644 (file)
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018 Inria
+ * Copyright (c) 2018-2020 Inria
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 
 #include "params/LFURP.hh"
 
-LFURP::LFURP(const Params *p)
-    : BaseReplacementPolicy(p)
+namespace ReplacementPolicy {
+
+LFU::LFU(const Params *p)
+  : Base(p)
 {
 }
 
 void
-LFURP::invalidate(const std::shared_ptr<ReplacementData>& replacement_data)
+LFU::invalidate(const std::shared_ptr<ReplacementData>& replacement_data)
 const
 {
     // Reset reference count
@@ -47,21 +49,21 @@ const
 }
 
 void
-LFURP::touch(const std::shared_ptr<ReplacementData>& replacement_data) const
+LFU::touch(const std::shared_ptr<ReplacementData>& replacement_data) const
 {
     // Update reference count
     std::static_pointer_cast<LFUReplData>(replacement_data)->refCount++;
 }
 
 void
-LFURP::reset(const std::shared_ptr<ReplacementData>& replacement_data) const
+LFU::reset(const std::shared_ptr<ReplacementData>& replacement_data) const
 {
     // Reset reference count
     std::static_pointer_cast<LFUReplData>(replacement_data)->refCount = 1;
 }
 
 ReplaceableEntry*
-LFURP::getVictim(const ReplacementCandidates& candidates) const
+LFU::getVictim(const ReplacementCandidates& candidates) const
 {
     // There must be at least one replacement candidate
     assert(candidates.size() > 0);
@@ -82,13 +84,15 @@ LFURP::getVictim(const ReplacementCandidates& candidates) const
 }
 
 std::shared_ptr<ReplacementData>
-LFURP::instantiateEntry()
+LFU::instantiateEntry()
 {
     return std::shared_ptr<ReplacementData>(new LFUReplData());
 }
 
-LFURP*
+} // namespace ReplacementPolicy
+
+ReplacementPolicy::LFU*
 LFURPParams::create()
 {
-    return new LFURP(this);
+    return new ReplacementPolicy::LFU(this);
 }
index dee13306583e9bc938fd18230193a70f24d2e930..36640e7de702bcea9ffab52eacbb18cb240442ee 100644 (file)
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018 Inria
+ * Copyright (c) 2018-2020 Inria
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -41,7 +41,9 @@
 
 struct LFURPParams;
 
-class LFURP : public BaseReplacementPolicy
+namespace ReplacementPolicy {
+
+class LFU : public Base
 {
   protected:
     /** LFU-specific implementation of replacement data. */
@@ -57,18 +59,9 @@ class LFURP : public BaseReplacementPolicy
     };
 
   public:
-    /** Convenience typedef. */
     typedef LFURPParams Params;
-
-    /**
-     * Construct and initiliaze this replacement policy.
-     */
-    LFURP(const Params *p);
-
-    /**
-     * Destructor.
-     */
-    ~LFURP() {}
+    LFU(const Params *p);
+    ~LFU() = default;
 
     /**
      * Invalidate replacement data to set it as the next probable victim.
@@ -114,4 +107,6 @@ class LFURP : public BaseReplacementPolicy
     std::shared_ptr<ReplacementData> instantiateEntry() override;
 };
 
+} // namespace ReplacementPolicy
+
 #endif // __MEM_CACHE_REPLACEMENT_POLICIES_LFU_RP_HH__
index f7d1f1d28daa7babfcb2ca5fd222c8908999e4b2..9775c154cc85ad644945f92fe1fe34de5ad0a3c2 100644 (file)
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018 Inria
+ * Copyright (c) 2018-2020 Inria
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 #include "params/LRURP.hh"
 #include "sim/core.hh"
 
-LRURP::LRURP(const Params *p)
-    : BaseReplacementPolicy(p)
+namespace ReplacementPolicy {
+
+LRU::LRU(const Params *p)
+  : Base(p)
 {
 }
 
 void
-LRURP::invalidate(const std::shared_ptr<ReplacementData>& replacement_data)
+LRU::invalidate(const std::shared_ptr<ReplacementData>& replacement_data)
 const
 {
     // Reset last touch timestamp
@@ -49,7 +51,7 @@ const
 }
 
 void
-LRURP::touch(const std::shared_ptr<ReplacementData>& replacement_data) const
+LRU::touch(const std::shared_ptr<ReplacementData>& replacement_data) const
 {
     // Update last touch timestamp
     std::static_pointer_cast<LRUReplData>(
@@ -57,7 +59,7 @@ LRURP::touch(const std::shared_ptr<ReplacementData>& replacement_data) const
 }
 
 void
-LRURP::reset(const std::shared_ptr<ReplacementData>& replacement_data) const
+LRU::reset(const std::shared_ptr<ReplacementData>& replacement_data) const
 {
     // Set last touch timestamp
     std::static_pointer_cast<LRUReplData>(
@@ -65,7 +67,7 @@ LRURP::reset(const std::shared_ptr<ReplacementData>& replacement_data) const
 }
 
 ReplaceableEntry*
-LRURP::getVictim(const ReplacementCandidates& candidates) const
+LRU::getVictim(const ReplacementCandidates& candidates) const
 {
     // There must be at least one replacement candidate
     assert(candidates.size() > 0);
@@ -86,13 +88,15 @@ LRURP::getVictim(const ReplacementCandidates& candidates) const
 }
 
 std::shared_ptr<ReplacementData>
-LRURP::instantiateEntry()
+LRU::instantiateEntry()
 {
     return std::shared_ptr<ReplacementData>(new LRUReplData());
 }
 
-LRURP*
+} // namespace ReplacementPolicy
+
+ReplacementPolicy::LRU*
 LRURPParams::create()
 {
-    return new LRURP(this);
+    return new ReplacementPolicy::LRU(this);
 }
index 284178b67a3325194f90f78fd37da042f3b27e5d..bb1b314c54870718ef5127b2d14200079a1b6dac 100644 (file)
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018 Inria
+ * Copyright (c) 2018-2020 Inria
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -39,7 +39,9 @@
 
 struct LRURPParams;
 
-class LRURP : public BaseReplacementPolicy
+namespace ReplacementPolicy {
+
+class LRU : public Base
 {
   protected:
     /** LRU-specific implementation of replacement data. */
@@ -55,18 +57,9 @@ class LRURP : public BaseReplacementPolicy
     };
 
   public:
-    /** Convenience typedef. */
     typedef LRURPParams Params;
-
-    /**
-     * Construct and initiliaze this replacement policy.
-     */
-    LRURP(const Params *p);
-
-    /**
-     * Destructor.
-     */
-    ~LRURP() {}
+    LRU(const Params *p);
+    ~LRU() = default;
 
     /**
      * Invalidate replacement data to set it as the next probable victim.
@@ -112,4 +105,6 @@ class LRURP : public BaseReplacementPolicy
     std::shared_ptr<ReplacementData> instantiateEntry() override;
 };
 
+} // namespace ReplacementPolicy
+
 #endif // __MEM_CACHE_REPLACEMENT_POLICIES_LRU_RP_HH__
index 892f9a000dc0f9335502314372ac4489efe91f94..04a7770738dccc890376f2a92bf78e59bd0f254b 100644 (file)
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018 Inria
+ * Copyright (c) 2018-2020 Inria
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 #include "params/MRURP.hh"
 #include "sim/core.hh"
 
-MRURP::MRURP(const Params *p)
-    : BaseReplacementPolicy(p)
+namespace ReplacementPolicy {
+
+MRU::MRU(const Params *p)
+  : Base(p)
 {
 }
 
 void
-MRURP::invalidate(const std::shared_ptr<ReplacementData>& replacement_data)
+MRU::invalidate(const std::shared_ptr<ReplacementData>& replacement_data)
 const
 {
     // Reset last touch timestamp
@@ -49,7 +51,7 @@ const
 }
 
 void
-MRURP::touch(const std::shared_ptr<ReplacementData>& replacement_data) const
+MRU::touch(const std::shared_ptr<ReplacementData>& replacement_data) const
 {
     // Update last touch timestamp
     std::static_pointer_cast<MRUReplData>(
@@ -57,7 +59,7 @@ MRURP::touch(const std::shared_ptr<ReplacementData>& replacement_data) const
 }
 
 void
-MRURP::reset(const std::shared_ptr<ReplacementData>& replacement_data) const
+MRU::reset(const std::shared_ptr<ReplacementData>& replacement_data) const
 {
     // Set last touch timestamp
     std::static_pointer_cast<MRUReplData>(
@@ -65,7 +67,7 @@ MRURP::reset(const std::shared_ptr<ReplacementData>& replacement_data) const
 }
 
 ReplaceableEntry*
-MRURP::getVictim(const ReplacementCandidates& candidates) const
+MRU::getVictim(const ReplacementCandidates& candidates) const
 {
     // There must be at least one replacement candidate
     assert(candidates.size() > 0);
@@ -91,13 +93,15 @@ MRURP::getVictim(const ReplacementCandidates& candidates) const
 }
 
 std::shared_ptr<ReplacementData>
-MRURP::instantiateEntry()
+MRU::instantiateEntry()
 {
     return std::shared_ptr<ReplacementData>(new MRUReplData());
 }
 
-MRURP*
+} // namespace ReplacementPolicy
+
+ReplacementPolicy::MRU*
 MRURPParams::create()
 {
-    return new MRURP(this);
+    return new ReplacementPolicy::MRU(this);
 }
index 7ca6e6607f9c04686e1fcdbeff976cb7c723abb2..2561556eb13d2f28bfba30f17b09d35f434a803a 100644 (file)
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018 Inria
+ * Copyright (c) 2018-2020 Inria
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -41,7 +41,9 @@
 
 struct MRURPParams;
 
-class MRURP : public BaseReplacementPolicy
+namespace ReplacementPolicy {
+
+class MRU : public Base
 {
   protected:
     /** MRU-specific implementation of replacement data. */
@@ -57,18 +59,9 @@ class MRURP : public BaseReplacementPolicy
     };
 
   public:
-    /** Convenience typedef. */
     typedef MRURPParams Params;
-
-    /**
-     * Construct and initiliaze this replacement policy.
-     */
-    MRURP(const Params *p);
-
-    /**
-     * Destructor.
-     */
-    ~MRURP() {}
+    MRU(const Params *p);
+    ~MRU() = default;
 
     /**
      * Invalidate replacement data to set it as the next probable victim.
@@ -114,4 +107,6 @@ class MRURP : public BaseReplacementPolicy
     std::shared_ptr<ReplacementData> instantiateEntry() override;
 };
 
+} // namespace ReplacementPolicy
+
 #endif // __MEM_CACHE_REPLACEMENT_POLICIES_MRU_RP_HH__
index 31910937ca31b5e23a3075140e3c827b22e38720..314e861d4b6f7e12b9cbba78fb921e667d481d34 100644 (file)
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018 Inria
+ * Copyright (c) 2018-2020 Inria
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 #include "base/random.hh"
 #include "params/RandomRP.hh"
 
-RandomRP::RandomRP(const Params *p)
-    : BaseReplacementPolicy(p)
+namespace ReplacementPolicy {
+
+Random::Random(const Params *p)
+  : Base(p)
 {
 }
 
 void
-RandomRP::invalidate(const std::shared_ptr<ReplacementData>& replacement_data)
+Random::invalidate(const std::shared_ptr<ReplacementData>& replacement_data)
 const
 {
     // Unprioritize replacement data victimization
@@ -49,12 +51,12 @@ const
 }
 
 void
-RandomRP::touch(const std::shared_ptr<ReplacementData>& replacement_data) const
+Random::touch(const std::shared_ptr<ReplacementData>& replacement_data) const
 {
 }
 
 void
-RandomRP::reset(const std::shared_ptr<ReplacementData>& replacement_data) const
+Random::reset(const std::shared_ptr<ReplacementData>& replacement_data) const
 {
     // Unprioritize replacement data victimization
     std::static_pointer_cast<RandomReplData>(
@@ -62,7 +64,7 @@ RandomRP::reset(const std::shared_ptr<ReplacementData>& replacement_data) const
 }
 
 ReplaceableEntry*
-RandomRP::getVictim(const ReplacementCandidates& candidates) const
+Random::getVictim(const ReplacementCandidates& candidates) const
 {
     // There must be at least one replacement candidate
     assert(candidates.size() > 0);
@@ -85,13 +87,15 @@ RandomRP::getVictim(const ReplacementCandidates& candidates) const
 }
 
 std::shared_ptr<ReplacementData>
-RandomRP::instantiateEntry()
+Random::instantiateEntry()
 {
     return std::shared_ptr<ReplacementData>(new RandomReplData());
 }
 
-RandomRP*
+} // namespace ReplacementPolicy
+
+ReplacementPolicy::Random*
 RandomRPParams::create()
 {
-    return new RandomRP(this);
+    return new ReplacementPolicy::Random(this);
 }
index c2a6d251802cace4e35e69b91fba3d04d17e1de1..a499211603411a3b1af10b2f4cd7b5a6c73d5057 100644 (file)
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018 Inria
+ * Copyright (c) 2018-2020 Inria
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 
 struct RandomRPParams;
 
-class RandomRP : public BaseReplacementPolicy
+namespace ReplacementPolicy {
+
+class Random : public Base
 {
   protected:
-    /** MRU-specific implementation of replacement data. */
+    /** Random-specific implementation of replacement data. */
     struct RandomReplData : ReplacementData
     {
         /**
@@ -58,18 +60,9 @@ class RandomRP : public BaseReplacementPolicy
     };
 
   public:
-    /** Convenience typedef. */
     typedef RandomRPParams Params;
-
-    /**
-     * Construct and initiliaze this replacement policy.
-     */
-    RandomRP(const Params *p);
-
-    /**
-     * Destructor.
-     */
-    ~RandomRP() {}
+    Random(const Params *p);
+    ~Random() = default;
 
     /**
      * Invalidate replacement data to set it as the next probable victim.
@@ -115,4 +108,6 @@ class RandomRP : public BaseReplacementPolicy
     std::shared_ptr<ReplacementData> instantiateEntry() override;
 };
 
+} // namespace ReplacementPolicy
+
 #endif // __MEM_CACHE_REPLACEMENT_POLICIES_RANDOM_RP_HH__
index 505cc1986b9b3663e42f8ad5a8cc045f06a71f63..85de6d1853bd7004b3a0303e30481140956b538e 100644 (file)
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018 Inria
+ * Copyright (c) 2018-2020 Inria
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 
 #include "base/cprintf.hh"
 
+namespace ReplacementPolicy {
+
 /**
  * The replacement data needed by replacement policies. Each replacement policy
  * should have its own implementation of replacement data.
  */
 struct ReplacementData {};
 
+} // namespace ReplacementPolicy
+
 /**
  * A replaceable entry is a basic entry in a 2d table-like structure that needs
  * to have replacement functionality. This entry is located in a specific row
@@ -71,7 +75,7 @@ class ReplaceableEntry
      * Replacement data associated to this entry.
      * It must be instantiated by the replacement policy before being used.
      */
-    std::shared_ptr<ReplacementData> replacementData;
+    std::shared_ptr<ReplacementPolicy::ReplacementData> replacementData;
 
     /**
      * Set both the set and way. Should be called only once.
index 14402293a840d4c26e7b15e72d932ef6594e432f..ddc68d76eec809d89a7a4bab4f3ac6a6a0661dfb 100644 (file)
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018 Inria
+ * Copyright (c) 2018-2020 Inria
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 
 #include "params/SecondChanceRP.hh"
 
-SecondChanceRP::SecondChanceRP(const Params *p)
-    : FIFORP(p)
+namespace ReplacementPolicy {
+
+SecondChance::SecondChance(const Params *p)
+  : FIFO(p)
 {
 }
 
 void
-SecondChanceRP::useSecondChance(
+SecondChance::useSecondChance(
     const std::shared_ptr<SecondChanceReplData>& replacement_data) const
 {
     // Reset FIFO data
-    FIFORP::reset(replacement_data);
+    FIFO::reset(replacement_data);
 
     // Use second chance
     replacement_data->hasSecondChance = false;
 }
 
 void
-SecondChanceRP::invalidate(
+SecondChance::invalidate(
     const std::shared_ptr<ReplacementData>& replacement_data) const
 {
-    FIFORP::invalidate(replacement_data);
+    FIFO::invalidate(replacement_data);
 
     // Do not give a second chance to invalid entries
     std::static_pointer_cast<SecondChanceReplData>(
@@ -60,10 +62,10 @@ SecondChanceRP::invalidate(
 }
 
 void
-SecondChanceRP::touch(const std::shared_ptr<ReplacementData>&
-                                                    replacement_data) const
+SecondChance::touch(
+    const std::shared_ptr<ReplacementData>& replacement_data) const
 {
-    FIFORP::touch(replacement_data);
+    FIFO::touch(replacement_data);
 
     // Whenever an entry is touched, it is given a second chance
     std::static_pointer_cast<SecondChanceReplData>(
@@ -71,10 +73,10 @@ SecondChanceRP::touch(const std::shared_ptr<ReplacementData>&
 }
 
 void
-SecondChanceRP::reset(const std::shared_ptr<ReplacementData>&
-                                                    replacement_data) const
+SecondChance::reset(
+    const std::shared_ptr<ReplacementData>& replacement_data) const
 {
-    FIFORP::reset(replacement_data);
+    FIFO::reset(replacement_data);
 
     // Entries are inserted with a second chance
     std::static_pointer_cast<SecondChanceReplData>(
@@ -82,7 +84,7 @@ SecondChanceRP::reset(const std::shared_ptr<ReplacementData>&
 }
 
 ReplaceableEntry*
-SecondChanceRP::getVictim(const ReplacementCandidates& candidates) const
+SecondChance::getVictim(const ReplacementCandidates& candidates) const
 {
     // There must be at least one replacement candidate
     assert(candidates.size() > 0);
@@ -106,7 +108,7 @@ SecondChanceRP::getVictim(const ReplacementCandidates& candidates) const
     bool search_victim = true;
     while (search_victim) {
         // Do a FIFO victim search
-        victim = FIFORP::getVictim(candidates);
+        victim = FIFO::getVictim(candidates);
 
         // Cast victim's replacement data for code readability
         std::shared_ptr<SecondChanceReplData> victim_replacement_data =
@@ -126,13 +128,15 @@ SecondChanceRP::getVictim(const ReplacementCandidates& candidates) const
 }
 
 std::shared_ptr<ReplacementData>
-SecondChanceRP::instantiateEntry()
+SecondChance::instantiateEntry()
 {
     return std::shared_ptr<ReplacementData>(new SecondChanceReplData());
 }
 
-SecondChanceRP*
+} // namespace ReplacementPolicy
+
+ReplacementPolicy::SecondChance*
 SecondChanceRPParams::create()
 {
-    return new SecondChanceRP(this);
+    return new ReplacementPolicy::SecondChance(this);
 }
index 83815d720dd09c2b90cc983afc3c0a990e38c598..d13ea7bc770d8b13127348970c90132db8d41853 100644 (file)
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018 Inria
+ * Copyright (c) 2018-2020 Inria
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -43,7 +43,9 @@
 
 struct SecondChanceRPParams;
 
-class SecondChanceRP : public FIFORP
+namespace ReplacementPolicy {
+
+class SecondChance : public FIFO
 {
   protected:
     /** Second-Chance-specific implementation of replacement data. */
@@ -52,7 +54,7 @@ class SecondChanceRP : public FIFORP
         /**
          * This is different from isTouched because isTouched accounts only
          * for insertion, while this bit is reset every new re-insertion.
-         * @sa SecondChanceRP.
+         * @sa SecondChance.
          */
         bool hasSecondChance;
 
@@ -71,18 +73,9 @@ class SecondChanceRP : public FIFORP
         const std::shared_ptr<SecondChanceReplData>& replacement_data) const;
 
   public:
-    /** Convenience typedef. */
     typedef SecondChanceRPParams Params;
-
-    /**
-     * Construct and initiliaze this replacement policy.
-     */
-    SecondChanceRP(const Params *p);
-
-    /**
-     * Destructor.
-     */
-    ~SecondChanceRP() {}
+    SecondChance(const Params *p);
+    ~SecondChance() = default;
 
     /**
      * Invalidate replacement data to set it as the next probable victim.
@@ -130,4 +123,6 @@ class SecondChanceRP : public FIFORP
     std::shared_ptr<ReplacementData> instantiateEntry() override;
 };
 
+} // namespace ReplacementPolicy
+
 #endif // __MEM_CACHE_REPLACEMENT_POLICIES_SECOND_CHANCE_RP_HH__
index eb2d0392b0d9373c12efa485e67273738faec1ad..eaf5cb488120593dba116e21235afd5871b5c68b 100644 (file)
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018 Inria
+ * Copyright (c) 2018-2020 Inria
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -40,6 +40,8 @@
 #include "base/logging.hh"
 #include "params/TreePLRURP.hh"
 
+namespace ReplacementPolicy {
+
 /**
  * Get the index of the parent of the given indexed subtree.
  *
@@ -89,22 +91,21 @@ isRightSubtree(const uint64_t index)
     return index%2 == 0;
 }
 
-TreePLRURP::TreePLRUReplData::TreePLRUReplData(
+TreePLRU::TreePLRUReplData::TreePLRUReplData(
     const uint64_t index, std::shared_ptr<PLRUTree> tree)
-    : index(index), tree(tree)
+  : index(index), tree(tree)
 {
 }
 
-TreePLRURP::TreePLRURP(const Params *p)
-    : BaseReplacementPolicy(p), numLeaves(p->num_leaves), count(0),
-      treeInstance(nullptr)
+TreePLRU::TreePLRU(const Params *p)
+  : Base(p), numLeaves(p->num_leaves), count(0), treeInstance(nullptr)
 {
     fatal_if(!isPowerOf2(numLeaves),
              "Number of leaves must be non-zero and a power of 2");
 }
 
 void
-TreePLRURP::invalidate(
+TreePLRU::invalidate(
     const std::shared_ptr<ReplacementData>& replacement_data) const
 {
     // Cast replacement data
@@ -130,7 +131,7 @@ TreePLRURP::invalidate(
 }
 
 void
-TreePLRURP::touch(const std::shared_ptr<ReplacementData>& replacement_data)
+TreePLRU::touch(const std::shared_ptr<ReplacementData>& replacement_data)
 const
 {
     // Cast replacement data
@@ -156,7 +157,7 @@ const
 }
 
 void
-TreePLRURP::reset(const std::shared_ptr<ReplacementData>& replacement_data)
+TreePLRU::reset(const std::shared_ptr<ReplacementData>& replacement_data)
 const
 {
     // A reset has the same functionality of a touch
@@ -164,7 +165,7 @@ const
 }
 
 ReplaceableEntry*
-TreePLRURP::getVictim(const ReplacementCandidates& candidates) const
+TreePLRU::getVictim(const ReplacementCandidates& candidates) const
 {
     // There must be at least one replacement candidate
     assert(candidates.size() > 0);
@@ -192,7 +193,7 @@ TreePLRURP::getVictim(const ReplacementCandidates& candidates) const
 }
 
 std::shared_ptr<ReplacementData>
-TreePLRURP::instantiateEntry()
+TreePLRU::instantiateEntry()
 {
     // Generate a tree instance every numLeaves created
     if (count % numLeaves == 0) {
@@ -210,8 +211,10 @@ TreePLRURP::instantiateEntry()
     return std::shared_ptr<ReplacementData>(treePLRUReplData);
 }
 
-TreePLRURP*
+} // namespace ReplacementPolicy
+
+ReplacementPolicy::TreePLRU*
 TreePLRURPParams::create()
 {
-    return new TreePLRURP(this);
+    return new ReplacementPolicy::TreePLRU(this);
 }
index 2fcd632df5c6723314eeb0fa479b2c03770608cb..709f0a202b39a538da024c3a3c23d62e880bdc77 100644 (file)
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018 Inria
+ * Copyright (c) 2018-2020 Inria
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -77,7 +77,9 @@
 
 struct TreePLRURPParams;
 
-class TreePLRURP : public BaseReplacementPolicy
+namespace ReplacementPolicy {
+
+class TreePLRU : public Base
 {
   private:
     /**
@@ -149,18 +151,9 @@ class TreePLRURP : public BaseReplacementPolicy
     };
 
   public:
-    /** Convenience typedef. */
     typedef TreePLRURPParams Params;
-
-    /**
-     * Construct and initiliaze this replacement policy.
-     */
-    TreePLRURP(const Params *p);
-
-    /**
-     * Destructor.
-     */
-    ~TreePLRURP() {}
+    TreePLRU(const Params *p);
+    ~TreePLRU() = default;
 
     /**
      * Invalidate replacement data to set it as the next probable victim.
@@ -212,4 +205,6 @@ class TreePLRURP : public BaseReplacementPolicy
     std::shared_ptr<ReplacementData> instantiateEntry() override;
 };
 
+} // namespace ReplacementPolicy
+
 #endif // __MEM_CACHE_REPLACEMENT_POLICIES_TREE_PLRU_RP_HH__
index eeaf2a62d5bef78fc76e9334e4f3bd91f44a9058..3044ce70140bf0c0988b57ea01f50d9af9102c5b 100644 (file)
 #include "params/WeightedLRURP.hh"
 #include "sim/core.hh"
 
-WeightedLRUPolicy::WeightedLRUPolicy(const Params* p)
-    : BaseReplacementPolicy(p)
-{
-}
+namespace ReplacementPolicy {
 
-WeightedLRUPolicy *
-WeightedLRURPParams::create()
+WeightedLRU::WeightedLRU(const Params* p)
+  : Base(p)
 {
-    return new WeightedLRUPolicy(this);
 }
 
 void
-WeightedLRUPolicy::touch(const std::shared_ptr<ReplacementData>&
+WeightedLRU::touch(const std::shared_ptr<ReplacementData>&
                                                   replacement_data) const
 {
     std::static_pointer_cast<WeightedLRUReplData>(replacement_data)->
@@ -58,7 +54,7 @@ WeightedLRUPolicy::touch(const std::shared_ptr<ReplacementData>&
 }
 
 void
-WeightedLRUPolicy::touch(const std::shared_ptr<ReplacementData>&
+WeightedLRU::touch(const std::shared_ptr<ReplacementData>&
                         replacement_data, int occupancy) const
 {
     std::static_pointer_cast<WeightedLRUReplData>(replacement_data)->
@@ -68,7 +64,7 @@ WeightedLRUPolicy::touch(const std::shared_ptr<ReplacementData>&
 }
 
 ReplaceableEntry*
-WeightedLRUPolicy::getVictim(const ReplacementCandidates& candidates) const
+WeightedLRU::getVictim(const ReplacementCandidates& candidates) const
 {
     assert(candidates.size() > 0);
 
@@ -102,13 +98,13 @@ WeightedLRUPolicy::getVictim(const ReplacementCandidates& candidates) const
 }
 
 std::shared_ptr<ReplacementData>
-WeightedLRUPolicy::instantiateEntry()
+WeightedLRU::instantiateEntry()
 {
     return std::shared_ptr<ReplacementData>(new WeightedLRUReplData);
 }
 
 void
-WeightedLRUPolicy::reset(const std::shared_ptr<ReplacementData>&
+WeightedLRU::reset(const std::shared_ptr<ReplacementData>&
                                                     replacement_data) const
 {
     // Set last touch timestamp
@@ -117,10 +113,18 @@ WeightedLRUPolicy::reset(const std::shared_ptr<ReplacementData>&
 }
 
 void
-WeightedLRUPolicy::invalidate(const std::shared_ptr<ReplacementData>&
+WeightedLRU::invalidate(const std::shared_ptr<ReplacementData>&
                                                     replacement_data) const
 {
     // Reset last touch timestamp
     std::static_pointer_cast<WeightedLRUReplData>(
         replacement_data)->last_touch_tick = Tick(0);
 }
+
+} // namespace ReplacementPolicy
+
+ReplacementPolicy::WeightedLRU*
+WeightedLRURPParams::create()
+{
+    return new ReplacementPolicy::WeightedLRU(this);
+}
index eea2fb5129795203722ce920c2e34859bdb42d5b..74e926eaf217805999fca5946c132e3aef3c82b1 100644 (file)
@@ -41,7 +41,9 @@
 
 struct WeightedLRURPParams;
 
-class WeightedLRUPolicy : public BaseReplacementPolicy
+namespace ReplacementPolicy {
+
+class WeightedLRU : public Base
 {
   protected:
     /** Weighted LRU implementation of replacement data. */
@@ -61,8 +63,8 @@ class WeightedLRUPolicy : public BaseReplacementPolicy
     };
   public:
     typedef WeightedLRURPParams Params;
-    WeightedLRUPolicy(const Params* p);
-    ~WeightedLRUPolicy() {}
+    WeightedLRU(const Params* p);
+    ~WeightedLRU() = default;
 
     /**
      * Invalidate replacement data to set it as the next probable victim.
@@ -109,4 +111,6 @@ class WeightedLRUPolicy : public BaseReplacementPolicy
                                               candidates) const override;
 };
 
+} // namespace ReplacementPolicy
+
 #endif // __MEM_CACHE_REPLACEMENT_POLICIES_WEIGHTED_LRU_RP_HH__
index 211bc1fdbfa4e0b46d05529acfdf7847654d5d24..b48428b6eda690038c1fc470a95c348af4eaf9fd 100644 (file)
@@ -82,7 +82,7 @@ class BaseSetAssoc : public BaseTags
     const bool sequentialAccess;
 
     /** Replacement policy */
-    BaseReplacementPolicy *replacementPolicy;
+    ReplacementPolicy::Base *replacementPolicy;
 
   public:
     /** Convenience typedef. */
index b651bd6005a0357e3f1105ce1de79f81c1e7d14f..380b3c1c8897178069f78216efb720f454299845 100644 (file)
@@ -44,7 +44,9 @@
 #include "mem/packet.hh"
 #include "params/SectorTags.hh"
 
-class BaseReplacementPolicy;
+namespace ReplacementPolicy {
+    class Base;
+}
 class ReplaceableEntry;
 
 /**
@@ -71,7 +73,7 @@ class SectorTags : public BaseTags
     const bool sequentialAccess;
 
     /** Replacement policy */
-    BaseReplacementPolicy *replacementPolicy;
+    ReplacementPolicy::Base *replacementPolicy;
 
     /** Number of data blocks per sector. */
     const unsigned numBlocksPerSector;
index dc4600220a6b0c14f91611ca600a67609ba60dbe..0024d8a3be57ec667fe80757a53fe8a99ac39d4d 100644 (file)
@@ -82,7 +82,7 @@ CacheMemory::CacheMemory(const Params *p)
     m_is_instruction_only_cache = p->is_icache;
     m_resource_stalls = p->resourceStalls;
     m_block_size = p->block_size;  // may be 0 at this point. Updated in init()
-    m_use_occupancy = dynamic_cast<WeightedLRUPolicy*>(
+    m_use_occupancy = dynamic_cast<ReplacementPolicy::WeightedLRU*>(
                                     m_replacementPolicy_ptr) ? true : false;
 }
 
@@ -387,7 +387,8 @@ CacheMemory::setMRU(Addr address, int occupancy)
         // replacement policy. Depending on different replacement policies,
         // use different touch() function.
         if (m_use_occupancy) {
-            static_cast<WeightedLRUPolicy*>(m_replacementPolicy_ptr)->touch(
+            static_cast<ReplacementPolicy::WeightedLRU*>(
+                m_replacementPolicy_ptr)->touch(
                 entry->replacementData, occupancy);
         } else {
             m_replacementPolicy_ptr->touch(entry->replacementData);
index 0899e681f219456ce339e781906564fe22ed301c..245cfa94adf7d91968e93d37b0749d592edc6ac1 100644 (file)
@@ -64,7 +64,7 @@ class CacheMemory : public SimObject
 {
   public:
     typedef RubyCacheParams Params;
-    typedef std::shared_ptr<ReplacementData> ReplData;
+    typedef std::shared_ptr<ReplacementPolicy::ReplacementData> ReplData;
     CacheMemory(const Params *p);
     ~CacheMemory();
 
@@ -200,11 +200,8 @@ class CacheMemory : public SimObject
     std::unordered_map<Addr, int> m_tag_index;
     std::vector<std::vector<AbstractCacheEntry*> > m_cache;
 
-    /**
-     * We use BaseReplacementPolicy from Classic system here, hence we can use
-     * different replacement policies from Classic system in Ruby system.
-     */
-    BaseReplacementPolicy *m_replacementPolicy_ptr;
+    /** We use the replacement policies from the Classic memory system. */
+    ReplacementPolicy::Base *m_replacementPolicy_ptr;
 
     BankedArray dataArray;
     BankedArray tagArray;