react-native-windows 0.84.0 → 0.84.1

package/external/folly/folly/synchronization/test/ThrottledLifoSemTest.cpp

@@ -0,0 +1,243 @@
+/*
+ * 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/ThrottledLifoSem.h>
+
+#include <chrono>
+#include <thread>
+#include <vector>
+
+#include <folly/Benchmark.h>
+#include <folly/Random.h>
+#include <folly/portability/GTest.h>
+#include <folly/synchronization/SaturatingSemaphore.h>
+
+namespace folly {
+
+class ThrottledLifoSemTestHelper {
+ public:
+  static void spinUntilWaiters(
+      folly::ThrottledLifoSem& sem, size_t n, bool assertExact = false) {
+    while (sem.numWaiters() != n) {
+    }
+    if (assertExact) {
+      ASSERT_EQ(sem.numWaiters(), n);
+    }
+  }
+};
+
+} // namespace folly
+
+const auto kNoSpin =
+    folly::WaitOptions{}.spin_max(std::chrono::nanoseconds::zero());
+
+TEST(ThrottledLifoSem, Basic) {
+  folly::ThrottledLifoSem sem;
+  EXPECT_TRUE(sem.post(0));
+  EXPECT_FALSE(sem.post());
+  EXPECT_TRUE(sem.try_wait());
+  EXPECT_FALSE(sem.try_wait());
+  EXPECT_FALSE(sem.try_wait_for(std::chrono::milliseconds(1)));
+}
+
+TEST(ThrottledLifoSem, Timeouts) {
+  constexpr auto kWakeUpInterval = std::chrono::milliseconds(200);
+
+  folly::ThrottledLifoSem sem({.wakeUpInterval = kWakeUpInterval});
+  std::atomic<size_t> timeouts = 0;
+  std::vector<std::thread> threads;
+  for (size_t i = 0; i < 3; ++i) {
+    threads.emplace_back([&] {
+      // One waiter will succeed, one will timeout while waiting on the baton,
+      // one while sleeping though the wakeup interval. The purpose of this test
+      // is to ensure that the invariants (checked at destruction) are restored
+      // in both timeout cases.
+      if (!sem.try_wait_for(kWakeUpInterval / 2, kNoSpin)) {
+        ++timeouts;
+      }
+    });
+  }
+
+  // May hang forever if any waiters time out before we get here, but the large
+  // timeout should make this unlikely unless the system is heavily loaded.
+  folly::ThrottledLifoSemTestHelper::spinUntilWaiters(
+      sem, 3, /* assertExact */ true);
+
+  EXPECT_TRUE(sem.post());
+  for (auto& t : threads) {
+    t.join();
+  }
+  EXPECT_EQ(timeouts.load(), 2);
+}
+
+// Exercise the race between post() and waiters that have just timed out.
+TEST(ThrottledLifoSem, TimeoutsStress) {
+  constexpr size_t kNumWaiters = 64;
+  constexpr size_t kNumPosts = 100000;
+  folly::ThrottledLifoSem sem(
+      {.wakeUpInterval = std::chrono::nanoseconds::zero()});
+
+  std::vector<std::thread> threads;
+  std::atomic<size_t> received = 0;
+  for (size_t i = 0; i < kNumWaiters; ++i) {
+    threads.emplace_back([&] {
+      while (received.load() != kNumPosts) {
+        if (sem.try_wait_for(std::chrono::microseconds{100}, kNoSpin)) {
+          ++received;
+        }
+      }
+    });
+  }
+
+  for (size_t i = 0; i < kNumPosts; ++i) {
+    sem.post();
+    // Wait until the post is consumed.
+    while (sem.valueGuess() > 0) {
+    }
+  }
+
+  for (auto& t : threads) {
+    t.join();
+  }
+}
+
+TEST(ThrottledLifoSem, MultipleWaiters) {
+  constexpr size_t kNumRounds = 10;
+  constexpr size_t kNumWaiters = 64;
+  constexpr auto kWakeUpInterval = std::chrono::microseconds(100);
+
+  folly::ThrottledLifoSem sem({.wakeUpInterval = kWakeUpInterval});
+
+  for (size_t round = 0; round < kNumRounds; ++round) {
+    std::vector<std::thread> threads;
+    for (size_t i = 0; i < kNumWaiters; ++i) {
+      threads.emplace_back([&] { sem.wait(); });
+    }
+
+    folly::ThrottledLifoSemTestHelper::spinUntilWaiters(
+        sem, kNumWaiters, /* assertExact */ true);
+
+    // Use the batch post() for half the rounds.
+    if (round % 2 == 0) {
+      EXPECT_TRUE(sem.post(kNumWaiters));
+    } else {
+      for (size_t i = 0; i < kNumWaiters; ++i) {
+        EXPECT_TRUE(sem.post());
+        folly::ThrottledLifoSemTestHelper::spinUntilWaiters(
+            sem, kNumWaiters - i - 1);
+        /* sleep override */ std::this_thread::sleep_for(
+            i * kWakeUpInterval / 10);
+      }
+    }
+
+    for (auto& t : threads) {
+      t.join();
+    }
+    // No more waiters.
+    EXPECT_FALSE(sem.post());
+    ASSERT_TRUE(sem.try_wait());
+  }
+}
+
+TEST(ThrottledLifoSem, MPMCStress) {
+  // Same number of producers and consumers.
+  constexpr size_t kNumThreads = 16;
+  constexpr size_t kNumPostsPerThread = 10000;
+  constexpr size_t kExpectedHandoffs = kNumThreads * kNumPostsPerThread;
+  constexpr auto kWakeUpInterval = std::chrono::microseconds(100);
+
+  folly::ThrottledLifoSem sem({.wakeUpInterval = kWakeUpInterval});
+
+  std::vector<std::thread> producers;
+  std::vector<std::thread> consumers;
+  folly::SaturatingSemaphore<> done;
+  std::atomic<size_t> handoffs = 0;
+  for (size_t t = 0; t < kNumThreads; ++t) {
+    producers.emplace_back([&] {
+      for (size_t i = 0; i < kNumPostsPerThread; ++i) {
+        // Force the consumers to go to sleep sometimes.
+        /* sleep override */ std::this_thread::sleep_for(
+            kWakeUpInterval * folly::Random::randDouble01());
+        sem.post();
+      }
+    });
+    consumers.emplace_back([&] {
+      while (true) {
+        sem.wait();
+        if (done.ready()) {
+          return;
+        }
+        if (++handoffs == kExpectedHandoffs) {
+          done.post();
+        }
+      }
+    });
+  }
+
+  done.wait();
+  EXPECT_EQ(sem.valueGuess(), 0);
+
+  // Wake up the consumers.
+  sem.post(kNumThreads);
+
+  for (auto& t : consumers) {
+    t.join();
+  }
+  for (auto& t : producers) {
+    t.join();
+  }
+
+  // Re-check that nothing has changed while joining the threads.
+  EXPECT_EQ(handoffs.load(), kExpectedHandoffs);
+  EXPECT_EQ(sem.valueGuess(), 0);
+}
+
+namespace {
+
+// Benchmark the cost of post() under contention when no wakeup is performed (by
+// not having waiters), which simulates the case where the waking chain is
+// already active or the thread pool is saturated.
+void post(size_t iters, size_t numThreads) {
+  folly::ThrottledLifoSem sem;
+
+  std::vector<std::thread> threads;
+  for (size_t t = 0; t < numThreads; ++t) {
+    threads.emplace_back([&] {
+      for (size_t i = 0; i < iters / numThreads; ++i) {
+        sem.post();
+      }
+    });
+  }
+
+  for (auto& t : threads) {
+    t.join();
+  }
+}
+
+} // namespace
+
+BENCHMARK_NAMED_PARAM(post, 1_thread, 1)
+BENCHMARK_NAMED_PARAM(post, 2_threads, 2)
+BENCHMARK_NAMED_PARAM(post, 4_threads, 4)
+BENCHMARK_NAMED_PARAM(post, 8_threads, 8)
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  gflags::ParseCommandLineFlags(&argc, &argv, true);
+  int rv = RUN_ALL_TESTS();
+  folly::runBenchmarksOnFlag();
+  return rv;
+}

package/external/folly/folly/system/AtFork.cpp

@@ -0,0 +1,205 @@
+/*
+ * 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/system/AtFork.h>
+
+#include <stdexcept>
+#include <system_error>
+
+#include <folly/ScopeGuard.h>
+#include <folly/lang/Exception.h>
+#include <folly/portability/PThread.h>
+#include <folly/synchronization/SanitizeThread.h>
+
+namespace folly {
+
+void AtForkList::prepare() noexcept {
+  mutex.lock();
+  while (true) {
+    auto task = tasks.rbegin();
+    for (; task != tasks.rend(); ++task) {
+      if (auto& f = task->prepare) {
+        if (!f()) {
+          break;
+        }
+      }
+    }
+    if (task == tasks.rend()) {
+      return;
+    }
+    for (auto untask = tasks.rbegin(); untask != task; ++untask) {
+      if (auto& f = untask->parent) {
+        f();
+      }
+    }
+  }
+}
+
+void AtForkList::parent() noexcept {
+  for (auto& task : tasks) {
+    if (auto& f = task.parent) {
+      f();
+    }
+  }
+  mutex.unlock();
+}
+
+void AtForkList::child() noexcept {
+  for (auto& task : tasks) {
+    if (auto& f = task.child) {
+      f();
+    }
+  }
+  mutex.unlock();
+}
+
+void AtForkList::append(
+    void const* handle,
+    Function<bool()> prepare,
+    Function<void()> parent,
+    Function<void()> child) {
+  std::unique_lock<std::mutex> lg{mutex};
+  if (handle && index.count(handle)) {
+    throw_exception<std::invalid_argument>("at-fork: append: duplicate");
+  }
+  auto task =
+      Task{handle, std::move(prepare), std::move(parent), std::move(child)};
+  auto inserted = tasks.insert(tasks.end(), std::move(task));
+  if (handle) {
+    index.emplace(handle, inserted);
+  }
+}
+
+void AtForkList::remove(void const* handle) {
+  if (!handle) {
+    return;
+  }
+  std::unique_lock<std::mutex> lg{mutex};
+  auto i1 = index.find(handle);
+  if (i1 == index.end()) {
+    throw_exception<std::out_of_range>("at-fork: remove: missing");
+  }
+  auto i2 = i1->second;
+  index.erase(i1);
+  tasks.erase(i2);
+}
+
+bool AtForkList::contains( //
+    void const* handle) {
+  if (!handle) {
+    return false;
+  }
+  std::unique_lock<std::mutex> lg{mutex};
+  return index.count(handle) != 0;
+}
+
+namespace {
+
+struct SkipAtForkHandlers {
+  static thread_local bool value;
+
+  struct Guard {
+    bool saved = value;
+    Guard() { value = true; }
+    ~Guard() { value = saved; }
+  };
+};
+thread_local bool SkipAtForkHandlers::value;
+
+void invoke_pthread_atfork(
+    void (*prepare)(), void (*parent)(), void (*child)()) {
+  int ret = 0;
+#if FOLLY_HAVE_PTHREAD_ATFORK // if no pthread_atfork, probably no fork either
+  ret = pthread_atfork(prepare, parent, child);
+#endif
+  if (ret != 0) {
+    throw_exception<std::system_error>(
+        ret, std::generic_category(), "pthread_atfork failed");
+  }
+}
+
+struct AtForkListSingleton {
+  static void init() {
+    static int reg = (get(), invoke_pthread_atfork(prepare, parent, child), 0);
+    (void)reg;
+  }
+
+  static AtForkList& get() {
+    static auto& instance = *new AtForkList();
+    return instance;
+  }
+
+  static void prepare() {
+    if (!SkipAtForkHandlers::value) {
+      get().prepare();
+    }
+  }
+
+  static void parent() {
+    if (!SkipAtForkHandlers::value) {
+      get().parent();
+    }
+  }
+
+  static void child() {
+    if (!SkipAtForkHandlers::value) {
+      // if we fork a multithreaded process
+      // some of the TSAN mutexes might be locked
+      // so we just enable ignores for everything
+      // while handling the child callbacks
+      // This might still be an issue if we do not exec right away
+      annotate_ignore_thread_sanitizer_guard g(__FILE__, __LINE__);
+      get().child();
+    }
+  }
+};
+
+} // namespace
+
+void AtFork::init() {
+  AtForkListSingleton::init();
+}
+
+void AtFork::registerHandler(
+    void const* handle,
+    Function<bool()> prepare,
+    Function<void()> parent,
+    Function<void()> child) {
+  (void)init_; // force the object not to be thrown out as unused
+  AtFork::init();
+  auto& list = AtForkListSingleton::get();
+  list.append(handle, std::move(prepare), std::move(parent), std::move(child));
+}
+
+void AtFork::unregisterHandler(void const* handle) {
+  auto& list = AtForkListSingleton::get();
+  list.remove(handle);
+}
+
+pid_t AtFork::forkInstrumented(fork_t forkFn) {
+  if (SkipAtForkHandlers::value) {
+    return forkFn();
+  }
+  auto& list = AtForkListSingleton::get();
+  list.prepare();
+  auto ret = (SkipAtForkHandlers::Guard(), forkFn());
+  ret ? list.parent() : list.child();
+  return ret;
+}
+
+bool AtFork::init_ = (AtFork::init(), false);
+
+} // namespace folly

package/external/folly/folly/system/AtFork.h

@@ -0,0 +1,116 @@
+/*
+ * 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 <sys/types.h>
+
+#include <list>
+#include <map>
+#include <mutex>
+
+#include <folly/Function.h>
+#include <folly/portability/SysTypes.h>
+
+namespace folly {
+
+//  AtForkList
+//
+//  The list data structure used internally in AtFork's internal singleton.
+//
+//  Useful for AtFork, but may not be useful more broadly.
+class AtForkList {
+ public:
+  //  prepare
+  //
+  //  Acquires the mutex. Performs trial passes in a loop until a trial pass
+  //  succeeds. A trial pass invokes each prepare handler in reverse order of
+  //  insertion, failing the pass and cleaning up if any handler returns false.
+  //  Cleanup entails invoking parent handlers in reverse order, up to but not
+  //  including the parent handler corresponding to the failed prepare handler.
+  void prepare() noexcept;
+
+  //  parent
+  //
+  //  Invokes parent handlers in order of insertion. Releases the mutex.
+  void parent() noexcept;
+
+  //  child
+  //
+  //  Invokes child handlers in order of insertion. Releases the mutex.
+  void child() noexcept;
+
+  //  append
+  //
+  //  While holding the mutex, inserts a set of handlers to the end of the list.
+  //
+  //  If handle is not nullptr, the set of handlers is indexed by handle and may
+  //  be found by members remove() and contain().
+  void append( //
+      void const* handle,
+      Function<bool()> prepare,
+      Function<void()> parent,
+      Function<void()> child);
+
+  //  remove
+  //
+  //  While holding the mutex, removes a set of handlers found by handle, if not
+  //  null.
+  void remove( //
+      void const* handle);
+
+  //  contains
+  //
+  //  While holding the mutex, finds a set of handlers found by handle, if not
+  //  null, returning true if found and false otherwise.
+  bool contains( //
+      void const* handle);
+
+ private:
+  struct Task {
+    void const* handle;
+    Function<bool()> prepare;
+    Function<void()> parent;
+    Function<void()> child;
+  };
+
+  std::mutex mutex;
+  std::list<Task> tasks;
+  std::map<void const*, std::list<Task>::iterator> index;
+};
+
+//  AtFork
+//
+//  Wraps pthread_atfork on platforms with pthread_atfork, but with additional
+//  facilities.
+class AtFork {
+ public:
+  static void init();
+  static void registerHandler(
+      void const* handle,
+      Function<bool()> prepare,
+      Function<void()> parent,
+      Function<void()> child);
+  static void unregisterHandler(void const* handle);
+
+  using fork_t = pid_t();
+  static pid_t forkInstrumented(fork_t forkFn);
+
+ private:
+  static bool init_;
+};
+
+} // namespace folly