mem-cache: Create Second-Chance replacement policy

Implementation of a Second-Chance replacement policy. Similar to FIFO,
but every block is given a second chance if it has been touched.

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

src/mem/cache/replacement_policies/ReplacementPolicies.py

@@ -40,6 +40,11 @@ class FIFORP(BaseReplacementPolicy):
     cxx_class = 'FIFORP'
     cxx_header = "mem/cache/replacement_policies/fifo_rp.hh"
 
+class SecondChanceRP(FIFORP):
+    type = 'SecondChanceRP'
+    cxx_class = 'SecondChanceRP'
+    cxx_header = "mem/cache/replacement_policies/second_chance_rp.hh"
+
 class LFURP(BaseReplacementPolicy):
     type = 'LFURP'
     cxx_class = 'LFURP'

src/mem/cache/replacement_policies/SConscript

@@ -39,3 +39,4 @@ Source('lfu_rp.cc')
 Source('lru_rp.cc')
 Source('mru_rp.cc')
 Source('random_rp.cc')
+Source('second_chance_rp.cc')

src/mem/cache/replacement_policies/fifo_rp.hh

@@ -43,6 +43,7 @@
 
 class FIFORP : public BaseReplacementPolicy
 {
+  protected:
     /** FIFO-specific implementation of replacement data. */
     struct FIFOReplData : ReplacementData
     {

src/mem/cache/replacement_policies/second_chance_rp.cc

@@ -0,0 +1,134 @@
+/**
+ * Copyright (c) 2018 Inria
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met: redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer;
+ * redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution;
+ * neither the name of the copyright holders nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Authors: Daniel Carvalho
+ */
+
+#include "mem/cache/replacement_policies/second_chance_rp.hh"
+
+SecondChanceRP::SecondChanceRP(const Params *p)
+    : FIFORP(p)
+{
+}
+
+void
+SecondChanceRP::useSecondChance(
+    const std::shared_ptr<SecondChanceReplData>& replacement_data) const
+{
+    // Reset FIFO data
+    FIFORP::reset(replacement_data);
+
+    // Use second chance
+    replacement_data->hasSecondChance = false;
+}
+
+void
+SecondChanceRP::invalidate(
+    const std::shared_ptr<ReplacementData>& replacement_data) const
+{
+    FIFORP::invalidate(replacement_data);
+
+    // Do not give a second chance to invalid entries
+    std::static_pointer_cast<SecondChanceReplData>(
+        replacement_data)->hasSecondChance = false;
+}
+
+void
+SecondChanceRP::touch(const std::shared_ptr<ReplacementData>& replacement_data) const
+{
+    FIFORP::touch(replacement_data);
+
+    // Whenever an entry is touched, it is given a second chance
+    std::static_pointer_cast<SecondChanceReplData>(
+        replacement_data)->hasSecondChance = true;
+}
+
+void
+SecondChanceRP::reset(const std::shared_ptr<ReplacementData>& replacement_data) const
+{
+    FIFORP::reset(replacement_data);
+
+    // Entries are inserted with a second chance
+    std::static_pointer_cast<SecondChanceReplData>(
+        replacement_data)->hasSecondChance = true;
+}
+
+ReplaceableEntry*
+SecondChanceRP::getVictim(const ReplacementCandidates& candidates) const
+{
+    // There must be at least one replacement candidate
+    assert(candidates.size() > 0);
+
+    // Search for invalid entries, as they have the eviction priority
+    for (const auto& candidate : candidates) {
+        // Cast candidate's replacement data
+        std::shared_ptr<SecondChanceReplData> candidate_replacement_data =
+            std::static_pointer_cast<SecondChanceReplData>(
+                candidate->replacementData);
+
+        // Stop iteration if found an invalid entry
+        if ((candidate_replacement_data->tickInserted == Tick(0)) &&
+            !candidate_replacement_data->hasSecondChance) {
+            return candidate;
+        }
+    }
+
+    // Visit all candidates to find victim
+    ReplaceableEntry* victim = candidates[0];
+    bool search_victim = true;
+    while (search_victim) {
+        // Do a FIFO victim search
+        victim = FIFORP::getVictim(candidates);
+
+        // Cast victim's replacement data for code readability
+        std::shared_ptr<SecondChanceReplData> victim_replacement_data =
+            std::static_pointer_cast<SecondChanceReplData>(
+                victim->replacementData);
+
+        // If victim has a second chance, use it and repeat search
+        if (victim_replacement_data->hasSecondChance) {
+            useSecondChance(victim_replacement_data);
+        } else {
+            // Found victim
+            search_victim = false;
+        }
+    }
+
+    return victim;
+}
+
+std::shared_ptr<ReplacementData>
+SecondChanceRP::instantiateEntry()
+{
+    return std::shared_ptr<ReplacementData>(new SecondChanceReplData());
+}
+
+SecondChanceRP*
+SecondChanceRPParams::create()
+{
+    return new SecondChanceRP(this);
+}

src/mem/cache/replacement_policies/second_chance_rp.hh

@@ -0,0 +1,133 @@
+/**
+ * Copyright (c) 2018 Inria
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met: redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer;
+ * redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution;
+ * neither the name of the copyright holders nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Authors: Daniel Carvalho
+ */
+
+/**
+ * @file
+ * Declaration of a Second-Chance replacement policy.
+ * The victim is chosen using the timestamp. The oldest entry is chosen
+ * to be evicted, if it hasn't been touched since its insertion. If it
+ * has been touched, it is given a second chance and re-inserted at the
+ * end of the queue.
+ */
+
+#ifndef __MEM_CACHE_REPLACEMENT_POLICIES_SECOND_CHANCE_RP_HH__
+#define __MEM_CACHE_REPLACEMENT_POLICIES_SECOND_CHANCE_RP_HH__
+
+#include "mem/cache/replacement_policies/fifo_rp.hh"
+#include "params/SecondChanceRP.hh"
+
+class SecondChanceRP : public FIFORP
+{
+  protected:
+    /** Second-Chance-specific implementation of replacement data. */
+    struct SecondChanceReplData : public FIFOReplData
+    {
+        /**
+         * This is different from isTouched because isTouched accounts only
+         * for insertion, while this bit is reset every new re-insertion.
+         * @sa SecondChanceRP.
+         */
+        bool hasSecondChance;
+
+        /**
+         * Default constructor.
+         */
+        SecondChanceReplData() : FIFOReplData(), hasSecondChance(false) {}
+    };
+
+    /**
+     * Use replacement data's second chance.
+     *
+     * @param replacement_data Entry that will use its second chance.
+     */
+    void useSecondChance(
+        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() {}
+
+    /**
+     * Invalidate replacement data to set it as the next probable victim.
+     * Invalid entries do not have a second chance, and their last touch tick
+     * is set as the oldest possible.
+     *
+     * @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 re-insertion tick and second chance bit.
+     *
+     * @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 or re-inserted
+     * in the queue.
+     * Sets its insertion tick and second chance bit.
+     *
+     * @param replacement_data Replacement data to be reset.
+     */
+    void reset(const std::shared_ptr<ReplacementData>& replacement_data) const
+                                                                     override;
+
+    /**
+     * Find replacement victim using insertion timestamps and second chance
+     * bit.
+     *
+     * @param cands Replacement candidates, selected by indexing policy.
+     * @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.
+     */
+    std::shared_ptr<ReplacementData> instantiateEntry() override;
+};
+
+#endif // __MEM_CACHE_REPLACEMENT_POLICIES_SECOND_CHANCE_RP_HH__