@nxtedition/rocksdb 7.0.27 → 7.0.30

package/binding.cc

@@ -10,11 +10,11 @@
 #include <rocksdb/db.h>
 #include <rocksdb/env.h>
 #include <rocksdb/filter_policy.h>
+#include <rocksdb/merge_operator.h>
 #include <rocksdb/options.h>
 #include <rocksdb/slice_transform.h>
 #include <rocksdb/table.h>
 #include <rocksdb/write_batch.h>
-#include <rocksdb/merge_operator.h>
 
 #include <array>
 #include <memory>
@@ -543,19 +543,8 @@ struct Updates {
           bool keys,
           bool values,
           bool data,
-          const std::optional<std::string>& column)
-      : database_(database), seqNumber_(seqNumber), keys_(keys), values_(values), data_(data) {
-    if (column) {
-      auto columns = database->columns_;
-      auto columnIt = std::find_if(columns.begin(), columns.end(),
-                                   [&](const auto& handle) { return handle->GetName() == *column; });
-      if (columnIt != columns.end()) {
-        column_family_id_ = (*columnIt)->GetID();
-      } else {
-        // TODO: Throw?
-      }
-    }
-  }
+          const rocksdb::ColumnFamilyHandle* column)
+      : database_(database), seqNumber_(seqNumber), keys_(keys), values_(values), data_(data), column_(column) {}
 
   void Close() { iterator_.reset(); }
 
@@ -577,7 +566,7 @@ struct Updates {
   bool keys_;
   bool values_;
   bool data_;
-  std::optional<uint32_t> column_family_id_;
+  const rocksdb::ColumnFamilyHandle* column_;
 
  private:
   napi_ref ref_ = nullptr;
@@ -586,7 +575,8 @@ struct Updates {
 static napi_status GetColumnFamily(Database* database,
                                    napi_env env,
                                    napi_value options,
-                                   rocksdb::ColumnFamilyHandle** column) {
+                                   rocksdb::ColumnFamilyHandle** column,
+                                   bool fallback = true) {
   bool hasColumn = false;
   NAPI_STATUS_RETURN(napi_has_named_property(env, options, "column", &hasColumn));
 
@@ -594,8 +584,10 @@ static napi_status GetColumnFamily(Database* database,
     napi_value value = nullptr;
     NAPI_STATUS_RETURN(napi_get_named_property(env, options, "column", &value));
     NAPI_STATUS_RETURN(napi_get_value_external(env, value, reinterpret_cast<void**>(column)));
-  } else {
+  } else if (fallback) {
     *column = database->db_->DefaultColumnFamily();
+  } else {
+    *column = nullptr;
   }
 
   return napi_ok;
@@ -822,8 +814,9 @@ NAPI_METHOD(db_open) {
 
   rocksdb::Options dbOptions;
 
-  dbOptions.IncreaseParallelism(Uint32Property(env, argv[2], "parallelism")
-                                    .value_or(std::max<uint32_t>(1, std::thread::hardware_concurrency() / 2)));
+  const auto parallelismValue = Uint32Property(env, argv[2], "parallelism")
+                                    .value_or(std::max<uint32_t>(1, std::thread::hardware_concurrency() / 2));
+  dbOptions.IncreaseParallelism(parallelismValue);
 
   dbOptions.create_if_missing = BooleanProperty(env, argv[2], "createIfMissing").value_or(true);
   dbOptions.error_if_exists = BooleanProperty(env, argv[2], "errorIfExists").value_or(false);
@@ -835,12 +828,53 @@ NAPI_METHOD(db_open) {
                                       .value_or(std::max<uint32_t>(2, std::thread::hardware_concurrency() / 8));
   dbOptions.WAL_ttl_seconds = Uint32Property(env, argv[2], "walTTL").value_or(0) / 1e3;
   dbOptions.WAL_size_limit_MB = Uint32Property(env, argv[2], "walSizeLimit").value_or(0) / 1e6;
-  dbOptions.create_missing_column_families = true;
-  dbOptions.unordered_write = BooleanProperty(env, argv[2], "unorderedWrite").value_or(false);
-  dbOptions.fail_if_options_file_error = true;
   dbOptions.wal_compression = BooleanProperty(env, argv[2], "walCompression").value_or(false)
                                   ? rocksdb::CompressionType::kZSTD
                                   : rocksdb::CompressionType::kNoCompression;
+  dbOptions.create_missing_column_families = true;
+  dbOptions.unordered_write = BooleanProperty(env, argv[2], "unorderedWrite").value_or(false);
+  dbOptions.fail_if_options_file_error = true;
+  dbOptions.manual_wal_flush = BooleanProperty(env, argv[2], "manualWalFlush").value_or(false);
+
+  napi_value ret;
+  NAPI_STATUS_THROWS(napi_create_object(env, &ret));
+  {
+    napi_value parallelism;
+    NAPI_STATUS_THROWS(napi_create_int64(env, parallelismValue, &parallelism));
+    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "parallelism", parallelism));
+
+    napi_value createIfMissing;
+    NAPI_STATUS_THROWS(napi_get_boolean(env, dbOptions.create_if_missing, &createIfMissing));
+    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "createIfMissing", createIfMissing));
+
+    napi_value errorIfExists;
+    NAPI_STATUS_THROWS(napi_get_boolean(env, dbOptions.error_if_exists, &errorIfExists));
+    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "errorIfExists", errorIfExists));
+
+    napi_value maxBackgroundJobs;
+    NAPI_STATUS_THROWS(napi_create_int64(env, dbOptions.max_background_jobs, &maxBackgroundJobs));
+    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "maxBackgroundJobs", maxBackgroundJobs));
+
+    napi_value walTTL;
+    NAPI_STATUS_THROWS(napi_create_int64(env, dbOptions.WAL_ttl_seconds, &walTTL));
+    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "walTTL", walTTL));
+
+    napi_value walSizeLimit;
+    NAPI_STATUS_THROWS(napi_create_int64(env, dbOptions.WAL_size_limit_MB, &walSizeLimit));
+    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "walSizeLimit", walSizeLimit));
+
+    napi_value walCompression;
+    NAPI_STATUS_THROWS(napi_create_int64(env, dbOptions.wal_compression, &walCompression));
+    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "walCompression", walCompression));
+
+    napi_value unorderedWrite;
+    NAPI_STATUS_THROWS(napi_get_boolean(env, dbOptions.error_if_exists, &unorderedWrite));
+    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "unorderedWrite", unorderedWrite));
+
+    napi_value manualWalFlush;
+    NAPI_STATUS_THROWS(napi_create_int64(env, dbOptions.manual_wal_flush, &manualWalFlush));
+    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "manualWalFlush", manualWalFlush));
+  }
 
   // TODO (feat): dbOptions.listeners
 
@@ -905,7 +939,7 @@ NAPI_METHOD(db_open) {
   auto worker = new OpenWorker(env, database, argv[3], location, dbOptions, columnsFamilies);
   worker->Queue(env);
 
-  return 0;
+  return ret;
 }
 
 struct CloseWorker final : public Worker {
@@ -1013,57 +1047,82 @@ struct UpdatesNextWorker final : public rocksdb::WriteBatch::Handler, public Wor
   }
 
   rocksdb::Status PutCF(uint32_t column_family_id, const rocksdb::Slice& key, const rocksdb::Slice& value) override {
-    if (updates_->column_family_id_ && *updates_->column_family_id_ != column_family_id) {
+    if (updates_->column_ && updates_->column_->GetID() != column_family_id) {
       return rocksdb::Status::OK();
     }
+
     cache_.emplace_back("put");
+
     if (updates_->keys_) {
       cache_.emplace_back(key.ToStringView());
     } else {
       cache_.emplace_back(std::nullopt);
     }
+
     if (updates_->values_) {
       cache_.emplace_back(value.ToStringView());
     } else {
       cache_.emplace_back(std::nullopt);
     }
-    cache_.emplace_back(GetColumnName(column_family_id));
+
+    if (!updates_->column_) {
+      cache_.emplace_back(GetColumnName(column_family_id));
+    } else {
+      cache_.emplace_back(std::nullopt);
+    }
+
     return rocksdb::Status::OK();
   }
 
   rocksdb::Status DeleteCF(uint32_t column_family_id, const rocksdb::Slice& key) override {
-    if (updates_->column_family_id_ && *updates_->column_family_id_ != column_family_id) {
+    if (updates_->column_ && updates_->column_->GetID() != column_family_id) {
       return rocksdb::Status::OK();
     }
+
     cache_.emplace_back("del");
+
     if (updates_->keys_) {
       cache_.emplace_back(key.ToStringView());
     } else {
       cache_.emplace_back(std::nullopt);
     }
+
     cache_.emplace_back(std::nullopt);
-    cache_.emplace_back(GetColumnName(column_family_id));
+
+    if (!updates_->column_) {
+      cache_.emplace_back(GetColumnName(column_family_id));
+    } else {
+      cache_.emplace_back(std::nullopt);
+    }
+
     return rocksdb::Status::OK();
   }
 
   rocksdb::Status MergeCF(uint32_t column_family_id, const rocksdb::Slice& key, const rocksdb::Slice& value) override {
-    if (updates_->column_family_id_ && *updates_->column_family_id_ != column_family_id) {
+    if (updates_->column_ && updates_->column_->GetID() != column_family_id) {
       return rocksdb::Status::OK();
     }
+
     cache_.emplace_back("put");
+
     if (updates_->keys_) {
       cache_.emplace_back(key.ToStringView());
     } else {
       cache_.emplace_back(std::nullopt);
     }
+
     if (updates_->values_) {
       cache_.emplace_back(value.ToStringView());
     } else {
       cache_.emplace_back(std::nullopt);
     }
-    if (!updates_->column_family_id_) {
+
+    if (!updates_->column_) {
       cache_.emplace_back(GetColumnName(column_family_id));
+    } else {
+      cache_.emplace_back(std::nullopt);
     }
+
     return rocksdb::Status::OK();
   }
 
@@ -1094,7 +1153,9 @@ NAPI_METHOD(updates_init) {
   const auto keys = BooleanProperty(env, argv[1], "keys").value_or(true);
   const auto values = BooleanProperty(env, argv[1], "values").value_or(true);
   const auto data = BooleanProperty(env, argv[1], "data").value_or(true);
-  const auto column = StringProperty(env, argv[1], "column");
+
+  rocksdb::ColumnFamilyHandle* column;
+  NAPI_STATUS_THROWS(GetColumnFamily(database, env, argv[1], &column, false));
 
   auto updates = std::make_unique<Updates>(database, seqNumber, keys, values, data, column);
 
@@ -1858,6 +1919,81 @@ NAPI_METHOD(batch_merge) {
   return 0;
 }
 
+NAPI_METHOD(db_flush_wal) {
+  NAPI_ARGV(2);
+
+  Database* database;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
+
+  const auto flush = BooleanProperty(env, argv[1], "flush").value_or(false);
+
+  ROCKS_STATUS_THROWS(database->db_->FlushWAL(flush));
+
+  return 0;
+}
+
+napi_status FromLogFile(napi_env env, const auto& file, napi_value* obj) {
+  NAPI_STATUS_RETURN(napi_create_object(env, obj));
+
+  napi_value pathName;
+  NAPI_STATUS_RETURN(napi_create_string_utf8(env, file->PathName().c_str(), NAPI_AUTO_LENGTH, &pathName));
+  NAPI_STATUS_RETURN(napi_set_named_property(env, *obj, "pathName", pathName));
+
+  napi_value logNumber;
+  NAPI_STATUS_RETURN(napi_create_int64(env, file->LogNumber(), &logNumber));
+  NAPI_STATUS_RETURN(napi_set_named_property(env, *obj, "logNumber", logNumber));
+
+  napi_value type;
+  NAPI_STATUS_RETURN(napi_create_int64(env, file->Type(), &type));
+  NAPI_STATUS_RETURN(napi_set_named_property(env, *obj, "type", type));
+
+  napi_value startSequence;
+  NAPI_STATUS_RETURN(napi_create_int64(env, file->StartSequence(), &startSequence));
+  NAPI_STATUS_RETURN(napi_set_named_property(env, *obj, "startSequence", startSequence));
+
+  napi_value sizeFileBytes;
+  NAPI_STATUS_RETURN(napi_create_int64(env, file->SizeFileBytes(), &sizeFileBytes));
+  NAPI_STATUS_RETURN(napi_set_named_property(env, *obj, "sizeFileBytes", sizeFileBytes));
+
+  return napi_ok;
+}
+
+NAPI_METHOD(db_get_sorted_wal_files) {
+  NAPI_ARGV(1);
+
+  Database* database;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
+
+  rocksdb::VectorLogPtr files;
+  ROCKS_STATUS_THROWS(database->db_->GetSortedWalFiles(files));
+
+  napi_value ret;
+  NAPI_STATUS_THROWS(napi_create_array_with_length(env, files.size(), &ret));
+
+  for (size_t n = 0; n < files.size(); ++n) {
+    napi_value obj;
+    NAPI_STATUS_THROWS(FromLogFile(env, files[n], &obj));
+    NAPI_STATUS_THROWS(napi_set_element(env, ret, n, obj));
+  }
+
+  return ret;
+}
+
+NAPI_METHOD(db_get_current_wal_file) {
+  NAPI_ARGV(1);
+
+  Database* database;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
+
+  std::unique_ptr<rocksdb::LogFile> file;
+  ROCKS_STATUS_THROWS(database->db_->GetCurrentWalFile(&file));
+
+  napi_value ret;
+  NAPI_STATUS_THROWS(FromLogFile(env, file, &ret));
+
+  return ret;
+}
+
 NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(db_init);
   NAPI_EXPORT_FUNCTION(db_open);
@@ -1880,6 +2016,10 @@ NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(updates_close);
   NAPI_EXPORT_FUNCTION(updates_next);
 
+  NAPI_EXPORT_FUNCTION(db_flush_wal);
+  NAPI_EXPORT_FUNCTION(db_get_sorted_wal_files);
+  NAPI_EXPORT_FUNCTION(db_get_current_wal_file);
+
   NAPI_EXPORT_FUNCTION(batch_do);
   NAPI_EXPORT_FUNCTION(batch_init);
   NAPI_EXPORT_FUNCTION(batch_put);

package/chained-batch.js

@@ -44,7 +44,7 @@ class ChainedBatch extends AbstractChainedBatch {
     binding.batch_put_log_data(this[kDbContext], this[kBatchContext], data, options)
   }
 
-  merge (key, value, options) {
+  merge (key, value, options = {}) {
     // TODO (fix): Check if open...
     binding.batch_merge(this[kDbContext], this[kBatchContext], key, value, options)
   }

package/deps/rocksdb/rocksdb/CMakeLists.txt

@@ -598,6 +598,7 @@ set(SOURCES
         cache/cache_entry_roles.cc
         cache/cache_key.cc
         cache/cache_reservation_manager.cc
+        cache/charged_cache.cc
         cache/clock_cache.cc
         cache/compressed_secondary_cache.cc
         cache/fast_lru_cache.cc
@@ -670,6 +671,7 @@ set(SOURCES
         db/range_del_aggregator.cc
         db/range_tombstone_fragmenter.cc
         db/repair.cc
+        db/seqno_to_time_mapping.cc
         db/snapshot_impl.cc
         db/table_cache.cc
         db/table_properties_collector.cc
@@ -1296,6 +1298,7 @@ if(WITH_TESTS)
         db/perf_context_test.cc
         db/periodic_work_scheduler_test.cc
         db/plain_table_db_test.cc
+        db/seqno_time_test.cc
         db/prefix_test.cc
         db/range_del_aggregator_test.cc
         db/range_tombstone_fragmenter_test.cc

package/deps/rocksdb/rocksdb/Makefile

@@ -1504,6 +1504,9 @@ db_table_properties_test: $(OBJ_DIR)/db/db_table_properties_test.o $(TEST_LIBRAR
 log_write_bench: $(OBJ_DIR)/util/log_write_bench.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK) $(PROFILING_FLAGS)
 
+seqno_time_test: $(OBJ_DIR)/db/seqno_time_test.o $(TEST_LIBRARY) $(LIBRARY)
+	$(AM_LINK)
+
 plain_table_db_test: $(OBJ_DIR)/db/plain_table_db_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)
 

package/deps/rocksdb/rocksdb/TARGETS

@@ -13,6 +13,7 @@ cpp_library_wrapper(name="rocksdb_lib", srcs=[
         "cache/cache_entry_roles.cc",
         "cache/cache_key.cc",
         "cache/cache_reservation_manager.cc",
+        "cache/charged_cache.cc",
         "cache/clock_cache.cc",
         "cache/compressed_secondary_cache.cc",
         "cache/fast_lru_cache.cc",
@@ -85,6 +86,7 @@ cpp_library_wrapper(name="rocksdb_lib", srcs=[
         "db/range_del_aggregator.cc",
         "db/range_tombstone_fragmenter.cc",
         "db/repair.cc",
+        "db/seqno_to_time_mapping.cc",
         "db/snapshot_impl.cc",
         "db/table_cache.cc",
         "db/table_properties_collector.cc",
@@ -347,6 +349,7 @@ cpp_library_wrapper(name="rocksdb_whole_archive_lib", srcs=[
         "cache/cache_entry_roles.cc",
         "cache/cache_key.cc",
         "cache/cache_reservation_manager.cc",
+        "cache/charged_cache.cc",
         "cache/clock_cache.cc",
         "cache/compressed_secondary_cache.cc",
         "cache/fast_lru_cache.cc",
@@ -419,6 +422,7 @@ cpp_library_wrapper(name="rocksdb_whole_archive_lib", srcs=[
         "db/range_del_aggregator.cc",
         "db/range_tombstone_fragmenter.cc",
         "db/repair.cc",
+        "db/seqno_to_time_mapping.cc",
         "db/snapshot_impl.cc",
         "db/table_cache.cc",
         "db/table_properties_collector.cc",
@@ -5688,6 +5692,12 @@ cpp_unittest_wrapper(name="ribbon_test",
             extra_compiler_flags=[])
 
 
+cpp_unittest_wrapper(name="seqno_time_test",
+            srcs=["db/seqno_time_test.cc"],
+            deps=[":rocksdb_test_lib"],
+            extra_compiler_flags=[])
+
+
 cpp_unittest_wrapper(name="sim_cache_test",
             srcs=["utilities/simulator_cache/sim_cache_test.cc"],
             deps=[":rocksdb_test_lib"],

package/deps/rocksdb/rocksdb/cache/cache_bench_tool.cc

@@ -74,6 +74,11 @@ DEFINE_uint32(
 DEFINE_uint32(gather_stats_entries_per_lock, 256,
               "For Cache::ApplyToAllEntries");
 DEFINE_bool(skewed, false, "If true, skew the key access distribution");
+
+DEFINE_bool(lean, false,
+            "If true, no additional computation is performed besides cache "
+            "operations.");
+
 #ifndef ROCKSDB_LITE
 DEFINE_string(secondary_cache_uri, "",
               "Full URI for creating a custom secondary cache object");
@@ -522,7 +527,6 @@ class CacheBench {
     StopWatchNano timer(clock);
 
     for (uint64_t i = 0; i < FLAGS_ops_per_thread; i++) {
-      timer.Start();
       Slice key = gen.GetRand(thread->rnd, max_key_, max_log_);
       uint64_t random_op = thread->rnd.Next();
       Cache::CreateCallback create_cb = [](const void* buf, size_t size,
@@ -534,6 +538,8 @@ class CacheBench {
         return Status::OK();
       };
 
+      timer.Start();
+
       if (random_op < lookup_insert_threshold_) {
         if (handle) {
           cache_->Release(handle);
@@ -543,9 +549,11 @@ class CacheBench {
         handle = cache_->Lookup(key, &helper2, create_cb, Cache::Priority::LOW,
                                 true);
         if (handle) {
-          // do something with the data
-          result += NPHash64(static_cast<char*>(cache_->Value(handle)),
-                             FLAGS_value_bytes);
+          if (!FLAGS_lean) {
+            // do something with the data
+            result += NPHash64(static_cast<char*>(cache_->Value(handle)),
+                               FLAGS_value_bytes);
+          }
         } else {
           // do insert
           Status s = cache_->Insert(key, createValue(thread->rnd), &helper2,
@@ -570,9 +578,11 @@ class CacheBench {
         handle = cache_->Lookup(key, &helper2, create_cb, Cache::Priority::LOW,
                                 true);
         if (handle) {
-          // do something with the data
-          result += NPHash64(static_cast<char*>(cache_->Value(handle)),
-                             FLAGS_value_bytes);
+          if (!FLAGS_lean) {
+            // do something with the data
+            result += NPHash64(static_cast<char*>(cache_->Value(handle)),
+                               FLAGS_value_bytes);
+          }
         }
       } else if (random_op < erase_threshold_) {
         // do erase

package/deps/rocksdb/rocksdb/cache/cache_entry_roles.cc

@@ -23,6 +23,7 @@ std::array<std::string, kNumCacheEntryRoles> kCacheEntryRoleToCamelString{{
     "FilterConstruction",
     "BlockBasedTableReader",
     "FileMetadata",
+    "BlobCache",
     "Misc",
 }};
 
@@ -38,6 +39,7 @@ std::array<std::string, kNumCacheEntryRoles> kCacheEntryRoleToHyphenString{{
     "filter-construction",
     "block-based-table-reader",
     "file-metadata",
+    "blob-cache",
     "misc",
 }};
 

package/deps/rocksdb/rocksdb/cache/cache_reservation_manager.cc

@@ -181,4 +181,5 @@ template class CacheReservationManagerImpl<CacheEntryRole::kFilterConstruction>;
 template class CacheReservationManagerImpl<CacheEntryRole::kMisc>;
 template class CacheReservationManagerImpl<CacheEntryRole::kWriteBuffer>;
 template class CacheReservationManagerImpl<CacheEntryRole::kFileMetadata>;
+template class CacheReservationManagerImpl<CacheEntryRole::kBlobCache>;
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/cache/charged_cache.cc

@@ -0,0 +1,117 @@
+//  Copyright (c) Meta Platforms, Inc. and affiliates.
+//  This source code is licensed under both the GPLv2 (found in the
+//  COPYING file in the root directory) and Apache 2.0 License
+//  (found in the LICENSE.Apache file in the root directory).
+
+#include "cache/charged_cache.h"
+
+#include "cache/cache_reservation_manager.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+ChargedCache::ChargedCache(std::shared_ptr<Cache> cache,
+                           std::shared_ptr<Cache> block_cache)
+    : cache_(cache),
+      cache_res_mgr_(std::make_shared<ConcurrentCacheReservationManager>(
+          std::make_shared<
+              CacheReservationManagerImpl<CacheEntryRole::kBlobCache>>(
+              block_cache))) {}
+
+Status ChargedCache::Insert(const Slice& key, void* value, size_t charge,
+                            DeleterFn deleter, Handle** handle,
+                            Priority priority) {
+  Status s = cache_->Insert(key, value, charge, deleter, handle, priority);
+  if (s.ok()) {
+    // Insert may cause the cache entry eviction if the cache is full. So we
+    // directly call the reservation manager to update the total memory used
+    // in the cache.
+    assert(cache_res_mgr_);
+    cache_res_mgr_->UpdateCacheReservation(cache_->GetUsage())
+        .PermitUncheckedError();
+  }
+  return s;
+}
+
+Status ChargedCache::Insert(const Slice& key, void* value,
+                            const CacheItemHelper* helper, size_t charge,
+                            Handle** handle, Priority priority) {
+  Status s = cache_->Insert(key, value, helper, charge, handle, priority);
+  if (s.ok()) {
+    // Insert may cause the cache entry eviction if the cache is full. So we
+    // directly call the reservation manager to update the total memory used
+    // in the cache.
+    assert(cache_res_mgr_);
+    cache_res_mgr_->UpdateCacheReservation(cache_->GetUsage())
+        .PermitUncheckedError();
+  }
+  return s;
+}
+
+Cache::Handle* ChargedCache::Lookup(const Slice& key, Statistics* stats) {
+  return cache_->Lookup(key, stats);
+}
+
+Cache::Handle* ChargedCache::Lookup(const Slice& key,
+                                    const CacheItemHelper* helper,
+                                    const CreateCallback& create_cb,
+                                    Priority priority, bool wait,
+                                    Statistics* stats) {
+  auto handle = cache_->Lookup(key, helper, create_cb, priority, wait, stats);
+  // Lookup may promote the KV pair from the secondary cache to the primary
+  // cache. So we directly call the reservation manager to update the total
+  // memory used in the cache.
+  assert(cache_res_mgr_);
+  cache_res_mgr_->UpdateCacheReservation(cache_->GetUsage())
+      .PermitUncheckedError();
+  return handle;
+}
+
+bool ChargedCache::Release(Cache::Handle* handle, bool useful,
+                           bool erase_if_last_ref) {
+  size_t memory_used_delta = cache_->GetUsage(handle);
+  bool erased = cache_->Release(handle, useful, erase_if_last_ref);
+  if (erased) {
+    assert(cache_res_mgr_);
+    cache_res_mgr_
+        ->UpdateCacheReservation(memory_used_delta, /* increase */ false)
+        .PermitUncheckedError();
+  }
+  return erased;
+}
+
+bool ChargedCache::Release(Cache::Handle* handle, bool erase_if_last_ref) {
+  size_t memory_used_delta = cache_->GetUsage(handle);
+  bool erased = cache_->Release(handle, erase_if_last_ref);
+  if (erased) {
+    assert(cache_res_mgr_);
+    cache_res_mgr_
+        ->UpdateCacheReservation(memory_used_delta, /* increase */ false)
+        .PermitUncheckedError();
+  }
+  return erased;
+}
+
+void ChargedCache::Erase(const Slice& key) {
+  cache_->Erase(key);
+  assert(cache_res_mgr_);
+  cache_res_mgr_->UpdateCacheReservation(cache_->GetUsage())
+      .PermitUncheckedError();
+}
+
+void ChargedCache::EraseUnRefEntries() {
+  cache_->EraseUnRefEntries();
+  assert(cache_res_mgr_);
+  cache_res_mgr_->UpdateCacheReservation(cache_->GetUsage())
+      .PermitUncheckedError();
+}
+
+void ChargedCache::SetCapacity(size_t capacity) {
+  cache_->SetCapacity(capacity);
+  // SetCapacity can result in evictions when the cache capacity is decreased,
+  // so we would want to update the cache reservation here as well.
+  assert(cache_res_mgr_);
+  cache_res_mgr_->UpdateCacheReservation(cache_->GetUsage())
+      .PermitUncheckedError();
+}
+
+}  // namespace ROCKSDB_NAMESPACE