feat multi-index-lru: extract and reusе nodes, avoid friend relations

Extract and reuse nodes for better efficiency

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

---

Pull Request resolved: #1155

Co-authored-by: antoshkka <antoshkka@userver.tech>
Co-authored-by: antoshkka <antoshkka@userver.tech>
Co-authored-by: antoshkka <antoshkka@userver.tech>
Co-authored-by: antoshkka <antoshkka@userver.tech>
Co-authored-by: antoshkka <antoshkka@userver.tech>
Co-authored-by: antoshkka <antoshkka@userver.tech>
commit_hash:97cb1958b739b5f3027c3de76d7e5416027e1898

Author: 2 people

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

@@ -3,6 +3,8 @@
 /// @file userver/multi-index-lru/container.hpp
 /// @brief @copybrief multi_index_lru::Container
 
+#include <vector>
+
 #include "impl/mpl_helpers.hpp"
 
 USERVER_NAMESPACE_BEGIN
@@ -25,12 +27,23 @@ class Container {
     template <typename... Args>
     auto emplace(Args&&... args) {
         auto& seq_index = get_sequenced();
-        auto result = seq_index.emplace_front(std::forward<Args>(args)...);
 
+        std::pair<decltype(seq_index.begin()), bool> result;
+
+        if (free_nodes_.size() > 0) {
+            auto node = std::move(free_nodes_.back());
+            free_nodes_.pop_back();
+
+            node.value() = Value(std::forward<Args>(args)...);
+            auto ret = seq_index.insert(seq_index.begin(), std::move(node));
+            result = {ret.position, ret.inserted};
+        } else {
+            result = seq_index.emplace_front(std::forward<Args>(args)...);
+        }
         if (!result.second) {
             seq_index.relocate(seq_index.begin(), result.first);
         } else if (seq_index.size() > max_size_) {
-            seq_index.pop_back();
+            free_nodes_.emplace_back(seq_index.extract(std::prev(seq_index.end())));
         }
         return result;
     }
@@ -89,39 +102,76 @@ class Container {
         return this->template find_no_update<Tag, Key>(key) != end<Tag>();
     }
 
+    /// Removes the @b it from container, leaving the node in an internal pool. The key and value are not destroyed
+    /// and are reused on next insertion.
+    template <typename IteratorType>
+    auto erase(IteratorType it) {
+        auto it_0 = project_to_sequenced(it);
+        auto& seq_index = get_sequenced();
+        if (it_0 == seq_index.end()) {
+            return it;
+        }
+
+        ++it;
+        free_nodes_.emplace_back(seq_index.extract(it_0));
+        return it;
+    }
+
+    /// Removes the @b key from container, leaving the node in an internal pool. The key and value are not destroyed
+    /// and are reused on next insertion.
     template <typename Tag, typename Key>
     bool erase(const Key& key) {
-        return get_index<Tag>().erase(key) > 0;
+        auto it = find_no_update<Tag, Key>(key);
+        return erase(it) != end<Tag>();
     }
 
     std::size_t size() const noexcept { return container_.size(); }
+
     bool empty() const noexcept { return container_.empty(); }
+
     std::size_t capacity() const noexcept { return max_size_; }
 
     void set_capacity(std::size_t new_capacity) {
         max_size_ = new_capacity;
+        if (container_.size() <= max_size_) {
+            return;
+        }
+
+        shrink_to_fit();
         auto& seq_index = get_sequenced();
         while (container_.size() > max_size_) {
-            seq_index.pop_back();
+            // Not putting the node to `free_nodes_`, because the container is already full
+            seq_index.extract(std::prev(seq_index.end()));
         }
     }
 
-    void clear() { container_.clear(); }
+    /// Clears the internal nodes pool
+    void shrink_to_fit() { free_nodes_.clear(); }
+
+    /// Removes all elements from the container, leaving the node in an internal pool. The keys and values are
+    /// not destroyed and are reused on next insertion.
+    void clear() {
+        auto& seq_index = get_sequenced();
+        free_nodes_.reserve(free_nodes_.size() + container_.size());
+        while (!container_.empty()) {
+            free_nodes_.emplace_back(seq_index.extract(std::prev(seq_index.end())));
+        }
+    }
 
     template <typename Tag>
     auto end() const {
         return get_index<Tag>().end();
     }
 
-private:
-    template <typename V, typename I, typename A>
-    friend class ExpirableContainer;
+    auto find_last_accessed_no_update() const { return std::prev(get_sequenced().end()); }
 
+private:
     using ExtendedIndexSpecifierList = impl::add_index_t<boost::multi_index::sequenced<>, IndexSpecifierList>;
     using BoostContainer = boost::multi_index::multi_index_container<Value, ExtendedIndexSpecifierList, Allocator>;
 
     BoostContainer container_;
     std::size_t max_size_;
+    std::vector<typename BoostContainer::node_type> free_nodes_;
 
     auto& get_sequenced() noexcept { return container_.template get<0>(); }
 

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

@@ -22,7 +22,8 @@ class ExpirableContainer {
         : container_(max_size),
           ttl_(ttl)
     {
-        UASSERT_MSG(ttl.count() > 0, "ttl must be positive");
+        UINVARIANT(ttl.count() > 0, "ttl must be positive");
+        UINVARIANT(max_size > 0, "capacity must be positive");
     }
 
     template <typename... Args>
@@ -47,7 +48,7 @@ class ExpirableContainer {
 
         if (it != container_.template end<Tag>()) {
             if (now > it->last_accessed + ttl_) {
-                container_.template get_index<Tag>().erase(it);
+                container_.erase(it);
                 return end<Tag>();
             } else {
                 it->last_accessed = now;
@@ -66,23 +67,22 @@ class ExpirableContainer {
     template <typename Tag, typename Key>
     auto equal_range(const Key& key) {
         const auto now = std::chrono::steady_clock::now();
-        auto& index = container_.template get_index<Tag>();
         auto range = container_.template equal_range<Tag, Key>(key);
 
         auto it = range.first;
         bool changed = false;
 
         while (it != range.second) {
             if (now > it->last_accessed + ttl_) {
-                it = index.erase(it);
+                it = container_.erase(it);
                 changed = true;
             } else {
                 it->last_accessed = now;
                 ++it;
             }
         }
         if (changed) {
-            range = index.equal_range(key);
+            range = container_.template equal_range_no_update<Tag, Key>(key);
         }
         return std::pair{impl::IteratorToValue{range.first}, impl::IteratorToValue{range.second}};
     }
@@ -103,17 +103,33 @@ class ExpirableContainer {
         return this->template find_no_update<Tag, Key>(key) != this->template end<Tag>();
     }
 
+    /// Removes the @b it from container, leaving the node in an internal pool. The key and value are not destroyed
+    /// and are reused on next insertion.
+    template <typename IteratorType>
+    bool erase(IteratorType it) {
+        return container_.template erase(it);
+    }
+
+    /// Removes the @b key from container, leaving the node in an internal pool. The key and value are not destroyed
+    /// and are reused on next insertion.
     template <typename Tag, typename Key>
     bool erase(const Key& key) {
         return container_.template erase<Tag, Key>(key);
     }
 
     std::size_t size() const noexcept { return container_.size(); }
+
     bool empty() const noexcept { return container_.empty(); }
+
     std::size_t capacity() const noexcept { return container_.capacity(); }
 
     void set_capacity(std::size_t new_capacity) { container_.set_capacity(new_capacity); }
 
+    /// Clears the internal nodes pool
+    void shrink_to_fit() { container_.shrink_to_fit(); }
+
+    /// Removes all elements from the container, leaving the node in an internal pool. The keys and values are
+    /// not destroyed and are reused on next insertion.
     void clear() { container_.clear(); }
 
     template <typename Tag>
@@ -123,12 +139,11 @@ class ExpirableContainer {
 
     void cleanup_expired() {
         const auto now = std::chrono::steady_clock::now();
-        auto& seq_index = container_.get_sequenced();
 
-        while (!seq_index.empty()) {
-            const auto it = seq_index.rbegin();
+        while (!container_.empty()) {
+            const auto it = container_.find_last_accessed_no_update();
             if (now > it->last_accessed + ttl_) {
-                seq_index.pop_back();
+                container_.erase(it);
             } else {
                 break;
             }

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

@@ -305,6 +305,27 @@ UTEST_F(ExpirableUsersTest, ThreadSafetyBasic) {
     EXPECT_LE(cache.size(), 100);
 }
 
+#ifdef NDEBUG
+
+UTEST_F(ExpirableUsersTest, ZeroTTL) {
+    using namespace std::chrono_literals;
+
+    EXPECT_THROW({ UserCacheExpirable cache(10, 0ms); }, utils::InvariantError);
+}
+
+UTEST_F(ExpirableUsersTest, ZeroCapacity) {
+    using namespace std::chrono_literals;
+
+    EXPECT_THROW({ UserCacheExpirable cache(0, 10s); }, utils::InvariantError);
+}
+
+UTEST_F(ExpirableUsersTest, NegativeTTL) {
+    using namespace std::chrono_literals;
+
+    EXPECT_THROW({ UserCacheExpirable cache(10, -1ms); }, utils::InvariantError);
+}
+#endif
+
 }  // namespace
 
 USERVER_NAMESPACE_END