react-native-windows 0.81.34 → 0.81.36

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

@@ -0,0 +1,37 @@
+/*
+ * 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/NativeSemaphore.h>
+
+#include <folly/portability/GTest.h>
+
+using folly::NativeSemaphore;
+
+class NativeSemaphoreTest : public testing::Test {};
+
+TEST_F(NativeSemaphoreTest, empty) {
+  NativeSemaphore sem;
+  EXPECT_FALSE(sem.try_wait());
+  EXPECT_FALSE(sem.try_wait());
+
+  sem.post();
+  EXPECT_TRUE(sem.try_wait());
+  EXPECT_FALSE(sem.try_wait());
+
+  sem.post();
+  sem.wait();
+  EXPECT_FALSE(sem.try_wait());
+}

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

@@ -0,0 +1,239 @@
+/*
+ * 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/ParkingLot.h>
+
+#include <thread>
+
+#include <folly/Benchmark.h>
+#include <folly/detail/Futex.h>
+#include <folly/synchronization/Baton.h>
+#include <folly/synchronization/test/Barrier.h>
+
+DEFINE_uint64(threads, 32, "Number of threads for benchmark");
+
+using namespace folly;
+using namespace folly::test;
+
+ParkingLot<> lot;
+
+BENCHMARK(FutexNoWaitersWake, iters) {
+  BenchmarkSuspender susp;
+  folly::detail::Futex<> fu;
+  Barrier b(FLAGS_threads + 1);
+
+  std::vector<std::thread> threads{FLAGS_threads};
+  for (auto& t : threads) {
+    t = std::thread([&]() {
+      b.wait();
+      for (auto i = 0u; i < iters; i++) {
+        detail::futexWake(&fu, 1);
+      }
+    });
+  }
+  susp.dismiss();
+  b.wait();
+
+  for (auto& t : threads) {
+    t.join();
+  }
+}
+
+BENCHMARK_RELATIVE(ParkingLotNoWaitersWake, iters) {
+  BenchmarkSuspender susp;
+  Barrier b(FLAGS_threads + 1);
+
+  std::vector<std::thread> threads{FLAGS_threads};
+  for (auto& t : threads) {
+    t = std::thread([&]() {
+      b.wait();
+      for (auto i = 0u; i < iters; i++) {
+        lot.unpark(&lot, [](Unit) { return UnparkControl::RetainContinue; });
+      }
+    });
+  }
+  susp.dismiss();
+  b.wait();
+
+  for (auto& t : threads) {
+    t.join();
+  }
+}
+
+BENCHMARK(FutexWakeOne, iters) {
+  BenchmarkSuspender susp;
+  folly::detail::Futex<> fu;
+  Barrier b(FLAGS_threads + 1);
+
+  std::vector<std::thread> threads{FLAGS_threads};
+  for (auto& t : threads) {
+    t = std::thread([&]() {
+      b.wait();
+      while (true) {
+        detail::futexWait(&fu, 0);
+        if (fu.load(std::memory_order_relaxed)) {
+          return;
+        }
+      }
+    });
+  }
+  susp.dismiss();
+  b.wait();
+  for (auto i = 0u; i < iters; i++) {
+    detail::futexWake(&fu, 1);
+  }
+  fu.store(1);
+  detail::futexWake(&fu, threads.size());
+
+  for (auto& t : threads) {
+    t.join();
+  }
+}
+
+BENCHMARK_RELATIVE(ParkingLotWakeOne, iters) {
+  BenchmarkSuspender susp;
+  std::atomic<bool> done{false};
+  Barrier b(FLAGS_threads + 1);
+
+  std::vector<std::thread> threads{FLAGS_threads};
+  for (auto& t : threads) {
+    t = std::thread([&]() {
+      b.wait();
+      while (true) {
+        Unit f;
+        lot.park(
+            &done,
+            f,
+            [&] { return done.load(std::memory_order_relaxed) == 0; },
+            [] {});
+        if (done.load(std::memory_order_relaxed)) {
+          return;
+        }
+      }
+    });
+  }
+  susp.dismiss();
+  b.wait();
+  for (auto i = 0u; i < iters; i++) {
+    lot.unpark(&done, [](Unit) { return UnparkControl::RemoveBreak; });
+  }
+  done = true;
+  lot.unpark(&done, [](Unit) { return UnparkControl::RemoveContinue; });
+
+  for (auto& t : threads) {
+    t.join();
+  }
+}
+
+BENCHMARK(FutexWakeAll, iters) {
+  BenchmarkSuspender susp;
+  Barrier b(FLAGS_threads + 1);
+  folly::detail::Futex<> fu;
+  std::atomic<bool> done{false};
+
+  std::vector<std::thread> threads{FLAGS_threads};
+  for (auto& t : threads) {
+    t = std::thread([&]() {
+      b.wait();
+      while (true) {
+        detail::futexWait(&fu, 0);
+        if (done.load(std::memory_order_relaxed)) {
+          return;
+        }
+      }
+    });
+  }
+  susp.dismiss();
+  b.wait();
+  for (auto i = 0u; i < iters; i++) {
+    detail::futexWake(&fu, threads.size());
+  }
+  fu.store(1);
+  done = true;
+  detail::futexWake(&fu, threads.size());
+
+  for (auto& t : threads) {
+    t.join();
+  }
+}
+
+BENCHMARK_RELATIVE(ParkingLotWakeAll, iters) {
+  BenchmarkSuspender susp;
+  Barrier b(FLAGS_threads + 1);
+  std::atomic<bool> done{false};
+
+  std::vector<std::thread> threads{FLAGS_threads};
+  for (auto& t : threads) {
+    t = std::thread([&]() {
+      b.wait();
+      while (true) {
+        Unit f;
+        lot.park(
+            &done,
+            f,
+            [&] { return done.load(std::memory_order_relaxed) == 0; },
+            [] {});
+        if (done.load(std::memory_order_relaxed)) {
+          return;
+        }
+      }
+    });
+  }
+  susp.dismiss();
+  b.wait();
+  for (auto i = 0u; i < iters; i++) {
+    lot.unpark(&done, [](Unit) { return UnparkControl::RemoveContinue; });
+  }
+  done = true;
+  lot.unpark(&done, [](Unit) { return UnparkControl::RemoveContinue; });
+
+  for (auto& t : threads) {
+    t.join();
+  }
+}
+
+int main(int argc, char** argv) {
+  gflags::ParseCommandLineFlags(&argc, &argv, true);
+
+  folly::runBenchmarks();
+}
+/*
+
+./buck-out/gen/folly/synchronization/test/parking_lot_test --benchmark
+--bm_min_iters=10000 --threads=4
+============================================================================
+folly/synchronization/test/ParkingLotBenchmark.cpprelative  time/iter  iters/s
+============================================================================
+FutexNoWaitersWake                                         163.43ns    6.12M
+ParkingLotNoWaitersWake                           29.64%   551.43ns    1.81M
+FutexWakeOne                                               156.78ns    6.38M
+ParkingLotWakeOne                                 37.49%   418.21ns    2.39M
+FutexWakeAll                                                 1.82us  549.52K
+ParkingLotWakeAll                                449.63%   404.73ns    2.47M
+============================================================================
+
+./buck-out/gen/folly/synchronization/test/parking_lot_test --benchmark
+--bm_min_iters=10000 --threads=32
+============================================================================
+folly/synchronization/test/ParkingLotBenchmark.cpprelative  time/iter  iters/s
+============================================================================
+FutexNoWaitersWake                                         379.59ns    2.63M
+ParkingLotNoWaitersWake                            7.94%     4.78us  209.08K
+FutexWakeOne                                               163.59ns    6.11M
+ParkingLotWakeOne                                  6.41%     2.55us  392.07K
+FutexWakeAll                                                12.46us   80.27K
+ParkingLotWakeAll                                784.76%     1.59us  629.92K
+============================================================================ */

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

@@ -0,0 +1,170 @@
+/*
+ * 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/ParkingLot.h>
+
+#include <thread>
+
+#include <folly/portability/GTest.h>
+#include <folly/synchronization/Baton.h>
+
+using namespace folly;
+
+TEST(ParkingLot, multilot) {
+  using SmallLot = ParkingLot<bool>;
+  using LargeLot = ParkingLot<uint64_t>;
+  SmallLot smalllot;
+  LargeLot largelot;
+  folly::Baton<> sb;
+  folly::Baton<> lb;
+
+  std::thread small([&]() {
+    smalllot.park(0, false, [] { return true; }, [&]() { sb.post(); });
+  });
+  std::thread large([&]() {
+    largelot.park(0, true, [] { return true; }, [&]() { lb.post(); });
+  });
+  sb.wait();
+  lb.wait();
+
+  int count = 0;
+  smalllot.unpark(0, [&](bool data) {
+    count++;
+    EXPECT_EQ(data, false);
+    return UnparkControl::RemoveContinue;
+  });
+  EXPECT_EQ(count, 1);
+  count = 0;
+  largelot.unpark(0, [&](bool data) {
+    count++;
+    EXPECT_EQ(data, true);
+    return UnparkControl::RemoveContinue;
+  });
+  EXPECT_EQ(count, 1);
+
+  small.join();
+  large.join();
+}
+
+TEST(ParkingLot, StressTestPingPong) {
+  auto lot = ParkingLot<std::uint32_t>{};
+  auto one = std::atomic<std::uint64_t>{0};
+  auto two = std::atomic<std::uint64_t>{0};
+
+  auto testDone = std::atomic<bool>{false};
+  auto threadOneDone = std::atomic<bool>{false};
+
+  auto threadOne = std::thread{[&]() {
+    auto local = std::uint64_t{0};
+    while (!testDone.load(std::memory_order_relaxed)) {
+      // wait while the atomic is still equal to c, the other thread unblocks us
+      // because it signals before spinning itself
+      lot.park(&one, -1, [&]() { return one.load() == local; }, []() {});
+      local = one.load(std::memory_order_acquire);
+      two.store(local, std::memory_order_release);
+    }
+
+    threadOneDone.store(true, std::memory_order_release);
+  }};
+
+  auto threadTwo = std::thread{[&]() {
+    for (auto i = std::uint64_t{1}; true; ++i) {
+      auto local = two.load(std::memory_order_acquire);
+      assert(local < i);
+
+      // unblock the other thread
+      one.store(i, std::memory_order_release);
+      lot.unpark(&one, [&](auto&&) { return UnparkControl::RemoveBreak; });
+
+      // spinning (vs sleeping with ParkingLot::park) happens to expose the bug
+      // more frequently in practice
+      while (two.load(std::memory_order_acquire) == local) {
+        if (threadOneDone.load(std::memory_order_acquire)) {
+          return;
+        }
+      }
+    }
+  }};
+
+  /* sleep override */
+  std::this_thread::sleep_for(std::chrono::seconds{10});
+  testDone.store(true);
+  threadOne.join();
+  threadTwo.join();
+}
+
+// This is not possible to implement with Futex, because futex
+// and the native linux syscall are 32-bit only.
+TEST(ParkingLot, LargeWord) {
+  ParkingLot<uint64_t> lot;
+  std::atomic<uint64_t> w{0};
+
+  lot.park(0, false, [&]() { return w == 1; }, []() {});
+
+  // Validate should return false, will hang otherwise.
+}
+
+class WaitableMutex : public std::mutex {
+  using Lot = ParkingLot<std::function<bool(void)>>;
+  static Lot lot;
+
+ public:
+  void unlock() {
+    bool unparked = false;
+    lot.unpark(uint64_t(this), [&](std::function<bool(void)> wfunc) {
+      if (wfunc()) {
+        unparked = true;
+        return UnparkControl::RemoveBreak;
+      } else {
+        return UnparkControl::RemoveContinue;
+      }
+    });
+    if (!unparked) {
+      std::mutex::unlock();
+    }
+    // Otherwise, we pass mutex directly to waiter without needing to unlock.
+  }
+
+  template <typename Wait>
+  void wait(Wait wfunc) {
+    lot.park(
+        uint64_t(this),
+        wfunc,
+        [&]() { return !wfunc(); },
+        [&]() { std::mutex::unlock(); });
+  }
+};
+
+WaitableMutex::Lot WaitableMutex::lot;
+
+TEST(ParkingLot, WaitableMutexTest) {
+  if (kIsSanitizeThread) {
+    return;
+  }
+  std::atomic<bool> go{false};
+  WaitableMutex mu;
+  std::thread t([&]() {
+    std::lock_guard<WaitableMutex> g(mu);
+    mu.wait([&]() { return go == true; });
+  });
+  sleep(1);
+
+  {
+    std::lock_guard<WaitableMutex> g(mu);
+    go = true;
+  }
+  t.join();
+}

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

@@ -0,0 +1,235 @@
+/*
+ * 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>
+
+#include <stdlib.h>
+
+#include <thread>
+#include <vector>
+
+#include <glog/logging.h>
+
+#include <folly/portability/GFlags.h>
+#include <folly/portability/GTest.h>
+#include <folly/portability/Unistd.h>
+
+DEFINE_int32(num_threads, 8, "num threads");
+
+namespace {
+
+static const int kMaxReaders = 50;
+static std::atomic<bool> stopThread;
+using namespace folly;
+
+template <typename RWSpinLockT>
+struct RWSpinLockTest : public testing::Test {
+  typedef RWSpinLockT RWSpinLockType;
+};
+
+typedef testing::Types<
+    RWSpinLock
+#ifdef RW_SPINLOCK_USE_X86_INTRINSIC_
+    ,
+    RWTicketSpinLockT<32, true>,
+    RWTicketSpinLockT<32, false>,
+    RWTicketSpinLockT<64, true>,
+    RWTicketSpinLockT<64, false>
+#endif
+    >
+    Implementations;
+
+TYPED_TEST_SUITE(RWSpinLockTest, Implementations);
+
+template <typename RWSpinLockType>
+static void run(RWSpinLockType& lock) {
+  while (!stopThread.load(std::memory_order_acquire)) {
+    if (rand() % 10 == 0) { // write
+      auto guard = std::unique_lock(lock);
+    } else { // read
+      auto guard = std::shared_lock(lock);
+    }
+  }
+}
+
+TYPED_TEST(RWSpinLockTest, WriterWaitReaders) {
+  typedef typename TestFixture::RWSpinLockType LockType;
+  LockType l;
+
+  for (int i = 0; i < kMaxReaders; ++i) {
+    EXPECT_TRUE(l.try_lock_shared());
+    EXPECT_FALSE(l.try_lock());
+  }
+
+  for (int i = 0; i < kMaxReaders; ++i) {
+    EXPECT_FALSE(l.try_lock());
+    l.unlock_shared();
+  }
+
+  EXPECT_TRUE(l.try_lock());
+}
+
+TYPED_TEST(RWSpinLockTest, ReadersWaitWriter) {
+  typedef typename TestFixture::RWSpinLockType LockType;
+  LockType l;
+
+  EXPECT_TRUE(l.try_lock());
+
+  for (int i = 0; i < kMaxReaders; ++i) {
+    EXPECT_FALSE(l.try_lock_shared());
+  }
+
+  l.unlock_and_lock_shared();
+  for (int i = 0; i < kMaxReaders - 1; ++i) {
+    EXPECT_TRUE(l.try_lock_shared());
+  }
+}
+
+TYPED_TEST(RWSpinLockTest, WriterWaitWriter) {
+  typedef typename TestFixture::RWSpinLockType LockType;
+  LockType l;
+
+  EXPECT_TRUE(l.try_lock());
+  EXPECT_FALSE(l.try_lock());
+  l.unlock();
+
+  EXPECT_TRUE(l.try_lock());
+  EXPECT_FALSE(l.try_lock());
+}
+
+TYPED_TEST(RWSpinLockTest, ReadHolders) {
+  typedef typename TestFixture::RWSpinLockType LockType;
+  LockType l;
+
+  {
+    std::shared_lock guard(l);
+    EXPECT_FALSE(l.try_lock());
+    EXPECT_TRUE(l.try_lock_shared());
+    l.unlock_shared();
+
+    EXPECT_FALSE(l.try_lock());
+  }
+
+  EXPECT_TRUE(l.try_lock());
+  l.unlock();
+}
+
+TYPED_TEST(RWSpinLockTest, WriteHolders) {
+  typedef typename TestFixture::RWSpinLockType LockType;
+  LockType l;
+  {
+    std::unique_lock guard(l);
+    EXPECT_FALSE(l.try_lock());
+    EXPECT_FALSE(l.try_lock_shared());
+  }
+
+  EXPECT_TRUE(l.try_lock_shared());
+  EXPECT_FALSE(l.try_lock());
+  l.unlock_shared();
+  EXPECT_TRUE(l.try_lock());
+}
+
+TYPED_TEST(RWSpinLockTest, ConcurrentTests) {
+  typedef typename TestFixture::RWSpinLockType LockType;
+  LockType l;
+  srand(time(nullptr));
+
+  std::vector<std::thread> threads;
+  for (int i = 0; i < FLAGS_num_threads; ++i) {
+    threads.push_back(std::thread(&run<LockType>, std::ref(l)));
+  }
+
+  sleep(1);
+  stopThread.store(true, std::memory_order_release);
+
+  for (auto& t : threads) {
+    t.join();
+  }
+}
+
+// RWSpinLock specific tests
+
+TEST(RWSpinLock, lockUnlockTests) {
+  folly::RWSpinLock lock;
+  EXPECT_TRUE(lock.try_lock_upgrade());
+  EXPECT_FALSE(lock.try_lock_shared());
+  EXPECT_FALSE(lock.try_lock());
+  EXPECT_FALSE(lock.try_lock_upgrade());
+  lock.unlock_upgrade();
+  lock.lock_shared();
+  EXPECT_FALSE(lock.try_lock());
+  EXPECT_TRUE(lock.try_lock_upgrade());
+  lock.unlock_upgrade();
+  lock.unlock_shared();
+  EXPECT_TRUE(lock.try_lock());
+  EXPECT_FALSE(lock.try_lock_upgrade());
+  lock.unlock_and_lock_upgrade();
+  EXPECT_FALSE(lock.try_lock_shared());
+  lock.unlock_upgrade_and_lock_shared();
+  lock.unlock_shared();
+  EXPECT_EQ(0, lock.bits());
+}
+
+TEST(RWSpinLock, concurrentHolderTest) {
+  srand(time(nullptr));
+
+  folly::RWSpinLock lock;
+  std::atomic<int64_t> reads(0);
+  std::atomic<int64_t> writes(0);
+  std::atomic<int64_t> upgrades(0);
+  std::atomic<bool> stop(false);
+
+  auto go = [&] {
+    while (!stop.load(std::memory_order_acquire)) {
+      auto r = (uint32_t)(rand()) % 10;
+      if (r < 3) { // starts from write lock
+        auto wg = std::unique_lock(lock);
+        auto ug = folly::transition_lock<folly::upgrade_lock>(wg);
+        auto rg = folly::transition_lock<std::shared_lock>(ug);
+        writes.fetch_add(1, std::memory_order_acq_rel);
+      } else if (r < 6) { // starts from upgrade lock
+        auto ug = folly::upgrade_lock(lock);
+        if (r < 4) {
+          auto wg = folly::transition_lock<std::unique_lock>(ug);
+        } else {
+          auto rg = folly::transition_lock<std::shared_lock>(ug);
+        }
+        upgrades.fetch_add(1, std::memory_order_acq_rel);
+      } else {
+        auto rg = std::shared_lock(lock);
+        reads.fetch_add(1, std::memory_order_acq_rel);
+      }
+    }
+  };
+
+  std::vector<std::thread> threads;
+  for (int i = 0; i < FLAGS_num_threads; ++i) {
+    threads.push_back(std::thread(go));
+  }
+
+  sleep(5);
+  stop.store(true, std::memory_order_release);
+
+  for (auto& t : threads) {
+    t.join();
+  }
+
+  LOG(INFO) << "reads: " << reads.load(std::memory_order_acquire)
+            << "; writes: " << writes.load(std::memory_order_acquire)
+            << "; upgrades: " << upgrades.load(std::memory_order_acquire);
+}
+
+} // namespace