fifo_rp.test.cc

Go to the documentation of this file.

 
#include <gtest/gtest-spi.h>
#include <gtest/gtest.h>
 
#include <cassert>
 
#include "mem/cache/replacement_policies/fifo_rp.hh"
#include "params/FIFORP.hh"

class FIFORPTestF : public ::testing::Test
{
  public:
    std::shared_ptr<gem5::replacement_policy::FIFO> rp;
 
    FIFORPTestF()
    {
        gem5::FIFORPParams params;
        params.eventq_index = 0;
        rp = std::make_shared<gem5::replacement_policy::FIFO>(params);
    }
};

TEST_F(FIFORPTestF, InstantiatedEntry)
{
    const auto repl_data = rp->instantiateEntry();
 
    // instantiateEntry must return a valid pointer
    ASSERT_NE(repl_data, nullptr);
}

TEST_F(FIFORPTestF, GetVictim1Candidate)
{
    gem5::ReplaceableEntry entry;
    entry.replacementData = rp->instantiateEntry();
    gem5::ReplacementCandidates candidates;
    candidates.push_back(&entry);
    ASSERT_EQ(rp->getVictim(candidates), &entry);
 
    rp->invalidate(entry.replacementData);
    ASSERT_EQ(rp->getVictim(candidates), &entry);
 
    rp->reset(entry.replacementData);
    ASSERT_EQ(rp->getVictim(candidates), &entry);
 
    rp->touch(entry.replacementData);
    ASSERT_EQ(rp->getVictim(candidates), &entry);
}

class FIFORPVictimizationTestF : public FIFORPTestF
{
  protected:
    // The entries being victimized
    std::vector<gem5::ReplaceableEntry> entries;
 
    // The entries, in candidate form
    gem5::ReplacementCandidates candidates;
 
  public:
    // The number of entries is arbitrary. It does not need to be high, since
    // having more entries is not expected to increase coverage
    FIFORPVictimizationTestF() : FIFORPTestF(), entries(4)
    {
        for (auto &entry : entries) {
            entry.replacementData = rp->instantiateEntry();
            candidates.push_back(&entry);
        }
    }
};

TEST_F(FIFORPVictimizationTestF, GetVictimAllInvalid)
{
    auto expected_victim = &entries.front();
 
    // At this point all candidates are considered to be first, since
    // no entries have ever been reset
    ASSERT_EQ(rp->getVictim(candidates), expected_victim);
 
    // Since all candidates are already invalid, nothing changes if we
    // invalidate all of them again. Do it with a reversed invalidation
    // order to show that we always pick the front candidate, even if it
    // was invalidated last
    for (auto it = candidates.rbegin(); it != candidates.rend(); ++it) {
        rp->invalidate((*it)->replacementData);
    }
    ASSERT_EQ(rp->getVictim(candidates), expected_victim);
}

TEST_F(FIFORPVictimizationTestF, GetVictimAllInvalid2)
{
    auto expected_victim = &entries.front();
 
    // At this point all candidates are considered to be first, since
    // no entries have ever been reset
    ASSERT_EQ(rp->getVictim(candidates), expected_victim);
 
    // Since all candidates are already invalid, nothing changes if we
    // invalidate all of them again.
    for (auto it = candidates.rbegin(); it != candidates.rend(); ++it) {
        rp->invalidate((*it)->replacementData);
    }
    ASSERT_EQ(rp->getVictim(candidates), expected_victim);
}

TEST_F(FIFORPVictimizationTestF, GetVictimOneInvalid)
{
    for (auto &entry : entries) {
        // Validate all entries to start from a clean state
        for (auto &entry : entries) {
            rp->reset(entry.replacementData);
        }
 
        // Set one of the entries as invalid
        rp->invalidate(entry.replacementData);
 
        ASSERT_EQ(rp->getVictim(candidates), &entry);
    }
}

TEST_F(FIFORPVictimizationTestF, GetVictim)
{
    for (size_t i = 0; i < entries.size(); ++i) {
        SCOPED_TRACE(i);
        auto &entry = entries[i];
 
        // Reset one of the entries to make it become the single first entry
        rp->reset(entry.replacementData);
 
        // Now change ticks and validate all other entries to make them not
        // tie for first entry
        for (size_t j = 0; j < entries.size(); ++j) {
            if (i != j) {
                rp->reset(entries[j].replacementData);
            }
        }
 
        ASSERT_EQ(rp->getVictim(candidates), &entry);
    }
}

TEST_F(FIFORPVictimizationTestF, GetVictimAfterTouch)
{
    for (size_t i = 0; i < entries.size(); ++i) {
        SCOPED_TRACE(i);
        auto &entry = entries[i];
 
        // Reset one of the entries to make it become first entry
        rp->reset(entry.replacementData);
 
        // Now change ticks and validate all other entries to make them not
        // tie for first entry
        for (size_t j = 0; j < entries.size(); ++j) {
            if (i != j) {
                rp->reset(entries[j].replacementData);
            }
        }
 
        // Even if we touch the first entry, it will not stop being the
        // first entry, so it will be selected for victimization
        rp->touch(entry.replacementData);
 
        ASSERT_EQ(rp->getVictim(candidates), &entry);
    }
}
 
typedef FIFORPTestF FIFORPFDeathTest;
 
TEST_F(FIFORPFDeathTest, InvalidateNull)
{
    ASSERT_DEATH(rp->invalidate(nullptr), "");
}
 
TEST_F(FIFORPFDeathTest, ResetNull)
{
    ASSERT_DEATH(rp->reset(nullptr), "");
}
 
TEST_F(FIFORPFDeathTest, TouchNull)
{
#ifdef NDEBUG
    GTEST_SKIP() << "Skipping as assertions are "
                    "stripped out of fast builds";
#endif
    ASSERT_DEATH(rp->touch(nullptr), "");
}
 
TEST_F(FIFORPFDeathTest, NoCandidates)
{
    gem5::ReplacementCandidates candidates;
    ASSERT_DEATH(rp->getVictim(candidates), "");
}