rocksdb-native 2.6.2 → 2.6.4

package/vendor/librocksdb/vendor/rocksdb/cache/cache_reservation_manager.cc

@@ -1,184 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  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).
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-#include "cache/cache_reservation_manager.h"
-
-#include <cassert>
-#include <cstddef>
-#include <cstring>
-#include <memory>
-
-#include "rocksdb/cache.h"
-#include "rocksdb/slice.h"
-#include "rocksdb/status.h"
-#include "table/block_based/reader_common.h"
-#include "util/coding.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-template <CacheEntryRole R>
-CacheReservationManagerImpl<R>::CacheReservationHandle::CacheReservationHandle(
-    std::size_t incremental_memory_used,
-    std::shared_ptr<CacheReservationManagerImpl> cache_res_mgr)
-    : incremental_memory_used_(incremental_memory_used) {
-  assert(cache_res_mgr);
-  cache_res_mgr_ = cache_res_mgr;
-}
-
-template <CacheEntryRole R>
-CacheReservationManagerImpl<
-    R>::CacheReservationHandle::~CacheReservationHandle() {
-  Status s = cache_res_mgr_->ReleaseCacheReservation(incremental_memory_used_);
-  s.PermitUncheckedError();
-}
-
-template <CacheEntryRole R>
-CacheReservationManagerImpl<R>::CacheReservationManagerImpl(
-    std::shared_ptr<Cache> cache, bool delayed_decrease)
-    : cache_(cache),
-      delayed_decrease_(delayed_decrease),
-      cache_allocated_size_(0),
-      memory_used_(0) {
-  assert(cache != nullptr);
-}
-
-template <CacheEntryRole R>
-CacheReservationManagerImpl<R>::~CacheReservationManagerImpl() {
-  for (auto* handle : dummy_handles_) {
-    cache_.ReleaseAndEraseIfLastRef(handle);
-  }
-}
-
-template <CacheEntryRole R>
-Status CacheReservationManagerImpl<R>::UpdateCacheReservation(
-    std::size_t new_mem_used) {
-  memory_used_ = new_mem_used;
-  std::size_t cur_cache_allocated_size =
-      cache_allocated_size_.load(std::memory_order_relaxed);
-  if (new_mem_used == cur_cache_allocated_size) {
-    return Status::OK();
-  } else if (new_mem_used > cur_cache_allocated_size) {
-    Status s = IncreaseCacheReservation(new_mem_used);
-    return s;
-  } else {
-    // In delayed decrease mode, we don't decrease cache reservation
-    // untill the memory usage is less than 3/4 of what we reserve
-    // in the cache.
-    // We do this because
-    // (1) Dummy entry insertion is expensive in block cache
-    // (2) Delayed releasing previously inserted dummy entries can save such
-    // expensive dummy entry insertion on memory increase in the near future,
-    // which is likely to happen when the memory usage is greater than or equal
-    // to 3/4 of what we reserve
-    if (delayed_decrease_ && new_mem_used >= cur_cache_allocated_size / 4 * 3) {
-      return Status::OK();
-    } else {
-      Status s = DecreaseCacheReservation(new_mem_used);
-      return s;
-    }
-  }
-}
-
-template <CacheEntryRole R>
-Status CacheReservationManagerImpl<R>::MakeCacheReservation(
-    std::size_t incremental_memory_used,
-    std::unique_ptr<CacheReservationManager::CacheReservationHandle>* handle) {
-  assert(handle);
-  Status s =
-      UpdateCacheReservation(GetTotalMemoryUsed() + incremental_memory_used);
-  (*handle).reset(new CacheReservationManagerImpl::CacheReservationHandle(
-      incremental_memory_used,
-      std::enable_shared_from_this<
-          CacheReservationManagerImpl<R>>::shared_from_this()));
-  return s;
-}
-
-template <CacheEntryRole R>
-Status CacheReservationManagerImpl<R>::ReleaseCacheReservation(
-    std::size_t incremental_memory_used) {
-  assert(GetTotalMemoryUsed() >= incremental_memory_used);
-  std::size_t updated_total_mem_used =
-      GetTotalMemoryUsed() - incremental_memory_used;
-  Status s = UpdateCacheReservation(updated_total_mem_used);
-  return s;
-}
-
-template <CacheEntryRole R>
-Status CacheReservationManagerImpl<R>::IncreaseCacheReservation(
-    std::size_t new_mem_used) {
-  Status return_status = Status::OK();
-  while (new_mem_used > cache_allocated_size_.load(std::memory_order_relaxed)) {
-    Cache::Handle* handle = nullptr;
-    return_status = cache_.Insert(GetNextCacheKey(), kSizeDummyEntry, &handle);
-
-    if (return_status != Status::OK()) {
-      return return_status;
-    }
-
-    dummy_handles_.push_back(handle);
-    cache_allocated_size_ += kSizeDummyEntry;
-  }
-  return return_status;
-}
-
-template <CacheEntryRole R>
-Status CacheReservationManagerImpl<R>::DecreaseCacheReservation(
-    std::size_t new_mem_used) {
-  Status return_status = Status::OK();
-
-  // Decrease to the smallest multiple of kSizeDummyEntry that is greater than
-  // or equal to new_mem_used We do addition instead of new_mem_used <=
-  // cache_allocated_size_.load(std::memory_order_relaxed) - kSizeDummyEntry to
-  // avoid underflow of size_t when cache_allocated_size_ = 0
-  while (new_mem_used + kSizeDummyEntry <=
-         cache_allocated_size_.load(std::memory_order_relaxed)) {
-    assert(!dummy_handles_.empty());
-    auto* handle = dummy_handles_.back();
-    cache_.ReleaseAndEraseIfLastRef(handle);
-    dummy_handles_.pop_back();
-    cache_allocated_size_ -= kSizeDummyEntry;
-  }
-  return return_status;
-}
-
-template <CacheEntryRole R>
-std::size_t CacheReservationManagerImpl<R>::GetTotalReservedCacheSize() {
-  return cache_allocated_size_.load(std::memory_order_relaxed);
-}
-
-template <CacheEntryRole R>
-std::size_t CacheReservationManagerImpl<R>::GetTotalMemoryUsed() {
-  return memory_used_;
-}
-
-template <CacheEntryRole R>
-Slice CacheReservationManagerImpl<R>::GetNextCacheKey() {
-  // Calling this function will have the side-effect of changing the
-  // underlying cache_key_ that is shared among other keys generated from this
-  // fucntion. Therefore please make sure the previous keys are saved/copied
-  // before calling this function.
-  cache_key_ = CacheKey::CreateUniqueForCacheLifetime(cache_.get());
-  return cache_key_.AsSlice();
-}
-
-template <CacheEntryRole R>
-const Cache::CacheItemHelper*
-CacheReservationManagerImpl<R>::TEST_GetCacheItemHelperForRole() {
-  return CacheInterface::GetHelper();
-}
-
-template class CacheReservationManagerImpl<
-    CacheEntryRole::kBlockBasedTableReader>;
-template class CacheReservationManagerImpl<
-    CacheEntryRole::kCompressionDictionaryBuildingBuffer>;
-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/vendor/librocksdb/vendor/rocksdb/cache/cache_reservation_manager.h

@@ -1,318 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  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).
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#pragma once
-
-#include <atomic>
-#include <cstddef>
-#include <cstdint>
-#include <memory>
-#include <mutex>
-#include <vector>
-
-#include "cache/cache_entry_roles.h"
-#include "cache/cache_key.h"
-#include "cache/typed_cache.h"
-#include "rocksdb/slice.h"
-#include "rocksdb/status.h"
-#include "util/coding.h"
-
-namespace ROCKSDB_NAMESPACE {
-// CacheReservationManager is an interface for reserving cache space for the
-// memory used
-class CacheReservationManager {
- public:
-  // CacheReservationHandle is for managing the lifetime of a cache reservation
-  // for an incremental amount of memory used (i.e, incremental_memory_used)
-  class CacheReservationHandle {
-   public:
-    virtual ~CacheReservationHandle() {}
-  };
-  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>
-          *handle) = 0;
-  virtual std::size_t GetTotalReservedCacheSize() = 0;
-  virtual std::size_t GetTotalMemoryUsed() = 0;
-};
-
-// CacheReservationManagerImpl implements interface CacheReservationManager
-// for reserving cache space for the memory used by inserting/releasing dummy
-// entries in the cache.
-//
-// This class is NOT thread-safe, except that GetTotalReservedCacheSize()
-// can be called without external synchronization.
-template <CacheEntryRole R>
-class CacheReservationManagerImpl
-    : public CacheReservationManager,
-      public std::enable_shared_from_this<CacheReservationManagerImpl<R>> {
- public:
-  class CacheReservationHandle
-      : public CacheReservationManager::CacheReservationHandle {
-   public:
-    CacheReservationHandle(
-        std::size_t incremental_memory_used,
-        std::shared_ptr<CacheReservationManagerImpl> cache_res_mgr);
-    ~CacheReservationHandle() override;
-
-   private:
-    std::size_t incremental_memory_used_;
-    std::shared_ptr<CacheReservationManagerImpl> cache_res_mgr_;
-  };
-
-  // Construct a CacheReservationManagerImpl
-  // @param cache The cache where dummy entries are inserted and released for
-  // reserving cache space
-  // @param delayed_decrease If set true, then dummy entries won't be released
-  //                         immediately when memory usage decreases.
-  //                         Instead, it will be released when the memory usage
-  //                         decreases to 3/4 of what we have reserved so far.
-  //                         This is for saving some future dummy entry
-  //                         insertion when memory usage increases are likely to
-  //                         happen in the near future.
-  //
-  // REQUIRED: cache is not nullptr
-  explicit CacheReservationManagerImpl(std::shared_ptr<Cache> cache,
-                                       bool delayed_decrease = false);
-
-  // no copy constructor, copy assignment, move constructor, move assignment
-  CacheReservationManagerImpl(const CacheReservationManagerImpl &) = delete;
-  CacheReservationManagerImpl &operator=(const CacheReservationManagerImpl &) =
-      delete;
-  CacheReservationManagerImpl(CacheReservationManagerImpl &&) = delete;
-  CacheReservationManagerImpl &operator=(CacheReservationManagerImpl &&) =
-      delete;
-
-  ~CacheReservationManagerImpl() override;
-
-  // One of the two ways of reserving/releasing cache space,
-  // see MakeCacheReservation() for the other.
-  //
-  // Use ONLY one of these two ways to prevent unexpected behavior.
-  //
-  // Insert and release dummy entries in the cache to
-  // match the size of total dummy entries with the least multiple of
-  // kSizeDummyEntry greater than or equal to new_mem_used
-  //
-  // Insert dummy entries if new_memory_used > cache_allocated_size_;
-  //
-  // Release dummy entries if new_memory_used < cache_allocated_size_
-  // (and new_memory_used < cache_allocated_size_ * 3/4
-  // when delayed_decrease is set true);
-  //
-  // Keey dummy entries the same if (1) new_memory_used == cache_allocated_size_
-  // or (2) new_memory_used is in the interval of
-  // [cache_allocated_size_ * 3/4, cache_allocated_size) when delayed_decrease
-  // is set true.
-  //
-  // @param new_memory_used The number of bytes used by new memory
-  //        The most recent new_memoy_used passed in will be returned
-  //        in GetTotalMemoryUsed() even when the call return non-ok status.
-  //
-  //        Since the class is NOT thread-safe, external synchronization on the
-  //        order of calling UpdateCacheReservation() is needed if you want
-  //        GetTotalMemoryUsed() indeed returns the latest memory used.
-  //
-  // @return On inserting dummy entries, it returns Status::OK() if all dummy
-  //         entry insertions succeed.
-  //         Otherwise, it returns the first non-ok status;
-  //         On releasing dummy entries, it always returns Status::OK().
-  //         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.
-  //
-  // Use ONLY one of these two ways to prevent unexpected behavior.
-  //
-  // Insert dummy entries in the cache for the incremental memory usage
-  // to match the size of total dummy entries with the least multiple of
-  // kSizeDummyEntry greater than or equal to the total memory used.
-  //
-  // A CacheReservationHandle is returned as an output parameter.
-  // The reserved dummy entries are automatically released on the destruction of
-  // this handle, which achieves better RAII per cache reservation.
-  //
-  // WARNING: Deallocate all the handles of the CacheReservationManager object
-  //          before deallocating the object to prevent unexpected behavior.
-  //
-  // @param incremental_memory_used The number of bytes increased in memory
-  //        usage.
-  //
-  //        Calling GetTotalMemoryUsed() afterward will return the total memory
-  //        increased by this number, even when calling MakeCacheReservation()
-  //        returns non-ok status.
-  //
-  //        Since the class is NOT thread-safe, external synchronization in
-  //        calling MakeCacheReservation() is needed if you want
-  //        GetTotalMemoryUsed() indeed returns the latest memory used.
-  //
-  // @param handle An pointer to std::unique_ptr<CacheReservationHandle> that
-  //        manages the lifetime of the cache reservation represented by the
-  //        handle.
-  //
-  // @return It returns Status::OK() if all dummy
-  //         entry insertions succeed.
-  //         Otherwise, it returns the first non-ok status;
-  //
-  // REQUIRES: handle != nullptr
-  Status MakeCacheReservation(
-      std::size_t incremental_memory_used,
-      std::unique_ptr<CacheReservationManager::CacheReservationHandle> *handle)
-      override;
-
-  // Return the size of the cache (which is a multiple of kSizeDummyEntry)
-  // successfully reserved by calling UpdateCacheReservation().
-  //
-  // When UpdateCacheReservation() returns non-ok status,
-  // calling GetTotalReservedCacheSize() after that might return a slightly
-  // smaller number than the actual reserved cache size due to
-  // the returned number will always be a multiple of kSizeDummyEntry
-  // and cache full might happen in the middle of inserting a dummy entry.
-  std::size_t GetTotalReservedCacheSize() override;
-
-  // Return the latest total memory used indicated by the most recent call of
-  // UpdateCacheReservation(std::size_t new_memory_used);
-  std::size_t GetTotalMemoryUsed() override;
-
-  static constexpr std::size_t GetDummyEntrySize() { return kSizeDummyEntry; }
-
-  // For testing only - it is to help ensure the CacheItemHelperForRole<R>
-  // accessed from CacheReservationManagerImpl and the one accessed from the
-  // test are from the same translation units
-  static const Cache::CacheItemHelper *TEST_GetCacheItemHelperForRole();
-
- private:
-  static constexpr std::size_t kSizeDummyEntry = 256 * 1024;
-
-  Slice GetNextCacheKey();
-
-  Status ReleaseCacheReservation(std::size_t incremental_memory_used);
-  Status IncreaseCacheReservation(std::size_t new_mem_used);
-  Status DecreaseCacheReservation(std::size_t new_mem_used);
-
-  using CacheInterface = PlaceholderSharedCacheInterface<R>;
-  CacheInterface cache_;
-  bool delayed_decrease_;
-  std::atomic<std::size_t> cache_allocated_size_;
-  std::size_t memory_used_;
-  std::vector<Cache::Handle *> dummy_handles_;
-  CacheKey cache_key_;
-};
-
-class ConcurrentCacheReservationManager
-    : public CacheReservationManager,
-      public std::enable_shared_from_this<ConcurrentCacheReservationManager> {
- public:
-  class CacheReservationHandle
-      : public CacheReservationManager::CacheReservationHandle {
-   public:
-    CacheReservationHandle(
-        std::shared_ptr<ConcurrentCacheReservationManager> cache_res_mgr,
-        std::unique_ptr<CacheReservationManager::CacheReservationHandle>
-            cache_res_handle) {
-      assert(cache_res_mgr && cache_res_handle);
-      cache_res_mgr_ = cache_res_mgr;
-      cache_res_handle_ = std::move(cache_res_handle);
-    }
-
-    ~CacheReservationHandle() override {
-      std::lock_guard<std::mutex> lock(cache_res_mgr_->cache_res_mgr_mu_);
-      cache_res_handle_.reset();
-    }
-
-   private:
-    std::shared_ptr<ConcurrentCacheReservationManager> cache_res_mgr_;
-    std::unique_ptr<CacheReservationManager::CacheReservationHandle>
-        cache_res_handle_;
-  };
-
-  explicit ConcurrentCacheReservationManager(
-      std::shared_ptr<CacheReservationManager> cache_res_mgr) {
-    cache_res_mgr_ = std::move(cache_res_mgr);
-  }
-  ConcurrentCacheReservationManager(const ConcurrentCacheReservationManager &) =
-      delete;
-  ConcurrentCacheReservationManager &operator=(
-      const ConcurrentCacheReservationManager &) = delete;
-  ConcurrentCacheReservationManager(ConcurrentCacheReservationManager &&) =
-      delete;
-  ConcurrentCacheReservationManager &operator=(
-      ConcurrentCacheReservationManager &&) = delete;
-
-  ~ConcurrentCacheReservationManager() override {}
-
-  inline Status UpdateCacheReservation(std::size_t new_memory_used) override {
-    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) {
-      s = cache_res_mgr_->UpdateCacheReservation(
-          (total_mem_used > memory_used_delta)
-              ? (total_mem_used - memory_used_delta)
-              : 0);
-    } 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)
-      override {
-    std::unique_ptr<CacheReservationManager::CacheReservationHandle>
-        wrapped_handle;
-    Status s;
-    {
-      std::lock_guard<std::mutex> lock(cache_res_mgr_mu_);
-      s = cache_res_mgr_->MakeCacheReservation(incremental_memory_used,
-                                               &wrapped_handle);
-    }
-    (*handle).reset(
-        new ConcurrentCacheReservationManager::CacheReservationHandle(
-            std::enable_shared_from_this<
-                ConcurrentCacheReservationManager>::shared_from_this(),
-            std::move(wrapped_handle)));
-    return s;
-  }
-  inline std::size_t GetTotalReservedCacheSize() override {
-    return cache_res_mgr_->GetTotalReservedCacheSize();
-  }
-  inline std::size_t GetTotalMemoryUsed() override {
-    std::lock_guard<std::mutex> lock(cache_res_mgr_mu_);
-    return cache_res_mgr_->GetTotalMemoryUsed();
-  }
-
- private:
-  std::mutex cache_res_mgr_mu_;
-  std::shared_ptr<CacheReservationManager> cache_res_mgr_;
-};
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/cache/charged_cache.cc

@@ -1,111 +0,0 @@
-//  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)
-    : CacheWrapper(cache),
-      cache_res_mgr_(std::make_shared<ConcurrentCacheReservationManager>(
-          std::make_shared<
-              CacheReservationManagerImpl<CacheEntryRole::kBlobCache>>(
-              block_cache))) {}
-
-Status ChargedCache::Insert(const Slice& key, ObjectPtr obj,
-                            const CacheItemHelper* helper, size_t charge,
-                            Handle** handle, Priority priority,
-                            const Slice& compressed_val, CompressionType type) {
-  Status s = target_->Insert(key, obj, helper, charge, handle, priority,
-                             compressed_val, type);
-  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(target_->GetUsage())
-        .PermitUncheckedError();
-  }
-  return s;
-}
-
-Cache::Handle* ChargedCache::Lookup(const Slice& key,
-                                    const CacheItemHelper* helper,
-                                    CreateContext* create_context,
-                                    Priority priority, Statistics* stats) {
-  auto handle = target_->Lookup(key, helper, create_context, priority, 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.
-  if (helper && helper->create_cb) {
-    assert(cache_res_mgr_);
-    cache_res_mgr_->UpdateCacheReservation(target_->GetUsage())
-        .PermitUncheckedError();
-  }
-  return handle;
-}
-
-void ChargedCache::WaitAll(AsyncLookupHandle* async_handles, size_t count) {
-  target_->WaitAll(async_handles, count);
-  // In case of any promotions. Although some could finish by return of
-  // StartAsyncLookup, Wait/WaitAll will generally be used, so simpler to
-  // update here.
-  assert(cache_res_mgr_);
-  cache_res_mgr_->UpdateCacheReservation(target_->GetUsage())
-      .PermitUncheckedError();
-}
-
-bool ChargedCache::Release(Cache::Handle* handle, bool useful,
-                           bool erase_if_last_ref) {
-  size_t memory_used_delta = target_->GetUsage(handle);
-  bool erased = target_->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 = target_->GetUsage(handle);
-  bool erased = target_->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) {
-  target_->Erase(key);
-  assert(cache_res_mgr_);
-  cache_res_mgr_->UpdateCacheReservation(target_->GetUsage())
-      .PermitUncheckedError();
-}
-
-void ChargedCache::EraseUnRefEntries() {
-  target_->EraseUnRefEntries();
-  assert(cache_res_mgr_);
-  cache_res_mgr_->UpdateCacheReservation(target_->GetUsage())
-      .PermitUncheckedError();
-}
-
-void ChargedCache::SetCapacity(size_t capacity) {
-  target_->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(target_->GetUsage())
-      .PermitUncheckedError();
-}
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/cache/charged_cache.h

@@ -1,61 +0,0 @@
-//  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).
-
-#pragma once
-
-#include <string>
-
-#include "port/port.h"
-#include "rocksdb/advanced_cache.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-class ConcurrentCacheReservationManager;
-
-// A cache interface which wraps around another cache and takes care of
-// reserving space in block cache towards a single global memory limit, and
-// forwards all the calls to the underlying cache.
-class ChargedCache : public CacheWrapper {
- public:
-  ChargedCache(std::shared_ptr<Cache> cache,
-               std::shared_ptr<Cache> block_cache);
-
-  Status Insert(
-      const Slice& key, ObjectPtr obj, const CacheItemHelper* helper,
-      size_t charge, Handle** handle = nullptr,
-      Priority priority = Priority::LOW, const Slice& compressed_val = Slice(),
-      CompressionType type = CompressionType::kNoCompression) override;
-
-  Cache::Handle* Lookup(const Slice& key, const CacheItemHelper* helper,
-                        CreateContext* create_context,
-                        Priority priority = Priority::LOW,
-                        Statistics* stats = nullptr) override;
-
-  void WaitAll(AsyncLookupHandle* async_handles, size_t count) override;
-
-  bool Release(Cache::Handle* handle, bool useful,
-               bool erase_if_last_ref = false) override;
-  bool Release(Cache::Handle* handle, bool erase_if_last_ref = false) override;
-
-  void Erase(const Slice& key) override;
-  void EraseUnRefEntries() override;
-
-  static const char* kClassName() { return "ChargedCache"; }
-  const char* Name() const override { return kClassName(); }
-
-  void SetCapacity(size_t capacity) override;
-
-  inline Cache* GetCache() const { return target_.get(); }
-
-  inline ConcurrentCacheReservationManager* TEST_GetCacheReservationManager()
-      const {
-    return cache_res_mgr_.get();
-  }
-
- private:
-  std::shared_ptr<ConcurrentCacheReservationManager> cache_res_mgr_;
-};
-
-}  // namespace ROCKSDB_NAMESPACE