@nxtedition/rocksdb 7.0.23 → 7.0.26

package/deps/rocksdb/rocksdb/cache/fast_lru_cache.h

@@ -78,8 +78,9 @@ class FastLRUCacheTest;
 // times at most a fraction p of all slots, without counting tombstones,
 // are occupied by elements. This means that the probability that a
 // random probe hits an empty slot is at most p, and thus at most 1/p probes
-// are required on average. We use p = 70%, so between 1 and 2 probes are
-// needed on average.
+// are required on average. For example, p = 70% implies that between 1 and 2
+// probes are needed on average (bear in mind that this reasoning doesn't
+// consider the effects of clustering over time).
 // Because the size of the hash table is always rounded up to the next
 // power of 2, p is really an upper bound on the actual load factor---the
 // actual load factor is anywhere between p/2 and p. This is a bit wasteful,
@@ -87,7 +88,12 @@ class FastLRUCacheTest;
 // Since space cost is dominated by the values (the LSM blocks),
 // overprovisioning the table with metadata only increases the total cache space
 // usage by a tiny fraction.
-constexpr double kLoadFactor = 0.7;
+constexpr double kLoadFactor = 0.35;
+
+// The user can exceed kLoadFactor if the sizes of the inserted values don't
+// match estimated_value_size, or if strict_capacity_limit == false. To
+// avoid performance to plunge, we set a strict upper bound on the load factor.
+constexpr double kStrictLoadFactor = 0.7;
 
 // Arbitrary seeds.
 constexpr uint32_t kProbingSeed1 = 0xbc9f1d34;
@@ -103,7 +109,7 @@ struct LRUHandle {
   size_t total_charge;  // TODO(opt): Only allow uint32_t?
   // The hash of key(). Used for fast sharding and comparisons.
   uint32_t hash;
-  // The number of external refs to this entry. The cache itself is not counted.
+  // The number of external refs to this entry.
   uint32_t refs;
 
   enum Flags : uint8_t {
@@ -226,16 +232,10 @@ struct LRUHandle {
   }
 };
 
-// TODO(Guido) Update the following comment.
 
-// We provide our own simple hash table since it removes a whole bunch
-// of porting hacks and is also faster than some of the built-in hash
-// table implementations in some of the compiler/runtime combinations
-// we have tested.  E.g., readrandom speeds up by ~5% over the g++
-// 4.4.3's builtin hashtable.
 class LRUHandleTable {
  public:
-  explicit LRUHandleTable(uint8_t hash_bits);
+  explicit LRUHandleTable(int hash_bits);
   ~LRUHandleTable();
 
   // Returns a pointer to a visible element matching the key/hash, or
@@ -269,10 +269,17 @@ class LRUHandleTable {
     }
   }
 
-  uint8_t GetLengthBits() const { return length_bits_; }
+  uint32_t GetTableSize() const { return uint32_t{1} << length_bits_; }
+
+  int GetLengthBits() const { return length_bits_; }
+
+  uint32_t GetOccupancyLimit() const { return occupancy_limit_; }
 
   uint32_t GetOccupancy() const { return occupancy_; }
 
+  // Returns x mod 2^{length_bits_}.
+  uint32_t ModTableSize(uint32_t x) { return x & length_bits_mask_; }
+
  private:
   int FindVisibleElement(const Slice& key, uint32_t hash, int& probe,
                          int displacement);
@@ -295,11 +302,16 @@ class LRUHandleTable {
 
   // Number of hash bits used for table index.
   // The size of the table is 1 << length_bits_.
-  uint8_t length_bits_;
+  int length_bits_;
+
+  const uint32_t length_bits_mask_;
 
   // Number of elements in the table.
   uint32_t occupancy_;
 
+  // Maximum number of elements the user can store in the table.
+  uint32_t occupancy_limit_;
+
   std::unique_ptr<LRUHandle[]> array_;
 };
 
@@ -374,7 +386,7 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
   void LRU_Insert(LRUHandle* e);
 
   // Free some space following strict LRU policy until enough space
-  // to hold (usage_ + charge) is freed or the lru list is empty
+  // to hold (usage_ + charge) is freed or the LRU list is empty
   // This function is not thread safe - it needs to be executed while
   // holding the mutex_.
   void EvictFromLRU(size_t charge, autovector<LRUHandle>* deleted);
@@ -386,8 +398,8 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
 
   // Returns the number of bits used to hash an element in the hash
   // table.
-  static uint8_t CalcHashBits(size_t capacity, size_t estimated_value_size,
-                              CacheMetadataChargePolicy metadata_charge_policy);
+  static int CalcHashBits(size_t capacity, size_t estimated_value_size,
+                          CacheMetadataChargePolicy metadata_charge_policy);
 
   // Initialized before use.
   size_t capacity_;

package/deps/rocksdb/rocksdb/cache/lru_cache.cc

@@ -332,7 +332,7 @@ Status LRUCacheShard::InsertItem(LRUHandle* e, Cache::Handle** handle,
           delete[] reinterpret_cast<char*>(e);
           *handle = nullptr;
         }
-        s = Status::Incomplete("Insert failed due to LRU cache being full.");
+        s = Status::MemoryLimit("Insert failed due to LRU cache being full.");
       }
     } else {
       // Insert into the cache. Note that the cache might get larger than its
@@ -757,6 +757,17 @@ void LRUCache::WaitAll(std::vector<Handle*>& handles) {
   }
 }
 
+std::string LRUCache::GetPrintableOptions() const {
+  std::string ret;
+  ret.reserve(20000);
+  ret.append(ShardedCache::GetPrintableOptions());
+  if (secondary_cache_) {
+    ret.append("  secondary_cache:\n");
+    ret.append(secondary_cache_->GetPrintableOptions());
+  }
+  return ret;
+}
+
 }  // namespace lru_cache
 
 std::shared_ptr<Cache> NewLRUCache(

package/deps/rocksdb/rocksdb/cache/lru_cache.h

@@ -482,6 +482,7 @@ class LRUCache
   virtual DeleterFn GetDeleter(Handle* handle) const override;
   virtual void DisownData() override;
   virtual void WaitAll(std::vector<Handle*>& handles) override;
+  std::string GetPrintableOptions() const override;
 
   //  Retrieves number of elements in LRU, for unit test purpose only.
   size_t TEST_GetLRUSize();

package/deps/rocksdb/rocksdb/cache/lru_cache_test.cc

@@ -9,6 +9,7 @@
 #include <vector>
 
 #include "cache/cache_key.h"
+#include "cache/clock_cache.h"
 #include "cache/fast_lru_cache.h"
 #include "db/db_test_util.h"
 #include "file/sst_file_manager_impl.h"
@@ -207,8 +208,8 @@ TEST_F(LRUCacheTest, EntriesWithPriority) {
 }
 
 namespace fast_lru_cache {
-// TODO(guido) Consolidate the following FastLRUCache tests with
-// that of LRUCache.
+
+// TODO(guido) Replicate LRU policy tests from LRUCache here.
 class FastLRUCacheTest : public testing::Test {
  public:
   FastLRUCacheTest() {}
@@ -246,9 +247,8 @@ class FastLRUCacheTest : public testing::Test {
         estimated_value_size, metadata_charge_policy);
   }
 
-  uint8_t CalcHashBitsWrapper(
-      size_t capacity, size_t estimated_value_size,
-      CacheMetadataChargePolicy metadata_charge_policy) {
+  int CalcHashBitsWrapper(size_t capacity, size_t estimated_value_size,
+                          CacheMetadataChargePolicy metadata_charge_policy) {
     return fast_lru_cache::LRUCacheShard::CalcHashBits(
         capacity, estimated_value_size, metadata_charge_policy);
   }
@@ -262,7 +262,7 @@ class FastLRUCacheTest : public testing::Test {
     return capacity / (fast_lru_cache::kLoadFactor * handle_charge);
   }
 
-  bool TableSizeIsAppropriate(uint8_t hash_bits, double max_occupancy) {
+  bool TableSizeIsAppropriate(int hash_bits, double max_occupancy) {
     if (hash_bits == 0) {
       return max_occupancy <= 1;
     } else {
@@ -287,51 +287,63 @@ TEST_F(FastLRUCacheTest, ValidateKeySize) {
 }
 
 TEST_F(FastLRUCacheTest, CalcHashBitsTest) {
-  size_t capacity = 1024;
-  size_t estimated_value_size = 1;
-  CacheMetadataChargePolicy metadata_charge_policy = kDontChargeCacheMetadata;
-  double max_occupancy =
-      CalcMaxOccupancy(capacity, estimated_value_size, metadata_charge_policy);
-  uint8_t hash_bits = CalcHashBitsWrapper(capacity, estimated_value_size,
-                                          metadata_charge_policy);
-  EXPECT_TRUE(TableSizeIsAppropriate(hash_bits, max_occupancy));
+  size_t capacity;
+  size_t estimated_value_size;
+  double max_occupancy;
+  int hash_bits;
+  CacheMetadataChargePolicy metadata_charge_policy;
+
+  // Vary the cache capacity, fix the element charge.
+  for (int i = 0; i < 2048; i++) {
+    capacity = i;
+    estimated_value_size = 0;
+    metadata_charge_policy = kFullChargeCacheMetadata;
+    max_occupancy = CalcMaxOccupancy(capacity, estimated_value_size,
+                                     metadata_charge_policy);
+    hash_bits = CalcHashBitsWrapper(capacity, estimated_value_size,
+                                    metadata_charge_policy);
+    EXPECT_TRUE(TableSizeIsAppropriate(hash_bits, max_occupancy));
+  }
 
-  capacity = 1024;
+  // Fix the cache capacity, vary the element charge.
+  for (int i = 0; i < 1024; i++) {
+    capacity = 1024;
+    estimated_value_size = i;
+    metadata_charge_policy = kFullChargeCacheMetadata;
+    max_occupancy = CalcMaxOccupancy(capacity, estimated_value_size,
+                                     metadata_charge_policy);
+    hash_bits = CalcHashBitsWrapper(capacity, estimated_value_size,
+                                    metadata_charge_policy);
+    EXPECT_TRUE(TableSizeIsAppropriate(hash_bits, max_occupancy));
+  }
+
+  // Zero-capacity cache, and only values have charge.
+  capacity = 0;
   estimated_value_size = 1;
-  metadata_charge_policy = kFullChargeCacheMetadata;
-  max_occupancy =
-      CalcMaxOccupancy(capacity, estimated_value_size, metadata_charge_policy);
+  metadata_charge_policy = kDontChargeCacheMetadata;
   hash_bits = CalcHashBitsWrapper(capacity, estimated_value_size,
                                   metadata_charge_policy);
-  EXPECT_TRUE(TableSizeIsAppropriate(hash_bits, max_occupancy));
+  EXPECT_TRUE(TableSizeIsAppropriate(hash_bits, 0 /* max_occupancy */));
 
-  // No elements fit in cache.
+  // Zero-capacity cache, and only metadata has charge.
   capacity = 0;
-  estimated_value_size = 1;
-  metadata_charge_policy = kDontChargeCacheMetadata;
+  estimated_value_size = 0;
+  metadata_charge_policy = kFullChargeCacheMetadata;
   hash_bits = CalcHashBitsWrapper(capacity, estimated_value_size,
                                   metadata_charge_policy);
   EXPECT_TRUE(TableSizeIsAppropriate(hash_bits, 0 /* max_occupancy */));
 
-  // Set the capacity just below a single handle. Because the load factor is <
-  // 100% at least one handle will fit in the table.
-  estimated_value_size = 1;
-  size_t handle_charge = CalcEstimatedHandleChargeWrapper(
-      8192 /* estimated_value_size */, kDontChargeCacheMetadata);
-  capacity = handle_charge - 1;
-  // The load factor should be bounded away from 100%.
-  assert(static_cast<size_t>(capacity / fast_lru_cache::kLoadFactor) >
-         handle_charge);
-  metadata_charge_policy = kDontChargeCacheMetadata;
-  max_occupancy =
-      CalcMaxOccupancy(capacity, estimated_value_size, metadata_charge_policy);
+  // Small cache, large elements.
+  capacity = 1024;
+  estimated_value_size = 8192;
+  metadata_charge_policy = kFullChargeCacheMetadata;
   hash_bits = CalcHashBitsWrapper(capacity, estimated_value_size,
                                   metadata_charge_policy);
-  EXPECT_TRUE(TableSizeIsAppropriate(hash_bits, max_occupancy));
+  EXPECT_TRUE(TableSizeIsAppropriate(hash_bits, 0 /* max_occupancy */));
 
   // Large capacity.
   capacity = 31924172;
-  estimated_value_size = 321;
+  estimated_value_size = 8192;
   metadata_charge_policy = kFullChargeCacheMetadata;
   max_occupancy =
       CalcMaxOccupancy(capacity, estimated_value_size, metadata_charge_policy);
@@ -342,6 +354,128 @@ TEST_F(FastLRUCacheTest, CalcHashBitsTest) {
 
 }  // namespace fast_lru_cache
 
+namespace clock_cache {
+
+class ClockCacheTest : public testing::Test {
+ public:
+  ClockCacheTest() {}
+  ~ClockCacheTest() override { DeleteShard(); }
+
+  void DeleteShard() {
+    if (shard_ != nullptr) {
+      shard_->~ClockCacheShard();
+      port::cacheline_aligned_free(shard_);
+      shard_ = nullptr;
+    }
+  }
+
+  void NewShard(size_t capacity) {
+    DeleteShard();
+    shard_ = reinterpret_cast<ClockCacheShard*>(
+        port::cacheline_aligned_alloc(sizeof(ClockCacheShard)));
+    new (shard_) ClockCacheShard(capacity, 1, true /*strict_capacity_limit*/,
+                                 kDontChargeCacheMetadata);
+  }
+
+  Status Insert(const std::string& key,
+                Cache::Priority priority = Cache::Priority::LOW) {
+    return shard_->Insert(key, 0 /*hash*/, nullptr /*value*/, 1 /*charge*/,
+                          nullptr /*deleter*/, nullptr /*handle*/, priority);
+  }
+
+  Status Insert(char key, Cache::Priority priority = Cache::Priority::LOW) {
+    return Insert(std::string(kCacheKeySize, key), priority);
+  }
+
+  Status Insert(char key, size_t len) { return Insert(std::string(len, key)); }
+
+  bool Lookup(const std::string& key) {
+    auto handle = shard_->Lookup(key, 0 /*hash*/);
+    if (handle) {
+      shard_->Release(handle);
+      return true;
+    }
+    return false;
+  }
+
+  bool Lookup(char key) { return Lookup(std::string(kCacheKeySize, key)); }
+
+  void Erase(const std::string& key) { shard_->Erase(key, 0 /*hash*/); }
+
+  // void ValidateLRUList(std::vector<std::string> keys,
+  //                      size_t num_high_pri_pool_keys = 0) {
+  // LRUHandle* lru;
+  // LRUHandle* lru_low_pri;
+  // cache_->TEST_GetLRUList(&lru, &lru_low_pri);
+  // LRUHandle* iter = lru;
+  // bool in_high_pri_pool = false;
+  // size_t high_pri_pool_keys = 0;
+  // if (iter == lru_low_pri) {
+  //   in_high_pri_pool = true;
+  // }
+  // for (const auto& key : keys) {
+  //   iter = iter->next;
+  //   ASSERT_NE(lru, iter);
+  //   ASSERT_EQ(key, iter->key().ToString());
+  //   ASSERT_EQ(in_high_pri_pool, iter->InHighPriPool());
+  //   if (in_high_pri_pool) {
+  //     high_pri_pool_keys++;
+  //   }
+  //   if (iter == lru_low_pri) {
+  //     ASSERT_FALSE(in_high_pri_pool);
+  //     in_high_pri_pool = true;
+  //   }
+  // }
+  // ASSERT_EQ(lru, iter->next);
+  // ASSERT_TRUE(in_high_pri_pool);
+  // ASSERT_EQ(num_high_pri_pool_keys, high_pri_pool_keys);
+  // }
+
+ private:
+  clock_cache::ClockCacheShard* shard_ = nullptr;
+};
+
+TEST_F(ClockCacheTest, Validate) {
+  NewShard(3);
+  EXPECT_OK(Insert('a', 16));
+  EXPECT_NOK(Insert('b', 15));
+  EXPECT_OK(Insert('b', 16));
+  EXPECT_NOK(Insert('c', 17));
+  EXPECT_NOK(Insert('d', 1000));
+  EXPECT_NOK(Insert('e', 11));
+  EXPECT_NOK(Insert('f', 0));
+}
+
+TEST_F(ClockCacheTest, ClockPriorityTest) {
+  clock_cache::ClockHandle handle;
+  EXPECT_EQ(handle.GetClockPriority(),
+            clock_cache::ClockHandle::ClockPriority::NONE);
+  handle.SetClockPriority(clock_cache::ClockHandle::ClockPriority::HIGH);
+  EXPECT_EQ(handle.GetClockPriority(),
+            clock_cache::ClockHandle::ClockPriority::HIGH);
+  handle.DecreaseClockPriority();
+  EXPECT_EQ(handle.GetClockPriority(),
+            clock_cache::ClockHandle::ClockPriority::MEDIUM);
+  handle.DecreaseClockPriority();
+  EXPECT_EQ(handle.GetClockPriority(),
+            clock_cache::ClockHandle::ClockPriority::LOW);
+  handle.SetClockPriority(clock_cache::ClockHandle::ClockPriority::MEDIUM);
+  EXPECT_EQ(handle.GetClockPriority(),
+            clock_cache::ClockHandle::ClockPriority::MEDIUM);
+  handle.SetClockPriority(clock_cache::ClockHandle::ClockPriority::NONE);
+  EXPECT_EQ(handle.GetClockPriority(),
+            clock_cache::ClockHandle::ClockPriority::NONE);
+  handle.SetClockPriority(clock_cache::ClockHandle::ClockPriority::MEDIUM);
+  EXPECT_EQ(handle.GetClockPriority(),
+            clock_cache::ClockHandle::ClockPriority::MEDIUM);
+  handle.DecreaseClockPriority();
+  handle.DecreaseClockPriority();
+  EXPECT_EQ(handle.GetClockPriority(),
+            clock_cache::ClockHandle::ClockPriority::NONE);
+}
+
+}  // namespace clock_cache
+
 class TestSecondaryCache : public SecondaryCache {
  public:
   // Specifies what action to take on a lookup for a particular key

package/deps/rocksdb/rocksdb/db/blob/blob_file_cache_test.cc

@@ -254,7 +254,7 @@ TEST_F(BlobFileCacheTest, GetBlobFileReader_CacheFull) {
   CacheHandleGuard<BlobFileReader> reader;
 
   ASSERT_TRUE(blob_file_cache.GetBlobFileReader(blob_file_number, &reader)
-                  .IsIncomplete());
+                  .IsMemoryLimit());
   ASSERT_EQ(reader.GetValue(), nullptr);
   ASSERT_EQ(options.statistics->getTickerCount(NO_FILE_OPENS), 1);
   ASSERT_EQ(options.statistics->getTickerCount(NO_FILE_ERRORS), 1);

package/deps/rocksdb/rocksdb/db/blob/blob_file_reader.cc

@@ -16,6 +16,7 @@
 #include "rocksdb/file_system.h"
 #include "rocksdb/slice.h"
 #include "rocksdb/status.h"
+#include "table/multiget_context.h"
 #include "test_util/sync_point.h"
 #include "util/compression.h"
 #include "util/crc32c.h"
@@ -335,7 +336,9 @@ Status BlobFileReader::GetBlob(const ReadOptions& read_options,
 
   if (!prefetched) {
     TEST_SYNC_POINT("BlobFileReader::GetBlob:ReadFromFile");
-
+    PERF_COUNTER_ADD(blob_read_count, 1);
+    PERF_COUNTER_ADD(blob_read_byte, record_size);
+    PERF_TIMER_GUARD(blob_read_time);
     const Status s = ReadFromFile(file_reader_.get(), record_offset,
                                   static_cast<size_t>(record_size), statistics_,
                                   &record_slice, &buf, &aligned_buf,
@@ -372,40 +375,50 @@ Status BlobFileReader::GetBlob(const ReadOptions& read_options,
   return Status::OK();
 }
 
-void BlobFileReader::MultiGetBlob(
-    const ReadOptions& read_options,
-    const autovector<std::reference_wrapper<const Slice>>& user_keys,
-    const autovector<uint64_t>& offsets,
-    const autovector<uint64_t>& value_sizes, autovector<Status*>& statuses,
-    autovector<PinnableSlice*>& values, uint64_t* bytes_read) const {
-  const size_t num_blobs = user_keys.size();
+void BlobFileReader::MultiGetBlob(const ReadOptions& read_options,
+                                  autovector<BlobReadRequest*>& blob_reqs,
+                                  uint64_t* bytes_read) const {
+  const size_t num_blobs = blob_reqs.size();
   assert(num_blobs > 0);
-  assert(num_blobs == offsets.size());
-  assert(num_blobs == value_sizes.size());
-  assert(num_blobs == statuses.size());
-  assert(num_blobs == values.size());
+  assert(num_blobs <= MultiGetContext::MAX_BATCH_SIZE);
 
 #ifndef NDEBUG
-  for (size_t i = 0; i < offsets.size() - 1; ++i) {
-    assert(offsets[i] <= offsets[i + 1]);
+  for (size_t i = 0; i < num_blobs - 1; ++i) {
+    assert(blob_reqs[i]->offset <= blob_reqs[i + 1]->offset);
   }
 #endif  // !NDEBUG
 
-  std::vector<FSReadRequest> read_reqs(num_blobs);
+  std::vector<FSReadRequest> read_reqs;
   autovector<uint64_t> adjustments;
   uint64_t total_len = 0;
+  read_reqs.reserve(num_blobs);
   for (size_t i = 0; i < num_blobs; ++i) {
-    const size_t key_size = user_keys[i].get().size();
-    assert(IsValidBlobOffset(offsets[i], key_size, value_sizes[i], file_size_));
+    const size_t key_size = blob_reqs[i]->user_key->size();
+    const uint64_t offset = blob_reqs[i]->offset;
+    const uint64_t value_size = blob_reqs[i]->len;
+
+    if (!IsValidBlobOffset(offset, key_size, value_size, file_size_)) {
+      *blob_reqs[i]->status = Status::Corruption("Invalid blob offset");
+      continue;
+    }
+    if (blob_reqs[i]->compression != compression_type_) {
+      *blob_reqs[i]->status =
+          Status::Corruption("Compression type mismatch when reading a blob");
+      continue;
+    }
+
     const uint64_t adjustment =
         read_options.verify_checksums
             ? BlobLogRecord::CalculateAdjustmentForRecordHeader(key_size)
             : 0;
-    assert(offsets[i] >= adjustment);
+    assert(blob_reqs[i]->offset >= adjustment);
     adjustments.push_back(adjustment);
-    read_reqs[i].offset = offsets[i] - adjustment;
-    read_reqs[i].len = value_sizes[i] + adjustment;
-    total_len += read_reqs[i].len;
+
+    FSReadRequest read_req;
+    read_req.offset = blob_reqs[i]->offset - adjustment;
+    read_req.len = blob_reqs[i]->len + adjustment;
+    read_reqs.emplace_back(read_req);
+    total_len += read_req.len;
   }
 
   RecordTick(statistics_, BLOB_DB_BLOB_FILE_BYTES_READ, total_len);
@@ -428,6 +441,8 @@ void BlobFileReader::MultiGetBlob(
     }
   }
   TEST_SYNC_POINT("BlobFileReader::MultiGetBlob:ReadFromFile");
+  PERF_COUNTER_ADD(blob_read_count, num_blobs);
+  PERF_COUNTER_ADD(blob_read_byte, total_len);
   s = file_reader_->MultiRead(IOOptions(), read_reqs.data(), read_reqs.size(),
                               direct_io ? &aligned_buf : nullptr,
                               read_options.rate_limiter_priority);
@@ -435,9 +450,12 @@ void BlobFileReader::MultiGetBlob(
     for (auto& req : read_reqs) {
       req.status.PermitUncheckedError();
     }
-    for (size_t i = 0; i < num_blobs; ++i) {
-      assert(statuses[i]);
-      *statuses[i] = s;
+    for (auto& req : blob_reqs) {
+      assert(req->status);
+      if (!req->status->IsCorruption()) {
+        // Avoid overwriting corruption status.
+        *req->status = s;
+      }
     }
     return;
   }
@@ -445,33 +463,39 @@ void BlobFileReader::MultiGetBlob(
   assert(s.ok());
 
   uint64_t total_bytes = 0;
-  for (size_t i = 0; i < num_blobs; ++i) {
-    auto& req = read_reqs[i];
-    const auto& record_slice = req.result;
+  for (size_t i = 0, j = 0; i < num_blobs; ++i) {
+    assert(blob_reqs[i]->status);
+    if (!blob_reqs[i]->status->ok()) {
+      continue;
+    }
 
-    assert(statuses[i]);
+    assert(j < read_reqs.size());
+    auto& req = read_reqs[j++];
+    const auto& record_slice = req.result;
     if (req.status.ok() && record_slice.size() != req.len) {
       req.status = IOStatus::Corruption("Failed to read data from blob file");
     }
 
-    *statuses[i] = req.status;
-    if (!statuses[i]->ok()) {
+    *blob_reqs[i]->status = req.status;
+    if (!blob_reqs[i]->status->ok()) {
       continue;
     }
 
     // Verify checksums if enabled
     if (read_options.verify_checksums) {
-      *statuses[i] = VerifyBlob(record_slice, user_keys[i], value_sizes[i]);
-      if (!statuses[i]->ok()) {
+      *blob_reqs[i]->status =
+          VerifyBlob(record_slice, *blob_reqs[i]->user_key, blob_reqs[i]->len);
+      if (!blob_reqs[i]->status->ok()) {
         continue;
       }
     }
 
     // Uncompress blob if needed
-    Slice value_slice(record_slice.data() + adjustments[i], value_sizes[i]);
-    *statuses[i] = UncompressBlobIfNeeded(value_slice, compression_type_,
-                                          clock_, statistics_, values[i]);
-    if (statuses[i]->ok()) {
+    Slice value_slice(record_slice.data() + adjustments[i], blob_reqs[i]->len);
+    *blob_reqs[i]->status =
+        UncompressBlobIfNeeded(value_slice, compression_type_, clock_,
+                               statistics_, blob_reqs[i]->result);
+    if (blob_reqs[i]->status->ok()) {
       total_bytes += record_slice.size();
     }
   }
@@ -483,6 +507,8 @@ void BlobFileReader::MultiGetBlob(
 
 Status BlobFileReader::VerifyBlob(const Slice& record_slice,
                                   const Slice& user_key, uint64_t value_size) {
+  PERF_TIMER_GUARD(blob_checksum_time);
+
   BlobLogRecord record;
 
   const Slice header_slice(record_slice.data(), BlobLogRecord::kHeaderSize);
@@ -547,6 +573,7 @@ Status BlobFileReader::UncompressBlobIfNeeded(const Slice& value_slice,
   CacheAllocationPtr output;
 
   {
+    PERF_TIMER_GUARD(blob_decompress_time);
     StopWatch stop_watch(clock, statistics, BLOB_DB_DECOMPRESSION_MICROS);
     output = UncompressData(info, value_slice.data(), value_slice.size(),
                             &uncompressed_size, compression_format_version,

package/deps/rocksdb/rocksdb/db/blob/blob_file_reader.h

@@ -8,6 +8,7 @@
 #include <cinttypes>
 #include <memory>
 
+#include "db/blob/blob_read_request.h"
 #include "file/random_access_file_reader.h"
 #include "rocksdb/compression_type.h"
 #include "rocksdb/rocksdb_namespace.h"
@@ -47,12 +48,9 @@ class BlobFileReader {
                  uint64_t* bytes_read) const;
 
   // offsets must be sorted in ascending order by caller.
-  void MultiGetBlob(
-      const ReadOptions& read_options,
-      const autovector<std::reference_wrapper<const Slice>>& user_keys,
-      const autovector<uint64_t>& offsets,
-      const autovector<uint64_t>& value_sizes, autovector<Status*>& statuses,
-      autovector<PinnableSlice*>& values, uint64_t* bytes_read) const;
+  void MultiGetBlob(const ReadOptions& read_options,
+                    autovector<BlobReadRequest*>& blob_reqs,
+                    uint64_t* bytes_read) const;
 
   CompressionType GetCompressionType() const { return compression_type_; }