mem-cache: ReplacementPolicy specific replacement data

Replacement data is specific for each replacement policy, and thus
should be instantiated differently by each policy.

Touch() and reset() do not need to be aware of CacheBlk, as they
only update its ReplacementData.

Invalidate() makes replacement policies independent of cache blocks,
by removing the awareness of the valid state.

An inheritable base ReplaceableEntry class was created to allow usage
of replacement policies with any table-like structure.

Change-Id: I998917d800fa48504ed95abffa2f1b7bfd68522b
Reviewed-on: https://gem5-review.googlesource.com/9421
Reviewed-by: Nikos Nikoleris <nikos.nikoleris@arm.com>
Maintainer: Nikos Nikoleris <nikos.nikoleris@arm.com>

1 files changed, 51 insertions, 3 deletions

diff --git a/src/mem/cache/replacement_policies/lfu_rp.hh b/src/mem/cache/replacement_policies/lfu_rp.hh
index affc849a2..8709e35d4 100644
--- a/src/mem/cache/replacement_policies/lfu_rp.hh
+++ b/src/mem/cache/replacement_policies/lfu_rp.hh
@@ -32,7 +32,7 @@
  * @file
  * Declaration of a Least Frequently Used replacement policy.
  * The victim is chosen using the reference frequency. The least referenced
- * block is always chosen to be evicted, regardless of the amount of times
+ * entry is always chosen to be evicted, regardless of the amount of times
  * it has been touched, or how long has passed since its last touch.
  */
 
@@ -44,6 +44,19 @@
 
 class LFURP : public BaseReplacementPolicy
 {
+  protected:
+    /** LFU-specific implementation of replacement data. */
+    struct LFUReplData : ReplacementData
+    {
+        /** Number of references to this entry since it was reset. */
+        unsigned refCount;
+
+        /**
+         * Default constructor. Invalidate data.
+         */
+        LFUReplData() : refCount(0) {}
+    };
+
   public:
     /** Convenience typedef. */
     typedef LFURPParams Params;
@@ -59,12 +72,47 @@ class LFURP : public BaseReplacementPolicy
     ~LFURP() {}
 
     /**
+     * Invalidate replacement data to set it as the next probable victim.
+     * Clear the number of references.
+     *
+     * @param replacement_data Replacement data to be invalidated.
+     */
+    void invalidate(const std::shared_ptr<ReplacementData>& replacement_data)
+                                                              const override;
+
+    /**
+     * Touch an entry to update its replacement data.
+     * Increase number of references.
+     *
+     * @param replacement_data Replacement data to be touched.
+     */
+    void touch(const std::shared_ptr<ReplacementData>& replacement_data) const
+                                                                     override;
+
+    /**
+     * Reset replacement data. Used when an entry is inserted.
+     * Reset number of references.
+     *
+     * @param replacement_data Replacement data to be reset.
+     */
+    void reset(const std::shared_ptr<ReplacementData>& replacement_data) const
+                                                                     override;
+
+    /**
      * Find replacement victim using reference frequency.
      *
      * @param cands Replacement candidates, selected by indexing policy.
-     * @return Cache block to be replaced.
+     * @return Replacement entry to be replaced.
+     */
+    ReplaceableEntry* getVictim(const ReplacementCandidates& candidates) const
+                                                                     override;
+
+    /**
+     * Instantiate a replacement data entry.
+     *
+     * @return A shared pointer to the new replacement data.
      */
-    CacheBlk* getVictim(const ReplacementCandidates& candidates) override;
+    std::shared_ptr<ReplacementData> instantiateEntry() override;
 };
 
 #endif // __MEM_CACHE_REPLACEMENT_POLICIES_LFU_RP_HH__