@nxtedition/rocksdb 5.2.21 → 5.2.28

package/deps/rocksdb/rocksdb/third-party/folly/folly/detail/Futex.cpp

@@ -1,263 +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/detail/Futex.h>
-#include <folly/portability/SysSyscall.h>
-#include <stdint.h>
-#include <string.h>
-#include <array>
-#include <cerrno>
-
-#include <folly/synchronization/ParkingLot.h>
-
-#ifdef __linux__
-#include <linux/futex.h>
-#endif
-
-#ifndef _WIN32
-#include <unistd.h>
-#endif
-
-using namespace std::chrono;
-
-namespace folly {
-namespace detail {
-
-namespace {
-
-////////////////////////////////////////////////////
-// native implementation using the futex() syscall
-
-#ifdef __linux__
-
-/// Certain toolchains (like Android's) don't include the full futex API in
-/// their headers even though they support it. Make sure we have our constants
-/// even if the headers don't have them.
-#ifndef FUTEX_WAIT_BITSET
-#define FUTEX_WAIT_BITSET 9
-#endif
-#ifndef FUTEX_WAKE_BITSET
-#define FUTEX_WAKE_BITSET 10
-#endif
-#ifndef FUTEX_PRIVATE_FLAG
-#define FUTEX_PRIVATE_FLAG 128
-#endif
-#ifndef FUTEX_CLOCK_REALTIME
-#define FUTEX_CLOCK_REALTIME 256
-#endif
-
-int nativeFutexWake(const void* addr, int count, uint32_t wakeMask) {
-  long rv = syscall(
-      __NR_futex,
-      addr, /* addr1 */
-      FUTEX_WAKE_BITSET | FUTEX_PRIVATE_FLAG, /* op */
-      count, /* val */
-      nullptr, /* timeout */
-      nullptr, /* addr2 */
-      wakeMask); /* val3 */
-
-  /* NOTE: we ignore errors on wake for the case of a futex
-     guarding its own destruction, similar to this
-     glibc bug with sem_post/sem_wait:
-     https://sourceware.org/bugzilla/show_bug.cgi?id=12674 */
-  if (rv < 0) {
-    return 0;
-  }
-  return static_cast<int>(rv);
-}
-
-template <class Clock>
-struct timespec timeSpecFromTimePoint(time_point<Clock> absTime) {
-  auto epoch = absTime.time_since_epoch();
-  if (epoch.count() < 0) {
-    // kernel timespec_valid requires non-negative seconds and nanos in [0,1G)
-    epoch = Clock::duration::zero();
-  }
-
-  // timespec-safe seconds and nanoseconds;
-  // chrono::{nano,}seconds are `long long int`
-  // whereas timespec uses smaller types
-  using time_t_seconds = duration<std::time_t, seconds::period>;
-  using long_nanos = duration<long int, nanoseconds::period>;
-
-  auto secs = duration_cast<time_t_seconds>(epoch);
-  auto nanos = duration_cast<long_nanos>(epoch - secs);
-  struct timespec result = {secs.count(), nanos.count()};
-  return result;
-}
-
-FutexResult nativeFutexWaitImpl(
-    const void* addr,
-    uint32_t expected,
-    system_clock::time_point const* absSystemTime,
-    steady_clock::time_point const* absSteadyTime,
-    uint32_t waitMask) {
-  assert(absSystemTime == nullptr || absSteadyTime == nullptr);
-
-  int op = FUTEX_WAIT_BITSET | FUTEX_PRIVATE_FLAG;
-  struct timespec ts;
-  struct timespec* timeout = nullptr;
-
-  if (absSystemTime != nullptr) {
-    op |= FUTEX_CLOCK_REALTIME;
-    ts = timeSpecFromTimePoint(*absSystemTime);
-    timeout = &ts;
-  } else if (absSteadyTime != nullptr) {
-    ts = timeSpecFromTimePoint(*absSteadyTime);
-    timeout = &ts;
-  }
-
-  // Unlike FUTEX_WAIT, FUTEX_WAIT_BITSET requires an absolute timeout
-  // value - http://locklessinc.com/articles/futex_cheat_sheet/
-  long rv = syscall(
-      __NR_futex,
-      addr, /* addr1 */
-      op, /* op */
-      expected, /* val */
-      timeout, /* timeout */
-      nullptr, /* addr2 */
-      waitMask); /* val3 */
-
-  if (rv == 0) {
-    return FutexResult::AWOKEN;
-  } else {
-    switch (errno) {
-      case ETIMEDOUT:
-        assert(timeout != nullptr);
-        return FutexResult::TIMEDOUT;
-      case EINTR:
-        return FutexResult::INTERRUPTED;
-      case EWOULDBLOCK:
-        return FutexResult::VALUE_CHANGED;
-      default:
-        assert(false);
-        // EINVAL, EACCESS, or EFAULT.  EINVAL means there was an invalid
-        // op (should be impossible) or an invalid timeout (should have
-        // been sanitized by timeSpecFromTimePoint).  EACCESS or EFAULT
-        // means *addr points to invalid memory, which is unlikely because
-        // the caller should have segfaulted already.  We can either
-        // crash, or return a value that lets the process continue for
-        // a bit. We choose the latter. VALUE_CHANGED probably turns the
-        // caller into a spin lock.
-        return FutexResult::VALUE_CHANGED;
-    }
-  }
-}
-
-#endif // __linux__
-
-///////////////////////////////////////////////////////
-// compatibility implementation using standard C++ API
-
-using Lot = ParkingLot<uint32_t>;
-Lot parkingLot;
-
-int emulatedFutexWake(const void* addr, int count, uint32_t waitMask) {
-  int woken = 0;
-  parkingLot.unpark(addr, [&](const uint32_t& mask) {
-    if ((mask & waitMask) == 0) {
-      return UnparkControl::RetainContinue;
-    }
-    assert(count > 0);
-    count--;
-    woken++;
-    return count > 0 ? UnparkControl::RemoveContinue
-                     : UnparkControl::RemoveBreak;
-  });
-  return woken;
-}
-
-template <typename F>
-FutexResult emulatedFutexWaitImpl(
-    F* futex,
-    uint32_t expected,
-    system_clock::time_point const* absSystemTime,
-    steady_clock::time_point const* absSteadyTime,
-    uint32_t waitMask) {
-  static_assert(
-      std::is_same<F, const Futex<std::atomic>>::value ||
-          std::is_same<F, const Futex<EmulatedFutexAtomic>>::value,
-      "Type F must be either Futex<std::atomic> or Futex<EmulatedFutexAtomic>");
-  ParkResult res;
-  if (absSystemTime) {
-    res = parkingLot.park_until(
-        futex,
-        waitMask,
-        [&] { return *futex == expected; },
-        [] {},
-        *absSystemTime);
-  } else if (absSteadyTime) {
-    res = parkingLot.park_until(
-        futex,
-        waitMask,
-        [&] { return *futex == expected; },
-        [] {},
-        *absSteadyTime);
-  } else {
-    res = parkingLot.park(
-        futex, waitMask, [&] { return *futex == expected; }, [] {});
-  }
-  switch (res) {
-    case ParkResult::Skip:
-      return FutexResult::VALUE_CHANGED;
-    case ParkResult::Unpark:
-      return FutexResult::AWOKEN;
-    case ParkResult::Timeout:
-      return FutexResult::TIMEDOUT;
-  }
-
-  return FutexResult::INTERRUPTED;
-}
-
-} // namespace
-
-/////////////////////////////////
-// Futex<> overloads
-
-int futexWakeImpl(
-    const Futex<std::atomic>* futex,
-    int count,
-    uint32_t wakeMask) {
-#ifdef __linux__
-  return nativeFutexWake(futex, count, wakeMask);
-#else
-  return emulatedFutexWake(futex, count, wakeMask);
-#endif
-}
-
-int futexWakeImpl(
-    const Futex<EmulatedFutexAtomic>* futex,
-    int count,
-    uint32_t wakeMask) {
-  return emulatedFutexWake(futex, count, wakeMask);
-}
-
-FutexResult futexWaitImpl(
-    const Futex<std::atomic>* futex,
-    uint32_t expected,
-    system_clock::time_point const* absSystemTime,
-    steady_clock::time_point const* absSteadyTime,
-    uint32_t waitMask) {
-#ifdef __linux__
-  return nativeFutexWaitImpl(
-      futex, expected, absSystemTime, absSteadyTime, waitMask);
-#else
-  return emulatedFutexWaitImpl(
-      futex, expected, absSystemTime, absSteadyTime, waitMask);
-#endif
-}
-
-FutexResult futexWaitImpl(
-    const Futex<EmulatedFutexAtomic>* futex,
-    uint32_t expected,
-    system_clock::time_point const* absSystemTime,
-    steady_clock::time_point const* absSteadyTime,
-    uint32_t waitMask) {
-  return emulatedFutexWaitImpl(
-      futex, expected, absSystemTime, absSteadyTime, waitMask);
-}
-
-} // namespace detail
-} // namespace folly

package/deps/rocksdb/rocksdb/third-party/folly/folly/detail/Futex.h

@@ -1,96 +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 <cassert>
-#include <chrono>
-#include <cstdint>
-#include <limits>
-#include <type_traits>
-
-namespace folly {
-namespace detail {
-
-enum class FutexResult {
-  VALUE_CHANGED, /* futex value didn't match expected */
-  AWOKEN, /* wakeup by matching futex wake, or spurious wakeup */
-  INTERRUPTED, /* wakeup by interrupting signal */
-  TIMEDOUT, /* wakeup by expiring deadline */
-};
-
-/**
- * Futex is an atomic 32 bit unsigned integer that provides access to the
- * futex() syscall on that value.  It is templated in such a way that it
- * can interact properly with DeterministicSchedule testing.
- *
- * If you don't know how to use futex(), you probably shouldn't be using
- * this class.  Even if you do know how, you should have a good reason
- * (and benchmarks to back you up).
- *
- * Because of the semantics of the futex syscall, the futex family of
- * functions are available as free functions rather than member functions
- */
-template <template <typename> class Atom = std::atomic>
-using Futex = Atom<std::uint32_t>;
-
-/**
- * Puts the thread to sleep if this->load() == expected.  Returns true when
- * it is returning because it has consumed a wake() event, false for any
- * other return (signal, this->load() != expected, or spurious wakeup).
- */
-template <typename Futex>
-FutexResult
-futexWait(const Futex* futex, uint32_t expected, uint32_t waitMask = -1);
-
-/**
- * Similar to futexWait but also accepts a deadline until when the wait call
- * may block.
- *
- * Optimal clock types: std::chrono::system_clock, std::chrono::steady_clock.
- * NOTE: On some systems steady_clock is just an alias for system_clock,
- * and is not actually steady.
- *
- * For any other clock type, now() will be invoked twice.
- */
-template <typename Futex, class Clock, class Duration>
-FutexResult futexWaitUntil(
-    const Futex* futex,
-    uint32_t expected,
-    std::chrono::time_point<Clock, Duration> const& deadline,
-    uint32_t waitMask = -1);
-
-/**
- * Wakes up to count waiters where (waitMask & wakeMask) != 0, returning the
- * number of awoken threads, or -1 if an error occurred.  Note that when
- * constructing a concurrency primitive that can guard its own destruction, it
- * is likely that you will want to ignore EINVAL here (as well as making sure
- * that you never touch the object after performing the memory store that is
- * the linearization point for unlock or control handoff).  See
- * https://sourceware.org/bugzilla/show_bug.cgi?id=13690
- */
-template <typename Futex>
-int futexWake(
-    const Futex* futex,
-    int count = std::numeric_limits<int>::max(),
-    uint32_t wakeMask = -1);
-
-/** A std::atomic subclass that can be used to force Futex to emulate
- *  the underlying futex() syscall.  This is primarily useful to test or
- *  benchmark the emulated implementation on systems that don't need it. */
-template <typename T>
-struct EmulatedFutexAtomic : public std::atomic<T> {
-  EmulatedFutexAtomic() noexcept = default;
-  constexpr /* implicit */ EmulatedFutexAtomic(T init) noexcept
-      : std::atomic<T>(init) {}
-  // It doesn't copy or move
-  EmulatedFutexAtomic(EmulatedFutexAtomic&& rhs) = delete;
-};
-
-} // namespace detail
-} // namespace folly
-
-#include <folly/detail/Futex-inl.h>

package/deps/rocksdb/rocksdb/third-party/folly/folly/functional/Invoke.h

@@ -1,40 +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/Traits.h>
-
-#include <functional>
-#include <type_traits>
-
-namespace folly {
-namespace invoke_detail {
-template <typename F, typename... Args>
-using invoke_result_ = decltype(std::declval<F>()(std::declval<Args>()...));
-
-template <typename Void, typename F, typename... Args>
-struct is_invocable : std::false_type {};
-
-template <typename F, typename... Args>
-struct is_invocable<void_t<invoke_result_<F, Args...>>, F, Args...>
-    : std::true_type {};
-
-template <typename Void, typename R, typename F, typename... Args>
-struct is_invocable_r : std::false_type {};
-
-template <typename R, typename F, typename... Args>
-struct is_invocable_r<void_t<invoke_result_<F, Args...>>, R, F, Args...>
-    : std::is_convertible<invoke_result_<F, Args...>, R> {};
-} // namespace invoke_detail
-
-//  mimic: std::is_invocable, C++17
-template <typename F, typename... Args>
-struct is_invocable : invoke_detail::is_invocable<void, F, Args...> {};
-
-//  mimic: std::is_invocable_r, C++17
-template <typename R, typename F, typename... Args>
-struct is_invocable_r : invoke_detail::is_invocable_r<void, R, F, Args...> {};
-} // namespace folly

package/deps/rocksdb/rocksdb/third-party/folly/folly/hash/Hash.h

@@ -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).
-
-#pragma once
-
-#include <cstdint>
-
-namespace folly {
-namespace hash {
-
-/*
- * Thomas Wang 64 bit mix hash function
- */
-
-inline uint64_t twang_mix64(uint64_t key) noexcept {
-  key = (~key) + (key << 21); // key *= (1 << 21) - 1; key -= 1;
-  key = key ^ (key >> 24);
-  key = key + (key << 3) + (key << 8); // key *= 1 + (1 << 3) + (1 << 8)
-  key = key ^ (key >> 14);
-  key = key + (key << 2) + (key << 4); // key *= 1 + (1 << 2) + (1 << 4)
-  key = key ^ (key >> 28);
-  key = key + (key << 31); // key *= 1 + (1 << 31)
-  return key;
-}
-
-} // namespace hash
-} // namespace folly

package/deps/rocksdb/rocksdb/third-party/folly/folly/lang/Align.h

@@ -1,144 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <cstddef>
-#include <cstdint>
-
-#include <folly/Portability.h>
-#include <folly/ConstexprMath.h>
-
-// Work around bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56019
-#ifdef __GNUC__
-#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 9)
-namespace std {
-using ::max_align_t;
-}
-#endif
-#endif
-
-namespace folly {
-
-//  has_extended_alignment
-//
-//  True if it may be presumed that the platform has static extended alignment;
-//  false if it may not be so presumed, even when the platform might actually
-//  have it. Static extended alignment refers to extended alignment of objects
-//  with automatic, static, or thread storage. Whether the there is support for
-//  dynamic extended alignment is a property of the allocator which is used for
-//  each given dynamic allocation.
-//
-//  Currently, very heuristical - only non-mobile 64-bit linux gets the extended
-//  alignment treatment. Theoretically, this could be tuned better.
-constexpr bool has_extended_alignment =
-    kIsLinux && sizeof(void*) >= sizeof(std::uint64_t);
-
-namespace detail {
-
-// Implemented this way because of a bug in Clang for ARMv7, which gives the
-// wrong result for `alignof` a `union` with a field of each scalar type.
-// Modified for RocksDB to use C++11 only
-constexpr std::size_t max_align_v = constexpr_max(
-    alignof(long double),
-    alignof(double),
-    alignof(float),
-    alignof(long long int),
-    alignof(long int),
-    alignof(int),
-    alignof(short int),
-    alignof(bool),
-    alignof(char),
-    alignof(char16_t),
-    alignof(char32_t),
-    alignof(wchar_t),
-    alignof(void*),
-    alignof(std::max_align_t));
-
-} // namespace detail
-
-// max_align_v is the alignment of max_align_t.
-//
-// max_align_t is a type which is aligned at least as strictly as the
-// most-aligned basic type (see the specification of std::max_align_t). This
-// implementation exists because 32-bit iOS platforms have a broken
-// std::max_align_t (see below).
-//
-// You should refer to this as `::folly::max_align_t` in portable code, even if
-// you have `using namespace folly;` because C11 defines a global namespace
-// `max_align_t` type.
-//
-// To be certain, we consider every non-void fundamental type specified by the
-// standard. On most platforms `long double` would be enough, but iOS 32-bit
-// has an 8-byte aligned `double` and `long long int` and a 4-byte aligned
-// `long double`.
-//
-// So far we've covered locals and other non-allocated storage, but we also need
-// confidence that allocated storage from `malloc`, `new`, etc will also be
-// suitable for objects with this alignment requirement.
-//
-// Apple document that their implementation of malloc will issue 16-byte
-// granularity chunks for small allocations (large allocations are page-size
-// granularity and page-aligned). We think that allocated storage will be
-// suitable for these objects based on the following assumptions:
-//
-// 1. 16-byte granularity also means 16-byte aligned.
-// 2. `new` and other allocators follow the `malloc` rules.
-//
-// We also have some anecdotal evidence: we don't see lots of misaligned-storage
-// crashes on 32-bit iOS apps that use `double`.
-//
-// Apple's allocation reference: http://bit.ly/malloc-small
-constexpr std::size_t max_align_v = detail::max_align_v;
-struct alignas(max_align_v) max_align_t {};
-
-//  Memory locations within the same cache line are subject to destructive
-//  interference, also known as false sharing, which is when concurrent
-//  accesses to these different memory locations from different cores, where at
-//  least one of the concurrent accesses is or involves a store operation,
-//  induce contention and harm performance.
-//
-//  Microbenchmarks indicate that pairs of cache lines also see destructive
-//  interference under heavy use of atomic operations, as observed for atomic
-//  increment on Sandy Bridge.
-//
-//  We assume a cache line size of 64, so we use a cache line pair size of 128
-//  to avoid destructive interference.
-//
-//  mimic: std::hardware_destructive_interference_size, C++17
-constexpr std::size_t hardware_destructive_interference_size =
-    kIsArchArm ? 64 : 128;
-static_assert(hardware_destructive_interference_size >= max_align_v, "math?");
-
-//  Memory locations within the same cache line are subject to constructive
-//  interference, also known as true sharing, which is when accesses to some
-//  memory locations induce all memory locations within the same cache line to
-//  be cached, benefiting subsequent accesses to different memory locations
-//  within the same cache line and heping performance.
-//
-//  mimic: std::hardware_constructive_interference_size, C++17
-constexpr std::size_t hardware_constructive_interference_size = 64;
-static_assert(hardware_constructive_interference_size >= max_align_v, "math?");
-
-//  A value corresponding to hardware_constructive_interference_size but which
-//  may be used with alignas, since hardware_constructive_interference_size may
-//  be too large on some platforms to be used with alignas.
-constexpr std::size_t cacheline_align_v = has_extended_alignment
-    ? hardware_constructive_interference_size
-    : max_align_v;
-struct alignas(cacheline_align_v) cacheline_align_t {};
-
-} // namespace folly

package/deps/rocksdb/rocksdb/third-party/folly/folly/lang/Bits.h

@@ -1,30 +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/Traits.h>
-
-#include <cstdint>
-#include <cstring>
-#include <type_traits>
-
-namespace folly {
-
-template <
-    typename To,
-    typename From,
-    _t<std::enable_if<
-        sizeof(From) == sizeof(To) && std::is_trivial<To>::value &&
-            is_trivially_copyable<From>::value,
-        int>> = 0>
-To bit_cast(const From& src) noexcept {
-  To to;
-  std::memcpy(&to, &src, sizeof(From));
-  return to;
-}
-
-} // namespace folly
-

package/deps/rocksdb/rocksdb/third-party/folly/folly/lang/Launder.h

@@ -1,51 +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 <new>
-
-#include <folly/Portability.h>
-
-/***
- *  include or backport:
- *  * std::launder
- */
-
-namespace folly {
-
-/**
- * Approximate backport from C++17 of std::launder. It should be `constexpr`
- * but that can't be done without specific support from the compiler.
- */
-template <typename T>
-FOLLY_NODISCARD inline T* launder(T* in) noexcept {
-#if FOLLY_HAS_BUILTIN(__builtin_launder) || __GNUC__ >= 7
-  // The builtin has no unwanted side-effects.
-  return __builtin_launder(in);
-#elif __GNUC__
-  // This inline assembler block declares that `in` is an input and an output,
-  // so the compiler has to assume that it has been changed inside the block.
-  __asm__("" : "+r"(in));
-  return in;
-#elif defined(_WIN32)
-  // MSVC does not currently have optimizations around const members of structs.
-  // _ReadWriteBarrier() will prevent compiler reordering memory accesses.
-  _ReadWriteBarrier();
-  return in;
-#else
-  static_assert(
-      false, "folly::launder is not implemented for this environment");
-#endif
-}
-
-/* The standard explicitly forbids laundering these */
-void launder(void*) = delete;
-void launder(void const*) = delete;
-void launder(void volatile*) = delete;
-void launder(void const volatile*) = delete;
-template <typename T, typename... Args>
-void launder(T (*)(Args...)) = delete;
-} // namespace folly

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

@@ -1,28 +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 <cstdint>
-
-#ifdef _MSC_VER
-#include <intrin.h>
-#endif
-
-namespace folly {
-inline void asm_volatile_pause() {
-#if defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))
-  ::_mm_pause();
-#elif defined(__i386__) || FOLLY_X64
-  asm volatile("pause");
-#elif FOLLY_AARCH64 || defined(__arm__)
-  asm volatile("yield");
-#elif FOLLY_PPC64
-  asm volatile("or 27,27,27");
-#endif
-}
-} // namespace folly