@nxtedition/rocksdb 5.2.21 → 5.2.28

package/deps/rocksdb/rocksdb/third-party/folly/folly/portability/SysSyscall.h

@@ -1,10 +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
-
-#ifndef _WIN32
-#include <sys/syscall.h>
-#endif

package/deps/rocksdb/rocksdb/third-party/folly/folly/portability/SysTypes.h

@@ -1,26 +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 <sys/types.h>
-
-#ifdef _WIN32
-#include <basetsd.h> // @manual
-
-#define HAVE_MODE_T 1
-
-// This is a massive pain to have be an `int` due to the pthread implementation
-// we support, but it's far more compatible with the rest of the windows world
-// as an `int` than it would be as a `void*`
-using pid_t = int;
-// This isn't actually supposed to be defined here, but it's the most
-// appropriate place without defining a portability header for stdint.h
-// with just this single typedef.
-using ssize_t = SSIZE_T;
-// The Windows headers don't define this anywhere, nor do any of the libs
-// that Folly depends on, so define it here.
-using mode_t = unsigned short;
-#endif

package/deps/rocksdb/rocksdb/third-party/folly/folly/synchronization/AtomicNotification-inl.h

@@ -1,138 +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 <folly/detail/Futex.h>
-#include <folly/synchronization/ParkingLot.h>
-
-#include <condition_variable>
-#include <cstdint>
-
-namespace folly {
-namespace detail {
-namespace atomic_notification {
-/**
- * We use Futex<std::atomic> as the alias that has the lowest performance
- * overhead with respect to atomic notifications.  Assert that
- * atomic_uint_fast_wait_t is the same as Futex<std::atomic>
- */
-static_assert(std::is_same<atomic_uint_fast_wait_t, Futex<std::atomic>>{}, "");
-
-/**
- * Implementation and specializations for the atomic_wait() family of
- * functions
- */
-inline std::cv_status toCvStatus(FutexResult result) {
-  return (result == FutexResult::TIMEDOUT) ? std::cv_status::timeout
-                                           : std::cv_status::no_timeout;
-}
-inline std::cv_status toCvStatus(ParkResult result) {
-  return (result == ParkResult::Timeout) ? std::cv_status::timeout
-                                         : std::cv_status::no_timeout;
-}
-
-// ParkingLot instantiation for futex management
-extern ParkingLot<std::uint32_t> parkingLot;
-
-template <template <typename...> class Atom, typename... Args>
-void atomic_wait_impl(
-    const Atom<std::uint32_t, Args...>* atomic,
-    std::uint32_t expected) {
-  futexWait(atomic, expected);
-  return;
-}
-
-template <template <typename...> class Atom, typename Integer, typename... Args>
-void atomic_wait_impl(const Atom<Integer, Args...>* atomic, Integer expected) {
-  static_assert(!std::is_same<Integer, std::uint32_t>{}, "");
-  parkingLot.park(
-      atomic, -1, [&] { return atomic->load() == expected; }, [] {});
-}
-
-template <
-    template <typename...> class Atom,
-    typename... Args,
-    typename Clock,
-    typename Duration>
-std::cv_status atomic_wait_until_impl(
-    const Atom<std::uint32_t, Args...>* atomic,
-    std::uint32_t expected,
-    const std::chrono::time_point<Clock, Duration>& deadline) {
-  return toCvStatus(futexWaitUntil(atomic, expected, deadline));
-}
-
-template <
-    template <typename...> class Atom,
-    typename Integer,
-    typename... Args,
-    typename Clock,
-    typename Duration>
-std::cv_status atomic_wait_until_impl(
-    const Atom<Integer, Args...>* atomic,
-    Integer expected,
-    const std::chrono::time_point<Clock, Duration>& deadline) {
-  static_assert(!std::is_same<Integer, std::uint32_t>{}, "");
-  return toCvStatus(parkingLot.park_until(
-      atomic, -1, [&] { return atomic->load() == expected; }, [] {}, deadline));
-}
-
-template <template <typename...> class Atom, typename... Args>
-void atomic_notify_one_impl(const Atom<std::uint32_t, Args...>* atomic) {
-  futexWake(atomic, 1);
-  return;
-}
-
-template <template <typename...> class Atom, typename Integer, typename... Args>
-void atomic_notify_one_impl(const Atom<Integer, Args...>* atomic) {
-  static_assert(!std::is_same<Integer, std::uint32_t>{}, "");
-  parkingLot.unpark(atomic, [&](std::uint32_t data) {
-    assert(data == std::numeric_limits<std::uint32_t>::max());
-    return UnparkControl::RemoveBreak;
-  });
-}
-
-template <template <typename...> class Atom, typename... Args>
-void atomic_notify_all_impl(const Atom<std::uint32_t, Args...>* atomic) {
-  futexWake(atomic);
-  return;
-}
-
-template <template <typename...> class Atom, typename Integer, typename... Args>
-void atomic_notify_all_impl(const Atom<Integer, Args...>* atomic) {
-  static_assert(!std::is_same<Integer, std::uint32_t>{}, "");
-  parkingLot.unpark(atomic, [&](std::uint32_t data) {
-    assert(data == std::numeric_limits<std::uint32_t>::max());
-    return UnparkControl::RemoveContinue;
-  });
-}
-} // namespace atomic_notification
-} // namespace detail
-
-template <typename Integer>
-void atomic_wait(const std::atomic<Integer>* atomic, Integer expected) {
-  detail::atomic_notification::atomic_wait_impl(atomic, expected);
-}
-
-template <typename Integer, typename Clock, typename Duration>
-std::cv_status atomic_wait_until(
-    const std::atomic<Integer>* atomic,
-    Integer expected,
-    const std::chrono::time_point<Clock, Duration>& deadline) {
-  return detail::atomic_notification::atomic_wait_until_impl(
-      atomic, expected, deadline);
-}
-
-template <typename Integer>
-void atomic_notify_one(const std::atomic<Integer>* atomic) {
-  detail::atomic_notification::atomic_notify_one_impl(atomic);
-}
-
-template <typename Integer>
-void atomic_notify_all(const std::atomic<Integer>* atomic) {
-  detail::atomic_notification::atomic_notify_all_impl(atomic);
-}
-
-} // namespace folly

package/deps/rocksdb/rocksdb/third-party/folly/folly/synchronization/AtomicNotification.cpp

@@ -1,23 +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 <folly/synchronization/AtomicNotification.h>
-
-#include <cstdint>
-
-namespace folly {
-namespace detail {
-namespace atomic_notification {
-
-// ParkingLot instance used for the atomic_wait() family of functions
-//
-// This has been defined as a static object (as opposed to allocated to avoid
-// destruction order problems) because of possible uses coming from
-// allocation-sensitive contexts.
-ParkingLot<std::uint32_t> parkingLot;
-
-} // namespace atomic_notification
-} // namespace detail
-} // namespace folly

package/deps/rocksdb/rocksdb/third-party/folly/folly/synchronization/AtomicNotification.h

@@ -1,57 +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 <atomic>
-#include <condition_variable>
-
-namespace folly {
-
-/**
- * The behavior of the atomic_wait() family of functions is semantically
- * identical to futex().  Correspondingly, calling atomic_notify_one(),
- * atomic_notify_all() is identical to futexWake() with 1 and
- * std::numeric_limits<int>::max() respectively
- *
- * The difference here compared to the futex API above is that it works with
- * all types of atomic widths.  When a 32 bit atomic integer is used, the
- * implementation falls back to using futex() if possible, and the
- * compatibility implementation for non-linux systems otherwise.  For all
- * other integer widths, the compatibility implementation is used
- *
- * The templating of this API is changed from the standard in the following
- * ways
- *
- * - At the time of writing, libstdc++'s implementation of std::atomic<> does
- *   not include the value_type alias.  So we rely on the atomic type being a
- *   template class such that the first type is the underlying value type
- * - The Atom parameter allows this API to be compatible with
- *   DeterministicSchedule testing.
- * - atomic_wait_until() does not exist in the linked paper, the version here
- *   is identical to futexWaitUntil() and returns std::cv_status
- */
-//  mimic: std::atomic_wait, p1135r0
-template <typename Integer>
-void atomic_wait(const std::atomic<Integer>* atomic, Integer expected);
-template <typename Integer, typename Clock, typename Duration>
-std::cv_status atomic_wait_until(
-    const std::atomic<Integer>* atomic,
-    Integer expected,
-    const std::chrono::time_point<Clock, Duration>& deadline);
-
-//  mimic: std::atomic_notify_one, p1135r0
-template <typename Integer>
-void atomic_notify_one(const std::atomic<Integer>* atomic);
-//  mimic: std::atomic_notify_all, p1135r0
-template <typename Integer>
-void atomic_notify_all(const std::atomic<Integer>* atomic);
-
-//  mimic: std::atomic_uint_fast_wait_t, p1135r0
-using atomic_uint_fast_wait_t = std::atomic<std::uint32_t>;
-
-} // namespace folly
-
-#include <folly/synchronization/AtomicNotification-inl.h>

package/deps/rocksdb/rocksdb/third-party/folly/folly/synchronization/AtomicUtil-inl.h

@@ -1,260 +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 <folly/Portability.h>
-
-#include <atomic>
-#include <cassert>
-#include <cstdint>
-#include <tuple>
-#include <type_traits>
-
-#if _WIN32
-#include <intrin.h>
-#endif
-
-namespace folly {
-namespace detail {
-
-// TODO: Remove the non-default implementations when both gcc and clang
-// can recognize single bit set/reset patterns and compile them down to locked
-// bts and btr instructions.
-//
-// Currently, at the time of writing it seems like gcc7 and greater can make
-// this optimization and clang cannot - https://gcc.godbolt.org/z/Q83rxX
-
-template <typename Atomic>
-bool atomic_fetch_set_default(
-    Atomic& atomic,
-    std::size_t bit,
-    std::memory_order order) {
-  using Integer = decltype(atomic.load());
-  auto mask = Integer{0b1} << static_cast<Integer>(bit);
-  return (atomic.fetch_or(mask, order) & mask);
-}
-
-template <typename Atomic>
-bool atomic_fetch_reset_default(
-    Atomic& atomic,
-    std::size_t bit,
-    std::memory_order order) {
-  using Integer = decltype(atomic.load());
-  auto mask = Integer{0b1} << static_cast<Integer>(bit);
-  return (atomic.fetch_and(~mask, order) & mask);
-}
-
-/**
- * A simple trait to determine if the given type is an instantiation of
- * std::atomic
- */
-template <typename T>
-struct is_atomic : std::false_type {};
-template <typename Integer>
-struct is_atomic<std::atomic<Integer>> : std::true_type {};
-
-#if FOLLY_X64
-
-#if _MSC_VER
-
-template <typename Integer>
-inline bool atomic_fetch_set_x86(
-    std::atomic<Integer>& atomic,
-    std::size_t bit,
-    std::memory_order order) {
-  static_assert(alignof(std::atomic<Integer>) == alignof(Integer), "");
-  static_assert(sizeof(std::atomic<Integer>) == sizeof(Integer), "");
-  assert(atomic.is_lock_free());
-
-  if /* constexpr */ (sizeof(Integer) == 4) {
-    return _interlockedbittestandset(
-        reinterpret_cast<volatile long*>(&atomic), static_cast<long>(bit));
-  } else if /* constexpr */ (sizeof(Integer) == 8) {
-    return _interlockedbittestandset64(
-        reinterpret_cast<volatile long long*>(&atomic),
-        static_cast<long long>(bit));
-  } else {
-    assert(sizeof(Integer) != 4 && sizeof(Integer) != 8);
-    return atomic_fetch_set_default(atomic, bit, order);
-  }
-}
-
-template <typename Atomic>
-inline bool
-atomic_fetch_set_x86(Atomic& atomic, std::size_t bit, std::memory_order order) {
-  static_assert(!std::is_same<Atomic, std::atomic<std::uint32_t>>{}, "");
-  static_assert(!std::is_same<Atomic, std::atomic<std::uint64_t>>{}, "");
-  return atomic_fetch_set_default(atomic, bit, order);
-}
-
-template <typename Integer>
-inline bool atomic_fetch_reset_x86(
-    std::atomic<Integer>& atomic,
-    std::size_t bit,
-    std::memory_order order) {
-  static_assert(alignof(std::atomic<Integer>) == alignof(Integer), "");
-  static_assert(sizeof(std::atomic<Integer>) == sizeof(Integer), "");
-  assert(atomic.is_lock_free());
-
-  if /* constexpr */ (sizeof(Integer) == 4) {
-    return _interlockedbittestandreset(
-        reinterpret_cast<volatile long*>(&atomic), static_cast<long>(bit));
-  } else if /* constexpr */ (sizeof(Integer) == 8) {
-    return _interlockedbittestandreset64(
-        reinterpret_cast<volatile long long*>(&atomic),
-        static_cast<long long>(bit));
-  } else {
-    assert(sizeof(Integer) != 4 && sizeof(Integer) != 8);
-    return atomic_fetch_reset_default(atomic, bit, order);
-  }
-}
-
-template <typename Atomic>
-inline bool
-atomic_fetch_reset_x86(Atomic& atomic, std::size_t bit, std::memory_order mo) {
-  static_assert(!std::is_same<Atomic, std::atomic<std::uint32_t>>{}, "");
-  static_assert(!std::is_same<Atomic, std::atomic<std::uint64_t>>{}, "");
-  return atomic_fetch_reset_default(atomic, bit, mo);
-}
-
-#else
-
-template <typename Integer>
-inline bool atomic_fetch_set_x86(
-    std::atomic<Integer>& atomic,
-    std::size_t bit,
-    std::memory_order order) {
-  auto previous = false;
-
-  if /* constexpr */ (sizeof(Integer) == 2) {
-    auto pointer = reinterpret_cast<std::uint16_t*>(&atomic);
-    asm volatile("lock; btsw %1, (%2); setc %0"
-                 : "=r"(previous)
-                 : "ri"(static_cast<std::uint16_t>(bit)), "r"(pointer)
-                 : "memory", "flags");
-  } else if /* constexpr */ (sizeof(Integer) == 4) {
-    auto pointer = reinterpret_cast<std::uint32_t*>(&atomic);
-    asm volatile("lock; btsl %1, (%2); setc %0"
-                 : "=r"(previous)
-                 : "ri"(static_cast<std::uint32_t>(bit)), "r"(pointer)
-                 : "memory", "flags");
-  } else if /* constexpr */ (sizeof(Integer) == 8) {
-    auto pointer = reinterpret_cast<std::uint64_t*>(&atomic);
-    asm volatile("lock; btsq %1, (%2); setc %0"
-                 : "=r"(previous)
-                 : "ri"(static_cast<std::uint64_t>(bit)), "r"(pointer)
-                 : "memory", "flags");
-  } else {
-    assert(sizeof(Integer) == 1);
-    return atomic_fetch_set_default(atomic, bit, order);
-  }
-
-  return previous;
-}
-
-template <typename Atomic>
-inline bool
-atomic_fetch_set_x86(Atomic& atomic, std::size_t bit, std::memory_order order) {
-  static_assert(!is_atomic<Atomic>::value, "");
-  return atomic_fetch_set_default(atomic, bit, order);
-}
-
-template <typename Integer>
-inline bool atomic_fetch_reset_x86(
-    std::atomic<Integer>& atomic,
-    std::size_t bit,
-    std::memory_order order) {
-  auto previous = false;
-
-  if /* constexpr */ (sizeof(Integer) == 2) {
-    auto pointer = reinterpret_cast<std::uint16_t*>(&atomic);
-    asm volatile("lock; btrw %1, (%2); setc %0"
-                 : "=r"(previous)
-                 : "ri"(static_cast<std::uint16_t>(bit)), "r"(pointer)
-                 : "memory", "flags");
-  } else if /* constexpr */ (sizeof(Integer) == 4) {
-    auto pointer = reinterpret_cast<std::uint32_t*>(&atomic);
-    asm volatile("lock; btrl %1, (%2); setc %0"
-                 : "=r"(previous)
-                 : "ri"(static_cast<std::uint32_t>(bit)), "r"(pointer)
-                 : "memory", "flags");
-  } else if /* constexpr */ (sizeof(Integer) == 8) {
-    auto pointer = reinterpret_cast<std::uint64_t*>(&atomic);
-    asm volatile("lock; btrq %1, (%2); setc %0"
-                 : "=r"(previous)
-                 : "ri"(static_cast<std::uint64_t>(bit)), "r"(pointer)
-                 : "memory", "flags");
-  } else {
-    assert(sizeof(Integer) == 1);
-    return atomic_fetch_reset_default(atomic, bit, order);
-  }
-
-  return previous;
-}
-
-template <typename Atomic>
-bool atomic_fetch_reset_x86(
-    Atomic& atomic,
-    std::size_t bit,
-    std::memory_order order) {
-  static_assert(!is_atomic<Atomic>::value, "");
-  return atomic_fetch_reset_default(atomic, bit, order);
-}
-
-#endif
-
-#else
-
-template <typename Atomic>
-bool atomic_fetch_set_x86(Atomic&, std::size_t, std::memory_order) noexcept {
-  // This should never be called on non x86_64 platforms.
-  std::terminate();
-}
-template <typename Atomic>
-bool atomic_fetch_reset_x86(Atomic&, std::size_t, std::memory_order) noexcept {
-  // This should never be called on non x86_64 platforms.
-  std::terminate();
-}
-
-#endif
-
-} // namespace detail
-
-template <typename Atomic>
-bool atomic_fetch_set(Atomic& atomic, std::size_t bit, std::memory_order mo) {
-  using Integer = decltype(atomic.load());
-  static_assert(std::is_unsigned<Integer>{}, "");
-  static_assert(!std::is_const<Atomic>{}, "");
-  assert(bit < (sizeof(Integer) * 8));
-
-  // do the optimized thing on x86 builds.  Also, some versions of TSAN do not
-  // properly instrument the inline assembly, so avoid it when TSAN is enabled
-  if (folly::kIsArchAmd64 && !folly::kIsSanitizeThread) {
-    return detail::atomic_fetch_set_x86(atomic, bit, mo);
-  } else {
-    // otherwise default to the default implementation using fetch_or()
-    return detail::atomic_fetch_set_default(atomic, bit, mo);
-  }
-}
-
-template <typename Atomic>
-bool atomic_fetch_reset(Atomic& atomic, std::size_t bit, std::memory_order mo) {
-  using Integer = decltype(atomic.load());
-  static_assert(std::is_unsigned<Integer>{}, "");
-  static_assert(!std::is_const<Atomic>{}, "");
-  assert(bit < (sizeof(Integer) * 8));
-
-  // do the optimized thing on x86 builds.  Also, some versions of TSAN do not
-  // properly instrument the inline assembly, so avoid it when TSAN is enabled
-  if (folly::kIsArchAmd64 && !folly::kIsSanitizeThread) {
-    return detail::atomic_fetch_reset_x86(atomic, bit, mo);
-  } else {
-    // otherwise default to the default implementation using fetch_and()
-    return detail::atomic_fetch_reset_default(atomic, bit, mo);
-  }
-}
-
-} // namespace folly

package/deps/rocksdb/rocksdb/third-party/folly/folly/synchronization/AtomicUtil.h

@@ -1,52 +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 <atomic>
-#include <cstdint>
-
-namespace folly {
-
-/**
- * Sets a bit at the given index in the binary representation of the integer
- * to 1.  Returns the previous value of the bit, so true if the bit was not
- * changed, false otherwise
- *
- * On some architectures, using this is more efficient than the corresponding
- * std::atomic::fetch_or() with a mask.  For example to set the first (least
- * significant) bit of an integer, you could do atomic.fetch_or(0b1)
- *
- * The efficiency win is only visible in x86 (yet) and comes from the
- * implementation using the x86 bts instruction when possible.
- *
- * When something other than std::atomic is passed, the implementation assumed
- * incompatibility with this interface and calls Atomic::fetch_or()
- */
-template <typename Atomic>
-bool atomic_fetch_set(
-    Atomic& atomic,
-    std::size_t bit,
-    std::memory_order order = std::memory_order_seq_cst);
-
-/**
- * Resets a bit at the given index in the binary representation of the integer
- * to 0.  Returns the previous value of the bit, so true if the bit was
- * changed, false otherwise
- *
- * This follows the same underlying principle and implementation as
- * fetch_set().  Using the optimized implementation when possible and falling
- * back to std::atomic::fetch_and() when in debug mode or in an architecture
- * where an optimization is not possible
- */
-template <typename Atomic>
-bool atomic_fetch_reset(
-    Atomic& atomic,
-    std::size_t bit,
-    std::memory_order order = std::memory_order_seq_cst);
-
-} // namespace folly
-
-#include <folly/synchronization/AtomicUtil-inl.h>