@nxtedition/rocksdb 7.1.14 → 7.1.16

package/deps/rocksdb/rocksdb/table/merging_iterator.h

@@ -9,12 +9,14 @@
 
 #pragma once
 
+#include "db/range_del_aggregator.h"
 #include "rocksdb/slice.h"
 #include "rocksdb/types.h"
 
 namespace ROCKSDB_NAMESPACE {
 
 class Arena;
+class ArenaWrappedDBIter;
 class InternalKeyComparator;
 
 template <class TValue>
@@ -36,6 +38,8 @@ extern InternalIterator* NewMergingIterator(
 class MergingIterator;
 
 // A builder class to build a merging iterator by adding iterators one by one.
+// User should call only one of AddIterator() or AddPointAndTombstoneIterator()
+// exclusively for the same builder.
 class MergeIteratorBuilder {
  public:
   // comparator: the comparator used in merging comparator
@@ -47,18 +51,41 @@ class MergeIteratorBuilder {
   // Add iter to the merging iterator.
   void AddIterator(InternalIterator* iter);
 
+  // Add a point key iterator and a range tombstone iterator.
+  // `tombstone_iter_ptr` should and only be set by LevelIterator.
+  // *tombstone_iter_ptr will be set to where the merging iterator stores
+  // `tombstone_iter` when MergeIteratorBuilder::Finish() is called. This is
+  // used by LevelIterator to update range tombstone iters when switching to a
+  // different SST file. If a single point iterator with a nullptr range
+  // tombstone iterator is provided, and the point iterator is not a level
+  // iterator, then this builder will return the point iterator directly,
+  // instead of creating a merging iterator on top of it. Internally, if all
+  // point iterators are not LevelIterator, then range tombstone iterator is
+  // only added to the merging iter if there is a non-null `tombstone_iter`.
+  void AddPointAndTombstoneIterator(
+      InternalIterator* point_iter, TruncatedRangeDelIterator* tombstone_iter,
+      TruncatedRangeDelIterator*** tombstone_iter_ptr = nullptr);
+
   // Get arena used to build the merging iterator. It is called one a child
   // iterator needs to be allocated.
   Arena* GetArena() { return arena; }
 
   // Return the result merging iterator.
-  InternalIterator* Finish();
+  // If db_iter is not nullptr, then db_iter->SetMemtableRangetombstoneIter()
+  // will be called with pointer to where the merging iterator
+  // stores the memtable range tombstone iterator.
+  // This is used for DB iterator to refresh memtable range tombstones.
+  InternalIterator* Finish(ArenaWrappedDBIter* db_iter = nullptr);
 
  private:
   MergingIterator* merge_iter;
   InternalIterator* first_iter;
   bool use_merging_iter;
   Arena* arena;
+  // Used to set LevelIterator.range_tombstone_iter_.
+  // See AddRangeTombstoneIterator() implementation for more detail.
+  std::vector<std::pair<size_t, TruncatedRangeDelIterator***>>
+      range_del_iter_ptrs_;
 };
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/table/meta_blocks.cc

@@ -196,10 +196,11 @@ bool NotifyCollectTableCollectorsOnAdd(
 
 void NotifyCollectTableCollectorsOnBlockAdd(
     const std::vector<std::unique_ptr<IntTblPropCollector>>& collectors,
-    const uint64_t block_raw_bytes, const uint64_t block_compressed_bytes_fast,
+    const uint64_t block_uncomp_bytes,
+    const uint64_t block_compressed_bytes_fast,
     const uint64_t block_compressed_bytes_slow) {
   for (auto& collector : collectors) {
-    collector->BlockAdd(block_raw_bytes, block_compressed_bytes_fast,
+    collector->BlockAdd(block_uncomp_bytes, block_compressed_bytes_fast,
                         block_compressed_bytes_slow);
   }
 }

package/deps/rocksdb/rocksdb/table/meta_blocks.h

@@ -92,7 +92,7 @@ bool NotifyCollectTableCollectorsOnAdd(
 
 void NotifyCollectTableCollectorsOnBlockAdd(
     const std::vector<std::unique_ptr<IntTblPropCollector>>& collectors,
-    uint64_t block_raw_bytes, uint64_t block_compressed_bytes_fast,
+    uint64_t block_uncomp_bytes, uint64_t block_compressed_bytes_fast,
     uint64_t block_compressed_bytes_slow);
 
 // NotifyCollectTableCollectorsOnFinish() triggers the `Finish` event for all

package/deps/rocksdb/rocksdb/table/persistent_cache_helper.cc

@@ -11,7 +11,7 @@ namespace ROCKSDB_NAMESPACE {
 
 const PersistentCacheOptions PersistentCacheOptions::kEmpty;
 
-void PersistentCacheHelper::InsertRawPage(
+void PersistentCacheHelper::InsertSerialized(
     const PersistentCacheOptions& cache_options, const BlockHandle& handle,
     const char* data, const size_t size) {
   assert(cache_options.persistent_cache);
@@ -24,7 +24,7 @@ void PersistentCacheHelper::InsertRawPage(
       .PermitUncheckedError();
 }
 
-void PersistentCacheHelper::InsertUncompressedPage(
+void PersistentCacheHelper::InsertUncompressed(
     const PersistentCacheOptions& cache_options, const BlockHandle& handle,
     const BlockContents& contents) {
   assert(cache_options.persistent_cache);
@@ -42,11 +42,11 @@ void PersistentCacheHelper::InsertUncompressedPage(
   ;
 }
 
-Status PersistentCacheHelper::LookupRawPage(
+Status PersistentCacheHelper::LookupSerialized(
     const PersistentCacheOptions& cache_options, const BlockHandle& handle,
-    std::unique_ptr<char[]>* raw_data, const size_t raw_data_size) {
+    std::unique_ptr<char[]>* out_data, const size_t expected_data_size) {
 #ifdef NDEBUG
-  (void)raw_data_size;
+  (void)expected_data_size;
 #endif
   assert(cache_options.persistent_cache);
   assert(cache_options.persistent_cache->IsCompressed());
@@ -56,7 +56,7 @@ Status PersistentCacheHelper::LookupRawPage(
 
   size_t size;
   Status s =
-      cache_options.persistent_cache->Lookup(key.AsSlice(), raw_data, &size);
+      cache_options.persistent_cache->Lookup(key.AsSlice(), out_data, &size);
   if (!s.ok()) {
     // cache miss
     RecordTick(cache_options.statistics, PERSISTENT_CACHE_MISS);
@@ -65,13 +65,14 @@ Status PersistentCacheHelper::LookupRawPage(
 
   // cache hit
   // Block-based table is assumed
-  assert(raw_data_size == handle.size() + BlockBasedTable::kBlockTrailerSize);
-  assert(size == raw_data_size);
+  assert(expected_data_size ==
+         handle.size() + BlockBasedTable::kBlockTrailerSize);
+  assert(size == expected_data_size);
   RecordTick(cache_options.statistics, PERSISTENT_CACHE_HIT);
   return Status::OK();
 }
 
-Status PersistentCacheHelper::LookupUncompressedPage(
+Status PersistentCacheHelper::LookupUncompressed(
     const PersistentCacheOptions& cache_options, const BlockHandle& handle,
     BlockContents* contents) {
   assert(cache_options.persistent_cache);

package/deps/rocksdb/rocksdb/table/persistent_cache_helper.h

@@ -19,26 +19,28 @@ struct BlockContents;
 // Encapsulates  some of the helper logic for read and writing from the cache
 class PersistentCacheHelper {
  public:
-  // insert block into raw page cache
-  static void InsertRawPage(const PersistentCacheOptions& cache_options,
-                            const BlockHandle& handle, const char* data,
-                            const size_t size);
-
-  // insert block into uncompressed cache
-  static void InsertUncompressedPage(
-      const PersistentCacheOptions& cache_options, const BlockHandle& handle,
-      const BlockContents& contents);
-
-  // lookup block from raw page cacge
-  static Status LookupRawPage(const PersistentCacheOptions& cache_options,
-                              const BlockHandle& handle,
-                              std::unique_ptr<char[]>* raw_data,
-                              const size_t raw_data_size);
-
-  // lookup block from uncompressed cache
-  static Status LookupUncompressedPage(
-      const PersistentCacheOptions& cache_options, const BlockHandle& handle,
-      BlockContents* contents);
+  // Insert block into cache of serialized blocks. Size includes block trailer
+  // (if applicable).
+  static void InsertSerialized(const PersistentCacheOptions& cache_options,
+                               const BlockHandle& handle, const char* data,
+                               const size_t size);
+
+  // Insert block into cache of uncompressed blocks. No block trailer.
+  static void InsertUncompressed(const PersistentCacheOptions& cache_options,
+                                 const BlockHandle& handle,
+                                 const BlockContents& contents);
+
+  // Lookup block from cache of serialized blocks. Size includes block trailer
+  // (if applicable).
+  static Status LookupSerialized(const PersistentCacheOptions& cache_options,
+                                 const BlockHandle& handle,
+                                 std::unique_ptr<char[]>* out_data,
+                                 const size_t expected_data_size);
+
+  // Lookup block from uncompressed cache. No block trailer.
+  static Status LookupUncompressed(const PersistentCacheOptions& cache_options,
+                                   const BlockHandle& handle,
+                                   BlockContents* contents);
 };
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/table/plain/plain_table_builder.cc

@@ -277,7 +277,7 @@ Status PlainTableBuilder::Finish() {
   IOStatus s = WriteBlock(property_block_builder.Finish(), file_, &offset_,
                           &property_block_handle);
   if (!s.ok()) {
-    return std::move(s);
+    return static_cast<Status>(s);
   }
   meta_index_builer.Add(kPropertiesBlockName, property_block_handle);
 

package/deps/rocksdb/rocksdb/table/sst_file_writer_collectors.h

@@ -36,7 +36,7 @@ class SstFileWriterPropertiesCollector : public IntTblPropCollector {
     return Status::OK();
   }
 
-  virtual void BlockAdd(uint64_t /* block_raw_bytes */,
+  virtual void BlockAdd(uint64_t /* block_uncomp_bytes */,
                         uint64_t /* block_compressed_bytes_fast */,
                         uint64_t /* block_compressed_bytes_slow */) override {
     // Intentionally left blank. No interest in collecting stats for

package/deps/rocksdb/rocksdb/table/table_builder.h

@@ -22,6 +22,7 @@
 #include "options/cf_options.h"
 #include "rocksdb/options.h"
 #include "rocksdb/table_properties.h"
+#include "table/unique_id_impl.h"
 #include "trace_replay/block_cache_tracer.h"
 
 namespace ROCKSDB_NAMESPACE {
@@ -40,25 +41,8 @@ struct TableReaderOptions {
       bool _force_direct_prefetch = false, int _level = -1,
       BlockCacheTracer* const _block_cache_tracer = nullptr,
       size_t _max_file_size_for_l0_meta_pin = 0,
-      const std::string& _cur_db_session_id = "", uint64_t _cur_file_num = 0)
-      : TableReaderOptions(
-            _ioptions, _prefix_extractor, _env_options, _internal_comparator,
-            _skip_filters, _immortal, _force_direct_prefetch, _level,
-            0 /* _largest_seqno */, _block_cache_tracer,
-            _max_file_size_for_l0_meta_pin, _cur_db_session_id, _cur_file_num) {
-  }
-
-  // @param skip_filters Disables loading/accessing the filter block
-  TableReaderOptions(
-      const ImmutableOptions& _ioptions,
-      const std::shared_ptr<const SliceTransform>& _prefix_extractor,
-      const EnvOptions& _env_options,
-      const InternalKeyComparator& _internal_comparator, bool _skip_filters,
-      bool _immortal, bool _force_direct_prefetch, int _level,
-      SequenceNumber _largest_seqno,
-      BlockCacheTracer* const _block_cache_tracer,
-      size_t _max_file_size_for_l0_meta_pin,
-      const std::string& _cur_db_session_id, uint64_t _cur_file_num)
+      const std::string& _cur_db_session_id = "", uint64_t _cur_file_num = 0,
+      UniqueId64x2 _unique_id = {}, SequenceNumber _largest_seqno = 0)
       : ioptions(_ioptions),
         prefix_extractor(_prefix_extractor),
         env_options(_env_options),
@@ -71,7 +55,8 @@ struct TableReaderOptions {
         block_cache_tracer(_block_cache_tracer),
         max_file_size_for_l0_meta_pin(_max_file_size_for_l0_meta_pin),
         cur_db_session_id(_cur_db_session_id),
-        cur_file_num(_cur_file_num) {}
+        cur_file_num(_cur_file_num),
+        unique_id(_unique_id) {}
 
   const ImmutableOptions& ioptions;
   const std::shared_ptr<const SliceTransform>& prefix_extractor;
@@ -88,7 +73,7 @@ struct TableReaderOptions {
   // What level this table/file is on, -1 for "not set, don't know." Used
   // for level-specific statistics.
   int level;
-  // largest seqno in the table
+  // largest seqno in the table (or 0 means unknown???)
   SequenceNumber largest_seqno;
   BlockCacheTracer* const block_cache_tracer;
   // Largest L0 file size whose meta-blocks may be pinned (can be zero when
@@ -98,6 +83,9 @@ struct TableReaderOptions {
   std::string cur_db_session_id;
 
   uint64_t cur_file_num;
+
+  // Known unique_id or {}, kNullUniqueId64x2 means unknown
+  UniqueId64x2 unique_id;
 };
 
 struct TableBuilderOptions {

package/deps/rocksdb/rocksdb/table/table_test.cc

@@ -407,7 +407,7 @@ class TableConstructor : public Constructor {
     EXPECT_EQ(TEST_GetSink()->contents().size(), builder->FileSize());
 
     // Open the table
-    uniq_id_ = cur_uniq_id_++;
+    file_num_ = cur_file_num_++;
 
     return Reopen(ioptions, moptions);
   }
@@ -438,15 +438,15 @@ class TableConstructor : public Constructor {
   virtual Status Reopen(const ImmutableOptions& ioptions,
                         const MutableCFOptions& moptions) {
     std::unique_ptr<FSRandomAccessFile> source(new test::StringSource(
-        TEST_GetSink()->contents(), uniq_id_, ioptions.allow_mmap_reads));
+        TEST_GetSink()->contents(), file_num_, ioptions.allow_mmap_reads));
 
     file_reader_.reset(new RandomAccessFileReader(std::move(source), "test"));
     return ioptions.table_factory->NewTableReader(
         TableReaderOptions(ioptions, moptions.prefix_extractor, soptions,
                            *last_internal_comparator_, /*skip_filters*/ false,
-                           /*immortal*/ false, false, level_, largest_seqno_,
+                           /*immortal*/ false, false, level_,
                            &block_cache_tracer_, moptions.write_buffer_size, "",
-                           uniq_id_),
+                           file_num_, kNullUniqueId64x2, largest_seqno_),
         std::move(file_reader_), TEST_GetSink()->contents().size(),
         &table_reader_);
   }
@@ -469,14 +469,14 @@ class TableConstructor : public Constructor {
 
  private:
   void Reset() {
-    uniq_id_ = 0;
+    file_num_ = 0;
     table_reader_.reset();
     file_writer_.reset();
     file_reader_.reset();
   }
 
   const ReadOptions read_options_;
-  uint64_t uniq_id_;
+  uint64_t file_num_;
   std::unique_ptr<WritableFileWriter> file_writer_;
   std::unique_ptr<RandomAccessFileReader> file_reader_;
   std::unique_ptr<TableReader> table_reader_;
@@ -486,11 +486,11 @@ class TableConstructor : public Constructor {
 
   TableConstructor();
 
-  static uint64_t cur_uniq_id_;
+  static uint64_t cur_file_num_;
   EnvOptions soptions;
   Env* env_;
 };
-uint64_t TableConstructor::cur_uniq_id_ = 1;
+uint64_t TableConstructor::cur_file_num_ = 1;
 
 class MemTableConstructor: public Constructor {
  public:
@@ -1310,7 +1310,7 @@ class FileChecksumTestHelper {
   Status CalculateFileChecksum(FileChecksumGenerator* file_checksum_generator,
                                std::string* checksum) {
     assert(file_checksum_generator != nullptr);
-    cur_uniq_id_ = checksum_uniq_id_++;
+    cur_file_num_ = checksum_file_num_++;
     test::StringSink* ss_rw =
         static_cast<test::StringSink*>(file_writer_->writable_file());
     std::unique_ptr<FSRandomAccessFile> source(
@@ -1344,17 +1344,17 @@ class FileChecksumTestHelper {
 
  private:
   bool convert_to_internal_key_;
-  uint64_t cur_uniq_id_;
+  uint64_t cur_file_num_;
   std::unique_ptr<WritableFileWriter> file_writer_;
   std::unique_ptr<RandomAccessFileReader> file_reader_;
   std::unique_ptr<TableBuilder> table_builder_;
   stl_wrappers::KVMap kv_map_;
   test::StringSink* sink_ = nullptr;
 
-  static uint64_t checksum_uniq_id_;
+  static uint64_t checksum_file_num_;
 };
 
-uint64_t FileChecksumTestHelper::checksum_uniq_id_ = 1;
+uint64_t FileChecksumTestHelper::checksum_file_num_ = 1;
 
 INSTANTIATE_TEST_CASE_P(FormatVersions, BlockBasedTableTest,
                         testing::ValuesIn(test::kFooterFormatVersionsToTest));

package/deps/rocksdb/rocksdb/tools/block_cache_analyzer/block_cache_pysim_test.py

@@ -8,9 +8,12 @@ import sys
 from block_cache_pysim import (
     ARCCache,
     CacheEntry,
+    create_cache,
     GDSizeCache,
     HashTable,
     HyperbolicPolicy,
+    kMicrosInSecond,
+    kSampleSize,
     LFUPolicy,
     LinUCBCache,
     LRUCache,
@@ -18,13 +21,10 @@ from block_cache_pysim import (
     MRUPolicy,
     OPTCache,
     OPTCacheEntry,
+    run,
     ThompsonSamplingCache,
     TraceCache,
     TraceRecord,
-    create_cache,
-    kMicrosInSecond,
-    kSampleSize,
-    run,
 )
 
 

package/deps/rocksdb/rocksdb/tools/block_cache_analyzer/block_cache_trace_analyzer_plot.py

@@ -13,6 +13,7 @@ import random
 import sys
 
 import matplotlib
+
 matplotlib.use("Agg")
 import matplotlib.backends.backend_pdf
 import matplotlib.pyplot as plt

package/deps/rocksdb/rocksdb/tools/db_bench_tool.cc

@@ -37,7 +37,6 @@
 #include <thread>
 #include <unordered_map>
 
-#include "cache/clock_cache.h"
 #include "cache/fast_lru_cache.h"
 #include "db/db_impl/db_impl.h"
 #include "db/malloc_stats.h"
@@ -560,7 +559,7 @@ DEFINE_bool(universal_incremental, false,
 DEFINE_int64(cache_size, 8 << 20,  // 8MB
              "Number of bytes to use as a cache of uncompressed data");
 
-DEFINE_int32(cache_numshardbits, 6,
+DEFINE_int32(cache_numshardbits, -1,
              "Number of shards for the block cache"
              " is 2 ** cache_numshardbits. Negative means use default settings."
              " This is applied only if FLAGS_cache_size is non-negative.");
@@ -617,8 +616,11 @@ DEFINE_int64(simcache_size, -1,
 DEFINE_bool(cache_index_and_filter_blocks, false,
             "Cache index/filter blocks in block cache.");
 
+DEFINE_bool(use_cache_jemalloc_no_dump_allocator, false,
+            "Use JemallocNodumpAllocator for block/blob cache.");
+
 DEFINE_bool(use_cache_memkind_kmem_allocator, false,
-            "Use memkind kmem allocator for block cache.");
+            "Use memkind kmem allocator for block/blob cache.");
 
 DEFINE_bool(partition_index_and_filters, false,
             "Partition index and filter blocks.");
@@ -1236,6 +1238,14 @@ DEFINE_uint64(
     "BlockBasedTableOptions.initial_auto_readahead_size and doubles on every "
     "additional read upto max_auto_readahead_size");
 
+DEFINE_uint64(
+    num_file_reads_for_auto_readahead,
+    ROCKSDB_NAMESPACE::BlockBasedTableOptions()
+        .num_file_reads_for_auto_readahead,
+    "Rocksdb implicit readahead is enabled if reads are sequential and "
+    "num_file_reads_for_auto_readahead indicates after how many sequential "
+    "reads into that file internal auto prefetching should be start.");
+
 static enum ROCKSDB_NAMESPACE::CompressionType StringToCompressionType(
     const char* ctype) {
   assert(ctype);
@@ -3020,20 +3030,39 @@ class Benchmark {
     const char* Name() const override { return "KeepFilter"; }
   };
 
-  std::shared_ptr<Cache> NewCache(int64_t capacity) {
+  static std::shared_ptr<MemoryAllocator> GetCacheAllocator() {
+    std::shared_ptr<MemoryAllocator> allocator;
+
+    if (FLAGS_use_cache_jemalloc_no_dump_allocator) {
+      JemallocAllocatorOptions jemalloc_options;
+      if (!NewJemallocNodumpAllocator(jemalloc_options, &allocator).ok()) {
+        fprintf(stderr, "JemallocNodumpAllocator not supported.\n");
+        exit(1);
+      }
+    } else if (FLAGS_use_cache_memkind_kmem_allocator) {
+#ifdef MEMKIND
+      allocator = std::make_shared<MemkindKmemAllocator>();
+#else
+      fprintf(stderr, "Memkind library is not linked with the binary.\n");
+      exit(1);
+#endif
+    }
+
+    return allocator;
+  }
+
+  static std::shared_ptr<Cache> NewCache(int64_t capacity) {
     if (capacity <= 0) {
       return nullptr;
     }
     if (FLAGS_cache_type == "clock_cache") {
-      auto cache = ExperimentalNewClockCache(
-          static_cast<size_t>(capacity), FLAGS_block_size,
-          FLAGS_cache_numshardbits, false /*strict_capacity_limit*/,
-          kDefaultCacheMetadataChargePolicy);
-      if (!cache) {
-        fprintf(stderr, "Clock cache not supported.");
-        exit(1);
-      }
-      return cache;
+      fprintf(stderr, "Old clock cache implementation has been removed.\n");
+      exit(1);
+    } else if (FLAGS_cache_type == "hyper_clock_cache") {
+      return HyperClockCacheOptions(static_cast<size_t>(capacity),
+                                    FLAGS_block_size /*estimated_entry_charge*/,
+                                    FLAGS_cache_numshardbits)
+          .MakeSharedCache();
     } else if (FLAGS_cache_type == "fast_lru_cache") {
       return NewFastLRUCache(static_cast<size_t>(capacity), FLAGS_block_size,
                              FLAGS_cache_numshardbits,
@@ -3043,21 +3072,9 @@ class Benchmark {
       LRUCacheOptions opts(
           static_cast<size_t>(capacity), FLAGS_cache_numshardbits,
           false /*strict_capacity_limit*/, FLAGS_cache_high_pri_pool_ratio,
-#ifdef MEMKIND
-          FLAGS_use_cache_memkind_kmem_allocator
-              ? std::make_shared<MemkindKmemAllocator>()
-              : nullptr,
-#else
-          nullptr,
-#endif
-          kDefaultToAdaptiveMutex, kDefaultCacheMetadataChargePolicy,
-          FLAGS_cache_low_pri_pool_ratio);
-      if (FLAGS_use_cache_memkind_kmem_allocator) {
-#ifndef MEMKIND
-        fprintf(stderr, "Memkind library is not linked with the binary.");
-        exit(1);
-#endif
-      }
+          GetCacheAllocator(), kDefaultToAdaptiveMutex,
+          kDefaultCacheMetadataChargePolicy, FLAGS_cache_low_pri_pool_ratio);
+
 #ifndef ROCKSDB_LITE
       if (!FLAGS_secondary_cache_uri.empty()) {
         Status s = SecondaryCache::CreateFromString(
@@ -3598,6 +3615,9 @@ class Benchmark {
         }
         fresh_db = true;
         method = &Benchmark::TimeSeries;
+      } else if (name == "block_cache_entry_stats") {
+        // DB::Properties::kBlockCacheEntryStats
+        PrintStats("rocksdb.block-cache-entry-stats");
       } else if (name == "stats") {
         PrintStats("rocksdb.stats");
       } else if (name == "resetstats") {
@@ -4372,6 +4392,8 @@ class Benchmark {
           FLAGS_max_auto_readahead_size;
       block_based_options.initial_auto_readahead_size =
           FLAGS_initial_auto_readahead_size;
+      block_based_options.num_file_reads_for_auto_readahead =
+          FLAGS_num_file_reads_for_auto_readahead;
       BlockBasedTableOptions::PrepopulateBlockCache prepopulate_block_cache =
           block_based_options.prepopulate_block_cache;
       switch (FLAGS_prepopulate_block_cache) {
@@ -4444,6 +4466,8 @@ class Benchmark {
             LRUCacheOptions co;
             co.capacity = FLAGS_blob_cache_size;
             co.num_shard_bits = FLAGS_blob_cache_numshardbits;
+            co.memory_allocator = GetCacheAllocator();
+
             options.blob_cache = NewLRUCache(co);
           } else {
             fprintf(
@@ -4464,13 +4488,19 @@ class Benchmark {
             fprintf(stderr, "Unknown prepopulate blob cache mode\n");
             exit(1);
         }
+
         fprintf(stdout,
-                "Integrated BlobDB: blob cache enabled, block and blob caches "
-                "shared: %d, blob cache size %" PRIu64
-                ", blob cache num shard bits: %d, hot/warm blobs prepopulated: "
-                "%d\n",
-                FLAGS_use_shared_block_and_blob_cache, FLAGS_blob_cache_size,
-                FLAGS_blob_cache_numshardbits, FLAGS_prepopulate_blob_cache);
+                "Integrated BlobDB: blob cache enabled"
+                ", block and blob caches shared: %d",
+                FLAGS_use_shared_block_and_blob_cache);
+        if (!FLAGS_use_shared_block_and_blob_cache) {
+          fprintf(stdout,
+                  ", blob cache size %" PRIu64
+                  ", blob cache num shard bits: %d",
+                  FLAGS_blob_cache_size, FLAGS_blob_cache_numshardbits);
+        }
+        fprintf(stdout, ", blob cache prepopulated: %d\n",
+                FLAGS_prepopulate_blob_cache);
       } else {
         fprintf(stdout, "Integrated BlobDB: blob cache disabled\n");
       }
@@ -6900,6 +6930,19 @@ class Benchmark {
     std::unique_ptr<const char[]> key_guard;
     Slice key = AllocateKey(&key_guard);
     std::unique_ptr<char[]> ts_guard;
+    std::unique_ptr<const char[]> begin_key_guard;
+    Slice begin_key = AllocateKey(&begin_key_guard);
+    std::unique_ptr<const char[]> end_key_guard;
+    Slice end_key = AllocateKey(&end_key_guard);
+    uint64_t num_range_deletions = 0;
+    std::vector<std::unique_ptr<const char[]>> expanded_key_guards;
+    std::vector<Slice> expanded_keys;
+    if (FLAGS_expand_range_tombstones) {
+      expanded_key_guards.resize(range_tombstone_width_);
+      for (auto& expanded_key_guard : expanded_key_guards) {
+        expanded_keys.emplace_back(AllocateKey(&expanded_key_guard));
+      }
+    }
     if (user_timestamp_size_ > 0) {
       ts_guard.reset(new char[user_timestamp_size_]);
     }
@@ -6962,6 +7005,45 @@ class Benchmark {
             key.size() + val.size(), Env::IO_HIGH,
             nullptr /* stats */, RateLimiter::OpType::kWrite);
       }
+
+      if (writes_per_range_tombstone_ > 0 &&
+          written > writes_before_delete_range_ &&
+          (written - writes_before_delete_range_) /
+                  writes_per_range_tombstone_ <=
+              max_num_range_tombstones_ &&
+          (written - writes_before_delete_range_) %
+                  writes_per_range_tombstone_ ==
+              0) {
+        num_range_deletions++;
+        int64_t begin_num = thread->rand.Next() % FLAGS_num;
+        if (FLAGS_expand_range_tombstones) {
+          for (int64_t offset = 0; offset < range_tombstone_width_; ++offset) {
+            GenerateKeyFromInt(begin_num + offset, FLAGS_num,
+                               &expanded_keys[offset]);
+            if (!db->Delete(write_options_, expanded_keys[offset]).ok()) {
+              fprintf(stderr, "delete error: %s\n", s.ToString().c_str());
+              exit(1);
+            }
+          }
+        } else {
+          GenerateKeyFromInt(begin_num, FLAGS_num, &begin_key);
+          GenerateKeyFromInt(begin_num + range_tombstone_width_, FLAGS_num,
+                             &end_key);
+          if (!db->DeleteRange(write_options_, db->DefaultColumnFamily(),
+                               begin_key, end_key)
+                   .ok()) {
+            fprintf(stderr, "deleterange error: %s\n", s.ToString().c_str());
+            exit(1);
+          }
+        }
+        thread->stats.FinishedOps(&db_, db_.db, 1, kWrite);
+        // TODO: DeleteRange is not included in calculcation of bytes/rate
+        // limiter request
+      }
+    }
+    if (num_range_deletions > 0) {
+      std::cout << "Number of range deletions: " << num_range_deletions
+                << std::endl;
     }
     thread->stats.AddBytes(bytes);
   }

package/deps/rocksdb/rocksdb/tools/ldb_cmd.cc

@@ -4196,7 +4196,12 @@ void UnsafeRemoveSstFileCommand::DoCommand() {
     VersionEdit edit;
     edit.SetColumnFamily(cfd->GetID());
     edit.DeleteFile(level, sst_file_number_);
-    s = w.LogAndApply(cfd, &edit);
+    std::unique_ptr<FSDirectory> db_dir;
+    s = options_.env->GetFileSystem()->NewDirectory(db_path_, IOOptions(),
+                                                    &db_dir, nullptr);
+    if (s.ok()) {
+      s = w.LogAndApply(cfd, &edit, db_dir.get());
+    }
   }
 
   if (!s.ok()) {