tmp

Signed-off-by: Vladislav Oleshko <vlad@dragonflydb.io>

Author: dranikpg

src/core/detail/listpack_wrap.cc

@@ -37,10 +37,6 @@ ListpackWrap ListpackWrap::WithCapacity(size_t capacity) {
   return ListpackWrap{lpNew(capacity)};
 }
 
-ListpackWrap ListpackWrap::WithCapacity(size_t capacity) {
-  return ListpackWrap{lpNew(capacity)};
-}
-
 uint8_t* ListpackWrap::GetPointer() {
   return lp_;
 }
@@ -106,6 +102,10 @@ size_t ListpackWrap::size() const {
   return lpLength(lp_) / 2;
 }
 
+size_t ListpackWrap::DataBytes() const {
+  return lpBytes(lp_);
+}
+
 ListpackWrap::Iterator ListpackWrap::begin() const {
   return Iterator{lp_, lpFirst(lp_), intbuf_};
 }

src/core/detail/listpack_wrap.h

@@ -58,6 +58,8 @@ struct ListpackWrap {
   Iterator end() const;
   size_t size() const;  // number of entries
 
+  size_t DataBytes() const;
+
   // Get view from raw listpack iterator
   static std::string_view GetView(uint8_t* lp_it, uint8_t int_buf[]);
 

src/server/tiered_storage.cc

@@ -222,11 +222,7 @@ class TieredStorage::ShardOpManager : public tiering::OpManager {
       stats->tiered_used_bytes += segment.length;
       stats_.total_stashes++;
 
-<<<<<<< HEAD
       CompactObj::ExternalRep rep = DetermineSerializationParams(*pv).second;
-=======
-      CompactObj::ExternalRep rep = EstimateSerializedSize(*pv)->second;
->>>>>>> 77a24f54 (feat(tiering): Serialize hashes)
       if (ts_->config_.experimental_cooling) {
         RetireColdEntries(pv->MallocUsed());
         ts_->CoolDown(key.first, key.second, segment, rep, pv);
@@ -711,13 +707,8 @@ bool TieredStorage::ShouldStash(const PrimeValue& pv) const {
 }
 
 void TieredStorage::CoolDown(DbIndex db_ind, std::string_view str,
-<<<<<<< HEAD
                              const tiering::DiskSegment& segment, CompactObj::ExternalRep rep,
                              PrimeValue* pv) {
-=======
-                             const tiering::DiskSegment& segment, PrimeValue* pv,
-                             CompactObj::ExternalRep rep) {
->>>>>>> 5b1ceb13 (cooling fixes)
   detail::TieredColdRecord* record = CompactObj::AllocateMR<detail::TieredColdRecord>();
   cool_queue_.push_front(*record);
   stats_.cool_memory_used += (sizeof(detail::TieredColdRecord) + pv->MallocUsed());
@@ -727,11 +718,7 @@ void TieredStorage::CoolDown(DbIndex db_ind, std::string_view str,
   record->page_index = segment.offset / tiering::kPageSize;
   record->value = std::move(*pv);
 
-<<<<<<< HEAD
   pv->SetCool(segment.offset, segment.length, rep, record);
-=======
-  pv->SetCool(segment.offset, segment.length, record, rep);
->>>>>>> 5b1ceb13 (cooling fixes)
 }
 
 PrimeValue TieredStorage::Warmup(DbIndex dbid, PrimeValue::CoolItem item) {

src/server/tiered_storage_test.cc

@@ -516,6 +516,8 @@ TEST_P(LatentCoolingTSTest, SimpleHash) {
   // Wait for all to be stashed or in end up in bins
   ExpectConditionWithinTimeout([=] {
     auto metrics = GetMetrics();
+    VLOG(0) << metrics.tiered_stats.total_stashes << " "
+            << metrics.tiered_stats.small_bins_entries_cnt;
     return metrics.tiered_stats.total_stashes +
                metrics.tiered_stats.small_bins_filling_entries_cnt ==
            kNUM;
@@ -530,6 +532,21 @@ TEST_P(LatentCoolingTSTest, SimpleHash) {
     auto v = string{31, 'x'} + 'f';
     EXPECT_EQ(resp, v);
   }
+
+  // Wait for all offloads again
+  ExpectConditionWithinTimeout([=] {
+    auto metrics = GetMetrics();
+    return metrics.db_stats[0].tiered_entries +
+               metrics.tiered_stats.small_bins_filling_entries_cnt ==
+           kNUM;
+  });
+
+  // HDEL
+  for (size_t i = 0; i < kNUM; i++) {
+    string key = absl::StrCat("k", i);
+    EXPECT_THAT(Run({"DEL", key, string{1, 'c'}}), IntArg(1));
+    EXPECT_THAT(Run({"HLEN", key}), IntArg(25));
+  }
 }
 
 }  // namespace dfly

src/server/tiering/decoders.cc

@@ -4,12 +4,9 @@
 
 #include "server/tiering/decoders.h"
 
-<<<<<<< HEAD
-#include "base/logging.h"
-=======
 #include "core/compact_object.h"
->>>>>>> fbcc8d59 (more than POc)
 #include "core/detail/listpack_wrap.h"
+#include "core/overloaded.h"
 #include "server/tiering/serialized_map.h"
 
 extern "C" {
@@ -82,8 +79,12 @@ void SerializedMapDecoder::Initialize(std::string_view slice) {
 }
 
 Decoder::UploadMetrics SerializedMapDecoder::GetMetrics() const {
-  return UploadMetrics{.modified = modified_,
-                       .estimated_mem_usage = map_->DataBytes() + map_->size() * 2 * 8};
+  Overloaded ov{
+      [](const SerializedMap& sm) { return sm.DataBytes() + sm.size() * 8; },
+      [](const detail::ListpackWrap& lw) { return lw.DataBytes(); },
+  };
+  size_t bytes = visit(Overloaded{ov, [&](const auto& ptr) { return ov(*ptr); }}, map_);
+  return UploadMetrics{.modified = modified_, .estimated_mem_usage = bytes};
 }
 
 void SerializedMapDecoder::Upload(CompactObj* obj) {