@nxtedition/rocksdb 7.0.0 → 7.0.3

package/binding.cc

@@ -40,13 +40,13 @@ struct Updates;
     }                            \
   }
 
-#define ROCKS_STATUS_THROWS(call) \
-  {                              \
-    const auto status = (call);  \
-    if (!status.ok()) {     \
+#define ROCKS_STATUS_THROWS(call)            \
+  {                                          \
+    const auto status = (call);              \
+    if (!status.ok()) {                      \
       napi_throw(env, ToError(env, status)); \
-      return NULL; \
-    }                            \
+      return NULL;                           \
+    }                                        \
   }
 
 static bool IsString(napi_env env, napi_value value) {
@@ -224,7 +224,7 @@ static void Finalize(napi_env env, void* data, void* hint) {
   }
 }
 
-napi_status Convert(napi_env env, rocksdb::PinnableSlice&& s, bool asBuffer, napi_value& result) {
+napi_status Convert(napi_env env, rocksdb::PinnableSlice& s, bool asBuffer, napi_value& result) {
   if (asBuffer) {
     auto ptr = new rocksdb::PinnableSlice(std::move(s));
     return napi_create_external_buffer(env, ptr->size(), const_cast<char*>(ptr->data()),
@@ -234,7 +234,7 @@ napi_status Convert(napi_env env, rocksdb::PinnableSlice&& s, bool asBuffer, nap
   }
 }
 
-napi_status Convert(napi_env env, std::optional<std::string>&& s, bool asBuffer, napi_value& result) {
+napi_status Convert(napi_env env, std::optional<std::string>& s, bool asBuffer, napi_value& result) {
   if (!s) {
     return napi_get_null(env, &result);
   } else if (asBuffer) {
@@ -663,17 +663,17 @@ struct OpenWorker final : public Worker {
   rocksdb::Status Execute(Database& database) override {
     rocksdb::DB* db = nullptr;
     const auto status = column_families_.empty()
-      ? rocksdb::DB::Open(options_, location_, &db)
-      : rocksdb::DB::Open(options_, location_, column_families_, &database.columns_, &db);
+                            ? rocksdb::DB::Open(options_, location_, &db)
+                            : rocksdb::DB::Open(options_, location_, column_families_, &database.columns_, &db);
     database.db_.reset(db);
     return status;
   }
 
-  napi_status OnOk(napi_env env, napi_value callback) override {    
+  napi_status OnOk(napi_env env, napi_value callback) override {
     const auto size = database_->columns_.size();
     napi_value result;
     NAPI_STATUS_RETURN(napi_create_object(env, &result));
-  
+
     for (size_t n = 0; n < size; ++n) {
       napi_value column;
       NAPI_STATUS_RETURN(napi_create_external(env, database_->columns_[n], nullptr, nullptr, &column));
@@ -691,8 +691,8 @@ struct OpenWorker final : public Worker {
   std::vector<rocksdb::ColumnFamilyDescriptor> column_families_;
 };
 
-template <typename T>
-napi_status InitOptions(napi_env env, T& columnOptions, auto options) {
+template <typename T, typename U>
+napi_status InitOptions(napi_env env, T& columnOptions, const U& options) {
   const auto memtable_memory_budget = Uint32Property(env, options, "memtableMemoryBudget").value_or(256 * 1024 * 1024);
 
   const auto compaction = StringProperty(env, options, "compaction").value_or("level");
@@ -787,16 +787,16 @@ NAPI_METHOD(db_open) {
 
   rocksdb::Options dbOptions;
 
-  dbOptions.IncreaseParallelism(
-      Uint32Property(env, options, "parallelism").value_or(std::thread::hardware_concurrency() / 2));
+  dbOptions.IncreaseParallelism(Uint32Property(env, options, "parallelism")
+                                    .value_or(std::max<uint32_t>(1, std::thread::hardware_concurrency() / 2)));
 
   dbOptions.create_if_missing = BooleanProperty(env, options, "createIfMissing").value_or(true);
   dbOptions.error_if_exists = BooleanProperty(env, options, "errorIfExists").value_or(false);
   dbOptions.avoid_unnecessary_blocking_io = true;
   dbOptions.use_adaptive_mutex = true;
   dbOptions.enable_pipelined_write = false;
-  dbOptions.max_background_jobs =
-      Uint32Property(env, options, "maxBackgroundJobs").value_or(std::thread::hardware_concurrency() / 4);
+  dbOptions.max_background_jobs = Uint32Property(env, options, "maxBackgroundJobs")
+                                      .value_or(std::max<uint32_t>(2, std::thread::hardware_concurrency() / 8));
   dbOptions.WAL_ttl_seconds = Uint32Property(env, options, "walTTL").value_or(0) / 1e3;
   dbOptions.WAL_size_limit_MB = Uint32Property(env, options, "walSizeLimit").value_or(0) / 1e6;
   dbOptions.create_missing_column_families = true;
@@ -832,7 +832,7 @@ NAPI_METHOD(db_open) {
   NAPI_STATUS_THROWS(InitOptions(env, dbOptions, options));
 
   std::vector<rocksdb::ColumnFamilyDescriptor> column_families;
-  
+
   if (HasProperty(env, options, "columns")) {
     napi_value columns;
     NAPI_STATUS_THROWS(napi_get_named_property(env, options, "columns", &columns));
@@ -846,7 +846,7 @@ NAPI_METHOD(db_open) {
     for (uint32_t n = 0; n < len; ++n) {
       napi_value key;
       NAPI_STATUS_THROWS(napi_get_element(env, keys, n, &key));
-      
+
       napi_value column;
       NAPI_STATUS_THROWS(napi_get_property(env, columns, key, &column));
 
@@ -867,12 +867,12 @@ struct CloseWorker final : public Worker {
   CloseWorker(napi_env env, Database* database, napi_value callback)
       : Worker(env, database, callback, "leveldown.db.close") {}
 
-  rocksdb::Status Execute(Database& database) override { 
+  rocksdb::Status Execute(Database& database) override {
     for (auto it : database.columns_) {
       database.db_->DestroyColumnFamilyHandle(it);
     }
 
-    return database.db_->Close(); 
+    return database.db_->Close();
   }
 };
 
@@ -944,8 +944,8 @@ struct UpdateNextWorker final : public rocksdb::WriteBatch::Handler, public Work
         napi_value key;
         napi_value val;
 
-        NAPI_STATUS_RETURN(Convert(env, std::move(cache_[idx + 0]), updates_->keyAsBuffer_, key));
-        NAPI_STATUS_RETURN(Convert(env, std::move(cache_[idx + 1]), updates_->valueAsBuffer_, val));
+        NAPI_STATUS_RETURN(Convert(env, cache_[idx + 0], updates_->keyAsBuffer_, key));
+        NAPI_STATUS_RETURN(Convert(env, cache_[idx + 1], updates_->valueAsBuffer_, val));
 
         NAPI_STATUS_RETURN(napi_set_element(env, result, static_cast<int>(idx + 0), key));
         NAPI_STATUS_RETURN(napi_set_element(env, result, static_cast<int>(idx + 1), val));
@@ -1085,7 +1085,7 @@ struct GetWorker final : public Worker {
   napi_status OnOk(napi_env env, napi_value callback) override {
     napi_value argv[2];
     NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
-    NAPI_STATUS_RETURN(Convert(env, std::move(value_), asBuffer_, argv[1]));
+    NAPI_STATUS_RETURN(Convert(env, value_, asBuffer_, argv[1]));
     return CallFunction(env, callback, 2, argv);
   }
 
@@ -1145,23 +1145,23 @@ struct GetManyWorker final : public Worker {
     readOptions.snapshot = snapshot_.get();
     readOptions.async_io = true;
 
-    const auto numKeys = keys_.size();
-
     std::vector<rocksdb::Slice> keys;
     keys.reserve(keys_.size());
     for (const auto& key : keys_) {
       keys.emplace_back(key);
     }
 
-    statuses_.resize(numKeys);
-    values_.resize(numKeys);
+    statuses_.resize(keys.size());
+    values_.resize(keys.size());
 
-    database.db_->MultiGet(readOptions, column_, numKeys, keys.data(), values_.data(), statuses_.data());
+    // database.db_->MultiGet(readOptions, column_, keys.size(), keys.data(), values_.data(), statuses_.data());
 
-    keys_.clear();
-    snapshot_ = nullptr;
+    // TODO (fix): Use MultiGet once https://github.com/facebook/rocksdb/issues/10186 is resolved.
+    for (auto n = 0; n < keys.size(); ++n) {
+      statuses_[n] = database.db_->Get(readOptions, column_, keys[n], &values_[n]);
+    }
 
-    for (auto status : statuses_) {
+    for (const auto& status : statuses_) {
       if (!status.ok() && !status.IsNotFound()) {
         return status;
       }
@@ -1179,16 +1179,13 @@ struct GetManyWorker final : public Worker {
     for (size_t idx = 0; idx < size; idx++) {
       napi_value element;
       if (statuses_[idx].ok()) {
-        NAPI_STATUS_RETURN(Convert(env, std::move(values_[idx]), valueAsBuffer_, element));
+        NAPI_STATUS_RETURN(Convert(env, values_[idx], valueAsBuffer_, element));
       } else {
         NAPI_STATUS_RETURN(napi_get_undefined(env, &element));
       }
       NAPI_STATUS_RETURN(napi_set_element(env, array, static_cast<uint32_t>(idx), element));
     }
 
-    values_.clear();
-    statuses_.clear();
-
     napi_value argv[2];
     NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
     argv[1] = array;
@@ -1481,7 +1478,8 @@ struct NextWorker final : public Worker {
         cache_.push_back(v.ToString());
       }
 
-      if ((iterator_->highWaterMarkBytes_ != -1 && bytesRead > static_cast<size_t>(iterator_->highWaterMarkBytes_)) || cache_.size() / 2 >= size_) {
+      if ((iterator_->highWaterMarkBytes_ != -1 && bytesRead > static_cast<size_t>(iterator_->highWaterMarkBytes_)) ||
+          cache_.size() / 2 >= size_) {
         finished_ = false;
         return rocksdb::Status::OK();
       }
@@ -1501,8 +1499,8 @@ struct NextWorker final : public Worker {
       napi_value key;
       napi_value val;
 
-      NAPI_STATUS_RETURN(Convert(env, std::move(cache_[n + 0]), iterator_->keyAsBuffer_, key));
-      NAPI_STATUS_RETURN(Convert(env, std::move(cache_[n + 1]), iterator_->valueAsBuffer_, val));
+      NAPI_STATUS_RETURN(Convert(env, cache_[n + 0], iterator_->keyAsBuffer_, key));
+      NAPI_STATUS_RETURN(Convert(env, cache_[n + 1], iterator_->valueAsBuffer_, val));
 
       NAPI_STATUS_RETURN(napi_set_element(env, result, static_cast<int>(n + 0), key));
       NAPI_STATUS_RETURN(napi_set_element(env, result, static_cast<int>(n + 1), val));

package/deps/rocksdb/rocksdb/CMakeLists.txt

@@ -194,7 +194,7 @@ else()
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wstrict-prototypes")
   endif()
   if(MINGW)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-format -fno-asynchronous-unwind-tables")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-format")
     add_definitions(-D_POSIX_C_SOURCE=1)
   endif()
   if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")

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

@@ -287,7 +287,9 @@ class CacheBench {
         exit(1);
       }
     } else if (FLAGS_cache_type == "fast_lru_cache") {
-      cache_ = NewFastLRUCache(FLAGS_cache_size, FLAGS_num_shard_bits);
+      cache_ = NewFastLRUCache(
+          FLAGS_cache_size, FLAGS_value_bytes, FLAGS_num_shard_bits,
+          false /*strict_capacity_limit*/, kDefaultCacheMetadataChargePolicy);
     } else if (FLAGS_cache_type == "lru_cache") {
       LRUCacheOptions opts(FLAGS_cache_size, FLAGS_num_shard_bits, false, 0.5);
 #ifndef ROCKSDB_LITE

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

@@ -22,6 +22,7 @@ std::array<std::string, kNumCacheEntryRoles> kCacheEntryRoleToCamelString{{
     "CompressionDictionaryBuildingBuffer",
     "FilterConstruction",
     "BlockBasedTableReader",
+    "FileMetadata",
     "Misc",
 }};
 
@@ -36,6 +37,7 @@ std::array<std::string, kNumCacheEntryRoles> kCacheEntryRoleToHyphenString{{
     "compression-dictionary-building-buffer",
     "filter-construction",
     "block-based-table-reader",
+    "file-metadata",
     "misc",
 }};
 

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

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

package/deps/rocksdb/rocksdb/cache/cache_reservation_manager.h

@@ -36,6 +36,12 @@ class CacheReservationManager {
   };
   virtual ~CacheReservationManager() {}
   virtual Status UpdateCacheReservation(std::size_t new_memory_used) = 0;
+  // TODO(hx235): replace the usage of
+  // `UpdateCacheReservation(memory_used_delta, increase)` with
+  // `UpdateCacheReservation(new_memory_used)` so that we only have one
+  // `UpdateCacheReservation` function
+  virtual Status UpdateCacheReservation(std::size_t memory_used_delta,
+                                        bool increase) = 0;
   virtual Status MakeCacheReservation(
       std::size_t incremental_memory_used,
       std::unique_ptr<CacheReservationManager::CacheReservationHandle>
@@ -128,6 +134,11 @@ class CacheReservationManagerImpl
   //         On keeping dummy entries the same, it always returns Status::OK().
   Status UpdateCacheReservation(std::size_t new_memory_used) override;
 
+  Status UpdateCacheReservation(std::size_t /* memory_used_delta */,
+                                bool /* increase */) override {
+    return Status::NotSupported();
+  }
+
   // One of the two ways of reserving cache space and releasing is done through
   // destruction of CacheReservationHandle.
   // See UpdateCacheReservation() for the other way.
@@ -254,6 +265,23 @@ class ConcurrentCacheReservationManager
     std::lock_guard<std::mutex> lock(cache_res_mgr_mu_);
     return cache_res_mgr_->UpdateCacheReservation(new_memory_used);
   }
+
+  inline Status UpdateCacheReservation(std::size_t memory_used_delta,
+                                       bool increase) override {
+    std::lock_guard<std::mutex> lock(cache_res_mgr_mu_);
+    std::size_t total_mem_used = cache_res_mgr_->GetTotalMemoryUsed();
+    Status s;
+    if (!increase) {
+      assert(total_mem_used >= memory_used_delta);
+      s = cache_res_mgr_->UpdateCacheReservation(total_mem_used -
+                                                 memory_used_delta);
+    } else {
+      s = cache_res_mgr_->UpdateCacheReservation(total_mem_used +
+                                                 memory_used_delta);
+    }
+    return s;
+  }
+
   inline Status MakeCacheReservation(
       std::size_t incremental_memory_used,
       std::unique_ptr<CacheReservationManager::CacheReservationHandle> *handle)

package/deps/rocksdb/rocksdb/cache/cache_test.cc

@@ -114,7 +114,9 @@ class CacheTest : public testing::TestWithParam<std::string> {
       return NewClockCache(capacity);
     }
     if (type == kFast) {
-      return NewFastLRUCache(capacity);
+      return NewFastLRUCache(
+          capacity, 1 /*estimated_value_size*/, -1 /*num_shard_bits*/,
+          false /*strict_capacity_limit*/, kDefaultCacheMetadataChargePolicy);
     }
     return nullptr;
   }
@@ -137,7 +139,8 @@ class CacheTest : public testing::TestWithParam<std::string> {
                            charge_policy);
     }
     if (type == kFast) {
-      return NewFastLRUCache(capacity, num_shard_bits, strict_capacity_limit,
+      return NewFastLRUCache(capacity, 1 /*estimated_value_size*/,
+                             num_shard_bits, strict_capacity_limit,
                              charge_policy);
     }
     return nullptr;

package/deps/rocksdb/rocksdb/cache/fast_lru_cache.cc

@@ -18,15 +18,17 @@
 #include "port/lang.h"
 #include "util/mutexlock.h"
 
+#define KEY_LENGTH \
+  16  // TODO(guido) Make use of this symbol in other parts of the source code
+      // (e.g., cache_key.h, cache_test.cc, etc.)
+
 namespace ROCKSDB_NAMESPACE {
 
 namespace fast_lru_cache {
 
-LRUHandleTable::LRUHandleTable(int max_upper_hash_bits)
-    : length_bits_(/* historical starting size*/ 4),
-      list_(new LRUHandle* [size_t{1} << length_bits_] {}),
-      elems_(0),
-      max_length_bits_(max_upper_hash_bits) {}
+LRUHandleTable::LRUHandleTable(int hash_bits)
+    : length_bits_(hash_bits),
+      list_(new LRUHandle* [size_t{1} << length_bits_] {}) {}
 
 LRUHandleTable::~LRUHandleTable() {
   ApplyToEntriesRange(
@@ -42,19 +44,15 @@ LRUHandle* LRUHandleTable::Lookup(const Slice& key, uint32_t hash) {
   return *FindPointer(key, hash);
 }
 
+inline LRUHandle** LRUHandleTable::Head(uint32_t hash) {
+  return &list_[hash >> (32 - length_bits_)];
+}
+
 LRUHandle* LRUHandleTable::Insert(LRUHandle* h) {
   LRUHandle** ptr = FindPointer(h->key(), h->hash);
   LRUHandle* old = *ptr;
   h->next_hash = (old == nullptr ? nullptr : old->next_hash);
   *ptr = h;
-  if (old == nullptr) {
-    ++elems_;
-    if ((elems_ >> length_bits_) > 0) {  // elems_ >= length
-      // Since each cache entry is fairly large, we aim for a small
-      // average linked list length (<= 1).
-      Resize();
-    }
-  }
   return old;
 }
 
@@ -63,7 +61,6 @@ LRUHandle* LRUHandleTable::Remove(const Slice& key, uint32_t hash) {
   LRUHandle* result = *ptr;
   if (result != nullptr) {
     *ptr = result->next_hash;
-    --elems_;
   }
   return result;
 }
@@ -76,46 +73,13 @@ LRUHandle** LRUHandleTable::FindPointer(const Slice& key, uint32_t hash) {
   return ptr;
 }
 
-void LRUHandleTable::Resize() {
-  if (length_bits_ >= max_length_bits_) {
-    // Due to reaching limit of hash information, if we made the table bigger,
-    // we would allocate more addresses but only the same number would be used.
-    return;
-  }
-  if (length_bits_ >= 31) {
-    // Avoid undefined behavior shifting uint32_t by 32.
-    return;
-  }
-
-  uint32_t old_length = uint32_t{1} << length_bits_;
-  int new_length_bits = length_bits_ + 1;
-  std::unique_ptr<LRUHandle* []> new_list {
-    new LRUHandle* [size_t{1} << new_length_bits] {}
-  };
-  uint32_t count = 0;
-  for (uint32_t i = 0; i < old_length; i++) {
-    LRUHandle* h = list_[i];
-    while (h != nullptr) {
-      LRUHandle* next = h->next_hash;
-      uint32_t hash = h->hash;
-      LRUHandle** ptr = &new_list[hash >> (32 - new_length_bits)];
-      h->next_hash = *ptr;
-      *ptr = h;
-      h = next;
-      count++;
-    }
-  }
-  assert(elems_ == count);
-  list_ = std::move(new_list);
-  length_bits_ = new_length_bits;
-}
-
-LRUCacheShard::LRUCacheShard(size_t capacity, bool strict_capacity_limit,
-                             CacheMetadataChargePolicy metadata_charge_policy,
-                             int max_upper_hash_bits)
+LRUCacheShard::LRUCacheShard(size_t capacity, size_t estimated_value_size,
+                             bool strict_capacity_limit,
+                             CacheMetadataChargePolicy metadata_charge_policy)
     : capacity_(0),
       strict_capacity_limit_(strict_capacity_limit),
-      table_(max_upper_hash_bits),
+      table_(
+          GetHashBits(capacity, estimated_value_size, metadata_charge_policy)),
       usage_(0),
       lru_usage_(0) {
   set_metadata_charge_policy(metadata_charge_policy);
@@ -220,6 +184,27 @@ void LRUCacheShard::EvictFromLRU(size_t charge,
   }
 }
 
+int LRUCacheShard::GetHashBits(
+    size_t capacity, size_t estimated_value_size,
+    CacheMetadataChargePolicy metadata_charge_policy) {
+  LRUHandle* e = reinterpret_cast<LRUHandle*>(
+      new char[sizeof(LRUHandle) - 1 + KEY_LENGTH]);
+  e->key_length = KEY_LENGTH;
+  e->deleter = nullptr;
+  e->refs = 0;
+  e->flags = 0;
+  e->refs = 0;
+
+  e->CalcTotalCharge(estimated_value_size, metadata_charge_policy);
+  size_t num_entries = capacity / e->total_charge;
+  e->Free();
+  int num_hash_bits = 0;
+  while (num_entries >>= 1) {
+    ++num_hash_bits;
+  }
+  return num_hash_bits;
+}
+
 void LRUCacheShard::SetCapacity(size_t capacity) {
   autovector<LRUHandle*> last_reference_list;
   {
@@ -368,8 +353,9 @@ Status LRUCacheShard::Insert(const Slice& key, uint32_t hash, void* value,
                              size_t charge, Cache::DeleterFn deleter,
                              Cache::Handle** handle,
                              Cache::Priority /*priority*/) {
-  if (key.size() != 16) {
-    return Status::NotSupported("FastLRUCache only supports key size 16B.");
+  if (key.size() != KEY_LENGTH) {
+    return Status::NotSupported("FastLRUCache only supports key size " +
+                                std::to_string(KEY_LENGTH) + "B");
   }
 
   // Allocate the memory here outside of the mutex.
@@ -431,8 +417,8 @@ size_t LRUCacheShard::GetPinnedUsage() const {
 
 std::string LRUCacheShard::GetPrintableOptions() const { return std::string{}; }
 
-LRUCache::LRUCache(size_t capacity, int num_shard_bits,
-                   bool strict_capacity_limit,
+LRUCache::LRUCache(size_t capacity, size_t estimated_value_size,
+                   int num_shard_bits, bool strict_capacity_limit,
                    CacheMetadataChargePolicy metadata_charge_policy)
     : ShardedCache(capacity, num_shard_bits, strict_capacity_limit) {
   num_shards_ = 1 << num_shard_bits;
@@ -441,8 +427,8 @@ LRUCache::LRUCache(size_t capacity, int num_shard_bits,
   size_t per_shard = (capacity + (num_shards_ - 1)) / num_shards_;
   for (int i = 0; i < num_shards_; i++) {
     new (&shards_[i])
-        LRUCacheShard(per_shard, strict_capacity_limit, metadata_charge_policy,
-                      /* max_upper_hash_bits */ 32 - num_shard_bits);
+        LRUCacheShard(per_shard, estimated_value_size, strict_capacity_limit,
+                      metadata_charge_policy);
   }
 }
 
@@ -497,7 +483,8 @@ void LRUCache::DisownData() {
 }  // namespace fast_lru_cache
 
 std::shared_ptr<Cache> NewFastLRUCache(
-    size_t capacity, int num_shard_bits, bool strict_capacity_limit,
+    size_t capacity, size_t estimated_value_size, int num_shard_bits,
+    bool strict_capacity_limit,
     CacheMetadataChargePolicy metadata_charge_policy) {
   if (num_shard_bits >= 20) {
     return nullptr;  // The cache cannot be sharded into too many fine pieces.
@@ -506,7 +493,8 @@ std::shared_ptr<Cache> NewFastLRUCache(
     num_shard_bits = GetDefaultCacheShardBits(capacity);
   }
   return std::make_shared<fast_lru_cache::LRUCache>(
-      capacity, num_shard_bits, strict_capacity_limit, metadata_charge_policy);
+      capacity, estimated_value_size, num_shard_bits, strict_capacity_limit,
+      metadata_charge_policy);
 }
 
 }  // namespace ROCKSDB_NAMESPACE

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

@@ -114,10 +114,7 @@ struct LRUHandle {
 // 4.4.3's builtin hashtable.
 class LRUHandleTable {
  public:
-  // If the table uses more hash bits than `max_upper_hash_bits`,
-  // it will eat into the bits used for sharding, which are constant
-  // for a given LRUHandleTable.
-  explicit LRUHandleTable(int max_upper_hash_bits);
+  explicit LRUHandleTable(int hash_bits);
   ~LRUHandleTable();
 
   LRUHandle* Lookup(const Slice& key, uint32_t hash);
@@ -139,14 +136,16 @@ class LRUHandleTable {
 
   int GetLengthBits() const { return length_bits_; }
 
+  // Return the address of the head of the chain in the bucket given
+  // by the hash.
+  inline LRUHandle** Head(uint32_t hash);
+
  private:
   // Return a pointer to slot that points to a cache entry that
   // matches key/hash.  If there is no such cache entry, return a
   // pointer to the trailing slot in the corresponding linked list.
   LRUHandle** FindPointer(const Slice& key, uint32_t hash);
 
-  void Resize();
-
   // Number of hash bits (upper because lower bits used for sharding)
   // used for table index. Length == 1 << length_bits_
   int length_bits_;
@@ -154,20 +153,14 @@ class LRUHandleTable {
   // The table consists of an array of buckets where each bucket is
   // a linked list of cache entries that hash into the bucket.
   std::unique_ptr<LRUHandle*[]> list_;
-
-  // Number of elements currently in the table.
-  uint32_t elems_;
-
-  // Set from max_upper_hash_bits (see constructor).
-  const int max_length_bits_;
 };
 
 // A single shard of sharded cache.
 class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
  public:
-  LRUCacheShard(size_t capacity, bool strict_capacity_limit,
-                CacheMetadataChargePolicy metadata_charge_policy,
-                int max_upper_hash_bits);
+  LRUCacheShard(size_t capacity, size_t estimated_value_size,
+                bool strict_capacity_limit,
+                CacheMetadataChargePolicy metadata_charge_policy);
   ~LRUCacheShard() override = default;
 
   // Separate from constructor so caller can easily make an array of LRUCache
@@ -239,6 +232,11 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
   // holding the mutex_.
   void EvictFromLRU(size_t charge, autovector<LRUHandle*>* deleted);
 
+  // Returns the number of bits used to hash an element in the per-shard
+  // table.
+  static int GetHashBits(size_t capacity, size_t estimated_value_size,
+                         CacheMetadataChargePolicy metadata_charge_policy);
+
   // Initialized before use.
   size_t capacity_;
 
@@ -284,7 +282,8 @@ class LRUCache
 #endif
     : public ShardedCache {
  public:
-  LRUCache(size_t capacity, int num_shard_bits, bool strict_capacity_limit,
+  LRUCache(size_t capacity, size_t estimated_value_size, int num_shard_bits,
+           bool strict_capacity_limit,
            CacheMetadataChargePolicy metadata_charge_policy =
                kDontChargeCacheMetadata);
   ~LRUCache() override;
@@ -304,9 +303,8 @@ class LRUCache
 }  // namespace fast_lru_cache
 
 std::shared_ptr<Cache> NewFastLRUCache(
-    size_t capacity, int num_shard_bits = -1,
-    bool strict_capacity_limit = false,
-    CacheMetadataChargePolicy metadata_charge_policy =
-        kDefaultCacheMetadataChargePolicy);
+    size_t capacity, size_t estimated_value_size, int num_shard_bits,
+    bool strict_capacity_limit,
+    CacheMetadataChargePolicy metadata_charge_policy);
 
 }  // namespace ROCKSDB_NAMESPACE

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

@@ -226,8 +226,8 @@ class FastLRUCacheTest : public testing::Test {
     cache_ = reinterpret_cast<fast_lru_cache::LRUCacheShard*>(
         port::cacheline_aligned_alloc(sizeof(fast_lru_cache::LRUCacheShard)));
     new (cache_) fast_lru_cache::LRUCacheShard(
-        capacity, false /*strict_capcity_limit*/, kDontChargeCacheMetadata,
-        24 /*max_upper_hash_bits*/);
+        capacity, 1 /*estimated_value_size*/, false /*strict_capacity_limit*/,
+        kDontChargeCacheMetadata);
   }
 
   Status Insert(const std::string& key) {

package/deps/rocksdb/rocksdb/db/c.cc

@@ -3048,6 +3048,11 @@ int rocksdb_options_get_blob_file_starting_level(rocksdb_options_t* opt) {
   return opt->rep.blob_file_starting_level;
 }
 
+void rocksdb_options_set_blob_cache(rocksdb_options_t* opt,
+                                    rocksdb_cache_t* blob_cache) {
+  opt->rep.blob_cache = blob_cache->rep;
+}
+
 void rocksdb_options_set_num_levels(rocksdb_options_t* opt, int n) {
   opt->rep.num_levels = n;
 }

package/deps/rocksdb/rocksdb/db/column_family.cc

@@ -619,6 +619,26 @@ ColumnFamilyData::ColumnFamilyData(
   }
 
   RecalculateWriteStallConditions(mutable_cf_options_);
+
+  if (cf_options.table_factory->IsInstanceOf(
+          TableFactory::kBlockBasedTableName()) &&
+      cf_options.table_factory->GetOptions<BlockBasedTableOptions>()) {
+    const BlockBasedTableOptions* bbto =
+        cf_options.table_factory->GetOptions<BlockBasedTableOptions>();
+    const auto& options_overrides = bbto->cache_usage_options.options_overrides;
+    const auto file_metadata_charged =
+        options_overrides.at(CacheEntryRole::kFileMetadata).charged;
+    if (bbto->block_cache &&
+        file_metadata_charged == CacheEntryRoleOptions::Decision::kEnabled) {
+      // TODO(hx235): Add a `ConcurrentCacheReservationManager` at DB scope
+      // responsible for reservation of `ObsoleteFileInfo` so that we can keep
+      // this `file_metadata_cache_res_mgr_` nonconcurrent
+      file_metadata_cache_res_mgr_.reset(new ConcurrentCacheReservationManager(
+          std::make_shared<
+              CacheReservationManagerImpl<CacheEntryRole::kFileMetadata>>(
+              bbto->block_cache)));
+    }
+  }
 }
 
 // DB mutex held