rocksdb-native 2.6.2 → 2.6.4

package/vendor/librocksdb/vendor/rocksdb/util/data_structure.cc

@@ -1,16 +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 "rocksdb/data_structure.h"
-
-#include "util/math.h"
-
-namespace ROCKSDB_NAMESPACE::detail {
-
-int CountTrailingZeroBitsForSmallEnumSet(uint64_t v) {
-  return CountTrailingZeroBits(v);
-}
-
-}  // namespace ROCKSDB_NAMESPACE::detail

package/vendor/librocksdb/vendor/rocksdb/util/defer.h

@@ -1,82 +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 <functional>
-
-#include "rocksdb/rocksdb_namespace.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-// Defers the execution of the provided function until the Defer
-// object goes out of scope.
-//
-// Usage example:
-//
-// Status DeferTest() {
-//   Status s;
-//   Defer defer([&s]() {
-//     if (!s.ok()) {
-//       // do cleanups ...
-//     }
-//   });
-//   // do something ...
-//   if (!s.ok()) return;
-//   // do some other things ...
-//   return s;
-// }
-//
-// The above code ensures that cleanups will always happen on returning.
-//
-// Without the help of Defer, you can
-// 1. every time when !s.ok(), do the cleanup;
-// 2. instead of returning when !s.ok(), continue the work only when s.ok(),
-//    but sometimes, this might lead to nested blocks of "if (s.ok()) {...}".
-//
-// With the help of Defer, you can centralize the cleanup logic inside the
-// lambda passed to Defer, and you can return immediately on failure when
-// necessary.
-class Defer final {
- public:
-  explicit Defer(std::function<void()>&& fn) : fn_(std::move(fn)) {}
-  ~Defer() { fn_(); }
-
-  // Disallow copy.
-  Defer(const Defer&) = delete;
-  Defer& operator=(const Defer&) = delete;
-
- private:
-  std::function<void()> fn_;
-};
-
-// An RAII utility object that saves the current value of an object so that
-// it can be overwritten, and restores it to the saved value when the
-// SaveAndRestore object goes out of scope.
-template <typename T>
-class SaveAndRestore {
- public:
-  // obj is non-null pointer to value to be saved and later restored.
-  explicit SaveAndRestore(T* obj) : obj_(obj), saved_(*obj) {}
-  // new_value is stored in *obj
-  SaveAndRestore(T* obj, const T& new_value)
-      : obj_(obj), saved_(std::move(*obj)) {
-    *obj = new_value;
-  }
-  SaveAndRestore(T* obj, T&& new_value) : obj_(obj), saved_(std::move(*obj)) {
-    *obj = std::move(new_value);
-  }
-  ~SaveAndRestore() { *obj_ = std::move(saved_); }
-
-  // No copies
-  SaveAndRestore(const SaveAndRestore&) = delete;
-  SaveAndRestore& operator=(const SaveAndRestore&) = delete;
-
- private:
-  T* const obj_;
-  T saved_;
-};
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/util/distributed_mutex.h

@@ -1,50 +0,0 @@
-//  Copyright (c) Facebook, Inc. and its affiliates. 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 "rocksdb/rocksdb_namespace.h"
-
-// This file declares a wrapper around the efficient folly DistributedMutex
-// that falls back on a standard mutex when not available. See
-// https://github.com/facebook/folly/blob/main/folly/synchronization/DistributedMutex.h
-// for benefits and limitations.
-
-// At the moment, only scoped locking is supported using DMutexLock
-// RAII wrapper, because lock/unlock APIs will vary.
-
-#ifdef USE_FOLLY
-
-#include <folly/synchronization/DistributedMutex.h>
-
-namespace ROCKSDB_NAMESPACE {
-
-class DMutex : public folly::DistributedMutex {
- public:
-  static const char* kName() { return "folly::DistributedMutex"; }
-
-  explicit DMutex(bool IGNORED_adaptive = false) { (void)IGNORED_adaptive; }
-
-  // currently no-op
-  void AssertHeld() const {}
-};
-using DMutexLock = std::lock_guard<folly::DistributedMutex>;
-
-}  // namespace ROCKSDB_NAMESPACE
-
-#else
-
-#include <mutex>
-
-#include "port/port.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-using DMutex = port::Mutex;
-using DMutexLock = std::lock_guard<DMutex>;
-
-}  // namespace ROCKSDB_NAMESPACE
-
-#endif

package/vendor/librocksdb/vendor/rocksdb/util/duplicate_detector.h

@@ -1,69 +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 <cstdint>
-
-#include "db/db_impl/db_impl.h"
-#include "logging/logging.h"
-#include "util/set_comparator.h"
-
-namespace ROCKSDB_NAMESPACE {
-// During recovery if the memtable is flushed we cannot rely on its help on
-// duplicate key detection and as key insert will not be attempted. This class
-// will be used as a emulator of memtable to tell if insertion of a key/seq
-// would have resulted in duplication.
-class DuplicateDetector {
- public:
-  explicit DuplicateDetector(DBImpl* db) : db_(db) {}
-  bool IsDuplicateKeySeq(uint32_t cf, const Slice& key, SequenceNumber seq) {
-    assert(seq >= batch_seq_);
-    if (batch_seq_ != seq) {  // it is a new batch
-      keys_.clear();
-    }
-    batch_seq_ = seq;
-    CFKeys& cf_keys = keys_[cf];
-    if (cf_keys.size() == 0) {  // just inserted
-      InitWithComp(cf);
-    }
-    auto it = cf_keys.insert(key);
-    if (it.second == false) {  // second is false if a element already existed.
-      keys_.clear();
-      InitWithComp(cf);
-      keys_[cf].insert(key);
-      return true;
-    }
-    return false;
-  }
-
- private:
-  SequenceNumber batch_seq_ = 0;
-  DBImpl* db_;
-  using CFKeys = std::set<Slice, SetComparator>;
-  std::map<uint32_t, CFKeys> keys_;
-  void InitWithComp(const uint32_t cf) {
-    auto h = db_->GetColumnFamilyHandle(cf);
-    if (!h) {
-      // TODO(myabandeh): This is not a concern in MyRocks as drop cf is not
-      // implemented yet. When it does, we should return proper error instead
-      // of throwing exception.
-      ROCKS_LOG_FATAL(
-          db_->immutable_db_options().info_log,
-          "Recovering an entry from the dropped column family %" PRIu32
-          ". WAL must must have been emptied before dropping the column "
-          "family",
-          cf);
-      throw std::runtime_error(
-          "Recovering an entry from a dropped column family. "
-          "WAL must must have been flushed before dropping the column "
-          "family");
-      return;
-    }
-    auto cmp = h->GetComparator();
-    keys_[cf] = CFKeys(SetComparator(cmp));
-  }
-};
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/util/dynamic_bloom.cc

@@ -1,70 +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 "dynamic_bloom.h"
-
-#include <algorithm>
-
-#include "memory/allocator.h"
-#include "port/port.h"
-#include "rocksdb/slice.h"
-#include "util/hash.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-namespace {
-
-uint32_t roundUpToPow2(uint32_t x) {
-  uint32_t rv = 1;
-  while (rv < x) {
-    rv <<= 1;
-  }
-  return rv;
-}
-}  // namespace
-
-DynamicBloom::DynamicBloom(Allocator* allocator, uint32_t total_bits,
-                           uint32_t num_probes, size_t huge_page_tlb_size,
-                           Logger* logger)
-    // Round down, except round up with 1
-    : kNumDoubleProbes((num_probes + (num_probes == 1)) / 2) {
-  assert(num_probes % 2 == 0);  // limitation of current implementation
-  assert(num_probes <= 10);     // limitation of current implementation
-  assert(kNumDoubleProbes > 0);
-
-  // Determine how much to round off + align by so that x ^ i (that's xor) is
-  // a valid u64 index if x is a valid u64 index and 0 <= i < kNumDoubleProbes.
-  uint32_t block_bytes = /*bytes/u64*/ 8 *
-                         /*u64s*/ std::max(1U, roundUpToPow2(kNumDoubleProbes));
-  uint32_t block_bits = block_bytes * 8;
-  uint32_t blocks = (total_bits + block_bits - 1) / block_bits;
-  uint32_t sz = blocks * block_bytes;
-  kLen = sz / /*bytes/u64*/ 8;
-  assert(kLen > 0);
-#ifndef NDEBUG
-  for (uint32_t i = 0; i < kNumDoubleProbes; ++i) {
-    // Ensure probes starting at last word are in range
-    assert(((kLen - 1) ^ i) < kLen);
-  }
-#endif
-
-  // Padding to correct for allocation not originally aligned on block_bytes
-  // boundary
-  sz += block_bytes - 1;
-  assert(allocator);
-
-  char* raw = allocator->AllocateAligned(sz, huge_page_tlb_size, logger);
-  memset(raw, 0, sz);
-  auto block_offset = reinterpret_cast<uintptr_t>(raw) % block_bytes;
-  if (block_offset > 0) {
-    // Align on block_bytes boundary
-    raw += block_bytes - block_offset;
-  }
-  static_assert(sizeof(std::atomic<uint64_t>) == sizeof(uint64_t),
-                "Expecting zero-space-overhead atomic");
-  data_ = reinterpret_cast<std::atomic<uint64_t>*>(raw);
-}
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/util/dynamic_bloom.h

@@ -1,214 +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 <array>
-#include <atomic>
-#include <memory>
-#include <string>
-
-#include "port/port.h"
-#include "rocksdb/slice.h"
-#include "table/multiget_context.h"
-#include "util/hash.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-class Slice;
-class Allocator;
-class Logger;
-
-// A Bloom filter intended only to be used in memory, never serialized in a way
-// that could lead to schema incompatibility. Supports opt-in lock-free
-// concurrent access.
-//
-// This implementation is also intended for applications generally preferring
-// speed vs. maximum accuracy: roughly 0.9x BF op latency for 1.1x FP rate.
-// For 1% FP rate, that means that the latency of a look-up triggered by an FP
-// should be less than roughly 100x the cost of a Bloom filter op.
-//
-// For simplicity and performance, the current implementation requires
-// num_probes to be a multiple of two and <= 10.
-//
-class DynamicBloom {
- public:
-  // allocator: pass allocator to bloom filter, hence trace the usage of memory
-  // total_bits: fixed total bits for the bloom
-  // num_probes: number of hash probes for a single key
-  // hash_func:  customized hash function
-  // huge_page_tlb_size:  if >0, try to allocate bloom bytes from huge page TLB
-  //                      within this page size. Need to reserve huge pages for
-  //                      it to be allocated, like:
-  //                         sysctl -w vm.nr_hugepages=20
-  //                     See linux doc Documentation/vm/hugetlbpage.txt
-  explicit DynamicBloom(Allocator* allocator, uint32_t total_bits,
-                        uint32_t num_probes = 6, size_t huge_page_tlb_size = 0,
-                        Logger* logger = nullptr);
-
-  ~DynamicBloom() {}
-
-  // Assuming single threaded access to this function.
-  void Add(const Slice& key);
-
-  // Like Add, but may be called concurrent with other functions.
-  void AddConcurrently(const Slice& key);
-
-  // Assuming single threaded access to this function.
-  void AddHash(uint32_t hash);
-
-  // Like AddHash, but may be called concurrent with other functions.
-  void AddHashConcurrently(uint32_t hash);
-
-  // Multithreaded access to this function is OK
-  bool MayContain(const Slice& key) const;
-
-  void MayContain(int num_keys, Slice* keys, bool* may_match) const;
-
-  // Multithreaded access to this function is OK
-  bool MayContainHash(uint32_t hash) const;
-
-  void Prefetch(uint32_t h);
-
- private:
-  // Length of the structure, in 64-bit words. For this structure, "word"
-  // will always refer to 64-bit words.
-  uint32_t kLen;
-  // We make the k probes in pairs, two for each 64-bit read/write. Thus,
-  // this stores k/2, the number of words to double-probe.
-  const uint32_t kNumDoubleProbes;
-
-  std::atomic<uint64_t>* data_;
-
-  // or_func(ptr, mask) should effect *ptr |= mask with the appropriate
-  // concurrency safety, working with bytes.
-  template <typename OrFunc>
-  void AddHash(uint32_t hash, const OrFunc& or_func);
-
-  bool DoubleProbe(uint32_t h32, size_t a) const;
-};
-
-inline void DynamicBloom::Add(const Slice& key) { AddHash(BloomHash(key)); }
-
-inline void DynamicBloom::AddConcurrently(const Slice& key) {
-  AddHashConcurrently(BloomHash(key));
-}
-
-inline void DynamicBloom::AddHash(uint32_t hash) {
-  AddHash(hash, [](std::atomic<uint64_t>* ptr, uint64_t mask) {
-    ptr->store(ptr->load(std::memory_order_relaxed) | mask,
-               std::memory_order_relaxed);
-  });
-}
-
-inline void DynamicBloom::AddHashConcurrently(uint32_t hash) {
-  AddHash(hash, [](std::atomic<uint64_t>* ptr, uint64_t mask) {
-    // Happens-before between AddHash and MaybeContains is handled by
-    // access to versions_->LastSequence(), so all we have to do here is
-    // avoid races (so we don't give the compiler a license to mess up
-    // our code) and not lose bits.  std::memory_order_relaxed is enough
-    // for that.
-    if ((mask & ptr->load(std::memory_order_relaxed)) != mask) {
-      ptr->fetch_or(mask, std::memory_order_relaxed);
-    }
-  });
-}
-
-inline bool DynamicBloom::MayContain(const Slice& key) const {
-  return (MayContainHash(BloomHash(key)));
-}
-
-inline void DynamicBloom::MayContain(int num_keys, Slice* keys,
-                                     bool* may_match) const {
-  std::array<uint32_t, MultiGetContext::MAX_BATCH_SIZE> hashes;
-  std::array<size_t, MultiGetContext::MAX_BATCH_SIZE> byte_offsets;
-  for (int i = 0; i < num_keys; ++i) {
-    hashes[i] = BloomHash(keys[i]);
-    size_t a = FastRange32(hashes[i], kLen);
-    PREFETCH(data_ + a, 0, 3);
-    byte_offsets[i] = a;
-  }
-
-  for (int i = 0; i < num_keys; i++) {
-    may_match[i] = DoubleProbe(hashes[i], byte_offsets[i]);
-  }
-}
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-// local variable is initialized but not referenced
-#pragma warning(disable : 4189)
-#endif
-inline void DynamicBloom::Prefetch(uint32_t h32) {
-  size_t a = FastRange32(h32, kLen);
-  PREFETCH(data_ + a, 0, 3);
-}
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
-// Speed hacks in this implementation:
-// * Uses fastrange instead of %
-// * Minimum logic to determine first (and all) probed memory addresses.
-//   (Uses constant bit-xor offsets from the starting probe address.)
-// * (Major) Two probes per 64-bit memory fetch/write.
-//   Code simplification / optimization: only allow even number of probes.
-// * Very fast and effective (murmur-like) hash expansion/re-mixing. (At
-// least on recent CPUs, integer multiplication is very cheap. Each 64-bit
-// remix provides five pairs of bit addresses within a uint64_t.)
-//   Code simplification / optimization: only allow up to 10 probes, from a
-//   single 64-bit remix.
-//
-// The FP rate penalty for this implementation, vs. standard Bloom filter, is
-// roughly 1.12x on top of the 1.15x penalty for a 512-bit cache-local Bloom.
-// This implementation does not explicitly use the cache line size, but is
-// effectively cache-local (up to 16 probes) because of the bit-xor offsetting.
-//
-// NB: could easily be upgraded to support a 64-bit hash and
-// total_bits > 2^32 (512MB). (The latter is a bad idea without the former,
-// because of false positives.)
-
-inline bool DynamicBloom::MayContainHash(uint32_t h32) const {
-  size_t a = FastRange32(h32, kLen);
-  PREFETCH(data_ + a, 0, 3);
-  return DoubleProbe(h32, a);
-}
-
-inline bool DynamicBloom::DoubleProbe(uint32_t h32, size_t byte_offset) const {
-  // Expand/remix with 64-bit golden ratio
-  uint64_t h = 0x9e3779b97f4a7c13ULL * h32;
-  for (unsigned i = 0;; ++i) {
-    // Two bit probes per uint64_t probe
-    uint64_t mask =
-        ((uint64_t)1 << (h & 63)) | ((uint64_t)1 << ((h >> 6) & 63));
-    uint64_t val = data_[byte_offset ^ i].load(std::memory_order_relaxed);
-    if (i + 1 >= kNumDoubleProbes) {
-      return (val & mask) == mask;
-    } else if ((val & mask) != mask) {
-      return false;
-    }
-    h = (h >> 12) | (h << 52);
-  }
-}
-
-template <typename OrFunc>
-inline void DynamicBloom::AddHash(uint32_t h32, const OrFunc& or_func) {
-  size_t a = FastRange32(h32, kLen);
-  PREFETCH(data_ + a, 0, 3);
-  // Expand/remix with 64-bit golden ratio
-  uint64_t h = 0x9e3779b97f4a7c13ULL * h32;
-  for (unsigned i = 0;; ++i) {
-    // Two bit probes per uint64_t probe
-    uint64_t mask =
-        ((uint64_t)1 << (h & 63)) | ((uint64_t)1 << ((h >> 6) & 63));
-    or_func(&data_[a ^ i], mask);
-    if (i + 1 >= kNumDoubleProbes) {
-      return;
-    }
-    h = (h >> 12) | (h << 52);
-  }
-}
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/util/fastrange.h

@@ -1,114 +0,0 @@
-//  Copyright (c) Facebook, Inc. and its affiliates. 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).
-
-// fastrange/FastRange: A faster alternative to % for mapping a hash value
-// to an arbitrary range. See https://github.com/lemire/fastrange
-//
-// Generally recommended are FastRange32 for mapping results of 32-bit
-// hash functions and FastRange64 for mapping results of 64-bit hash
-// functions. FastRange is less forgiving than % if the input hashes are
-// not well distributed over the full range of the type (32 or 64 bits).
-//
-// Also included is a templated implementation FastRangeGeneric for use
-// in generic algorithms, but not otherwise recommended because of
-// potential ambiguity. Unlike with %, it is critical to use the right
-// FastRange variant for the output size of your hash function.
-
-#pragma once
-
-#include <cstddef>
-#include <cstdint>
-#include <type_traits>
-
-#include "rocksdb/rocksdb_namespace.h"
-
-#ifdef TEST_UINT128_COMPAT
-#undef HAVE_UINT128_EXTENSION
-#endif
-
-namespace ROCKSDB_NAMESPACE {
-
-namespace detail {
-
-// Using a class template to support partial specialization
-template <typename Hash, typename Range>
-struct FastRangeGenericImpl {
-  // only reach this on no supported specialization
-};
-
-template <typename Range>
-struct FastRangeGenericImpl<uint32_t, Range> {
-  static inline Range Fn(uint32_t hash, Range range) {
-    static_assert(std::is_unsigned<Range>::value, "must be unsigned");
-    static_assert(sizeof(Range) <= sizeof(uint32_t),
-                  "cannot be larger than hash (32 bits)");
-
-    uint64_t product = uint64_t{range} * hash;
-    return static_cast<Range>(product >> 32);
-  }
-};
-
-template <typename Range>
-struct FastRangeGenericImpl<uint64_t, Range> {
-  static inline Range Fn(uint64_t hash, Range range) {
-    static_assert(std::is_unsigned<Range>::value, "must be unsigned");
-    static_assert(sizeof(Range) <= sizeof(uint64_t),
-                  "cannot be larger than hash (64 bits)");
-
-#ifdef HAVE_UINT128_EXTENSION
-    // Can use compiler's 128-bit type. Trust it to do the right thing.
-    __uint128_t wide = __uint128_t{range} * hash;
-    return static_cast<Range>(wide >> 64);
-#else
-    // Fall back: full decomposition.
-    // NOTE: GCC seems to fully understand this code as 64-bit x 64-bit
-    // -> 128-bit multiplication and optimize it appropriately
-    uint64_t range64 = range;  // ok to shift by 32, even if Range is 32-bit
-    uint64_t tmp = uint64_t{range64 & 0xffffFFFF} * uint64_t{hash & 0xffffFFFF};
-    tmp >>= 32;
-    tmp += uint64_t{range64 & 0xffffFFFF} * uint64_t{hash >> 32};
-    // Avoid overflow: first add lower 32 of tmp2, and later upper 32
-    uint64_t tmp2 = uint64_t{range64 >> 32} * uint64_t{hash & 0xffffFFFF};
-    tmp += static_cast<uint32_t>(tmp2);
-    tmp >>= 32;
-    tmp += (tmp2 >> 32);
-    tmp += uint64_t{range64 >> 32} * uint64_t{hash >> 32};
-    return static_cast<Range>(tmp);
-#endif
-  }
-};
-
-}  // namespace detail
-
-// Now an omnibus templated function (yay parameter inference).
-//
-// NOTICE:
-// This templated version is not recommended for typical use because
-// of the potential to mix a 64-bit FastRange with a 32-bit bit hash,
-// most likely because you put your 32-bit hash in an "unsigned long"
-// which is 64 bits on some platforms. That doesn't really matter for
-// an operation like %, but 64-bit FastRange gives extremely bad results,
-// mostly zero, on 32-bit hash values. And because good hashing is not
-// generally required for correctness, this kind of mistake could go
-// unnoticed with just unit tests. Plus it could vary by platform.
-template <typename Hash, typename Range>
-inline Range FastRangeGeneric(Hash hash, Range range) {
-  return detail::FastRangeGenericImpl<Hash, Range>::Fn(hash, range);
-}
-
-// The most popular / convenient / recommended variants:
-
-// Map a quality 64-bit hash value down to an arbitrary size_t range.
-// (size_t is standard for mapping to things in memory.)
-inline size_t FastRange64(uint64_t hash, size_t range) {
-  return FastRangeGeneric(hash, range);
-}
-
-// Map a quality 32-bit hash value down to an arbitrary uint32_t range.
-inline uint32_t FastRange32(uint32_t hash, uint32_t range) {
-  return FastRangeGeneric(hash, range);
-}
-
-}  // namespace ROCKSDB_NAMESPACE