react-native-windows 0.84.0-preview.9 → 0.84.1

package/external/folly/folly/Preprocessor.h

@@ -0,0 +1,236 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and 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 <folly/CPortability.h>
+
+/**
+ * Necessarily evil preprocessor-related amenities.
+ */
+
+// MSVC's preprocessor is a pain, so we have to
+// forcefully expand the VA args in some places.
+#define FB_VA_GLUE(a, b) a b
+
+/**
+ * FB_ONE_OR_NONE(hello, world) expands to hello and
+ * FB_ONE_OR_NONE(hello) expands to nothing. This macro is used to
+ * insert or eliminate text based on the presence of another argument.
+ */
+#define FB_ONE_OR_NONE(a, ...) FB_VA_GLUE(FB_THIRD, (a, ##__VA_ARGS__, a))
+#define FB_THIRD(a, b, ...) __VA_ARGS__
+
+/**
+ * Helper macro that extracts the first argument out of a list of any
+ * number of arguments.
+ */
+#define FB_ARG_1(a, ...) a
+
+/**
+ * Helper macro that extracts the second argument out of a list of any
+ * number of arguments. If only one argument is given, it returns
+ * that.
+ */
+#ifdef _MSC_VER
+// GCC refuses to expand this correctly if this macro itself was
+// called with FB_VA_GLUE :(
+#define FB_ARG_2_OR_1(...) \
+  FB_VA_GLUE(FB_ARG_2_OR_1_IMPL, (__VA_ARGS__, __VA_ARGS__))
+#else
+#define FB_ARG_2_OR_1(...) FB_ARG_2_OR_1_IMPL(__VA_ARGS__, __VA_ARGS__)
+#endif
+// Support macro for the above
+#define FB_ARG_2_OR_1_IMPL(a, b, ...) b
+
+/**
+ * Helper macro that provides a way to pass argument with commas in it to
+ * some other macro whose syntax doesn't allow using extra parentheses.
+ * Example:
+ *
+ *   #define MACRO(type, name) type name
+ *   MACRO(FB_SINGLE_ARG(std::pair<size_t, size_t>), x);
+ *
+ */
+#define FB_SINGLE_ARG(...) __VA_ARGS__
+
+#define FOLLY_PP_DETAIL_APPEND_VA_ARG(...) , ##__VA_ARGS__
+
+/**
+ * Helper macro that just ignores its parameters.
+ */
+#define FOLLY_IGNORE(...)
+
+/**
+ * Helper macro that just ignores its parameters and inserts a semicolon.
+ */
+#define FOLLY_SEMICOLON(...) ;
+
+/**
+ * FB_ANONYMOUS_VARIABLE(str) introduces an identifier starting with
+ * str and ending with a number that varies with the line.
+ */
+#ifndef FB_ANONYMOUS_VARIABLE
+#define FB_CONCATENATE_IMPL(s1, s2) s1##s2
+#define FB_CONCATENATE(s1, s2) FB_CONCATENATE_IMPL(s1, s2)
+#ifdef __COUNTER__
+// Modular builds build each module with its own preprocessor state, meaning
+// `__COUNTER__` no longer provides a unique number across a TU.  Instead of
+// calling back to just `__LINE__`, use a mix of `__COUNTER__` and `__LINE__`
+// to try provide as much uniqueness as possible.
+#if FOLLY_HAS_FEATURE(modules)
+#define FB_ANONYMOUS_VARIABLE(str) \
+  FB_CONCATENATE(FB_CONCATENATE(FB_CONCATENATE(str, __COUNTER__), _), __LINE__)
+#else
+#define FB_ANONYMOUS_VARIABLE(str) FB_CONCATENATE(str, __COUNTER__)
+#endif
+#else
+#define FB_ANONYMOUS_VARIABLE(str) FB_CONCATENATE(str, __LINE__)
+#endif
+// FB_ANONYMOUS_VARIABLE_ODR_SAFE doesn't rely on __COUNTER__ and is safe to use
+// in headers that should not violate the one-definition rule (ODR). It is
+// especially useful for C++ modules that check for ODR violations.
+#define FB_ANONYMOUS_VARIABLE_ODR_SAFE(str) FB_CONCATENATE(str, __LINE__)
+#endif
+
+/**
+ * Use FOLLY_PP_STRINGIZE(x) when you'd want to do what #x does inside
+ * another macro expansion.
+ */
+#define FOLLY_PP_STRINGIZE(x) #x
+
+#define FOLLY_PP_DETAIL_NARGS_1( \
+    dummy,                       \
+    _15,                         \
+    _14,                         \
+    _13,                         \
+    _12,                         \
+    _11,                         \
+    _10,                         \
+    _9,                          \
+    _8,                          \
+    _7,                          \
+    _6,                          \
+    _5,                          \
+    _4,                          \
+    _3,                          \
+    _2,                          \
+    _1,                          \
+    _0,                          \
+    ...)                         \
+  _0
+#define FOLLY_PP_DETAIL_NARGS(...) \
+  FOLLY_PP_DETAIL_NARGS_1(         \
+      dummy,                       \
+      ##__VA_ARGS__,               \
+      15,                          \
+      14,                          \
+      13,                          \
+      12,                          \
+      11,                          \
+      10,                          \
+      9,                           \
+      8,                           \
+      7,                           \
+      6,                           \
+      5,                           \
+      4,                           \
+      3,                           \
+      2,                           \
+      1,                           \
+      0)
+
+#define FOLLY_PP_DETAIL_FOR_EACH_REC_0(fn, ...)
+#define FOLLY_PP_DETAIL_FOR_EACH_REC_1(fn, a, ...) \
+  fn(a) FOLLY_PP_DETAIL_FOR_EACH_REC_0(fn, __VA_ARGS__)
+#define FOLLY_PP_DETAIL_FOR_EACH_REC_2(fn, a, ...) \
+  fn(a) FOLLY_PP_DETAIL_FOR_EACH_REC_1(fn, __VA_ARGS__)
+#define FOLLY_PP_DETAIL_FOR_EACH_REC_3(fn, a, ...) \
+  fn(a) FOLLY_PP_DETAIL_FOR_EACH_REC_2(fn, __VA_ARGS__)
+#define FOLLY_PP_DETAIL_FOR_EACH_REC_4(fn, a, ...) \
+  fn(a) FOLLY_PP_DETAIL_FOR_EACH_REC_3(fn, __VA_ARGS__)
+#define FOLLY_PP_DETAIL_FOR_EACH_REC_5(fn, a, ...) \
+  fn(a) FOLLY_PP_DETAIL_FOR_EACH_REC_4(fn, __VA_ARGS__)
+#define FOLLY_PP_DETAIL_FOR_EACH_REC_6(fn, a, ...) \
+  fn(a) FOLLY_PP_DETAIL_FOR_EACH_REC_5(fn, __VA_ARGS__)
+#define FOLLY_PP_DETAIL_FOR_EACH_REC_7(fn, a, ...) \
+  fn(a) FOLLY_PP_DETAIL_FOR_EACH_REC_6(fn, __VA_ARGS__)
+#define FOLLY_PP_DETAIL_FOR_EACH_REC_8(fn, a, ...) \
+  fn(a) FOLLY_PP_DETAIL_FOR_EACH_REC_7(fn, __VA_ARGS__)
+#define FOLLY_PP_DETAIL_FOR_EACH_REC_9(fn, a, ...) \
+  fn(a) FOLLY_PP_DETAIL_FOR_EACH_REC_8(fn, __VA_ARGS__)
+#define FOLLY_PP_DETAIL_FOR_EACH_REC_10(fn, a, ...) \
+  fn(a) FOLLY_PP_DETAIL_FOR_EACH_REC_9(fn, __VA_ARGS__)
+#define FOLLY_PP_DETAIL_FOR_EACH_REC_11(fn, a, ...) \
+  fn(a) FOLLY_PP_DETAIL_FOR_EACH_REC_10(fn, __VA_ARGS__)
+#define FOLLY_PP_DETAIL_FOR_EACH_REC_12(fn, a, ...) \
+  fn(a) FOLLY_PP_DETAIL_FOR_EACH_REC_11(fn, __VA_ARGS__)
+#define FOLLY_PP_DETAIL_FOR_EACH_REC_13(fn, a, ...) \
+  fn(a) FOLLY_PP_DETAIL_FOR_EACH_REC_12(fn, __VA_ARGS__)
+#define FOLLY_PP_DETAIL_FOR_EACH_REC_14(fn, a, ...) \
+  fn(a) FOLLY_PP_DETAIL_FOR_EACH_REC_13(fn, __VA_ARGS__)
+#define FOLLY_PP_DETAIL_FOR_EACH_REC_15(fn, a, ...) \
+  fn(a) FOLLY_PP_DETAIL_FOR_EACH_REC_14(fn, __VA_ARGS__)
+
+#define FOLLY_PP_DETAIL_FOR_EACH_2(fn, n, ...) \
+  FOLLY_PP_DETAIL_FOR_EACH_REC_##n(fn, __VA_ARGS__)
+#define FOLLY_PP_DETAIL_FOR_EACH_1(fn, n, ...) \
+  FOLLY_PP_DETAIL_FOR_EACH_2(fn, n, __VA_ARGS__)
+
+/**
+ *  FOLLY_PP_FOR_EACH
+ *
+ *  Used to invoke a preprocessor macro, the name of which is passed as the
+ *  first argument, once for each subsequent variadic argument.
+ *
+ *  At present, supports [0, 16) arguments.
+ *
+ *  This input:
+ *
+ *    #define DOIT(a) go_do_it(a);
+ *    FOLLY_PP_FOR_EACH(DOIT, 3, 5, 7)
+ *    #undef DOIT
+ *
+ *  Expands to this output (with whitespace adjusted for clarity):
+ *
+ *    go_do_it(3);
+ *    go_do_it(5);
+ *    go_do_it(7);
+ */
+#define FOLLY_PP_FOR_EACH(fn, ...) \
+  FOLLY_PP_DETAIL_FOR_EACH_1(      \
+      fn, FOLLY_PP_DETAIL_NARGS(__VA_ARGS__), __VA_ARGS__)
+
+#if defined(U)
+#error defined(U) // literal U is used below
+#endif
+
+//  FOLLY_PP_CONSTINIT_LINE_UNSIGNED
+//
+//  MSVC with /ZI has a special backing variable for __LINE__ which is not a
+//  literal - but token-pasting __LINE__ suppresses this backing variable. This
+//  is done in MSVC to support its edit-and-continue feature.
+//
+//  This macro evaluates to:
+//    __LINE__ ## U
+//
+//  So this macro may be ill-suited to cases which need exactly __LINE__.
+//
+//  Documentation:
+//    https://docs.microsoft.com/en-us/cpp/build/reference/z7-zi-zi-debug-information-format?view=msvc-170#zi-1
+//  Workaround:
+//    https://stackoverflow.com/questions/57137351/line-is-not-constexpr-in-msvc
+#define FOLLY_PP_CONSTINIT_LINE_UNSIGNED FB_CONCATENATE(__LINE__, U)

package/external/folly/folly/ProducerConsumerQueue.h

@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and 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 <atomic>
+#include <cassert>
+#include <cstdlib>
+#include <memory>
+#include <stdexcept>
+#include <type_traits>
+#include <utility>
+
+#include <folly/concurrency/CacheLocality.h>
+
+namespace folly {
+
+/*
+ * ProducerConsumerQueue is a one producer and one consumer queue
+ * without locks.
+ */
+template <class T>
+struct ProducerConsumerQueue {
+  typedef T value_type;
+
+  ProducerConsumerQueue(const ProducerConsumerQueue&) = delete;
+  ProducerConsumerQueue& operator=(const ProducerConsumerQueue&) = delete;
+
+  // size must be >= 2.
+  //
+  // Also, note that the number of usable slots in the queue at any
+  // given time is actually (size-1), so if you start with an empty queue,
+  // isFull() will return true after size-1 insertions.
+  explicit ProducerConsumerQueue(uint32_t size)
+      : size_(size),
+        records_(static_cast<T*>(std::malloc(sizeof(T) * size))),
+        readIndex_(0),
+        writeIndex_(0) {
+    assert(size >= 2);
+    if (!records_) {
+      throw std::bad_alloc();
+    }
+  }
+
+  ~ProducerConsumerQueue() {
+    // We need to destruct anything that may still exist in our queue.
+    // (No real synchronization needed at destructor time: only one
+    // thread can be doing this.)
+    if (!std::is_trivially_destructible<T>::value) {
+      size_t readIndex = readIndex_;
+      size_t endIndex = writeIndex_;
+      while (readIndex != endIndex) {
+        records_[readIndex].~T();
+        if (++readIndex == size_) {
+          readIndex = 0;
+        }
+      }
+    }
+
+    std::free(records_);
+  }
+
+  template <class... Args>
+  bool write(Args&&... recordArgs) {
+    auto const currentWrite = writeIndex_.load(std::memory_order_relaxed);
+    auto nextRecord = currentWrite + 1;
+    if (nextRecord == size_) {
+      nextRecord = 0;
+    }
+    if (nextRecord != readIndex_.load(std::memory_order_acquire)) {
+      new (&records_[currentWrite]) T(std::forward<Args>(recordArgs)...);
+      writeIndex_.store(nextRecord, std::memory_order_release);
+      return true;
+    }
+
+    // queue is full
+    return false;
+  }
+
+  // move (or copy) the value at the front of the queue to given variable
+  bool read(T& record) {
+    auto const currentRead = readIndex_.load(std::memory_order_relaxed);
+    if (currentRead == writeIndex_.load(std::memory_order_acquire)) {
+      // queue is empty
+      return false;
+    }
+
+    auto nextRecord = currentRead + 1;
+    if (nextRecord == size_) {
+      nextRecord = 0;
+    }
+    record = std::move(records_[currentRead]);
+    records_[currentRead].~T();
+    readIndex_.store(nextRecord, std::memory_order_release);
+    return true;
+  }
+
+  // pointer to the value at the front of the queue (for use in-place) or
+  // nullptr if empty.
+  T* frontPtr() {
+    auto const currentRead = readIndex_.load(std::memory_order_relaxed);
+    if (currentRead == writeIndex_.load(std::memory_order_acquire)) {
+      // queue is empty
+      return nullptr;
+    }
+    return &records_[currentRead];
+  }
+
+  // queue must not be empty
+  void popFront() {
+    auto const currentRead = readIndex_.load(std::memory_order_relaxed);
+    assert(currentRead != writeIndex_.load(std::memory_order_acquire));
+
+    auto nextRecord = currentRead + 1;
+    if (nextRecord == size_) {
+      nextRecord = 0;
+    }
+    records_[currentRead].~T();
+    readIndex_.store(nextRecord, std::memory_order_release);
+  }
+
+  bool isEmpty() const {
+    return readIndex_.load(std::memory_order_acquire) ==
+        writeIndex_.load(std::memory_order_acquire);
+  }
+
+  bool isFull() const {
+    auto nextRecord = writeIndex_.load(std::memory_order_acquire) + 1;
+    if (nextRecord == size_) {
+      nextRecord = 0;
+    }
+    if (nextRecord != readIndex_.load(std::memory_order_acquire)) {
+      return false;
+    }
+    // queue is full
+    return true;
+  }
+
+  // * If called by consumer, then true size may be more (because producer may
+  //   be adding items concurrently).
+  // * If called by producer, then true size may be less (because consumer may
+  //   be removing items concurrently).
+  // * It is undefined to call this from any other thread.
+  size_t sizeGuess() const {
+    int ret = writeIndex_.load(std::memory_order_acquire) -
+        readIndex_.load(std::memory_order_acquire);
+    if (ret < 0) {
+      ret += size_;
+    }
+    return ret;
+  }
+
+  // maximum number of items in the queue.
+  size_t capacity() const { return size_ - 1; }
+
+ private:
+  using AtomicIndex = std::atomic<unsigned int>;
+
+  char pad0_[hardware_destructive_interference_size];
+  const uint32_t size_;
+  T* const records_;
+
+  alignas(hardware_destructive_interference_size) AtomicIndex readIndex_;
+  alignas(hardware_destructive_interference_size) AtomicIndex writeIndex_;
+
+  char pad1_[hardware_destructive_interference_size - sizeof(AtomicIndex)];
+};
+
+} // namespace folly

package/external/folly/folly/RWSpinLock.h

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and 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.
+ */
+
+#include <folly/synchronization/RWSpinLock.h> // @shim

package/external/folly/folly/Random-inl.h

@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and 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.
+ */
+
+#ifndef FOLLY_RANDOM_H_
+#error This file may only be included from folly/Random.h
+#endif
+
+namespace folly {
+
+namespace detail {
+
+// Return the state size needed by RNG, expressed as a number of uint32_t
+// integers. Specialized for all templates specified in the C++11 standard.
+// For some (mersenne_twister_engine), this is exported as a state_size static
+// data member; for others, the standard shows formulas.
+
+template <class RNG, typename = void>
+struct StateSize {
+  // A sane default.
+  using type = std::integral_constant<size_t, 512>;
+};
+
+template <class RNG>
+struct StateSize<RNG, void_t<decltype(RNG::state_size)>> {
+  using type = std::integral_constant<size_t, RNG::state_size>;
+};
+
+template <class UIntType, UIntType a, UIntType c, UIntType m>
+struct StateSize<std::linear_congruential_engine<UIntType, a, c, m>> {
+  // From the standard [rand.eng.lcong], this is ceil(log2(m) / 32) + 3,
+  // which is the same as ceil(ceil(log2(m) / 32) + 3, and
+  // ceil(log2(m)) <= std::numeric_limits<UIntType>::digits
+  using type = std::integral_constant<
+      size_t,
+      (std::numeric_limits<UIntType>::digits + 31) / 32 + 3>;
+};
+
+template <class UIntType, size_t w, size_t s, size_t r>
+struct StateSize<std::subtract_with_carry_engine<UIntType, w, s, r>> {
+  // [rand.eng.sub]: r * ceil(w / 32)
+  using type = std::integral_constant<size_t, r*((w + 31) / 32)>;
+};
+
+template <typename RNG>
+using StateSizeT = _t<StateSize<RNG>>;
+
+template <class RNG>
+struct SeedData {
+  SeedData() {
+    Random::secureRandom(seedData.data(), seedData.size() * sizeof(uint32_t));
+  }
+
+  static constexpr size_t stateSize = StateSizeT<RNG>::value;
+  std::array<uint32_t, stateSize> seedData;
+};
+
+} // namespace detail
+
+template <class RNG, class /* EnableIf */>
+void Random::seed(RNG& rng) {
+  detail::SeedData<RNG> sd;
+  std::seed_seq s(std::begin(sd.seedData), std::end(sd.seedData));
+  rng.seed(s);
+}
+
+template <class RNG, class /* EnableIf */>
+auto Random::create() -> RNG {
+  detail::SeedData<RNG> sd;
+  std::seed_seq s(std::begin(sd.seedData), std::end(sd.seedData));
+  return RNG(s);
+}
+
+} // namespace folly

package/external/folly/folly/Random.cpp

@@ -0,0 +1,184 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and 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.
+ */
+
+#include <folly/Random.h>
+
+#include <array>
+#include <mutex>
+#include <random>
+
+#include <folly/CppAttributes.h>
+#include <folly/SingletonThreadLocal.h>
+#include <folly/ThreadLocal.h>
+#include <folly/detail/FileUtilDetail.h>
+#include <folly/portability/Config.h>
+#include <folly/portability/SysTime.h>
+#include <folly/portability/Unistd.h>
+#include <folly/synchronization/RelaxedAtomic.h>
+
+#include <glog/logging.h>
+
+#ifdef _MSC_VER
+#include <wincrypt.h> // @manual
+#else
+#include <fcntl.h>
+#endif
+
+#if FOLLY_HAVE_GETRANDOM
+#include <sys/random.h>
+#endif
+
+namespace folly {
+
+namespace {
+
+void readRandomDevice(void* data, size_t size) {
+#ifdef _MSC_VER
+  static auto const cryptoProv = [] {
+    HCRYPTPROV prov;
+    if (!CryptAcquireContext(
+            &prov, nullptr, nullptr, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) {
+      if (GetLastError() == NTE_BAD_KEYSET) {
+        // Mostly likely cause of this is that no key container
+        // exists yet, so try to create one.
+        PCHECK(CryptAcquireContext(
+            &prov, nullptr, nullptr, PROV_RSA_FULL, CRYPT_NEWKEYSET));
+      } else {
+        LOG(FATAL) << "Failed to acquire the default crypto context.";
+      }
+    }
+    return prov;
+  }();
+  CHECK(size <= std::numeric_limits<DWORD>::max());
+  PCHECK(CryptGenRandom(cryptoProv, (DWORD)size, (BYTE*)data));
+#else
+  ssize_t bytesRead = 0;
+  auto gen = [](int, void* buf, size_t buflen) {
+#if FOLLY_HAVE_GETRANDOM
+    auto flags = 0u;
+    return ::getrandom(buf, buflen, flags);
+#else
+    [](...) {}(buf, buflen);
+    errno = ENOSYS;
+    return -1;
+#endif
+  };
+  bytesRead = fileutil_detail::wrapFull(gen, -1, data, size);
+  if (bytesRead == -1 && errno == ENOSYS) {
+    // Keep the random device open for the duration of the program.
+    static int randomFd = ::open("/dev/urandom", O_RDONLY | O_CLOEXEC);
+    PCHECK(randomFd >= 0);
+    bytesRead = fileutil_detail::wrapFull(::read, randomFd, data, size);
+  }
+  PCHECK(bytesRead >= 0);
+  CHECK_EQ(size_t(bytesRead), size);
+#endif
+}
+
+class BufferedRandomDevice {
+ public:
+  static constexpr size_t kDefaultBufferSize = 128;
+
+  static void notifyNewGlobalEpoch() { ++globalEpoch_; }
+
+  explicit BufferedRandomDevice(size_t bufferSize = kDefaultBufferSize);
+
+  void get(void* data, size_t size) {
+    if (FOLLY_LIKELY(epoch_ == globalEpoch_ && size <= remaining())) {
+      memcpy(data, ptr_, size);
+      ptr_ += size;
+    } else {
+      getSlow(static_cast<unsigned char*>(data), size);
+    }
+  }
+
+ private:
+  void getSlow(unsigned char* data, size_t size);
+
+  inline size_t remaining() const {
+    return size_t(buffer_.get() + bufferSize_ - ptr_);
+  }
+
+  static relaxed_atomic<size_t> globalEpoch_;
+
+  size_t epoch_{size_t(-1)}; // refill on first use
+  const size_t bufferSize_;
+  std::unique_ptr<unsigned char[]> buffer_;
+  unsigned char* ptr_;
+};
+
+relaxed_atomic<size_t> BufferedRandomDevice::globalEpoch_{0};
+struct RandomTag {};
+
+BufferedRandomDevice::BufferedRandomDevice(size_t bufferSize)
+    : bufferSize_(bufferSize),
+      buffer_(new unsigned char[bufferSize]),
+      ptr_(buffer_.get() + bufferSize) { // refill on first use
+  [[maybe_unused]] static auto const init = [] {
+    AtFork::registerHandler(
+        nullptr,
+        /*prepare*/ []() { return true; },
+        /*parent*/ []() {},
+        /*child*/
+        []() {
+          // Ensure child and parent do not share same entropy pool.
+          BufferedRandomDevice::notifyNewGlobalEpoch();
+        });
+    return 0;
+  }();
+}
+
+void BufferedRandomDevice::getSlow(unsigned char* data, size_t size) {
+  if (epoch_ != globalEpoch_) {
+    epoch_ = globalEpoch_;
+    ptr_ = buffer_.get() + bufferSize_;
+  }
+
+  DCHECK_GT(size, remaining());
+  if (size >= bufferSize_) {
+    // Just read directly.
+    readRandomDevice(data, size);
+    return;
+  }
+
+  size_t copied = remaining();
+  memcpy(data, ptr_, copied);
+  data += copied;
+  size -= copied;
+
+  // refill
+  readRandomDevice(buffer_.get(), bufferSize_);
+  ptr_ = buffer_.get();
+
+  memcpy(data, ptr_, size);
+  ptr_ += size;
+}
+
+} // namespace
+
+void Random::secureRandom(void* data, size_t size) {
+  using Single = SingletonThreadLocal<BufferedRandomDevice, RandomTag>;
+  Single::get().get(data, size);
+}
+
+ThreadLocalPRNG::result_type ThreadLocalPRNG::operator()() {
+  struct Wrapper {
+    Generator object{Random::create()};
+  };
+  using Single = SingletonThreadLocal<Wrapper, RandomTag>;
+  return Single::get().object();
+}
+} // namespace folly