TaggedCache.cpp

#include <xrpl/basics/TaggedCache.h>
 
#include <xrpl/basics/IntrusivePointer.h>
#include <xrpl/basics/IntrusiveRefCounts.h>
#include <xrpl/basics/TaggedCache.ipp>  // IWYU pragma: keep
#include <xrpl/basics/chrono.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/protocol/Protocol.h>
 
#include <gtest/gtest.h>
#include <helpers/TestSink.h>
 
#include <memory>
#include <string>
#include <utility>
 
namespace xrpl {
 
/*
I guess you can put some items in, make sure they're still there. Let some
time pass, make sure they're gone. Keep a strong pointer to one of them, make
sure you can still find it even after time passes. Create two objects with
the same key, canonicalize them both and make sure you get the same object.
Put an object in but keep a strong pointer to it, advance the clock a lot,
then canonicalize a new object with the same key, make sure you get the
original object.
*/
 
TEST(TaggedCacheTest, tagged_cache)
{
    using namespace std::chrono_literals;
    beast::Journal const journal{TestSink::instance()};
 
    TestStopwatch clock;
    clock.set(0);
 
    using Key = LedgerIndex;
    using Value = std::string;
    using Cache = TaggedCache<Key, Value>;
 
    Cache c("test", 1, 1s, clock, journal);
 
    // Insert an item, retrieve it, and age it so it gets purged.
    {
        EXPECT_EQ(c.getCacheSize(), 0);
        EXPECT_EQ(c.getTrackSize(), 0);
        EXPECT_FALSE(c.insert(1, "one"));
        EXPECT_EQ(c.getCacheSize(), 1);
        EXPECT_EQ(c.getTrackSize(), 1);
 
        {
            std::string s;
            EXPECT_TRUE(c.retrieve(1, s));
            EXPECT_EQ(s, "one");
        }
 
        ++clock;
        c.sweep();
        EXPECT_EQ(c.getCacheSize(), 0);
        EXPECT_EQ(c.getTrackSize(), 0);
    }
 
    // Insert an item, maintain a strong pointer, age it, and
    // verify that the entry still exists.
    {
        EXPECT_FALSE(c.insert(2, "two"));
        EXPECT_EQ(c.getCacheSize(), 1);
        EXPECT_EQ(c.getTrackSize(), 1);
 
        {
            auto p = c.fetch(2);
            EXPECT_NE(p, nullptr);
            ++clock;
            c.sweep();
            EXPECT_EQ(c.getCacheSize(), 0);
            EXPECT_EQ(c.getTrackSize(), 1);
        }
 
        // Make sure its gone now that our reference is gone
        ++clock;
        c.sweep();
        EXPECT_EQ(c.getCacheSize(), 0);
        EXPECT_EQ(c.getTrackSize(), 0);
    }
 
    // Insert the same key/value pair and make sure we get the same result
    {
        EXPECT_FALSE(c.insert(3, "three"));
 
        {
            auto const p1 = c.fetch(3);
            auto p2 = std::make_shared<Value>("three");
            c.canonicalizeReplaceClient(3, p2);
            EXPECT_EQ(p1.get(), p2.get());
        }
        ++clock;
        c.sweep();
        EXPECT_EQ(c.getCacheSize(), 0);
        EXPECT_EQ(c.getTrackSize(), 0);
    }
 
    // Put an object in but keep a strong pointer to it, advance the clock a
    // lot, then canonicalize a new object with the same key, make sure you
    // get the original object.
    {
        // Put an object in
        EXPECT_FALSE(c.insert(4, "four"));
        EXPECT_EQ(c.getCacheSize(), 1);
        EXPECT_EQ(c.getTrackSize(), 1);
 
        {
            // Keep a strong pointer to it
            auto const p1 = c.fetch(4);
            EXPECT_NE(p1, nullptr);
            EXPECT_EQ(c.getCacheSize(), 1);
            EXPECT_EQ(c.getTrackSize(), 1);
            // Advance the clock a lot
            ++clock;
            c.sweep();
            EXPECT_EQ(c.getCacheSize(), 0);
            EXPECT_EQ(c.getTrackSize(), 1);
            // Canonicalize a new object with the same key
            auto p2 = std::make_shared<std::string>("four");
            EXPECT_TRUE(c.canonicalizeReplaceClient(4, p2));
            EXPECT_EQ(c.getCacheSize(), 1);
            EXPECT_EQ(c.getTrackSize(), 1);
            // Make sure we get the original object
            EXPECT_EQ(p1.get(), p2.get());
        }
 
        ++clock;
        c.sweep();
        EXPECT_EQ(c.getCacheSize(), 0);
        EXPECT_EQ(c.getTrackSize(), 0);
    }
 
    {
        EXPECT_FALSE(c.insert(5, "five"));
        EXPECT_EQ(c.getCacheSize(), 1);
        EXPECT_EQ(c.size(), 1);
 
        {
            auto const p1 = c.fetch(5);
            EXPECT_NE(p1, nullptr);
            EXPECT_EQ(c.getCacheSize(), 1);
            EXPECT_EQ(c.size(), 1);
 
            // Advance the clock a lot
            ++clock;
            c.sweep();
            EXPECT_EQ(c.getCacheSize(), 0);
            EXPECT_EQ(c.size(), 1);
 
            auto p2 = std::make_shared<std::string>("five_2");
            EXPECT_TRUE(c.canonicalizeReplaceCache(5, p2));
            EXPECT_EQ(c.getCacheSize(), 1);
            EXPECT_EQ(c.size(), 1);
            // Make sure the caller's original pointer is unchanged
            EXPECT_NE(p1.get(), p2.get());
            EXPECT_EQ(*p2, "five_2");
 
            auto const p3 = c.fetch(5);
            EXPECT_NE(p3, nullptr);
            EXPECT_EQ(p3.get(), p2.get());
            EXPECT_NE(p3.get(), p1.get());
        }
 
        ++clock;
        c.sweep();
        EXPECT_EQ(c.getCacheSize(), 0);
        EXPECT_EQ(c.size(), 0);
    }
 
    {
        struct MyRefCountObject : IntrusiveRefCounts
        {
            std::string data;
 
            // Needed to support weak intrusive pointers
            virtual void
            partialDestructor()
            {
            }
 
            MyRefCountObject() = default;
            explicit MyRefCountObject(std::string data) : data(std::move(data))
            {
            }
 
            bool
            operator==(std::string const& other) const
            {
                return data == other;
            }
        };
 
        using IntrPtrCache = TaggedCache<
            Key,
            MyRefCountObject,
            /*IsKeyCache*/ false,
            intr_ptr::SharedWeakUnionPtr<MyRefCountObject>,
            intr_ptr::SharedPtr<MyRefCountObject>>;
 
        IntrPtrCache intrPtrCache("IntrPtrTest", 1, 1s, clock, journal);
 
        intrPtrCache.canonicalizeReplaceCache(1, intr_ptr::makeShared<MyRefCountObject>("one"));
        EXPECT_EQ(intrPtrCache.getCacheSize(), 1);
        EXPECT_EQ(intrPtrCache.size(), 1);
 
        {
            {
                intrPtrCache.canonicalizeReplaceCache(
                    1, intr_ptr::makeShared<MyRefCountObject>("one_replaced"));
 
                auto p = intrPtrCache.fetch(1);
                EXPECT_EQ(*p, "one_replaced");
 
                // Advance the clock a lot
                ++clock;
                intrPtrCache.sweep();
                EXPECT_EQ(intrPtrCache.getCacheSize(), 0);
                EXPECT_EQ(intrPtrCache.size(), 1);
 
                intrPtrCache.canonicalizeReplaceCache(
                    1, intr_ptr::makeShared<MyRefCountObject>("one_replaced_2"));
 
                auto p2 = intrPtrCache.fetch(1);
                EXPECT_EQ(*p2, "one_replaced_2");
 
                intrPtrCache.del(1, true);
            }
 
            intrPtrCache.canonicalizeReplaceCache(
                1, intr_ptr::makeShared<MyRefCountObject>("one_replaced_3"));
            auto p3 = intrPtrCache.fetch(1);
            EXPECT_EQ(*p3, "one_replaced_3");
        }
 
        ++clock;
        intrPtrCache.sweep();
        EXPECT_EQ(intrPtrCache.getCacheSize(), 0);
        EXPECT_EQ(intrPtrCache.size(), 0);
    }
}
 
}  // namespace xrpl