rocksdb-native 2.6.2 → 2.6.4

package/vendor/librocksdb/vendor/rocksdb/db/multi_cf_iterator_impl.h

@@ -1,296 +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 <functional>
-#include <variant>
-
-#include "rocksdb/comparator.h"
-#include "rocksdb/iterator.h"
-#include "rocksdb/options.h"
-#include "util/heap.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-struct MultiCfIteratorInfo {
-  ColumnFamilyHandle* cfh;
-  Iterator* iterator;
-  int order;
-};
-
-class MultiCfIteratorImpl {
- public:
-  MultiCfIteratorImpl(
-      const Comparator* comparator,
-      const std::vector<ColumnFamilyHandle*>& column_families,
-      const std::vector<Iterator*>& child_iterators,
-      std::function<void()> reset_func,
-      std::function<void(const autovector<MultiCfIteratorInfo>&)> populate_func)
-      : comparator_(comparator),
-        heap_(MultiCfMinHeap(
-            MultiCfHeapItemComparator<std::greater<int>>(comparator_))),
-        reset_func_(std::move(reset_func)),
-        populate_func_(std::move(populate_func)) {
-    assert(column_families.size() > 0 &&
-           column_families.size() == child_iterators.size());
-    cfh_iter_pairs_.reserve(column_families.size());
-    for (size_t i = 0; i < column_families.size(); ++i) {
-      cfh_iter_pairs_.emplace_back(
-          column_families[i], std::unique_ptr<Iterator>(child_iterators[i]));
-    }
-  }
-  ~MultiCfIteratorImpl() { status_.PermitUncheckedError(); }
-
-  // No copy allowed
-  MultiCfIteratorImpl(const MultiCfIteratorImpl&) = delete;
-  MultiCfIteratorImpl& operator=(const MultiCfIteratorImpl&) = delete;
-
-  Slice key() const {
-    assert(Valid());
-    return current()->key();
-  }
-
-  bool Valid() const {
-    if (std::holds_alternative<MultiCfMaxHeap>(heap_)) {
-      auto& max_heap = std::get<MultiCfMaxHeap>(heap_);
-      return !max_heap.empty() && status_.ok();
-    }
-    auto& min_heap = std::get<MultiCfMinHeap>(heap_);
-    return !min_heap.empty() && status_.ok();
-  }
-
-  Status status() const { return status_; }
-
-  void SeekToFirst() {
-    auto& min_heap = GetHeap<MultiCfMinHeap>([this]() { InitMinHeap(); });
-    SeekCommon(min_heap, [](Iterator* iter) { iter->SeekToFirst(); });
-  }
-  void Seek(const Slice& target) {
-    auto& min_heap = GetHeap<MultiCfMinHeap>([this]() { InitMinHeap(); });
-    SeekCommon(min_heap, [&target](Iterator* iter) { iter->Seek(target); });
-  }
-  void SeekToLast() {
-    auto& max_heap = GetHeap<MultiCfMaxHeap>([this]() { InitMaxHeap(); });
-    SeekCommon(max_heap, [](Iterator* iter) { iter->SeekToLast(); });
-  }
-  void SeekForPrev(const Slice& target) {
-    auto& max_heap = GetHeap<MultiCfMaxHeap>([this]() { InitMaxHeap(); });
-    SeekCommon(max_heap,
-               [&target](Iterator* iter) { iter->SeekForPrev(target); });
-  }
-
-  void Next() {
-    assert(Valid());
-    auto& min_heap = GetHeap<MultiCfMinHeap>([this]() {
-      std::string target(key().data(), key().size());
-      InitMinHeap();
-      Seek(target);
-    });
-    AdvanceIterator(min_heap, [](Iterator* iter) { iter->Next(); });
-  }
-  void Prev() {
-    assert(Valid());
-    auto& max_heap = GetHeap<MultiCfMaxHeap>([this]() {
-      std::string target(key().data(), key().size());
-      InitMaxHeap();
-      SeekForPrev(target);
-    });
-    AdvanceIterator(max_heap, [](Iterator* iter) { iter->Prev(); });
-  }
-
- private:
-  std::vector<std::pair<ColumnFamilyHandle*, std::unique_ptr<Iterator>>>
-      cfh_iter_pairs_;
-  Status status_;
-
-  template <typename CompareOp>
-  class MultiCfHeapItemComparator {
-   public:
-    explicit MultiCfHeapItemComparator(const Comparator* comparator)
-        : comparator_(comparator) {}
-    bool operator()(const MultiCfIteratorInfo& a,
-                    const MultiCfIteratorInfo& b) const {
-      assert(a.iterator);
-      assert(b.iterator);
-      assert(a.iterator->Valid());
-      assert(b.iterator->Valid());
-      int c = comparator_->Compare(a.iterator->key(), b.iterator->key());
-      assert(c != 0 || a.order != b.order);
-      return c == 0 ? a.order - b.order > 0 : CompareOp()(c, 0);
-    }
-
-   private:
-    const Comparator* comparator_;
-  };
-  const Comparator* comparator_;
-  using MultiCfMinHeap =
-      BinaryHeap<MultiCfIteratorInfo,
-                 MultiCfHeapItemComparator<std::greater<int>>>;
-  using MultiCfMaxHeap = BinaryHeap<MultiCfIteratorInfo,
-                                    MultiCfHeapItemComparator<std::less<int>>>;
-
-  using MultiCfIterHeap = std::variant<MultiCfMinHeap, MultiCfMaxHeap>;
-
-  MultiCfIterHeap heap_;
-
-  std::function<void()> reset_func_;
-  std::function<void(autovector<MultiCfIteratorInfo>)> populate_func_;
-
-  Iterator* current() const {
-    if (std::holds_alternative<MultiCfMaxHeap>(heap_)) {
-      auto& max_heap = std::get<MultiCfMaxHeap>(heap_);
-      return max_heap.top().iterator;
-    }
-    auto& min_heap = std::get<MultiCfMinHeap>(heap_);
-    return min_heap.top().iterator;
-  }
-
-  void considerStatus(Status s) {
-    if (!s.ok() && status_.ok()) {
-      status_ = std::move(s);
-    }
-  }
-
-  template <typename HeapType, typename InitFunc>
-  HeapType& GetHeap(InitFunc initFunc) {
-    if (!std::holds_alternative<HeapType>(heap_)) {
-      initFunc();
-    }
-    return std::get<HeapType>(heap_);
-  }
-
-  void InitMinHeap() {
-    heap_.emplace<MultiCfMinHeap>(
-        MultiCfHeapItemComparator<std::greater<int>>(comparator_));
-  }
-  void InitMaxHeap() {
-    heap_.emplace<MultiCfMaxHeap>(
-        MultiCfHeapItemComparator<std::less<int>>(comparator_));
-  }
-
-  template <typename BinaryHeap, typename ChildSeekFuncType>
-  void SeekCommon(BinaryHeap& heap, ChildSeekFuncType child_seek_func) {
-    reset_func_();
-    heap.clear();
-    int i = 0;
-    for (auto& [cfh, iter] : cfh_iter_pairs_) {
-      child_seek_func(iter.get());
-      if (iter->Valid()) {
-        assert(iter->status().ok());
-        heap.push(MultiCfIteratorInfo{cfh, iter.get(), i});
-      } else {
-        considerStatus(iter->status());
-        if (!status_.ok()) {
-          // Non-OK status from the iterator. Bail out early
-          heap.clear();
-          break;
-        }
-      }
-      ++i;
-    }
-    if (!heap.empty()) {
-      PopulateIterator(heap);
-    }
-  }
-
-  template <typename BinaryHeap, typename AdvanceFuncType>
-  void AdvanceIterator(BinaryHeap& heap, AdvanceFuncType advance_func) {
-    reset_func_();
-    // It is possible for one or more child iters are at invalid keys due to
-    // manual prefix iteration. For such cases, we consider the result of the
-    // multi-cf-iter is also undefined.
-    // https://github.com/facebook/rocksdb/wiki/Prefix-Seek#manual-prefix-iterating
-    // for details about manual prefix iteration
-    if (heap.empty()) {
-      return;
-    }
-
-    // 1. Keep the top iterator (by popping it from the heap)
-    // 2. Make sure all others have iterated past the top iterator key slice
-    // 3. Advance the top iterator, and add it back to the heap if valid
-    auto top = heap.top();
-    heap.pop();
-    if (!heap.empty()) {
-      auto current = heap.top();
-      assert(current.iterator);
-      while (current.iterator->Valid() &&
-             comparator_->Compare(top.iterator->key(),
-                                  current.iterator->key()) == 0) {
-        assert(current.iterator->status().ok());
-        advance_func(current.iterator);
-        if (current.iterator->Valid()) {
-          heap.replace_top(heap.top());
-        } else {
-          considerStatus(current.iterator->status());
-          if (!status_.ok()) {
-            heap.clear();
-            return;
-          } else {
-            heap.pop();
-          }
-        }
-        if (!heap.empty()) {
-          current = heap.top();
-        }
-      }
-    }
-    advance_func(top.iterator);
-    if (top.iterator->Valid()) {
-      assert(top.iterator->status().ok());
-      heap.push(top);
-    } else {
-      considerStatus(top.iterator->status());
-      if (!status_.ok()) {
-        heap.clear();
-        return;
-      }
-    }
-
-    if (!heap.empty()) {
-      PopulateIterator(heap);
-    }
-  }
-
-  template <typename BinaryHeap>
-  void PopulateIterator(BinaryHeap& heap) {
-    // 1. Keep the top iterator (by popping it from the heap) and add it to list
-    //    to populate
-    // 2. For all non-top iterators having the same key as top iter popped
-    //    from the previous step, add them to the same list and pop it
-    //    temporarily from the heap
-    // 3. Once no other iters have the same key as the top iter from step 1,
-    //    populate the value/columns and attribute_groups from the list
-    //    collected in step 1 and 2 and add all the iters back to the heap
-    assert(!heap.empty());
-    auto top = heap.top();
-    heap.pop();
-    autovector<MultiCfIteratorInfo> to_populate;
-    to_populate.push_back(top);
-    if (!heap.empty()) {
-      auto current = heap.top();
-      assert(current.iterator);
-      while (current.iterator->Valid() &&
-             comparator_->Compare(top.iterator->key(),
-                                  current.iterator->key()) == 0) {
-        assert(current.iterator->status().ok());
-        to_populate.push_back(current);
-        heap.pop();
-        if (!heap.empty()) {
-          current = heap.top();
-        } else {
-          break;
-        }
-      }
-    }
-    // Add the items back to the heap
-    for (auto& item : to_populate) {
-      heap.push(item);
-    }
-    populate_func_(to_populate);
-  }
-};
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/db/output_validator.cc

@@ -1,29 +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).
-//
-#include "db/output_validator.h"
-
-#include "test_util/sync_point.h"
-#include "util/hash.h"
-
-namespace ROCKSDB_NAMESPACE {
-Status OutputValidator::Add(const Slice& key, const Slice& value) {
-  if (enable_hash_) {
-    // Generate a rolling 64-bit hash of the key and values
-    paranoid_hash_ = NPHash64(key.data(), key.size(), paranoid_hash_);
-    paranoid_hash_ = NPHash64(value.data(), value.size(), paranoid_hash_);
-  }
-  if (key.size() < kNumInternalBytes) {
-    return Status::Corruption(
-        "Compaction tries to write a key without internal bytes.");
-  }
-  // prev_key_ starts with empty.
-  if (!prev_key_.empty() && icmp_.Compare(key, prev_key_) < 0) {
-    return Status::Corruption("Compaction sees out-of-order keys.");
-  }
-  prev_key_.assign(key.data(), key.size());
-  return Status::OK();
-}
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/db/output_validator.h

@@ -1,45 +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).
-//
-#pragma once
-#include "db/dbformat.h"
-#include "rocksdb/slice.h"
-#include "rocksdb/status.h"
-
-namespace ROCKSDB_NAMESPACE {
-// A class that validates key/value that is inserted to an SST file.
-// Pass every key/value of the file using OutputValidator::Add()
-// and the class validates key order and optionally calculate a hash
-// of all the key and value.
-class OutputValidator {
- public:
-  explicit OutputValidator(const InternalKeyComparator& icmp, bool enable_hash,
-                           uint64_t precalculated_hash = 0)
-      : icmp_(icmp),
-        paranoid_hash_(precalculated_hash),
-        enable_hash_(enable_hash) {}
-
-  // Add a key to the KV sequence, and return whether the key follows
-  // criteria, e.g. key is ordered.
-  Status Add(const Slice& key, const Slice& value);
-
-  // Compare result of two key orders are the same. It can be used
-  // to compare the keys inserted into a file, and what is read back.
-  // Return true if the validation passes.
-  bool CompareValidator(const OutputValidator& other_validator) {
-    return GetHash() == other_validator.GetHash();
-  }
-
-  // Not (yet) intended to be persisted, so subject to change
-  // without notice between releases.
-  uint64_t GetHash() const { return paranoid_hash_; }
-
- private:
-  const InternalKeyComparator& icmp_;
-  std::string prev_key_;
-  uint64_t paranoid_hash_ = 0;
-  bool enable_hash_;
-};
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/db/periodic_task_scheduler.cc

@@ -1,110 +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 "db/periodic_task_scheduler.h"
-
-#include "rocksdb/system_clock.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-// `timer_mutex` is a global mutex serves 3 purposes currently:
-// (1) to ensure calls to `Start()` and `Shutdown()` are serialized, as
-//     they are currently not implemented in a thread-safe way; and
-// (2) to ensure the `Timer::Add()`s and `Timer::Start()` run atomically, and
-//     the `Timer::Cancel()`s and `Timer::Shutdown()` run atomically.
-// (3) protect tasks_map_ in PeriodicTaskScheduler
-// Note: It's not efficient to have a static global mutex, for
-// PeriodicTaskScheduler it should be okay, as the operations are called
-// infrequently.
-static port::Mutex timer_mutex;
-
-static const std::map<PeriodicTaskType, uint64_t> kDefaultPeriodSeconds = {
-    {PeriodicTaskType::kDumpStats, kInvalidPeriodSec},
-    {PeriodicTaskType::kPersistStats, kInvalidPeriodSec},
-    {PeriodicTaskType::kFlushInfoLog, 10},
-    {PeriodicTaskType::kRecordSeqnoTime, kInvalidPeriodSec},
-};
-
-static const std::map<PeriodicTaskType, std::string> kPeriodicTaskTypeNames = {
-    {PeriodicTaskType::kDumpStats, "dump_st"},
-    {PeriodicTaskType::kPersistStats, "pst_st"},
-    {PeriodicTaskType::kFlushInfoLog, "flush_info_log"},
-    {PeriodicTaskType::kRecordSeqnoTime, "record_seq_time"},
-};
-
-Status PeriodicTaskScheduler::Register(PeriodicTaskType task_type,
-                                       const PeriodicTaskFunc& fn) {
-  return Register(task_type, fn, kDefaultPeriodSeconds.at(task_type));
-}
-
-Status PeriodicTaskScheduler::Register(PeriodicTaskType task_type,
-                                       const PeriodicTaskFunc& fn,
-                                       uint64_t repeat_period_seconds) {
-  MutexLock l(&timer_mutex);
-  static std::atomic<uint64_t> initial_delay(0);
-
-  if (repeat_period_seconds == kInvalidPeriodSec) {
-    return Status::InvalidArgument("Invalid task repeat period");
-  }
-  auto it = tasks_map_.find(task_type);
-  if (it != tasks_map_.end()) {
-    // the task already exists and it's the same, no update needed
-    if (it->second.repeat_every_sec == repeat_period_seconds) {
-      return Status::OK();
-    }
-    // cancel the existing one before register new one
-    timer_->Cancel(it->second.name);
-    tasks_map_.erase(it);
-  }
-
-  timer_->Start();
-  // put task type name as prefix, for easy debug
-  std::string unique_id =
-      kPeriodicTaskTypeNames.at(task_type) + std::to_string(id_++);
-
-  bool succeeded = timer_->Add(
-      fn, unique_id,
-      (initial_delay.fetch_add(1) % repeat_period_seconds) * kMicrosInSecond,
-      repeat_period_seconds * kMicrosInSecond);
-  if (!succeeded) {
-    return Status::Aborted("Failed to register periodic task");
-  }
-  auto result = tasks_map_.try_emplace(
-      task_type, TaskInfo{unique_id, repeat_period_seconds});
-  if (!result.second) {
-    return Status::Aborted("Failed to add periodic task");
-  }
-  return Status::OK();
-}
-
-Status PeriodicTaskScheduler::Unregister(PeriodicTaskType task_type) {
-  MutexLock l(&timer_mutex);
-  auto it = tasks_map_.find(task_type);
-  if (it != tasks_map_.end()) {
-    timer_->Cancel(it->second.name);
-    tasks_map_.erase(it);
-  }
-  if (!timer_->HasPendingTask()) {
-    timer_->Shutdown();
-  }
-  return Status::OK();
-}
-
-Timer* PeriodicTaskScheduler::Default() {
-  STATIC_AVOID_DESTRUCTION(Timer, timer)(SystemClock::Default().get());
-  return &timer;
-}
-
-#ifndef NDEBUG
-void PeriodicTaskScheduler::TEST_OverrideTimer(SystemClock* clock) {
-  static Timer test_timer(clock);
-  test_timer.TEST_OverrideTimer(clock);
-  MutexLock l(&timer_mutex);
-  timer_ = &test_timer;
-}
-#endif  // NDEBUG
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/db/periodic_task_scheduler.h

@@ -1,108 +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 "util/timer.h"
-
-namespace ROCKSDB_NAMESPACE {
-class SystemClock;
-
-using PeriodicTaskFunc = std::function<void()>;
-
-constexpr uint64_t kInvalidPeriodSec = 0;
-
-// List of task types
-enum class PeriodicTaskType : uint8_t {
-  kDumpStats = 0,
-  kPersistStats,
-  kFlushInfoLog,
-  kRecordSeqnoTime,
-  kMax,
-};
-
-// PeriodicTaskScheduler contains the periodic task scheduled from the DB
-// instance. It's used to schedule/unschedule DumpStats(), PersistStats(),
-// FlushInfoLog(), etc. Each type of the task can only have one instance,
-// re-register the same task type would only update the repeat period.
-//
-// Internally, it uses a global single threaded timer object to run the periodic
-// task functions. Timer thread will always be started since the info log
-// flushing cannot be disabled.
-class PeriodicTaskScheduler {
- public:
-  explicit PeriodicTaskScheduler() = default;
-
-  PeriodicTaskScheduler(const PeriodicTaskScheduler&) = delete;
-  PeriodicTaskScheduler(PeriodicTaskScheduler&&) = delete;
-  PeriodicTaskScheduler& operator=(const PeriodicTaskScheduler&) = delete;
-  PeriodicTaskScheduler& operator=(PeriodicTaskScheduler&&) = delete;
-
-  // Register a task with its default repeat period. Thread safe call.
-  Status Register(PeriodicTaskType task_type, const PeriodicTaskFunc& fn);
-
-  // Register a task with specified repeat period. 0 is an invalid argument
-  // (kInvalidPeriodSec). To stop the task, please use Unregister().
-  // Thread safe call.
-  Status Register(PeriodicTaskType task_type, const PeriodicTaskFunc& fn,
-                  uint64_t repeat_period_seconds);
-
-  // Unregister the task. Thread safe call.
-  Status Unregister(PeriodicTaskType task_type);
-
-#ifndef NDEBUG
-  // Override the timer for the unittest
-  void TEST_OverrideTimer(SystemClock* clock);
-
-  // Call Timer TEST_WaitForRun() which wait until Timer starting waiting.
-  void TEST_WaitForRun(const std::function<void()>& callback) const {
-    if (timer_ != nullptr) {
-      timer_->TEST_WaitForRun(callback);
-    }
-  }
-
-  // Get global valid task number in the Timer
-  size_t TEST_GetValidTaskNum() const {
-    if (timer_ != nullptr) {
-      return timer_->TEST_GetPendingTaskNum();
-    }
-    return 0;
-  }
-
-  // If it has the specified task type registered
-  bool TEST_HasTask(PeriodicTaskType task_type) const {
-    auto it = tasks_map_.find(task_type);
-    return it != tasks_map_.end();
-  }
-#endif  // NDEBUG
-
- private:
-  // default global Timer instance
-  static Timer* Default();
-
-  // Internal structure to store task information
-  struct TaskInfo {
-    TaskInfo(std::string _name, uint64_t _repeat_every_sec)
-        : name(std::move(_name)), repeat_every_sec(_repeat_every_sec) {}
-    std::string name;
-    uint64_t repeat_every_sec;
-  };
-
-  // Internal tasks map
-  std::map<PeriodicTaskType, TaskInfo> tasks_map_;
-
-  // Global timer pointer, which doesn't support synchronous add/cancel tasks
-  // so having a global `timer_mutex` for add/cancel task.
-  Timer* timer_ = Default();
-
-  // Global task id, protected by the global `timer_mutex`
-  inline static uint64_t id_;
-
-  static constexpr uint64_t kMicrosInSecond = 1000U * 1000U;
-};
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/db/pinned_iterators_manager.h

@@ -1,92 +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).
-//
-#pragma once
-#include <algorithm>
-#include <memory>
-#include <utility>
-#include <vector>
-
-#include "table/internal_iterator.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-// PinnedIteratorsManager will be notified whenever we need to pin an Iterator
-// and it will be responsible for deleting pinned Iterators when they are
-// not needed anymore.
-class PinnedIteratorsManager : public Cleanable {
- public:
-  PinnedIteratorsManager() : pinning_enabled(false) {}
-  ~PinnedIteratorsManager() {
-    if (pinning_enabled) {
-      ReleasePinnedData();
-    }
-  }
-
-  // Move constructor and move assignment is allowed.
-  PinnedIteratorsManager(PinnedIteratorsManager&& other) noexcept = default;
-  PinnedIteratorsManager& operator=(PinnedIteratorsManager&& other) noexcept =
-      default;
-
-  // Enable Iterators pinning
-  void StartPinning() {
-    assert(pinning_enabled == false);
-    pinning_enabled = true;
-  }
-
-  // Is pinning enabled ?
-  bool PinningEnabled() { return pinning_enabled; }
-
-  // Take ownership of iter and delete it when ReleasePinnedData() is called
-  void PinIterator(InternalIterator* iter, bool arena = false) {
-    if (arena) {
-      PinPtr(iter, &PinnedIteratorsManager::ReleaseArenaInternalIterator);
-    } else {
-      PinPtr(iter, &PinnedIteratorsManager::ReleaseInternalIterator);
-    }
-  }
-
-  using ReleaseFunction = void (*)(void* arg1);
-  void PinPtr(void* ptr, ReleaseFunction release_func) {
-    assert(pinning_enabled);
-    if (ptr == nullptr) {
-      return;
-    }
-    pinned_ptrs_.emplace_back(ptr, release_func);
-  }
-
-  // Release pinned Iterators
-  inline void ReleasePinnedData() {
-    assert(pinning_enabled == true);
-    pinning_enabled = false;
-
-    // Remove duplicate pointers
-    std::sort(pinned_ptrs_.begin(), pinned_ptrs_.end());
-    auto unique_end = std::unique(pinned_ptrs_.begin(), pinned_ptrs_.end());
-
-    for (auto i = pinned_ptrs_.begin(); i != unique_end; ++i) {
-      void* ptr = i->first;
-      ReleaseFunction release_func = i->second;
-      release_func(ptr);
-    }
-    pinned_ptrs_.clear();
-    // Also do cleanups from the base Cleanable
-    Cleanable::Reset();
-  }
-
- private:
-  static void ReleaseInternalIterator(void* ptr) {
-    delete static_cast<InternalIterator*>(ptr);
-  }
-
-  static void ReleaseArenaInternalIterator(void* ptr) {
-    static_cast<InternalIterator*>(ptr)->~InternalIterator();
-  }
-
-  bool pinning_enabled;
-  std::vector<std::pair<void*, ReleaseFunction>> pinned_ptrs_;
-};
-
-}  // namespace ROCKSDB_NAMESPACE