chore(hset_family): Listpack wrapper (#5889)

Author: dranikpg

src/core/CMakeLists.txt

@@ -26,7 +26,7 @@ add_library(dfly_core allocation_tracker.cc bloom.cc compact_object.cc dense_set
     dragonfly_core.cc extent_tree.cc huff_coder.cc
     interpreter.cc glob_matcher.cc mi_memory_resource.cc qlist.cc sds_utils.cc
     segment_allocator.cc score_map.cc small_string.cc sorted_map.cc task_queue.cc
-    tx_queue.cc string_set.cc string_map.cc top_keys.cc detail/bitpacking.cc
+    tx_queue.cc string_set.cc string_map.cc top_keys.cc detail/bitpacking.cc detail/listpack_wrap.cc
         page_usage_stats.cc count_min_sketch.cc)
 
 cxx_link(dfly_core base dfly_search_core fibers2 jsonpath

src/core/detail/listpack_wrap.cc

@@ -0,0 +1,57 @@
+// Copyright 2025, DragonflyDB authors.  All rights reserved.
+// See LICENSE for licensing terms.
+//
+#include "core/detail/listpack_wrap.h"
+
+#include "server/container_utils.h"
+
+extern "C" {
+#include "redis/listpack.h"
+}
+
+namespace dfly::detail {
+
+ListpackWrap::Iterator::Iterator(uint8_t* lp, uint8_t* ptr)
+    : lp_{lp}, ptr_{ptr}, next_ptr_{nullptr} {
+  static_assert(sizeof(intbuf_[0]) >= LP_INTBUF_SIZE);  // to avoid header dependency
+  Read();
+}
+
+ListpackWrap::Iterator& ListpackWrap::Iterator::operator++() {
+  ptr_ = next_ptr_;
+  Read();
+  return *this;
+}
+
+void ListpackWrap::Iterator::Read() {
+  if (!ptr_)
+    return;
+
+  using container_utils::LpGetView;
+  key_v_ = LpGetView(ptr_, intbuf_[0]);
+  next_ptr_ = lpNext(lp_, ptr_);
+  value_v_ = LpGetView(next_ptr_, intbuf_[1]);
+  next_ptr_ = lpNext(lp_, next_ptr_);
+}
+
+ListpackWrap::Iterator ListpackWrap::Find(std::string_view key) const {
+  uint8_t* ptr = lpFind(lp_, lpFirst(lp_), (unsigned char*)key.data(), key.size(), 1);
+  return Iterator{lp_, ptr};
+}
+
+size_t ListpackWrap::size() const {
+  return lpLength(lp_) / 2;
+}
+
+ListpackWrap::Iterator ListpackWrap::begin() const {
+  return Iterator{lp_, lpFirst(lp_)};
+}
+
+ListpackWrap::Iterator ListpackWrap::end() const {
+  return Iterator{lp_, nullptr};
+}
+
+bool ListpackWrap::Iterator::operator==(const Iterator& other) const {
+  return lp_ == other.lp_ && ptr_ == other.ptr_;
+}
+}  // namespace dfly::detail

src/core/detail/listpack_wrap.h

@@ -0,0 +1,57 @@
+// Copyright 2025, DragonflyDB authors.  All rights reserved.
+// See LICENSE for licensing terms.
+//
+#pragma once
+
+#include <cstdint>
+#include <cstdio>
+#include <string_view>
+
+namespace dfly::detail {
+
+// Wrapper around map data structure based on listpack
+struct ListpackWrap {
+  struct Iterator {
+    using iterator_category = std::forward_iterator_tag;
+    using difference_type = std::ptrdiff_t;
+    using value_type = std::pair<std::string_view, std::string_view>;
+
+    Iterator(uint8_t* lp, uint8_t* ptr);
+    Iterator(const Iterator&) = delete;  // self-referential with intbuf
+    Iterator(Iterator&&) = delete;       // self-referential with intbuf
+    Iterator& operator=(Iterator&&) = delete;
+    Iterator& operator=(const Iterator&) = delete;
+
+    Iterator& operator++();
+
+    value_type operator*() const {
+      return {key_v_, value_v_};
+    }
+
+    bool operator==(const Iterator& other) const;
+
+    bool operator!=(const Iterator& other) const {
+      return !(operator==(other));
+    }
+
+   private:
+    void Read();  // Read next entry at ptr and determine next_ptr
+
+    uint8_t *lp_ = nullptr, *ptr_ = nullptr, *next_ptr_ = nullptr;
+    std::string_view key_v_, value_v_;
+    uint8_t intbuf_[2][24];
+  };
+
+  explicit ListpackWrap(uint8_t* lp) : lp_{lp} {
+  }
+
+  Iterator Find(std::string_view key) const;  // Linear search
+  Iterator begin() const;
+  Iterator end() const;
+  size_t size() const;  // number of entries
+
+ private:
+  uint8_t* lp_;
+};
+
+}  // namespace dfly::detail

src/server/container_utils.cc

@@ -5,6 +5,7 @@
 
 #include "base/flags.h"
 #include "base/logging.h"
+#include "core/detail/listpack_wrap.h"
 #include "core/qlist.h"
 #include "core/sorted_map.h"
 #include "core/string_map.h"
@@ -243,14 +244,8 @@ bool IterateMap(const PrimeValue& pv, const IterateKVFunc& func) {
   bool finished = true;
 
   if (pv.Encoding() == kEncodingListPack) {
-    uint8_t k_intbuf[LP_INTBUF_SIZE], v_intbuf[LP_INTBUF_SIZE];
-    uint8_t* lp = (uint8_t*)pv.RObjPtr();
-    uint8_t* fptr = lpFirst(lp);
-    while (fptr) {
-      string_view key = LpGetView(fptr, k_intbuf);
-      fptr = lpNext(lp, fptr);
-      string_view val = LpGetView(fptr, v_intbuf);
-      fptr = lpNext(lp, fptr);
+    detail::ListpackWrap lw{static_cast<uint8_t*>(pv.RObjPtr())};
+    for (const auto [key, val] : lw) {
       if (!func(ContainerEntry{key.data(), key.size()}, ContainerEntry{val.data(), val.size()})) {
         finished = false;
         break;