feat multi-index-lru: implement without Boost.Intrusive and const_cast

Tests: протестировано CI

---

Pull Request resolved: #1067

Co-authored-by: antoshkka <[email protected]>
commit_hash:02835f364790081afdc274bc1f8269756c534646

Author: 2 people

libraries/multi-index-lru/include/userver/multi-index-lru/container.hpp

@@ -3,94 +3,40 @@
 /// @file userver/multi-index-lru/container.hpp
 /// @brief @copybrief multi_index_lru::Container
 
-#include <boost/intrusive/link_mode.hpp>
-#include <boost/intrusive/list.hpp>
-#include <boost/intrusive/list_hook.hpp>
-#include <boost/multi_index/hashed_index.hpp>
-#include <boost/multi_index/mem_fun.hpp>
-#include <boost/multi_index/member.hpp>
+#include <boost/multi_index/identity.hpp>
 #include <boost/multi_index/ordered_index.hpp>
-#include <boost/multi_index/tag.hpp>
+#include <boost/multi_index/sequenced_index.hpp>
 #include <boost/multi_index_container.hpp>
 
+#include <boost/mpl/joint_view.hpp>
+#include <boost/mpl/list.hpp>
+
 #include <cstddef>
 #include <utility>
 
 USERVER_NAMESPACE_BEGIN
 
 namespace multi_index_lru {
 
-namespace impl {
-
-template <typename Value>
-struct ValueWithHook {
-    Value value;
-    mutable boost::intrusive::list_member_hook<> list_hook;
-
-    const ValueWithHook* GetPointerToSelf() const { return this; };
-
-    explicit ValueWithHook(const Value& val)
-        : value(val)
-    {}
-
-    explicit ValueWithHook(Value&& val)
-        : value(std::move(val))
-    {}
-
-    ValueWithHook() = delete;
-    ValueWithHook(const ValueWithHook&) = delete;
-    ValueWithHook(ValueWithHook&&) = delete;
-
-    ValueWithHook& operator=(const ValueWithHook&) = delete;
-    ValueWithHook& operator=(ValueWithHook&&) = delete;
-
-    operator Value&() { return value; }
-    operator const Value&() const { return value; }
-
-    Value* operator->() { return &value; }
-    const Value* operator->() const { return &value; }
-
-    Value& get() { return value; }
-    const Value& get() const { return value; }
-};
-
-template <class List, class Node>
-void PushBackToList(List& lst, const Node& node) {
-    lst.push_back(const_cast<Node&>(node));  // TODO:
-}
-
-template <class List, class Node>
-void SpliceInList(List& lst, Node& node) {
-    lst.splice(lst.end(), lst, lst.iterator_to(node));
-}
-
-struct InternalPtrTag {};
-
-}  // namespace impl
-
 /// @ingroup userver_containers
 ///
 /// @brief MultiIndex LRU container
-template <typename Value, typename IndexSpecifierList, typename Allocator = std::allocator<impl::ValueWithHook<Value>>>
+template <typename Value, typename IndexSpecifierList, typename Allocator = std::allocator<Value> >
 class Container {
 public:
     explicit Container(size_t max_size)
-        : max_size(max_size)
+        : max_size_(max_size)
     {}
 
     template <typename... Args>
     bool emplace(Args&&... args) {
-        if (container.size() >= max_size) {
-            EvictLru();
-        }
-
-        auto result = container.emplace(std::forward<Args>(args)...);
+        auto& seq_index = container_.template get<0>();
+        auto result = seq_index.emplace_front(std::forward<Args>(args)...);
 
-        auto& value = *result.first;
-        if (result.second) {
-            impl::PushBackToList(usage_list, value);
-        } else {
-            impl::SpliceInList(usage_list, value);
+        if (!result.second) {
+            seq_index.relocate(seq_index.begin(), result.first);
+        } else if (seq_index.size() > max_size_) {
+            seq_index.pop_back();
         }
         return result.second;
     }
@@ -101,74 +47,56 @@ class Container {
 
     template <typename Tag, typename Key>
     auto find(const Key& key) {
-        auto& primary_index = container.template get<Tag>();
+        auto& primary_index = container_.template get<Tag>();
         auto it = primary_index.find(key);
 
         if (it != primary_index.end()) {
-            impl::SpliceInList(usage_list, *it);
+            auto& seq_index = container_.template get<0>();
+            auto seq_it = container_.template project<0>(it);
+            seq_index.relocate(seq_index.begin(), seq_it);
         }
 
         return it;
     }
 
-    template <typename Tag>
-    auto end() {
-        return container.template get<Tag>().end();
-    }
-
     template <typename Tag, typename Key>
     bool contains(const Key& key) {
-        return this->template find<Tag, Key>(key) != container.template get<Tag>().end();
+        return this->template find<Tag, Key>(key) != container_.template get<Tag>().end();
     }
 
     template <typename Tag, typename Key>
     bool erase(const Key& key) {
-        auto& primary_index = container.template get<Tag>();
-        auto it = primary_index.find(key);
-        if (it != primary_index.end()) {
-            usage_list.erase(usage_list.iterator_to(*it));
-        }
-        return container.template get<Tag>().erase(key) > 0;
+        return container_.template get<Tag>().erase(key) > 0;
     }
 
-    std::size_t size() const { return container.size(); }
-    bool empty() const { return container.empty(); }
-    std::size_t capacity() const { return max_size; }
+    size_t size() const { return container_.size(); }
+    bool empty() const { return container_.empty(); }
+    size_t capacity() const { return max_size_; }
 
     void set_capacity(size_t new_capacity) {
-        max_size = new_capacity;
-        while (container.size() > max_size) {
-            EvictLru();
+        max_size_ = new_capacity;
+        auto& seq_index = container_.template get<0>();
+        while (container_.size() > max_size_) {
+            seq_index.pop_back();
         }
     }
 
-    void clear() { container.clear(); }
+    void clear() { container_.clear(); }
 
-private:
-    using CacheItem = impl::ValueWithHook<Value>;
-    using List = boost::intrusive::list<
-        CacheItem,
-        boost::intrusive::member_hook<CacheItem, boost::intrusive::list_member_hook<>, &CacheItem::list_hook>>;
-
-    using ExtendedIndexSpecifierList = typename boost::mpl::push_back<
-        IndexSpecifierList,
-        boost::multi_index::hashed_unique<
-            boost::multi_index::tag<impl::InternalPtrTag>,
-            boost::multi_index::const_mem_fun<CacheItem, const CacheItem*, &CacheItem::GetPointerToSelf>>>::type;
-
-    using BoostContainer = boost::multi_index::multi_index_container<CacheItem, ExtendedIndexSpecifierList, Allocator>;
-
-    void EvictLru() {
-        if (!usage_list.empty()) {
-            CacheItem* ptr_to_erase = &*usage_list.begin();
-            usage_list.erase(usage_list.begin());
-            container.template get<impl::InternalPtrTag>().erase(ptr_to_erase);
-        }
+    template <typename Tag>
+    auto end() {
+        return container_.template get<Tag>().end();
     }
 
-    BoostContainer container;
-    std::size_t max_size;
-    List usage_list;
+private:
+    using AdditionalIndices = boost::mpl::list<boost::multi_index::sequenced<> >;
+
+    using ExtendedIndexSpecifierList = boost::mpl::joint_view<AdditionalIndices, IndexSpecifierList>;
+
+    using BoostContainer = boost::multi_index::multi_index_container<Value, ExtendedIndexSpecifierList, Allocator>;
+
+    BoostContainer container_;
+    size_t max_size_;
 };
 }  // namespace multi_index_lru
 

libraries/multi-index-lru/src/main_benchmark.cpp

@@ -86,7 +86,7 @@ void LruFindEmplaceMix(benchmark::State& state) {
             cache.find<IdTag, int>(ids[i]);
         }
 
-        for (size_t i = 0; i < writing_kOperationsNumber; ++i) {
+        for (std::size_t i = 0; i < writing_kOperationsNumber; ++i) {
             cache.emplace(users[i]);
         }
     }
@@ -141,12 +141,12 @@ static void EmplaceOperations(::benchmark::State& state) {
     for (auto _ : state) {
         state.PauseTiming();
         std::vector<User> users;
-        for (size_t i = 0; i < operations_count; ++i) {
+        for (std::size_t i = 0; i < operations_count; ++i) {
             users.push_back(GenerateUser());
         }
         state.ResumeTiming();
 
-        for (size_t i = 0; i < operations_count; ++i) {
+        for (std::size_t i = 0; i < operations_count; ++i) {
             cache.emplace(users[i]);
         }
     }

libraries/multi-index-lru/src/main_test.cpp

@@ -54,17 +54,17 @@ TEST_F(LRUUsersTest, BasicOperations) {
     // Test find by id
     auto by_id = cache.find<IdTag, int>(1);
     ASSERT_NE(by_id, cache.end<IdTag>());
-    EXPECT_EQ(by_id->get().name, "Alice");
+    EXPECT_EQ(by_id->name, "Alice");
 
     // Test find by email
     auto by_email = cache.find<EmailTag, std::string>("[email protected]");
     ASSERT_NE(by_email, cache.end<EmailTag>());
-    EXPECT_EQ(by_email->get().id, 2);
+    EXPECT_EQ(by_email->id, 2);
 
     // Test find by name
     auto by_name = cache.find<NameTag, std::string>("Charlie");
     ASSERT_NE(by_name, cache.end<NameTag>());
-    EXPECT_EQ(by_name->get().email, "[email protected]");
+    EXPECT_EQ(by_name->email, "[email protected]");
 
     // Test template find method
     auto it = cache.find<EmailTag, std::string>("[email protected]");
@@ -125,7 +125,7 @@ TEST_F(ProductsTest, BasicProductOperations) {
 
     auto laptop = cache.find<SkuTag, std::string>("A1");
     ASSERT_NE(laptop, cache.end<SkuTag>());
-    EXPECT_EQ(laptop->get().name, "Laptop");
+    EXPECT_EQ(laptop->name, "Laptop");
 }
 
 TEST_F(ProductsTest, ProductEviction) {