@nxtedition/rocksdb 7.0.0-alpha.7 → 7.0.1

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) {
@@ -526,7 +526,7 @@ struct Iterator final : public BaseIterator {
            const bool fillCache,
            const bool keyAsBuffer,
            const bool valueAsBuffer,
-           const uint32_t highWaterMarkBytes,
+           const int32_t highWaterMarkBytes,
            std::shared_ptr<const rocksdb::Snapshot> snapshot)
       : BaseIterator(database, column, reverse, lt, lte, gt, gte, limit, fillCache, snapshot),
         keys_(keys),
@@ -551,7 +551,7 @@ struct Iterator final : public BaseIterator {
   const bool values_;
   const bool keyAsBuffer_;
   const bool valueAsBuffer_;
-  const uint32_t highWaterMarkBytes_;
+  const int32_t highWaterMarkBytes_;
   bool first_ = true;
 
  private:
@@ -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,85 +691,86 @@ struct OpenWorker final : public Worker {
   std::vector<rocksdb::ColumnFamilyDescriptor> column_families_;
 };
 
-napi_status InitOptions(napi_env env, auto& options, auto options2) {
-  const auto memtable_memory_budget = Uint32Property(env, options2, "memtableMemoryBudget").value_or(256 * 1024 * 1024);
+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, options2, "compaction").value_or("level");
+  const auto compaction = StringProperty(env, options, "compaction").value_or("level");
 
   if (compaction == "universal") {
-    options.write_buffer_size = static_cast<size_t>(memtable_memory_budget / 4);
+    columnOptions.write_buffer_size = static_cast<size_t>(memtable_memory_budget / 4);
     // merge two memtables when flushing to L0
-    options.min_write_buffer_number_to_merge = 2;
+    columnOptions.min_write_buffer_number_to_merge = 2;
     // this means we'll use 50% extra memory in the worst case, but will reduce
     // write stalls.
-    options.max_write_buffer_number = 6;
+    columnOptions.max_write_buffer_number = 6;
     // universal style compaction
-    options.compaction_style = rocksdb::kCompactionStyleUniversal;
-    options.compaction_options_universal.compression_size_percent = 80;
+    columnOptions.compaction_style = rocksdb::kCompactionStyleUniversal;
+    columnOptions.compaction_options_universal.compression_size_percent = 80;
   } else {
     // merge two memtables when flushing to L0
-    options.min_write_buffer_number_to_merge = 2;
+    columnOptions.min_write_buffer_number_to_merge = 2;
     // this means we'll use 50% extra memory in the worst case, but will reduce
     // write stalls.
-    options.max_write_buffer_number = 6;
+    columnOptions.max_write_buffer_number = 6;
     // start flushing L0->L1 as soon as possible. each file on level0 is
     // (memtable_memory_budget / 2). This will flush level 0 when it's bigger than
     // memtable_memory_budget.
-    options.level0_file_num_compaction_trigger = 2;
+    columnOptions.level0_file_num_compaction_trigger = 2;
     // doesn't really matter much, but we don't want to create too many files
-    options.target_file_size_base = memtable_memory_budget / 8;
+    columnOptions.target_file_size_base = memtable_memory_budget / 8;
     // make Level1 size equal to Level0 size, so that L0->L1 compactions are fast
-    options.max_bytes_for_level_base = memtable_memory_budget;
+    columnOptions.max_bytes_for_level_base = memtable_memory_budget;
 
     // level style compaction
-    options.compaction_style = rocksdb::kCompactionStyleLevel;
+    columnOptions.compaction_style = rocksdb::kCompactionStyleLevel;
 
     // TODO (perf): only compress levels >= 2
   }
 
-  options.compression =
-      BooleanProperty(env, options2, "compression").value_or((true)) ? rocksdb::kZSTD : rocksdb::kNoCompression;
-  if (options.compression == rocksdb::kZSTD) {
-    options.compression_opts.max_dict_bytes = 16 * 1024;
-    options.compression_opts.zstd_max_train_bytes = 16 * 1024 * 100;
-    // options.compression_opts.parallel_threads
+  columnOptions.compression =
+      BooleanProperty(env, options, "compression").value_or((true)) ? rocksdb::kZSTD : rocksdb::kNoCompression;
+  if (columnOptions.compression == rocksdb::kZSTD) {
+    columnOptions.compression_opts.max_dict_bytes = 16 * 1024;
+    columnOptions.compression_opts.zstd_max_train_bytes = 16 * 1024 * 100;
+    // columnOptions.compression_opts.parallel_threads
   }
 
-  const auto cacheSize = Uint32Property(env, options2, "cacheSize").value_or(8 << 20);
+  const auto cacheSize = Uint32Property(env, options, "cacheSize").value_or(8 << 20);
 
   rocksdb::BlockBasedTableOptions tableOptions;
 
   if (cacheSize) {
     tableOptions.block_cache = rocksdb::NewLRUCache(cacheSize);
     tableOptions.cache_index_and_filter_blocks =
-        BooleanProperty(env, options2, "cacheIndexAndFilterBlocks").value_or(true);
+        BooleanProperty(env, options, "cacheIndexAndFilterBlocks").value_or(true);
   } else {
     tableOptions.no_block_cache = true;
     tableOptions.cache_index_and_filter_blocks = false;
   }
 
-  const auto optimize = StringProperty(env, options2, "optimize").value_or("");
+  const auto optimize = StringProperty(env, options, "optimize").value_or("");
 
   if (optimize == "point-lookup") {
     tableOptions.data_block_index_type = rocksdb::BlockBasedTableOptions::kDataBlockBinaryAndHash;
     tableOptions.data_block_hash_table_util_ratio = 0.75;
     tableOptions.filter_policy.reset(rocksdb::NewRibbonFilterPolicy(10, 1));
 
-    options.memtable_prefix_bloom_size_ratio = 0.02;
-    options.memtable_whole_key_filtering = true;
+    columnOptions.memtable_prefix_bloom_size_ratio = 0.02;
+    columnOptions.memtable_whole_key_filtering = true;
   } else if (optimize == "range-lookup") {
     // TODO?
   } else {
     tableOptions.filter_policy.reset(rocksdb::NewRibbonFilterPolicy(10));
   }
 
-  tableOptions.block_size = Uint32Property(env, options2, "blockSize").value_or(4096);
-  tableOptions.block_restart_interval = Uint32Property(env, options2, "blockRestartInterval").value_or(16);
+  tableOptions.block_size = Uint32Property(env, options, "blockSize").value_or(4096);
+  tableOptions.block_restart_interval = Uint32Property(env, options, "blockRestartInterval").value_or(16);
   tableOptions.format_version = 5;
   tableOptions.checksum = rocksdb::kXXH3;
-  tableOptions.optimize_filters_for_memory = BooleanProperty(env, options2, "optimizeFiltersForMemory").value_or(true);
+  tableOptions.optimize_filters_for_memory = BooleanProperty(env, options, "optimizeFiltersForMemory").value_or(true);
 
-  options.table_factory.reset(rocksdb::NewBlockBasedTableFactory(tableOptions));
+  columnOptions.table_factory.reset(rocksdb::NewBlockBasedTableFactory(tableOptions));
 
   return napi_ok;
 }
@@ -786,19 +787,20 @@ 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 = BooleanProperty(env, options, "useAdaptiveMutex").value_or(true);
-  dbOptions.enable_pipelined_write = BooleanProperty(env, options, "enablePipelinedWrite").value_or(true);
-  dbOptions.max_background_jobs =
-      Uint32Property(env, options, "maxBackgroundJobs").value_or(std::thread::hardware_concurrency() / 4);
+  dbOptions.use_adaptive_mutex = true;
+  dbOptions.enable_pipelined_write = false;
+  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;
+  dbOptions.unordered_write = BooleanProperty(env, options, "unorderedWrite").value_or(false);
 
   const auto infoLogLevel = StringProperty(env, options, "infoLogLevel").value_or("");
   if (infoLogLevel.size() > 0) {
@@ -830,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));
@@ -844,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));
 
@@ -865,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();
   }
 };
 
@@ -942,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));
@@ -1083,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);
   }
 
@@ -1143,21 +1145,16 @@ 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);
-
-    database.db_->MultiGet(readOptions, column_, numKeys, keys.data(), values_.data(), statuses_.data());
+    statuses_.resize(keys.size());
+    values_.resize(keys.size());
 
-    keys_.clear();
-    snapshot_ = nullptr;
+    database.db_->MultiGet(readOptions, column_, keys.size(), keys.data(), values_.data(), statuses_.data());
 
     for (auto status : statuses_) {
       if (!status.ok() && !status.IsNotFound()) {
@@ -1177,16 +1174,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;
@@ -1374,7 +1368,7 @@ NAPI_METHOD(iterator_init) {
   const bool keyAsBuffer = EncodingIsBuffer(env, options, "keyEncoding");
   const bool valueAsBuffer = EncodingIsBuffer(env, options, "valueEncoding");
   const auto limit = Int32Property(env, options, "limit").value_or(-1);
-  const auto highWaterMarkBytes = Uint32Property(env, options, "highWaterMarkBytes").value_or(16 * 1024);
+  const auto highWaterMarkBytes = Int32Property(env, options, "highWaterMarkBytes").value_or(16 * 1024);
 
   const auto lt = StringProperty(env, options, "lt");
   const auto lte = StringProperty(env, options, "lte");
@@ -1479,7 +1473,8 @@ struct NextWorker final : public Worker {
         cache_.push_back(v.ToString());
       }
 
-      if ((iterator_->highWaterMarkBytes_ != -1 && bytesRead > 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();
       }
@@ -1499,8 +1494,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));
@@ -1546,7 +1541,6 @@ NAPI_METHOD(batch_do) {
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
 
   const auto operations = argv[1];
-  const auto options = argv[2];
 
   rocksdb::WriteBatch batch;
 

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