@nxtedition/rocksdb 7.0.24 → 7.0.27

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

@@ -115,7 +115,7 @@ class BlobSourceTest : public DBTestBase {
     options_.create_if_missing = true;
 
     LRUCacheOptions co;
-    co.capacity = 2048;
+    co.capacity = 8 << 20;
     co.num_shard_bits = 2;
     co.metadata_charge_policy = kDontChargeCacheMetadata;
     options_.blob_cache = NewLRUCache(co);
@@ -134,6 +134,10 @@ TEST_F(BlobSourceTest, GetBlobsFromCache) {
   options_.cf_paths.emplace_back(
       test::PerThreadDBPath(env_, "BlobSourceTest_GetBlobsFromCache"), 0);
 
+  options_.statistics = CreateDBStatistics();
+  Statistics* statistics = options_.statistics.get();
+  assert(statistics);
+
   DestroyAndReopen(options_);
 
   ImmutableOptions immutable_options(options_);
@@ -193,8 +197,11 @@ TEST_F(BlobSourceTest, GetBlobsFromCache) {
     // GetBlob
     std::vector<PinnableSlice> values(keys.size());
     uint64_t bytes_read = 0;
+    uint64_t blob_bytes = 0;
+    uint64_t total_bytes = 0;
 
     read_options.fill_cache = false;
+    get_perf_context()->Reset();
 
     for (size_t i = 0; i < num_blobs; ++i) {
       ASSERT_FALSE(blob_source.TEST_BlobInCache(blob_file_number, file_size,
@@ -210,9 +217,28 @@ TEST_F(BlobSourceTest, GetBlobsFromCache) {
 
       ASSERT_FALSE(blob_source.TEST_BlobInCache(blob_file_number, file_size,
                                                 blob_offsets[i]));
+      total_bytes += bytes_read;
     }
 
+    // Retrieved the blob cache num_blobs * 3 times via TEST_BlobInCache,
+    // GetBlob, and TEST_BlobInCache.
+    ASSERT_EQ((int)get_perf_context()->blob_cache_hit_count, 0);
+    ASSERT_EQ((int)get_perf_context()->blob_read_count, num_blobs);
+    ASSERT_EQ((int)get_perf_context()->blob_read_byte, total_bytes);
+    ASSERT_GE((int)get_perf_context()->blob_checksum_time, 0);
+    ASSERT_EQ((int)get_perf_context()->blob_decompress_time, 0);
+
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_MISS), num_blobs * 3);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_HIT), 0);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_ADD), 0);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_BYTES_READ), 0);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_BYTES_WRITE), 0);
+
     read_options.fill_cache = true;
+    blob_bytes = 0;
+    total_bytes = 0;
+    get_perf_context()->Reset();
+    statistics->Reset().PermitUncheckedError();
 
     for (size_t i = 0; i < num_blobs; ++i) {
       ASSERT_FALSE(blob_source.TEST_BlobInCache(blob_file_number, file_size,
@@ -226,11 +252,36 @@ TEST_F(BlobSourceTest, GetBlobsFromCache) {
       ASSERT_EQ(bytes_read,
                 BlobLogRecord::kHeaderSize + keys[i].size() + blob_sizes[i]);
 
+      blob_bytes += blob_sizes[i];
+      total_bytes += bytes_read;
+      ASSERT_EQ((int)get_perf_context()->blob_cache_hit_count, i);
+      ASSERT_EQ((int)get_perf_context()->blob_read_count, i + 1);
+      ASSERT_EQ((int)get_perf_context()->blob_read_byte, total_bytes);
+
       ASSERT_TRUE(blob_source.TEST_BlobInCache(blob_file_number, file_size,
                                                blob_offsets[i]));
+
+      ASSERT_EQ((int)get_perf_context()->blob_cache_hit_count, i + 1);
+      ASSERT_EQ((int)get_perf_context()->blob_read_count, i + 1);
+      ASSERT_EQ((int)get_perf_context()->blob_read_byte, total_bytes);
     }
 
+    ASSERT_EQ((int)get_perf_context()->blob_cache_hit_count, num_blobs);
+    ASSERT_EQ((int)get_perf_context()->blob_read_count, num_blobs);
+    ASSERT_EQ((int)get_perf_context()->blob_read_byte, total_bytes);
+
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_MISS), num_blobs * 2);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_HIT), num_blobs);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_ADD), num_blobs);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_BYTES_READ), blob_bytes);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_BYTES_WRITE),
+              blob_bytes);
+
     read_options.fill_cache = true;
+    total_bytes = 0;
+    blob_bytes = 0;
+    get_perf_context()->Reset();
+    statistics->Reset().PermitUncheckedError();
 
     for (size_t i = 0; i < num_blobs; ++i) {
       ASSERT_TRUE(blob_source.TEST_BlobInCache(blob_file_number, file_size,
@@ -246,10 +297,29 @@ TEST_F(BlobSourceTest, GetBlobsFromCache) {
 
       ASSERT_TRUE(blob_source.TEST_BlobInCache(blob_file_number, file_size,
                                                blob_offsets[i]));
+      total_bytes += bytes_read;    // on-disk blob record size
+      blob_bytes += blob_sizes[i];  // cached blob value size
     }
 
+    // Retrieved the blob cache num_blobs * 3 times via TEST_BlobInCache,
+    // GetBlob, and TEST_BlobInCache.
+    ASSERT_EQ((int)get_perf_context()->blob_cache_hit_count, num_blobs * 3);
+    ASSERT_EQ((int)get_perf_context()->blob_read_count, 0);  // without i/o
+    ASSERT_EQ((int)get_perf_context()->blob_read_byte, 0);   // without i/o
+
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_MISS), 0);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_HIT), num_blobs * 3);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_ADD), 0);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_BYTES_READ),
+              blob_bytes * 3);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_BYTES_WRITE), 0);
+
     // Cache-only GetBlob
     read_options.read_tier = ReadTier::kBlockCacheTier;
+    total_bytes = 0;
+    blob_bytes = 0;
+    get_perf_context()->Reset();
+    statistics->Reset().PermitUncheckedError();
 
     for (size_t i = 0; i < num_blobs; ++i) {
       ASSERT_TRUE(blob_source.TEST_BlobInCache(blob_file_number, file_size,
@@ -265,7 +335,22 @@ TEST_F(BlobSourceTest, GetBlobsFromCache) {
 
       ASSERT_TRUE(blob_source.TEST_BlobInCache(blob_file_number, file_size,
                                                blob_offsets[i]));
+      total_bytes += bytes_read;
+      blob_bytes += blob_sizes[i];
     }
+
+    // Retrieved the blob cache num_blobs * 3 times via TEST_BlobInCache,
+    // GetBlob, and TEST_BlobInCache.
+    ASSERT_EQ((int)get_perf_context()->blob_cache_hit_count, num_blobs * 3);
+    ASSERT_EQ((int)get_perf_context()->blob_read_count, 0);  // without i/o
+    ASSERT_EQ((int)get_perf_context()->blob_read_byte, 0);   // without i/o
+
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_MISS), 0);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_HIT), num_blobs * 3);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_ADD), 0);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_BYTES_READ),
+              blob_bytes * 3);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_BYTES_WRITE), 0);
   }
 
   options_.blob_cache->EraseUnRefEntries();
@@ -277,6 +362,8 @@ TEST_F(BlobSourceTest, GetBlobsFromCache) {
 
     read_options.read_tier = ReadTier::kBlockCacheTier;
     read_options.fill_cache = true;
+    get_perf_context()->Reset();
+    statistics->Reset().PermitUncheckedError();
 
     for (size_t i = 0; i < num_blobs; ++i) {
       ASSERT_FALSE(blob_source.TEST_BlobInCache(blob_file_number, file_size,
@@ -294,6 +381,18 @@ TEST_F(BlobSourceTest, GetBlobsFromCache) {
       ASSERT_FALSE(blob_source.TEST_BlobInCache(blob_file_number, file_size,
                                                 blob_offsets[i]));
     }
+
+    // Retrieved the blob cache num_blobs * 3 times via TEST_BlobInCache,
+    // GetBlob, and TEST_BlobInCache.
+    ASSERT_EQ((int)get_perf_context()->blob_cache_hit_count, 0);
+    ASSERT_EQ((int)get_perf_context()->blob_read_count, 0);
+    ASSERT_EQ((int)get_perf_context()->blob_read_byte, 0);
+
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_MISS), num_blobs * 3);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_HIT), 0);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_ADD), 0);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_BYTES_READ), 0);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_BYTES_WRITE), 0);
   }
 
   {
@@ -304,6 +403,8 @@ TEST_F(BlobSourceTest, GetBlobsFromCache) {
 
     read_options.read_tier = ReadTier::kReadAllTier;
     read_options.fill_cache = true;
+    get_perf_context()->Reset();
+    statistics->Reset().PermitUncheckedError();
 
     for (size_t i = 0; i < num_blobs; ++i) {
       ASSERT_FALSE(blob_source.TEST_BlobInCache(file_number, file_size,
@@ -321,6 +422,18 @@ TEST_F(BlobSourceTest, GetBlobsFromCache) {
       ASSERT_FALSE(blob_source.TEST_BlobInCache(file_number, file_size,
                                                 blob_offsets[i]));
     }
+
+    // Retrieved the blob cache num_blobs * 3 times via TEST_BlobInCache,
+    // GetBlob, and TEST_BlobInCache.
+    ASSERT_EQ((int)get_perf_context()->blob_cache_hit_count, 0);
+    ASSERT_EQ((int)get_perf_context()->blob_read_count, 0);
+    ASSERT_EQ((int)get_perf_context()->blob_read_byte, 0);
+
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_MISS), num_blobs * 3);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_HIT), 0);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_ADD), 0);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_BYTES_READ), 0);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_BYTES_WRITE), 0);
   }
 }
 
@@ -403,6 +516,7 @@ TEST_F(BlobSourceTest, GetCompressedBlobs) {
 
     read_options.fill_cache = true;
     read_options.read_tier = ReadTier::kReadAllTier;
+    get_perf_context()->Reset();
 
     for (size_t i = 0; i < num_blobs; ++i) {
       ASSERT_FALSE(blob_source.TEST_BlobInCache(file_number, file_size,
@@ -420,7 +534,10 @@ TEST_F(BlobSourceTest, GetCompressedBlobs) {
                                                blob_offsets[i]));
     }
 
+    ASSERT_GE((int)get_perf_context()->blob_decompress_time, 0);
+
     read_options.read_tier = ReadTier::kBlockCacheTier;
+    get_perf_context()->Reset();
 
     for (size_t i = 0; i < num_blobs; ++i) {
       ASSERT_TRUE(blob_source.TEST_BlobInCache(file_number, file_size,
@@ -439,6 +556,201 @@ TEST_F(BlobSourceTest, GetCompressedBlobs) {
       ASSERT_TRUE(blob_source.TEST_BlobInCache(file_number, file_size,
                                                blob_offsets[i]));
     }
+
+    ASSERT_EQ((int)get_perf_context()->blob_decompress_time, 0);
+  }
+}
+
+TEST_F(BlobSourceTest, MultiGetBlobsFromMultiFiles) {
+  options_.cf_paths.emplace_back(
+      test::PerThreadDBPath(env_, "BlobSourceTest_MultiGetBlobsFromMultiFiles"),
+      0);
+
+  options_.statistics = CreateDBStatistics();
+  Statistics* statistics = options_.statistics.get();
+  assert(statistics);
+
+  DestroyAndReopen(options_);
+
+  ImmutableOptions immutable_options(options_);
+
+  constexpr uint32_t column_family_id = 1;
+  constexpr bool has_ttl = false;
+  constexpr ExpirationRange expiration_range;
+  constexpr uint64_t blob_files = 2;
+  constexpr size_t num_blobs = 32;
+
+  std::vector<std::string> key_strs;
+  std::vector<std::string> blob_strs;
+
+  for (size_t i = 0; i < num_blobs; ++i) {
+    key_strs.push_back("key" + std::to_string(i));
+    blob_strs.push_back("blob" + std::to_string(i));
+  }
+
+  std::vector<Slice> keys;
+  std::vector<Slice> blobs;
+
+  uint64_t file_size = BlobLogHeader::kSize;
+  uint64_t blob_value_bytes = 0;
+  for (size_t i = 0; i < num_blobs; ++i) {
+    keys.push_back({key_strs[i]});
+    blobs.push_back({blob_strs[i]});
+    blob_value_bytes += blobs[i].size();
+    file_size += BlobLogRecord::kHeaderSize + keys[i].size() + blobs[i].size();
+  }
+  file_size += BlobLogFooter::kSize;
+  const uint64_t blob_records_bytes =
+      file_size - BlobLogHeader::kSize - BlobLogFooter::kSize;
+
+  std::vector<uint64_t> blob_offsets(keys.size());
+  std::vector<uint64_t> blob_sizes(keys.size());
+
+  {
+    // Write key/blob pairs to multiple blob files.
+    for (size_t i = 0; i < blob_files; ++i) {
+      const uint64_t file_number = i + 1;
+      WriteBlobFile(immutable_options, column_family_id, has_ttl,
+                    expiration_range, expiration_range, file_number, keys,
+                    blobs, kNoCompression, blob_offsets, blob_sizes);
+    }
+  }
+
+  constexpr size_t capacity = 10;
+  std::shared_ptr<Cache> backing_cache =
+      NewLRUCache(capacity);  // Blob file cache
+
+  FileOptions file_options;
+  constexpr HistogramImpl* blob_file_read_hist = nullptr;
+
+  std::unique_ptr<BlobFileCache> blob_file_cache(new BlobFileCache(
+      backing_cache.get(), &immutable_options, &file_options, column_family_id,
+      blob_file_read_hist, nullptr /*IOTracer*/));
+
+  BlobSource blob_source(&immutable_options, db_id_, db_session_id_,
+                         blob_file_cache.get());
+
+  ReadOptions read_options;
+  read_options.verify_checksums = true;
+
+  uint64_t bytes_read = 0;
+
+  {
+    // MultiGetBlob
+    read_options.fill_cache = true;
+    read_options.read_tier = ReadTier::kReadAllTier;
+
+    autovector<BlobFileReadRequests> blob_reqs;
+    std::array<autovector<BlobReadRequest>, blob_files> blob_reqs_in_file;
+    std::array<PinnableSlice, num_blobs * blob_files> value_buf;
+    std::array<Status, num_blobs * blob_files> statuses_buf;
+
+    for (size_t i = 0; i < blob_files; ++i) {
+      const uint64_t file_number = i + 1;
+      for (size_t j = 0; j < num_blobs; ++j) {
+        blob_reqs_in_file[i].emplace_back(
+            keys[j], blob_offsets[j], blob_sizes[j], kNoCompression,
+            &value_buf[i * num_blobs + j], &statuses_buf[i * num_blobs + j]);
+      }
+      blob_reqs.emplace_back(file_number, file_size, blob_reqs_in_file[i]);
+    }
+
+    get_perf_context()->Reset();
+    statistics->Reset().PermitUncheckedError();
+
+    blob_source.MultiGetBlob(read_options, blob_reqs, &bytes_read);
+
+    for (size_t i = 0; i < blob_files; ++i) {
+      const uint64_t file_number = i + 1;
+      for (size_t j = 0; j < num_blobs; ++j) {
+        ASSERT_OK(statuses_buf[i * num_blobs + j]);
+        ASSERT_EQ(value_buf[i * num_blobs + j], blobs[j]);
+        ASSERT_TRUE(blob_source.TEST_BlobInCache(file_number, file_size,
+                                                 blob_offsets[j]));
+      }
+    }
+
+    // Retrieved all blobs from 2 blob files twice via MultiGetBlob and
+    // TEST_BlobInCache.
+    ASSERT_EQ((int)get_perf_context()->blob_cache_hit_count,
+              num_blobs * blob_files);
+    ASSERT_EQ((int)get_perf_context()->blob_read_count,
+              num_blobs * blob_files);  // blocking i/o
+    ASSERT_EQ((int)get_perf_context()->blob_read_byte,
+              blob_records_bytes * blob_files);  // blocking i/o
+    ASSERT_GE((int)get_perf_context()->blob_checksum_time, 0);
+    ASSERT_EQ((int)get_perf_context()->blob_decompress_time, 0);
+
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_MISS),
+              num_blobs * blob_files);  // MultiGetBlob
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_HIT),
+              num_blobs * blob_files);  // TEST_BlobInCache
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_ADD),
+              num_blobs * blob_files);  // MultiGetBlob
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_BYTES_READ),
+              blob_value_bytes * blob_files);  // TEST_BlobInCache
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_BYTES_WRITE),
+              blob_value_bytes * blob_files);  // MultiGetBlob
+
+    get_perf_context()->Reset();
+    statistics->Reset().PermitUncheckedError();
+
+    autovector<BlobReadRequest> fake_blob_reqs_in_file;
+    std::array<PinnableSlice, num_blobs> fake_value_buf;
+    std::array<Status, num_blobs> fake_statuses_buf;
+
+    const uint64_t fake_file_number = 100;
+    for (size_t i = 0; i < num_blobs; ++i) {
+      fake_blob_reqs_in_file.emplace_back(
+          keys[i], blob_offsets[i], blob_sizes[i], kNoCompression,
+          &fake_value_buf[i], &fake_statuses_buf[i]);
+    }
+
+    // Add a fake multi-get blob request.
+    blob_reqs.emplace_back(fake_file_number, file_size, fake_blob_reqs_in_file);
+
+    blob_source.MultiGetBlob(read_options, blob_reqs, &bytes_read);
+
+    // Check the real blob read requests.
+    for (size_t i = 0; i < blob_files; ++i) {
+      const uint64_t file_number = i + 1;
+      for (size_t j = 0; j < num_blobs; ++j) {
+        ASSERT_OK(statuses_buf[i * num_blobs + j]);
+        ASSERT_EQ(value_buf[i * num_blobs + j], blobs[j]);
+        ASSERT_TRUE(blob_source.TEST_BlobInCache(file_number, file_size,
+                                                 blob_offsets[j]));
+      }
+    }
+
+    // Check the fake blob request.
+    for (size_t i = 0; i < num_blobs; ++i) {
+      ASSERT_TRUE(fake_statuses_buf[i].IsIOError());
+      ASSERT_TRUE(fake_value_buf[i].empty());
+      ASSERT_FALSE(blob_source.TEST_BlobInCache(fake_file_number, file_size,
+                                                blob_offsets[i]));
+    }
+
+    // Retrieved all blobs from 3 blob files (including the fake one) twice
+    // via MultiGetBlob and TEST_BlobInCache.
+    ASSERT_EQ((int)get_perf_context()->blob_cache_hit_count,
+              num_blobs * blob_files * 2);
+    ASSERT_EQ((int)get_perf_context()->blob_read_count,
+              0);  // blocking i/o
+    ASSERT_EQ((int)get_perf_context()->blob_read_byte,
+              0);  // blocking i/o
+    ASSERT_GE((int)get_perf_context()->blob_checksum_time, 0);
+    ASSERT_EQ((int)get_perf_context()->blob_decompress_time, 0);
+
+    // Fake blob requests: MultiGetBlob and TEST_BlobInCache
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_MISS), num_blobs * 2);
+    // Real blob requests: MultiGetBlob and TEST_BlobInCache
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_HIT),
+              num_blobs * blob_files * 2);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_ADD), 0);
+    // Real blob requests: MultiGetBlob and TEST_BlobInCache
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_BYTES_READ),
+              blob_value_bytes * blob_files * 2);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_BYTES_WRITE), 0);
   }
 }
 
@@ -446,6 +758,10 @@ TEST_F(BlobSourceTest, MultiGetBlobsFromCache) {
   options_.cf_paths.emplace_back(
       test::PerThreadDBPath(env_, "BlobSourceTest_MultiGetBlobsFromCache"), 0);
 
+  options_.statistics = CreateDBStatistics();
+  Statistics* statistics = options_.statistics.get();
+  assert(statistics);
+
   DestroyAndReopen(options_);
 
   ImmutableOptions immutable_options(options_);
@@ -502,41 +818,39 @@ TEST_F(BlobSourceTest, MultiGetBlobsFromCache) {
   constexpr FilePrefetchBuffer* prefetch_buffer = nullptr;
 
   {
-    // MultiGetBlob
+    // MultiGetBlobFromOneFile
     uint64_t bytes_read = 0;
-
-    autovector<std::reference_wrapper<const Slice>> key_refs;
-    autovector<uint64_t> offsets;
-    autovector<uint64_t> sizes;
     std::array<Status, num_blobs> statuses_buf;
-    autovector<Status*> statuses;
     std::array<PinnableSlice, num_blobs> value_buf;
-    autovector<PinnableSlice*> values;
+    autovector<BlobReadRequest> blob_reqs;
 
     for (size_t i = 0; i < num_blobs; i += 2) {  // even index
-      key_refs.emplace_back(std::cref(keys[i]));
-      offsets.push_back(blob_offsets[i]);
-      sizes.push_back(blob_sizes[i]);
-      statuses.push_back(&statuses_buf[i]);
-      values.push_back(&value_buf[i]);
+      blob_reqs.emplace_back(keys[i], blob_offsets[i], blob_sizes[i],
+                             kNoCompression, &value_buf[i], &statuses_buf[i]);
       ASSERT_FALSE(blob_source.TEST_BlobInCache(blob_file_number, file_size,
                                                 blob_offsets[i]));
     }
 
     read_options.fill_cache = true;
     read_options.read_tier = ReadTier::kReadAllTier;
+    get_perf_context()->Reset();
+    statistics->Reset().PermitUncheckedError();
 
     // Get half of blobs
-    blob_source.MultiGetBlob(read_options, key_refs, blob_file_number,
-                             file_size, offsets, sizes, statuses, values,
-                             &bytes_read);
+    blob_source.MultiGetBlobFromOneFile(read_options, blob_file_number,
+                                        file_size, blob_reqs, &bytes_read);
 
+    uint64_t fs_read_bytes = 0;
+    uint64_t ca_read_bytes = 0;
     for (size_t i = 0; i < num_blobs; ++i) {
       if (i % 2 == 0) {
         ASSERT_OK(statuses_buf[i]);
         ASSERT_EQ(value_buf[i], blobs[i]);
+        fs_read_bytes +=
+            blob_sizes[i] + keys[i].size() + BlobLogRecord::kHeaderSize;
         ASSERT_TRUE(blob_source.TEST_BlobInCache(blob_file_number, file_size,
                                                  blob_offsets[i]));
+        ca_read_bytes += blob_sizes[i];
       } else {
         statuses_buf[i].PermitUncheckedError();
         ASSERT_TRUE(value_buf[i].empty());
@@ -545,6 +859,23 @@ TEST_F(BlobSourceTest, MultiGetBlobsFromCache) {
       }
     }
 
+    constexpr int num_even_blobs = num_blobs / 2;
+    ASSERT_EQ((int)get_perf_context()->blob_cache_hit_count, num_even_blobs);
+    ASSERT_EQ((int)get_perf_context()->blob_read_count,
+              num_even_blobs);  // blocking i/o
+    ASSERT_EQ((int)get_perf_context()->blob_read_byte,
+              fs_read_bytes);  // blocking i/o
+    ASSERT_GE((int)get_perf_context()->blob_checksum_time, 0);
+    ASSERT_EQ((int)get_perf_context()->blob_decompress_time, 0);
+
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_MISS), num_blobs);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_HIT), num_even_blobs);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_ADD), num_even_blobs);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_BYTES_READ),
+              ca_read_bytes);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_BYTES_WRITE),
+              ca_read_bytes);
+
     // Get the rest of blobs
     for (size_t i = 1; i < num_blobs; i += 2) {  // odd index
       ASSERT_FALSE(blob_source.TEST_BlobInCache(blob_file_number, file_size,
@@ -562,62 +893,68 @@ TEST_F(BlobSourceTest, MultiGetBlobsFromCache) {
                                                blob_offsets[i]));
     }
 
-    // Cache-only MultiGetBlob
+    // Cache-only MultiGetBlobFromOneFile
     read_options.read_tier = ReadTier::kBlockCacheTier;
+    get_perf_context()->Reset();
+    statistics->Reset().PermitUncheckedError();
 
-    key_refs.clear();
-    offsets.clear();
-    sizes.clear();
-    statuses.clear();
-    values.clear();
+    blob_reqs.clear();
     for (size_t i = 0; i < num_blobs; ++i) {
-      key_refs.emplace_back(std::cref(keys[i]));
-      offsets.push_back(blob_offsets[i]);
-      sizes.push_back(blob_sizes[i]);
-      statuses.push_back(&statuses_buf[i]);
-      values.push_back(&value_buf[i]);
+      blob_reqs.emplace_back(keys[i], blob_offsets[i], blob_sizes[i],
+                             kNoCompression, &value_buf[i], &statuses_buf[i]);
     }
 
-    blob_source.MultiGetBlob(read_options, key_refs, blob_file_number,
-                             file_size, offsets, sizes, statuses, values,
-                             &bytes_read);
+    blob_source.MultiGetBlobFromOneFile(read_options, blob_file_number,
+                                        file_size, blob_reqs, &bytes_read);
 
+    uint64_t blob_bytes = 0;
     for (size_t i = 0; i < num_blobs; ++i) {
       ASSERT_OK(statuses_buf[i]);
       ASSERT_EQ(value_buf[i], blobs[i]);
       ASSERT_TRUE(blob_source.TEST_BlobInCache(blob_file_number, file_size,
                                                blob_offsets[i]));
+      blob_bytes += blob_sizes[i];
     }
+
+    // Retrieved the blob cache num_blobs * 2 times via GetBlob and
+    // TEST_BlobInCache.
+    ASSERT_EQ((int)get_perf_context()->blob_cache_hit_count, num_blobs * 2);
+    ASSERT_EQ((int)get_perf_context()->blob_read_count, 0);  // blocking i/o
+    ASSERT_EQ((int)get_perf_context()->blob_read_byte, 0);   // blocking i/o
+    ASSERT_GE((int)get_perf_context()->blob_checksum_time, 0);
+    ASSERT_EQ((int)get_perf_context()->blob_decompress_time, 0);
+
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_MISS), 0);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_HIT), num_blobs * 2);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_ADD), 0);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_BYTES_READ),
+              blob_bytes * 2);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_BYTES_WRITE), 0);
   }
 
   options_.blob_cache->EraseUnRefEntries();
 
   {
-    // Cache-only MultiGetBlob
+    // Cache-only MultiGetBlobFromOneFile
     uint64_t bytes_read = 0;
     read_options.read_tier = ReadTier::kBlockCacheTier;
 
-    autovector<std::reference_wrapper<const Slice>> key_refs;
-    autovector<uint64_t> offsets;
-    autovector<uint64_t> sizes;
     std::array<Status, num_blobs> statuses_buf;
-    autovector<Status*> statuses;
     std::array<PinnableSlice, num_blobs> value_buf;
-    autovector<PinnableSlice*> values;
+    autovector<BlobReadRequest> blob_reqs;
 
     for (size_t i = 0; i < num_blobs; i++) {
-      key_refs.emplace_back(std::cref(keys[i]));
-      offsets.push_back(blob_offsets[i]);
-      sizes.push_back(blob_sizes[i]);
-      statuses.push_back(&statuses_buf[i]);
-      values.push_back(&value_buf[i]);
+      blob_reqs.emplace_back(keys[i], blob_offsets[i], blob_sizes[i],
+                             kNoCompression, &value_buf[i], &statuses_buf[i]);
       ASSERT_FALSE(blob_source.TEST_BlobInCache(blob_file_number, file_size,
                                                 blob_offsets[i]));
     }
 
-    blob_source.MultiGetBlob(read_options, key_refs, blob_file_number,
-                             file_size, offsets, sizes, statuses, values,
-                             &bytes_read);
+    get_perf_context()->Reset();
+    statistics->Reset().PermitUncheckedError();
+
+    blob_source.MultiGetBlobFromOneFile(read_options, blob_file_number,
+                                        file_size, blob_reqs, &bytes_read);
 
     for (size_t i = 0; i < num_blobs; ++i) {
       ASSERT_TRUE(statuses_buf[i].IsIncomplete());
@@ -625,41 +962,61 @@ TEST_F(BlobSourceTest, MultiGetBlobsFromCache) {
       ASSERT_FALSE(blob_source.TEST_BlobInCache(blob_file_number, file_size,
                                                 blob_offsets[i]));
     }
+
+    ASSERT_EQ((int)get_perf_context()->blob_cache_hit_count, 0);
+    ASSERT_EQ((int)get_perf_context()->blob_read_count, 0);  // blocking i/o
+    ASSERT_EQ((int)get_perf_context()->blob_read_byte, 0);   // blocking i/o
+    ASSERT_EQ((int)get_perf_context()->blob_checksum_time, 0);
+    ASSERT_EQ((int)get_perf_context()->blob_decompress_time, 0);
+
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_MISS), num_blobs * 2);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_HIT), 0);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_ADD), 0);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_BYTES_READ), 0);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_BYTES_WRITE), 0);
   }
 
   {
-    // MultiGetBlob from non-existing file
+    // MultiGetBlobFromOneFile from non-existing file
     uint64_t bytes_read = 0;
-    uint64_t file_number = 100;  // non-existing file
+    uint64_t non_existing_file_number = 100;
     read_options.read_tier = ReadTier::kReadAllTier;
 
-    autovector<std::reference_wrapper<const Slice>> key_refs;
-    autovector<uint64_t> offsets;
-    autovector<uint64_t> sizes;
     std::array<Status, num_blobs> statuses_buf;
-    autovector<Status*> statuses;
     std::array<PinnableSlice, num_blobs> value_buf;
-    autovector<PinnableSlice*> values;
+    autovector<BlobReadRequest> blob_reqs;
 
     for (size_t i = 0; i < num_blobs; i++) {
-      key_refs.emplace_back(std::cref(keys[i]));
-      offsets.push_back(blob_offsets[i]);
-      sizes.push_back(blob_sizes[i]);
-      statuses.push_back(&statuses_buf[i]);
-      values.push_back(&value_buf[i]);
-      ASSERT_FALSE(blob_source.TEST_BlobInCache(file_number, file_size,
-                                                blob_offsets[i]));
+      blob_reqs.emplace_back(keys[i], blob_offsets[i], blob_sizes[i],
+                             kNoCompression, &value_buf[i], &statuses_buf[i]);
+      ASSERT_FALSE(blob_source.TEST_BlobInCache(non_existing_file_number,
+                                                file_size, blob_offsets[i]));
     }
 
-    blob_source.MultiGetBlob(read_options, key_refs, file_number, file_size,
-                             offsets, sizes, statuses, values, &bytes_read);
+    get_perf_context()->Reset();
+    statistics->Reset().PermitUncheckedError();
+
+    blob_source.MultiGetBlobFromOneFile(read_options, non_existing_file_number,
+                                        file_size, blob_reqs, &bytes_read);
 
     for (size_t i = 0; i < num_blobs; ++i) {
       ASSERT_TRUE(statuses_buf[i].IsIOError());
       ASSERT_TRUE(value_buf[i].empty());
-      ASSERT_FALSE(blob_source.TEST_BlobInCache(file_number, file_size,
-                                                blob_offsets[i]));
+      ASSERT_FALSE(blob_source.TEST_BlobInCache(non_existing_file_number,
+                                                file_size, blob_offsets[i]));
     }
+
+    ASSERT_EQ((int)get_perf_context()->blob_cache_hit_count, 0);
+    ASSERT_EQ((int)get_perf_context()->blob_read_count, 0);  // blocking i/o
+    ASSERT_EQ((int)get_perf_context()->blob_read_byte, 0);   // blocking i/o
+    ASSERT_EQ((int)get_perf_context()->blob_checksum_time, 0);
+    ASSERT_EQ((int)get_perf_context()->blob_decompress_time, 0);
+
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_MISS), num_blobs * 2);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_HIT), 0);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_ADD), 0);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_BYTES_READ), 0);
+    ASSERT_EQ(statistics->getTickerCount(BLOB_DB_CACHE_BYTES_WRITE), 0);
   }
 }