react-native-windows 0.81.34 → 0.81.35

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

@@ -0,0 +1,224 @@
+/*
+ * 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 <numeric>
+#include <thread>
+
+#include <folly/portability/GTest.h>
+#include <folly/synchronization/Latch.h>
+
+TEST(LatchTest, ExpectedZero) {
+  folly::Latch latch(0);
+  EXPECT_TRUE(latch.try_wait());
+}
+
+TEST(LatchTest, ExpectedOne) {
+  folly::Latch latch(1);
+  EXPECT_FALSE(latch.try_wait());
+  latch.count_down();
+  EXPECT_TRUE(latch.try_wait());
+}
+
+TEST(LatchTest, ExpectedMax) {
+  const auto max = folly::Latch::max();
+  folly::Latch latch(max);
+  EXPECT_FALSE(latch.try_wait());
+  latch.count_down(max);
+  EXPECT_TRUE(latch.try_wait());
+}
+
+TEST(LatchTest, WaitFor) {
+  folly::Latch latch(1);
+  EXPECT_FALSE(latch.try_wait_for(std::chrono::seconds(1)));
+  latch.count_down();
+  EXPECT_TRUE(latch.try_wait_for(std::chrono::seconds(1)));
+}
+
+TEST(LatchTest, WaitUntil) {
+  folly::Latch latch(1);
+  EXPECT_FALSE(latch.try_wait_until(
+      std::chrono::steady_clock::now() + std::chrono::seconds(1)));
+  latch.count_down();
+  EXPECT_TRUE(latch.try_wait_until(
+      std::chrono::steady_clock::now() + std::chrono::seconds(1)));
+}
+
+TEST(LatchTest, Ready) {
+  folly::Latch latch(1);
+  auto ready = [](const folly::Latch& l) { return l.ready(); };
+  EXPECT_FALSE(ready(latch));
+  latch.count_down();
+  EXPECT_TRUE(ready(latch));
+}
+
+TEST(LatchTest, CountDown) {
+  folly::Latch latch(3);
+  EXPECT_FALSE(latch.try_wait());
+  latch.count_down(0); // (noop)
+  EXPECT_FALSE(latch.try_wait());
+  latch.count_down();
+  EXPECT_FALSE(latch.try_wait());
+  latch.count_down();
+  EXPECT_FALSE(latch.try_wait());
+  latch.count_down();
+  EXPECT_TRUE(latch.try_wait());
+}
+
+TEST(LatchTest, CountDownZero) {
+  folly::Latch latch(0);
+  EXPECT_TRUE(latch.try_wait());
+  latch.count_down(0);
+  EXPECT_TRUE(latch.try_wait());
+}
+
+TEST(LatchTest, CountDownN) {
+  folly::Latch latch(5);
+  EXPECT_FALSE(latch.try_wait());
+  latch.count_down(5);
+  EXPECT_TRUE(latch.try_wait());
+}
+
+TEST(LatchTest, CountDownThreads) {
+  const int N = 32;
+  std::vector<int> done(N);
+  folly::Latch latch(N);
+  std::vector<std::thread> threads;
+  for (int i = 0; i < N; i++) {
+    threads.emplace_back([&, i] {
+      done[i] = 1;
+      latch.count_down();
+    });
+  }
+  EXPECT_TRUE(latch.try_wait_for(std::chrono::seconds(60)));
+  EXPECT_EQ(std::accumulate(done.begin(), done.end(), 0), N);
+  for (auto& t : threads) {
+    t.join();
+  }
+}
+
+TEST(LatchTest, CountDownThreadsTwice1) {
+  const int N = 32;
+  std::vector<int> done(N);
+  folly::Latch latch(N * 2);
+  std::vector<std::thread> threads;
+  for (int i = 0; i < N; i++) {
+    threads.emplace_back([&, i] {
+      done[i] = 1;
+      // count_down() multiple times within same thread
+      latch.count_down();
+      latch.count_down();
+    });
+  }
+  EXPECT_TRUE(latch.try_wait_for(std::chrono::seconds(60)));
+  EXPECT_EQ(std::accumulate(done.begin(), done.end(), 0), N);
+  for (auto& t : threads) {
+    t.join();
+  }
+}
+
+TEST(LatchTest, CountDownThreadsTwice2) {
+  const int N = 32;
+  std::vector<int> done(N);
+  folly::Latch latch(N * 2);
+  std::vector<std::thread> threads;
+  for (int i = 0; i < N; i++) {
+    threads.emplace_back([&, i] {
+      done[i] = 1;
+      // count_down() multiple times within same thread
+      latch.count_down(2);
+    });
+  }
+  EXPECT_TRUE(latch.try_wait_for(std::chrono::seconds(60)));
+  EXPECT_EQ(std::accumulate(done.begin(), done.end(), 0), N);
+  for (auto& t : threads) {
+    t.join();
+  }
+}
+
+TEST(LatchTest, CountDownThreadsWait) {
+  const int N = 32;
+  std::vector<int> done(N);
+  folly::Latch latch(N);
+  std::vector<std::thread> threads;
+  for (int i = 0; i < N; i++) {
+    threads.emplace_back([&, i] {
+      done[i] = 1;
+      // count_down() and wait() within thread
+      latch.count_down();
+      EXPECT_TRUE(latch.try_wait_for(std::chrono::seconds(60)));
+      EXPECT_EQ(std::accumulate(done.begin(), done.end(), 0), N);
+    });
+  }
+  EXPECT_TRUE(latch.try_wait_for(std::chrono::seconds(60)));
+  EXPECT_EQ(std::accumulate(done.begin(), done.end(), 0), N);
+  for (auto& t : threads) {
+    t.join();
+  }
+}
+
+TEST(LatchTest, CountDownThreadsArriveAndWait) {
+  const int N = 32;
+  std::vector<int> done(N);
+  folly::Latch latch(N);
+  std::vector<std::thread> threads;
+  for (int i = 0; i < N; i++) {
+    threads.emplace_back([&, i] {
+      done[i] = 1;
+      // count_down() and wait() within thread
+      latch.arrive_and_wait();
+      EXPECT_EQ(std::accumulate(done.begin(), done.end(), 0), N);
+    });
+  }
+  EXPECT_TRUE(latch.try_wait_for(std::chrono::seconds(60)));
+  EXPECT_EQ(std::accumulate(done.begin(), done.end(), 0), N);
+  for (auto& t : threads) {
+    t.join();
+  }
+}
+
+TEST(LatchTest, OutOfScopeStillArmed) {
+  folly::Latch latch(3);
+  latch.count_down();
+  // mainly checking for blocking behavior which will result in a test timeout
+  // (latch should not block in this case)
+}
+
+TEST(LatchTest, InvalidInit) {
+  // latch initialized with a negative value
+  EXPECT_DEATH(folly::Latch latch(-1), ".*");
+  // latch initialized with a value bigger than max
+  const int64_t init = folly::Latch::max() + 1;
+  EXPECT_DEATH(folly::Latch latch(init), ".*");
+}
+
+TEST(LatchTest, InvalidCountDown) {
+  folly::Latch latch(1);
+  latch.count_down();
+  // count_down() called more times than expected
+  EXPECT_DEATH(latch.count_down(), ".*");
+}
+
+TEST(LatchTest, InvalidCountDownN) {
+  folly::Latch latch(5);
+  // count_down() called with a bigger value than expected
+  EXPECT_DEATH(latch.count_down(6), ".*");
+}
+
+TEST(LatchTest, InvalidCountDownNegative) {
+  folly::Latch latch(1);
+  // count_down() called with a negative value
+  EXPECT_DEATH(latch.count_down(-1), ".*");
+}

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

@@ -0,0 +1,185 @@
+/*
+ * 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/portability/Asm.h>
+#include <folly/synchronization/LifoSem.h>
+#include <folly/synchronization/NativeSemaphore.h>
+
+#include <folly/Benchmark.h>
+
+using namespace folly;
+
+BENCHMARK(lifo_sem_pingpong, iters) {
+  LifoSem a;
+  LifoSem b;
+  auto thr = std::thread([&] {
+    for (size_t i = 0; i < iters; ++i) {
+      a.wait();
+      b.post();
+    }
+  });
+  for (size_t i = 0; i < iters; ++i) {
+    a.post();
+    b.wait();
+  }
+  thr.join();
+}
+
+BENCHMARK(lifo_sem_oneway, iters) {
+  LifoSem a;
+  auto thr = std::thread([&] {
+    for (size_t i = 0; i < iters; ++i) {
+      a.wait();
+    }
+  });
+  for (size_t i = 0; i < iters; ++i) {
+    a.post();
+  }
+  thr.join();
+}
+
+BENCHMARK(single_thread_lifo_post, iters) {
+  LifoSem sem;
+  for (size_t n = 0; n < iters; ++n) {
+    sem.post();
+    asm_volatile_memory();
+  }
+}
+
+BENCHMARK(single_thread_lifo_wait, iters) {
+  LifoSem sem(iters);
+  for (size_t n = 0; n < iters; ++n) {
+    sem.wait();
+    asm_volatile_memory();
+  }
+}
+
+BENCHMARK(single_thread_lifo_postwait, iters) {
+  LifoSem sem;
+  for (size_t n = 0; n < iters; ++n) {
+    sem.post();
+    asm_volatile_memory();
+    sem.wait();
+    asm_volatile_memory();
+  }
+}
+
+BENCHMARK(single_thread_lifo_trypost, iters) {
+  LifoSem sem;
+  for (size_t n = 0; n < iters; ++n) {
+    CHECK(!sem.tryPost());
+    asm_volatile_memory();
+  }
+}
+
+BENCHMARK(single_thread_lifo_trywait, iters) {
+  LifoSem sem;
+  for (size_t n = 0; n < iters; ++n) {
+    CHECK(!sem.tryWait());
+    asm_volatile_memory();
+  }
+}
+
+BENCHMARK(single_thread_native_postwait, iters) {
+  folly::NativeSemaphore sem;
+  for (size_t n = 0; n < iters; ++n) {
+    sem.post();
+    sem.wait();
+  }
+}
+
+BENCHMARK(single_thread_native_trywait, iters) {
+  folly::NativeSemaphore sem;
+  for (size_t n = 0; n < iters; ++n) {
+    CHECK(!sem.try_wait());
+  }
+}
+
+static void contendedUse(uint32_t n, int posters, int waiters) {
+  LifoSemImpl<std::atomic> sem;
+
+  std::vector<std::thread> threads;
+  std::atomic<bool> go(false);
+
+  BENCHMARK_SUSPEND {
+    for (int t = 0; t < waiters; ++t) {
+      threads.emplace_back([=, &sem] {
+        for (uint32_t i = t; i < n; i += waiters) {
+          sem.wait();
+        }
+      });
+    }
+    for (int t = 0; t < posters; ++t) {
+      threads.emplace_back([=, &sem, &go] {
+        while (!go.load()) {
+          std::this_thread::yield();
+        }
+        for (uint32_t i = t; i < n; i += posters) {
+          sem.post();
+        }
+      });
+    }
+  }
+
+  go.store(true);
+  for (auto& thr : threads) {
+    thr.join();
+  }
+}
+
+BENCHMARK_DRAW_LINE();
+BENCHMARK_NAMED_PARAM(contendedUse, 1_to_1, 1, 1)
+BENCHMARK_NAMED_PARAM(contendedUse, 1_to_4, 1, 4)
+BENCHMARK_NAMED_PARAM(contendedUse, 1_to_32, 1, 32)
+BENCHMARK_NAMED_PARAM(contendedUse, 4_to_1, 4, 1)
+BENCHMARK_NAMED_PARAM(contendedUse, 4_to_24, 4, 24)
+BENCHMARK_NAMED_PARAM(contendedUse, 8_to_100, 8, 100)
+BENCHMARK_NAMED_PARAM(contendedUse, 32_to_1, 31, 1)
+BENCHMARK_NAMED_PARAM(contendedUse, 16_to_16, 16, 16)
+BENCHMARK_NAMED_PARAM(contendedUse, 32_to_32, 32, 32)
+BENCHMARK_NAMED_PARAM(contendedUse, 32_to_1000, 32, 1000)
+
+// sudo nice -n -20 _build/opt/folly/test/LifoSemTests
+//     --benchmark --bm_min_iters=10000000 --gtest_filter=-\*
+// ============================================================================
+// folly/test/LifoSemTests.cpp                     relative  time/iter  iters/s
+// ============================================================================
+// lifo_sem_pingpong                                            1.31us  762.40K
+// lifo_sem_oneway                                            193.89ns    5.16M
+// single_thread_lifo_post                                     15.37ns   65.08M
+// single_thread_lifo_wait                                     13.60ns   73.53M
+// single_thread_lifo_postwait                                 29.43ns   33.98M
+// single_thread_lifo_trywait                                 677.69ps    1.48G
+// single_thread_native_postwait                                25.03ns   39.95M
+// single_thread_native_trywait                                  7.30ns  136.98M
+// ----------------------------------------------------------------------------
+// contendedUse(1_to_1)                                       158.22ns    6.32M
+// contendedUse(1_to_4)                                       574.73ns    1.74M
+// contendedUse(1_to_32)                                      592.94ns    1.69M
+// contendedUse(4_to_1)                                       118.28ns    8.45M
+// contendedUse(4_to_24)                                      667.62ns    1.50M
+// contendedUse(8_to_100)                                     701.46ns    1.43M
+// contendedUse(32_to_1)                                      165.06ns    6.06M
+// contendedUse(16_to_16)                                     238.57ns    4.19M
+// contendedUse(32_to_32)                                     219.82ns    4.55M
+// contendedUse(32_to_1000)                                   777.42ns    1.29M
+// ============================================================================
+
+int main(int argc, char** argv) {
+  gflags::ParseCommandLineFlags(&argc, &argv, true);
+  folly::runBenchmarksOnFlag();
+  return 0;
+}