@nxtedition/rocksdb 5.2.21 → 5.2.26

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

@@ -1,207 +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/Optional.h>
-#include <folly/Portability.h>
-#include <folly/Utility.h>
-
-#include <cassert>
-#include <memory>
-#include <mutex>
-#include <stdexcept>
-#include <utility>
-
-namespace folly {
-namespace detail {
-namespace proxylockable_detail {
-template <typename Bool>
-void throwIfAlreadyLocked(Bool&& locked) {
-  if (kIsDebug && locked) {
-    throw std::system_error{
-        std::make_error_code(std::errc::resource_deadlock_would_occur)};
-  }
-}
-
-template <typename Bool>
-void throwIfNotLocked(Bool&& locked) {
-  if (kIsDebug && !locked) {
-    throw std::system_error{
-        std::make_error_code(std::errc::operation_not_permitted)};
-  }
-}
-
-template <typename Bool>
-void throwIfNoMutex(Bool&& mutex) {
-  if (kIsDebug && !mutex) {
-    throw std::system_error{
-        std::make_error_code(std::errc::operation_not_permitted)};
-  }
-}
-} // namespace proxylockable_detail
-
-template <typename Mutex>
-ProxyLockableUniqueLock<Mutex>::~ProxyLockableUniqueLock() {
-  if (owns_lock()) {
-    unlock();
-  }
-}
-
-template <typename Mutex>
-ProxyLockableUniqueLock<Mutex>::ProxyLockableUniqueLock(
-    mutex_type& mtx) noexcept {
-  proxy_.emplace(mtx.lock());
-  mutex_ = std::addressof(mtx);
-}
-
-template <typename Mutex>
-ProxyLockableUniqueLock<Mutex>::ProxyLockableUniqueLock(
-    ProxyLockableUniqueLock&& a) noexcept {
-  *this = std::move(a);
-}
-
-template <typename Mutex>
-ProxyLockableUniqueLock<Mutex>& ProxyLockableUniqueLock<Mutex>::operator=(
-    ProxyLockableUniqueLock&& other) noexcept {
-  proxy_ = std::move(other.proxy_);
-  mutex_ = folly::exchange(other.mutex_, nullptr);
-  return *this;
-}
-
-template <typename Mutex>
-ProxyLockableUniqueLock<Mutex>::ProxyLockableUniqueLock(
-    mutex_type& mtx,
-    std::defer_lock_t) noexcept {
-  mutex_ = std::addressof(mtx);
-}
-
-template <typename Mutex>
-ProxyLockableUniqueLock<Mutex>::ProxyLockableUniqueLock(
-    mutex_type& mtx,
-    std::try_to_lock_t) {
-  mutex_ = std::addressof(mtx);
-  if (auto state = mtx.try_lock()) {
-    proxy_.emplace(std::move(state));
-  }
-}
-
-template <typename Mutex>
-template <typename Rep, typename Period>
-ProxyLockableUniqueLock<Mutex>::ProxyLockableUniqueLock(
-    mutex_type& mtx,
-    const std::chrono::duration<Rep, Period>& duration) {
-  mutex_ = std::addressof(mtx);
-  if (auto state = mtx.try_lock_for(duration)) {
-    proxy_.emplace(std::move(state));
-  }
-}
-
-template <typename Mutex>
-template <typename Clock, typename Duration>
-ProxyLockableUniqueLock<Mutex>::ProxyLockableUniqueLock(
-    mutex_type& mtx,
-    const std::chrono::time_point<Clock, Duration>& time) {
-  mutex_ = std::addressof(mtx);
-  if (auto state = mtx.try_lock_until(time)) {
-    proxy_.emplace(std::move(state));
-  }
-}
-
-template <typename Mutex>
-void ProxyLockableUniqueLock<Mutex>::lock() {
-  proxylockable_detail::throwIfAlreadyLocked(proxy_);
-  proxylockable_detail::throwIfNoMutex(mutex_);
-
-  proxy_.emplace(mutex_->lock());
-}
-
-template <typename Mutex>
-void ProxyLockableUniqueLock<Mutex>::unlock() {
-  proxylockable_detail::throwIfNoMutex(mutex_);
-  proxylockable_detail::throwIfNotLocked(proxy_);
-
-  mutex_->unlock(std::move(*proxy_));
-  proxy_.reset();
-}
-
-template <typename Mutex>
-bool ProxyLockableUniqueLock<Mutex>::try_lock() {
-  proxylockable_detail::throwIfNoMutex(mutex_);
-  proxylockable_detail::throwIfAlreadyLocked(proxy_);
-
-  if (auto state = mutex_->try_lock()) {
-    proxy_.emplace(std::move(state));
-    return true;
-  }
-
-  return false;
-}
-
-template <typename Mutex>
-template <typename Rep, typename Period>
-bool ProxyLockableUniqueLock<Mutex>::try_lock_for(
-    const std::chrono::duration<Rep, Period>& duration) {
-  proxylockable_detail::throwIfNoMutex(mutex_);
-  proxylockable_detail::throwIfAlreadyLocked(proxy_);
-
-  if (auto state = mutex_->try_lock_for(duration)) {
-    proxy_.emplace(std::move(state));
-    return true;
-  }
-
-  return false;
-}
-
-template <typename Mutex>
-template <typename Clock, typename Duration>
-bool ProxyLockableUniqueLock<Mutex>::try_lock_until(
-    const std::chrono::time_point<Clock, Duration>& time) {
-  proxylockable_detail::throwIfNoMutex(mutex_);
-  proxylockable_detail::throwIfAlreadyLocked(proxy_);
-
-  if (auto state = mutex_->try_lock_until(time)) {
-    proxy_.emplace(std::move(state));
-    return true;
-  }
-
-  return false;
-}
-
-template <typename Mutex>
-void ProxyLockableUniqueLock<Mutex>::swap(
-    ProxyLockableUniqueLock& other) noexcept {
-  std::swap(mutex_, other.mutex_);
-  std::swap(proxy_, other.proxy_);
-}
-
-template <typename Mutex>
-typename ProxyLockableUniqueLock<Mutex>::mutex_type*
-ProxyLockableUniqueLock<Mutex>::mutex() const noexcept {
-  return mutex_;
-}
-
-template <typename Mutex>
-typename ProxyLockableUniqueLock<Mutex>::proxy_type*
-ProxyLockableUniqueLock<Mutex>::proxy() const noexcept {
-  return proxy_ ? std::addressof(proxy_.value()) : nullptr;
-}
-
-template <typename Mutex>
-bool ProxyLockableUniqueLock<Mutex>::owns_lock() const noexcept {
-  return proxy_.has_value();
-}
-
-template <typename Mutex>
-ProxyLockableUniqueLock<Mutex>::operator bool() const noexcept {
-  return owns_lock();
-}
-
-template <typename Mutex>
-ProxyLockableLockGuard<Mutex>::ProxyLockableLockGuard(mutex_type& mtx)
-    : ProxyLockableUniqueLock<Mutex>{mtx} {}
-
-} // namespace detail
-} // namespace folly

package/deps/rocksdb/rocksdb/third-party/folly/folly/synchronization/detail/ProxyLockable.h

@@ -1,164 +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/Optional.h>
-
-#include <mutex>
-
-namespace folly {
-namespace detail {
-
-/**
- * ProxyLockable is a "concept" that is used usually for mutexes that don't
- * return void, but rather a proxy object that contains data that should be
- * passed to the unlock function.
- *
- * This is in contrast with the normal Lockable concept that imposes no
- * requirement on the return type of lock(), and requires an unlock() with no
- * parameters.  Here we require that lock() returns non-void and that unlock()
- * accepts the return type of lock() by value, rvalue-reference or
- * const-reference
- *
- * Here we define two classes, that can be used by the top level to implement
- * specializations for std::unique_lock and std::lock_guard.  Both
- * ProxyLockableUniqueLock and ProxyLockableLockGuard implement the entire
- * interface of std::unique_lock and std::lock_guard respectively
- */
-template <typename Mutex>
-class ProxyLockableUniqueLock {
- public:
-  using mutex_type = Mutex;
-  using proxy_type =
-      _t<std::decay<decltype(std::declval<mutex_type>().lock())>>;
-
-  /**
-   * Default constructor initializes the unique_lock to an empty state
-   */
-  ProxyLockableUniqueLock() = default;
-
-  /**
-   * Destructor releases the mutex if it is locked
-   */
-  ~ProxyLockableUniqueLock();
-
-  /**
-   * Move constructor and move assignment operators take state from the other
-   * lock
-   */
-  ProxyLockableUniqueLock(ProxyLockableUniqueLock&& other) noexcept;
-  ProxyLockableUniqueLock& operator=(ProxyLockableUniqueLock&&) noexcept;
-
-  /**
-   * Locks the mutex, blocks until the mutex can be acquired.
-   *
-   * The mutex is guaranteed to be acquired after this function returns.
-   */
-  ProxyLockableUniqueLock(mutex_type&) noexcept;
-
-  /**
-   * Explicit locking constructors to control how the lock() method is called
-   *
-   * std::defer_lock_t causes the mutex to get tracked, but not locked
-   * std::try_to_lock_t causes try_lock() to be called.  The current object is
-   *                    converts to true if the lock was successful
-   */
-  ProxyLockableUniqueLock(mutex_type& mtx, std::defer_lock_t) noexcept;
-  ProxyLockableUniqueLock(mutex_type& mtx, std::try_to_lock_t);
-
-  /**
-   * Timed locking constructors
-   */
-  template <typename Rep, typename Period>
-  ProxyLockableUniqueLock(
-      mutex_type& mtx,
-      const std::chrono::duration<Rep, Period>& duration);
-  template <typename Clock, typename Duration>
-  ProxyLockableUniqueLock(
-      mutex_type& mtx,
-      const std::chrono::time_point<Clock, Duration>& time);
-
-  /**
-   * Lock and unlock methods
-   *
-   * lock() and try_lock() throw if the mutex is already locked, or there is
-   * no mutex.  unlock() throws if there is no mutex or if the mutex was not
-   * locked
-   */
-  void lock();
-  void unlock();
-  bool try_lock();
-
-  /**
-   * Timed locking methods
-   *
-   * These throw if there was no mutex, or if the mutex was already locked
-   */
-  template <typename Rep, typename Period>
-  bool try_lock_for(const std::chrono::duration<Rep, Period>& duration);
-  template <typename Clock, typename Duration>
-  bool try_lock_until(const std::chrono::time_point<Clock, Duration>& time);
-
-  /**
-   * Swap this unique lock with the other one
-   */
-  void swap(ProxyLockableUniqueLock& other) noexcept;
-
-  /**
-   * Returns true if the unique lock contains a lock and also has acquired an
-   * exclusive lock successfully
-   */
-  bool owns_lock() const noexcept;
-  explicit operator bool() const noexcept;
-
-  /**
-   * mutex() return a pointer to the mutex if there is a contained mutex and
-   * proxy() returns a pointer to the contained proxy if the mutex is locked
-   *
-   * If the unique lock was not constructed with a mutex, then mutex() returns
-   * nullptr.  If the mutex is not locked, then proxy() returns nullptr
-   */
-  mutex_type* mutex() const noexcept;
-  proxy_type* proxy() const noexcept;
-
- private:
-  friend class ProxyLockableTest;
-
-  /**
-   * If the optional has a value, the mutex is locked, if it is empty, it is
-   * not
-   */
-  mutable folly::Optional<proxy_type> proxy_{};
-  mutex_type* mutex_{nullptr};
-};
-
-template <typename Mutex>
-class ProxyLockableLockGuard : private ProxyLockableUniqueLock<Mutex> {
- public:
-  using mutex_type = Mutex;
-
-  /**
-   * Constructor locks the mutex, and destructor unlocks
-   */
-  ProxyLockableLockGuard(mutex_type& mtx);
-  ~ProxyLockableLockGuard() = default;
-
-  /**
-   * This class is not movable or assignable
-   *
-   * For more complicated usecases, consider the UniqueLock variant, which
-   * provides more options
-   */
-  ProxyLockableLockGuard(const ProxyLockableLockGuard&) = delete;
-  ProxyLockableLockGuard(ProxyLockableLockGuard&&) = delete;
-  ProxyLockableLockGuard& operator=(ProxyLockableLockGuard&&) = delete;
-  ProxyLockableLockGuard& operator=(const ProxyLockableLockGuard&) = delete;
-};
-
-} // namespace detail
-} // namespace folly
-
-#include <folly/synchronization/detail/ProxyLockable-inl.h>

package/deps/rocksdb/rocksdb/third-party/folly/folly/synchronization/detail/Sleeper.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
-
-/*
- * @author Keith Adams <kma@fb.com>
- * @author Jordan DeLong <delong.j@fb.com>
- */
-
-#include <cstdint>
-#include <thread>
-
-#include <folly/portability/Asm.h>
-
-namespace folly {
-
-//////////////////////////////////////////////////////////////////////
-
-namespace detail {
-
-/*
- * A helper object for the contended case. Starts off with eager
- * spinning, and falls back to sleeping for small quantums.
- */
-class Sleeper {
-  static const uint32_t kMaxActiveSpin = 4000;
-
-  uint32_t spinCount;
-
- public:
-  Sleeper() noexcept : spinCount(0) {}
-
-  static void sleep() noexcept {
-    /*
-     * Always sleep 0.5ms, assuming this will make the kernel put
-     * us down for whatever its minimum timer resolution is (in
-     * linux this varies by kernel version from 1ms to 10ms).
-     */
-    std::this_thread::sleep_for(std::chrono::microseconds{500});
-  }
-
-  void wait() noexcept {
-    if (spinCount < kMaxActiveSpin) {
-      ++spinCount;
-      asm_volatile_pause();
-    } else {
-      sleep();
-    }
-  }
-};
-
-} // namespace detail
-} // namespace folly
-

package/deps/rocksdb/rocksdb/third-party/folly/folly/synchronization/detail/Spin.h

@@ -1,77 +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 <chrono>
-#include <thread>
-
-#include <folly/portability/Asm.h>
-#include <folly/synchronization/WaitOptions.h>
-
-namespace folly {
-namespace detail {
-
-enum class spin_result {
-  success, // condition passed
-  timeout, // exceeded deadline
-  advance, // exceeded current wait-options component timeout
-};
-
-template <typename Clock, typename Duration, typename F>
-spin_result spin_pause_until(
-    std::chrono::time_point<Clock, Duration> const& deadline,
-    WaitOptions const& opt,
-    F f) {
-  if (opt.spin_max() <= opt.spin_max().zero()) {
-    return spin_result::advance;
-  }
-
-  auto tbegin = Clock::now();
-  while (true) {
-    if (f()) {
-      return spin_result::success;
-    }
-
-    auto const tnow = Clock::now();
-    if (tnow >= deadline) {
-      return spin_result::timeout;
-    }
-
-    //  Backward time discontinuity in Clock? revise pre_block starting point
-    tbegin = std::min(tbegin, tnow);
-    if (tnow >= tbegin + opt.spin_max()) {
-      return spin_result::advance;
-    }
-
-    //  The pause instruction is the polite way to spin, but it doesn't
-    //  actually affect correctness to omit it if we don't have it. Pausing
-    //  donates the full capabilities of the current core to its other
-    //  hyperthreads for a dozen cycles or so.
-    asm_volatile_pause();
-  }
-}
-
-template <typename Clock, typename Duration, typename F>
-spin_result spin_yield_until(
-    std::chrono::time_point<Clock, Duration> const& deadline,
-    F f) {
-  while (true) {
-    if (f()) {
-      return spin_result::success;
-    }
-
-    auto const max = std::chrono::time_point<Clock, Duration>::max();
-    if (deadline != max && Clock::now() >= deadline) {
-      return spin_result::timeout;
-    }
-
-    std::this_thread::yield();
-  }
-}
-
-} // namespace detail
-} // namespace folly