add bulk reinsertion

Author: williamnixon20

cachelib/allocator/MMS3FIFO.h

@@ -409,6 +409,7 @@ void MMS3FIFO::Container<T, HookPtr>::lazyPromoteSmallTailLocked()
   auto& smallList = lru_.getList(LruType::Small);
 
   // Only process Small when it exceeds target size.
+  // At stable state, this op is constant time.
   while (smallList.size() > targetSmallSize) {
     auto* tail = smallList.getTail();
     if (!tail) {
@@ -430,20 +431,24 @@ template <typename T, MMS3FIFO::Hook<T> T::* HookPtr>
 void MMS3FIFO::Container<T, HookPtr>::lazyReinsertMainTailLocked()
     const noexcept {
   auto& mainList = lru_.getList(LruType::Main);
-  // Cap at mainList.size() to guarantee termination — after one full
-  // pass all access bits are cleared.
-  size_t maxReinsertions = mainList.size();
-  size_t reinserted = 0;
-  while (reinserted < maxReinsertions) {
-    auto* tail = mainList.getTail();
-    if (!tail || !isAccessed(*tail)) {
-      break;
-    }
-    mainList.remove(*tail);
-    mainList.linkAtHead(*tail);
-    unmarkAccessed(*tail);
-    ++reinserted;
+  auto* tail = mainList.getTail();
+  if (tail == nullptr || !isAccessed(*tail)) {
+    return;
   }
+
+  auto* cur = tail;
+  auto* first = tail;
+
+  // Find the contiguous accessed suffix at Main tail and clear access bits.
+  while (cur && isAccessed(*cur)) {
+    unmarkAccessed(*cur);
+    first = cur;
+    cur = mainList.getPrev(*cur);
+  }
+
+  // Move that entire suffix to head in one splice.
+  // Reinsertion is expensive in a workload with high hit ratio.
+  mainList.moveSuffixToHead(*first);
 }
 
 template <typename T, MMS3FIFO::Hook<T> T::* HookPtr>

cachelib/allocator/datastruct/DList.h

@@ -173,6 +173,12 @@ class DList {
   // list.
   void moveToHead(T& node) noexcept;
 
+  // Splices the contiguous suffix [first, ..., tail_] to the head of the
+  // list in O(1). After the call, `first` is the new head and the node
+  // previously preceding `first` becomes the new tail.
+  // @param first   the leftmost node of the suffix to move; must be in the list
+  void moveSuffixToHead(T& first) noexcept;
+
   T* getHead() const noexcept { return head_; }
   T* getTail() const noexcept { return tail_; }
 
@@ -393,6 +399,27 @@ void DList<T, HookPtr>::moveToHead(T& node) noexcept {
   linkAtHead(node);
 }
 
+template <typename T, DListHook<T> T::*HookPtr>
+void DList<T, HookPtr>::moveSuffixToHead(T& first) noexcept {
+  if (&first == head_) {
+    return;
+  }
+
+  T* const newTail = getPrev(first);
+  XDCHECK(newTail != nullptr);
+
+  // Detach suffix [first, ..., tail_] from the prefix.
+  setNext(*newTail, nullptr);
+
+  // Splice the suffix in front of the old head.
+  setNext(*tail_, head_);
+  setPrev(*head_, tail_);
+  setPrev(first, nullptr);
+
+  head_ = &first;
+  tail_ = newTail;
+}
+
 /* Iterator Implementation */
 template <typename T, DListHook<T> T::*HookPtr>
 void DList<T, HookPtr>::Iterator::goForward() noexcept {