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

package/external/folly/folly/synchronization/test/BUCK

@@ -0,0 +1,495 @@
+load("@fbcode_macros//build_defs:cpp_benchmark.bzl", "cpp_benchmark")
+load("@fbcode_macros//build_defs:cpp_binary.bzl", "cpp_binary")
+load("@fbcode_macros//build_defs:cpp_library.bzl", "cpp_library")
+load("@fbcode_macros//build_defs:cpp_unittest.bzl", "cpp_unittest")
+
+oncall("fbcode_entropy_wardens_folly")
+
+cpp_unittest(
+    name = "atomic_notification_test",
+    srcs = [
+        "AtomicNotificationTest.cpp",
+    ],
+    deps = [
+        "//folly:optional",
+        "//folly/portability:gtest",
+        "//folly/synchronization:atomic_notification",
+    ],
+)
+
+cpp_unittest(
+    name = "atomic_ref_test",
+    srcs = ["AtomicRefTest.cpp"],
+    deps = [
+        "//folly/portability:gtest",
+        "//folly/synchronization:atomic_ref",
+    ],
+)
+
+cpp_unittest(
+    name = "atomic_struct_test",
+    srcs = ["AtomicStructTest.cpp"],
+    headers = [],
+    deps = [
+        "//folly/portability:gtest",
+        "//folly/synchronization:atomic_struct",
+    ],
+)
+
+cpp_benchmark(
+    name = "atomic_util_bench",
+    srcs = ["AtomicUtilBench.cpp"],
+    deps = [
+        "//folly:benchmark",
+        "//folly:constexpr_math",
+        "//folly/init:init",
+        "//folly/lang:aligned",
+        "//folly/lang:assume",
+        "//folly/lang:keep",
+        "//folly/synchronization:atomic_util",
+    ],
+)
+
+cpp_unittest(
+    name = "atomic_util_test",
+    srcs = ["AtomicUtilTest.cpp"],
+    supports_static_listing = False,
+    deps = [
+        "//folly:benchmark",
+        "//folly:portability",
+        "//folly:utility",
+        "//folly/functional:invoke",
+        "//folly/portability:gtest",
+        "//folly/synchronization:atomic_ref",
+        "//folly/synchronization:atomic_util",
+    ],
+)
+
+cpp_library(
+    name = "barrier",
+    headers = ["Barrier.h"],
+)
+
+cpp_unittest(
+    name = "barrier_test",
+    srcs = ["BarrierTest.cpp"],
+    deps = [
+        ":barrier",
+        "//folly/portability:gtest",
+    ],
+)
+
+cpp_benchmark(
+    name = "baton_benchmark",
+    srcs = ["BatonBenchmark.cpp"],
+    deps = [
+        ":baton_test_helpers",
+        "//folly:benchmark",
+        "//folly/synchronization:baton",
+        "//folly/synchronization:native_semaphore",
+        "//folly/test:deterministic_schedule",
+    ],
+)
+
+cpp_unittest(
+    name = "baton_test",
+    srcs = ["BatonTest.cpp"],
+    deps = [
+        ":baton_test_helpers",
+        "//folly/portability:gtest",
+        "//folly/synchronization:baton",
+        "//folly/test:deterministic_schedule",
+    ],
+)
+
+cpp_library(
+    name = "baton_test_helpers",
+    headers = ["BatonTestHelpers.h"],
+    exported_deps = [
+        "//folly/portability:gtest",
+        "//folly/synchronization:baton",
+        "//folly/test:deterministic_schedule",
+    ],
+)
+
+cpp_binary(
+    name = "call_once_benchmark",
+    srcs = ["CallOnceBenchmark.cpp"],
+    headers = [],
+    deps = [
+        "//folly:benchmark",
+        "//folly/synchronization:call_once",
+    ],
+    external_deps = [
+        "glog",
+    ],
+)
+
+cpp_unittest(
+    name = "call_once_test",
+    srcs = ["CallOnceTest.cpp"],
+    headers = [],
+    deps = [
+        "//folly:traits",
+        "//folly/portability:gtest",
+        "//folly/synchronization:call_once",
+    ],
+)
+
+cpp_unittest(
+    name = "delayed_init_test",
+    srcs = ["DelayedInitTest.cpp"],
+    headers = [],
+    deps = [
+        "fbsource//third-party/fmt:fmt",
+        ":barrier",
+        "//folly/portability:gtest",
+        "//folly/synchronization:delayed_init",
+    ],
+)
+
+cpp_unittest(
+    name = "distributed_mutex_test",
+    srcs = [
+        "DistributedMutexTest.cpp",
+    ],
+    deps = [
+        "//folly:map_util",
+        "//folly:synchronized",
+        "//folly/container:array",
+        "//folly/container:foreach",
+        "//folly/lang:customization_point",
+        "//folly/lang:keep",
+        "//folly/portability:gtest",
+        "//folly/synchronization:baton",
+        "//folly/synchronization:distributed_mutex",
+        "//folly/test:deterministic_schedule",
+        "//folly/test:test_utils",
+    ],
+)
+
+cpp_unittest(
+    name = "hazptr_test",
+    srcs = ["HazptrTest.cpp"],
+    deps = [
+        ":barrier",
+        "//folly:singleton",
+        "//folly/portability:gflags",
+        "//folly/portability:gtest",
+        "//folly/synchronization:hazptr",
+        "//folly/synchronization:hazptr_thread_pool_executor",
+        "//folly/synchronization/example:hazptr_lock_free_lifo",
+        "//folly/synchronization/example:hazptr_swmr_set",
+        "//folly/synchronization/example:hazptr_wide_cas",
+        "//folly/test:deterministic_schedule",
+    ],
+)
+
+cpp_unittest(
+    name = "latch_test",
+    srcs = ["LatchTest.cpp"],
+    deps = [
+        "//folly/portability:gtest",
+        "//folly/synchronization:latch",
+    ],
+)
+
+cpp_unittest(
+    name = "lifo_sem_test",
+    srcs = ["LifoSemTests.cpp"],
+    headers = [],
+    allocator = "jemalloc_debug",
+    deps = [
+        "//folly:random",
+        "//folly/portability:asm",
+        "//folly/portability:gflags",
+        "//folly/portability:gtest",
+        "//folly/synchronization:lifo_sem",
+        "//folly/synchronization:native_semaphore",
+        "//folly/test:deterministic_schedule",
+    ],
+)
+
+cpp_benchmark(
+    name = "lifo_sem_bench",
+    srcs = ["LifoSemBench.cpp"],
+    headers = [],
+    deps = [
+        "//folly:benchmark",
+        "//folly/portability:asm",
+        "//folly/synchronization:lifo_sem",
+        "//folly/synchronization:native_semaphore",
+    ],
+)
+
+cpp_unittest(
+    name = "lock_test",
+    srcs = ["LockTest.cpp"],
+    supports_static_listing = False,
+    deps = [
+        "//folly/portability:gtest",
+        "//folly/synchronization:lock",
+    ],
+)
+
+cpp_unittest(
+    name = "native_semaphore_test",
+    srcs = ["NativeSemaphoreTest.cpp"],
+    deps = [
+        "//folly/portability:gtest",
+        "//folly/synchronization:native_semaphore",
+    ],
+)
+
+cpp_binary(
+    name = "parking_lot_benchmark",
+    srcs = ["ParkingLotBenchmark.cpp"],
+    deps = [
+        ":barrier",
+        "//folly:benchmark",
+        "//folly/detail:futex",
+        "//folly/synchronization:baton",
+        "//folly/synchronization:parking_lot",
+    ],
+)
+
+cpp_unittest(
+    name = "parking_lot_test",
+    srcs = ["ParkingLotTest.cpp"],
+    deps = [
+        "//folly/portability:gtest",
+        "//folly/synchronization:baton",
+        "//folly/synchronization:parking_lot",
+    ],
+)
+
+cpp_binary(
+    name = "rcu_bench",
+    srcs = ["RcuBench.cpp"],
+    headers = [],
+    deps = [
+        "//folly:benchmark",
+        "//folly/synchronization:rcu",
+    ],
+)
+
+cpp_unittest(
+    name = "rcu_test",
+    srcs = ["RcuTest.cpp"],
+    deps = [
+        "//folly:benchmark",
+        "//folly:random",
+        "//folly/portability:gflags",
+        "//folly/portability:gtest",
+        "//folly/synchronization:rcu",
+        "//folly/synchronization:relaxed_atomic",
+    ],
+    external_deps = [
+        "glog",
+    ],
+)
+
+cpp_unittest(
+    name = "relaxed_atomic_test",
+    srcs = ["RelaxedAtomicTest.cpp"],
+    headers = [],
+    deps = [
+        "//folly/portability:gtest",
+        "//folly/synchronization:atomic_util",
+        "//folly/synchronization:relaxed_atomic",
+    ],
+)
+
+cpp_unittest(
+    name = "rw_spin_lock_test",
+    srcs = ["RWSpinLockTest.cpp"],
+    headers = [],
+    deps = [
+        "//folly/portability:gflags",
+        "//folly/portability:gtest",
+        "//folly/portability:unistd",
+        "//folly/synchronization:rw_spin_lock",
+    ],
+    external_deps = [
+        "glog",
+    ],
+)
+
+cpp_unittest(
+    name = "saturating_semaphore_test",
+    srcs = ["SaturatingSemaphoreTest.cpp"],
+    deps = [
+        "//folly/portability:gtest",
+        "//folly/synchronization:saturating_semaphore",
+        "//folly/test:deterministic_schedule",
+    ],
+)
+
+cpp_library(
+    name = "semaphore",
+    headers = ["Semaphore.h"],
+    exported_deps = [
+        "//folly:optional",
+        "//folly:scope_guard",
+        "//folly/lang:exception",
+    ],
+    exported_external_deps = [
+        "boost",
+    ],
+)
+
+cpp_unittest(
+    name = "semaphore_test",
+    srcs = ["SemaphoreTest.cpp"],
+    deps = [
+        ":barrier",
+        ":semaphore",
+        "//folly:traits",
+        "//folly/portability:gtest",
+        "//folly/portability:sys_mman",
+        "//folly/synchronization:latch",
+    ],
+    external_deps = [
+        "glog",
+    ],
+)
+
+cpp_benchmark(
+    name = "small_locks_benchmark",
+    srcs = ["SmallLocksBenchmark.cpp"],
+    deps = [
+        "fbsource//third-party/fmt:fmt",
+        "//folly:benchmark",
+        "//folly:shared_mutex",
+        "//folly/lang:aligned",
+        "//folly/synchronization:distributed_mutex",
+        "//folly/synchronization:flat_combining",
+        "//folly/synchronization:small_locks",
+    ],
+)
+
+cpp_unittest(
+    name = "small_locks_test",
+    srcs = ["SmallLocksTest.cpp"],
+    headers = [],
+    deps = [
+        "//folly:random",
+        "//folly/portability:asm",
+        "//folly/portability:gflags",
+        "//folly/portability:gmock",
+        "//folly/portability:gtest",
+        "//folly/portability:pthread",
+        "//folly/portability:unistd",
+        "//folly/synchronization:small_locks",
+        "//folly/test:test_utils",
+    ],
+    external_deps = [
+        "glog",
+    ],
+)
+
+cpp_library(
+    name = "thread_cached_epoch_bench_util",
+    headers = ["ThreadCachedEpochBench.h"],
+    exported_deps = [
+        "//folly:benchmark",
+        "//folly/synchronization/detail:rcu-detail",
+    ],
+)
+
+cpp_binary(
+    name = "thread_cached_readers_bench",
+    srcs = ["ThreadCachedReadersBench.cpp"],
+    headers = [],
+    deps = [
+        ":thread_cached_epoch_bench_util",
+        "//folly:benchmark",
+        "//folly/synchronization/detail:rcu-detail",
+    ],
+)
+
+cpp_unittest(
+    name = "thread_cached_readers_test",
+    srcs = ["ThreadCachedReadersTest.cpp"],
+    headers = [],
+    deps = [
+        "//folly:thread_local",
+        "//folly/portability:gtest",
+        "//folly/synchronization/detail:rcu-detail",
+    ],
+)
+
+cpp_unittest(
+    name = "throttled_lifo_sem_test",
+    srcs = [
+        "ThrottledLifoSemTest.cpp",
+    ],
+    deps = [
+        "//folly:benchmark",
+        "//folly:random",
+        "//folly/portability:gtest",
+        "//folly/synchronization:saturating_semaphore",
+        "//folly/synchronization:throttled_lifo_sem",
+    ],
+)
+
+cpp_library(
+    name = "flat_combining_examples",
+    headers = ["FlatCombiningExamples.h"],
+    exported_deps = [
+        "//folly/synchronization:baton",
+        "//folly/synchronization:flat_combining",
+    ],
+)
+
+cpp_library(
+    name = "flat_combining_test_helpers",
+    headers = ["FlatCombiningTestHelpers.h"],
+    exported_deps = [
+        "//folly:benchmark",
+        "//folly/synchronization/test:flat_combining_examples",
+    ],
+    exported_external_deps = [
+        "glog",
+    ],
+)
+
+cpp_unittest(
+    name = "flat_combining_benchmark",
+    srcs = ["FlatCombiningBenchmark.cpp"],
+    deps = [
+        "//folly:benchmark",
+        "//folly/portability:gtest",
+        "//folly/synchronization/test:flat_combining_test_helpers",
+    ],
+    external_deps = [
+        "glog",
+    ],
+)
+
+cpp_unittest(
+    name = "flat_combining_test",
+    srcs = ["FlatCombiningTest.cpp"],
+    supports_static_listing = False,
+    deps = [
+        "//folly/portability:gtest",
+        "//folly/synchronization/test:flat_combining_test_helpers",
+    ],
+    external_deps = [
+        "glog",
+    ],
+)
+
+cpp_unittest(
+    name = "event_count_test",
+    srcs = ["EventCountTest.cpp"],
+    headers = [],
+    deps = [
+        "//folly:random",
+        "//folly/portability:gtest",
+        "//folly/synchronization:event_count",
+    ],
+    external_deps = [
+        "glog",
+    ],
+)

package/external/folly/folly/synchronization/test/Barrier.h

@@ -0,0 +1,52 @@
+/*
+ * 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 <stdint.h>
+
+#include <condition_variable>
+#include <mutex>
+
+namespace folly {
+
+namespace test {
+
+struct Barrier {
+  explicit Barrier(size_t count) : lock_(), cv_(), count_(count) {}
+
+  void wait() {
+    std::unique_lock<std::mutex> lockHeld(lock_);
+    auto gen = gen_;
+    if (++num_ == count_) {
+      num_ = 0;
+      gen_++;
+      cv_.notify_all();
+    } else {
+      cv_.wait(lockHeld, [&]() { return gen != gen_; });
+    }
+  }
+
+ private:
+  std::mutex lock_;
+  std::condition_variable cv_;
+  size_t num_{0};
+  size_t count_;
+  size_t gen_{0};
+};
+
+} // namespace test
+} // namespace folly

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

@@ -0,0 +1,56 @@
+/*
+ * 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/test/Barrier.h>
+
+#include <atomic>
+#include <thread>
+#include <vector>
+
+#include <folly/portability/GTest.h>
+
+using namespace folly::test;
+
+class BarrierTest : public testing::Test {};
+
+TEST_F(BarrierTest, basic_barrier_test) {
+  constexpr unsigned kThreadCount = 10;
+
+  std::vector<std::thread> threads{kThreadCount};
+  Barrier gate{kThreadCount + 1};
+  std::atomic<int> mismatchCount{0};
+  std::atomic<bool> flag{false};
+
+  for (auto& t : threads) {
+    t = std::thread([&] {
+      gate.wait();
+      if (!flag.load()) {
+        mismatchCount.fetch_add(1);
+      }
+    });
+  }
+
+  // Set flag here and make sure all the threads see it correctly after wait()
+  // unblocks
+  flag.store(true);
+  gate.wait();
+
+  for (auto& t : threads) {
+    t.join();
+  }
+
+  EXPECT_EQ(mismatchCount.load(), 0);
+}

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

@@ -0,0 +1,77 @@
+/*
+ * 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/Baton.h>
+
+#include <thread>
+
+#include <folly/Benchmark.h>
+#include <folly/synchronization/NativeSemaphore.h>
+#include <folly/synchronization/test/BatonTestHelpers.h>
+#include <folly/test/DeterministicSchedule.h>
+
+using namespace folly::test;
+using folly::detail::EmulatedFutexAtomic;
+
+BENCHMARK(baton_pingpong_blocking, iters) {
+  run_pingpong_test<true, std::atomic>(iters);
+}
+
+BENCHMARK(baton_pingpong_nonblocking, iters) {
+  run_pingpong_test<false, std::atomic>(iters);
+}
+
+BENCHMARK_DRAW_LINE();
+
+BENCHMARK(baton_pingpong_emulated_futex_blocking, iters) {
+  run_pingpong_test<true, EmulatedFutexAtomic>(iters);
+}
+
+BENCHMARK(baton_pingpong_emulated_futex_nonblocking, iters) {
+  run_pingpong_test<false, EmulatedFutexAtomic>(iters);
+}
+
+BENCHMARK_DRAW_LINE();
+
+BENCHMARK(native_sem_pingpong, iters) {
+  alignas(folly::hardware_destructive_interference_size)
+      folly::NativeSemaphore a;
+  alignas(folly::hardware_destructive_interference_size)
+      folly::NativeSemaphore 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();
+}
+
+// I am omitting a benchmark result snapshot because these microbenchmarks
+// mainly illustrate that PreBlockAttempts is very effective for rapid
+// handoffs.  The performance of Baton and sem_t is essentially identical
+// to the required futex calls for the blocking case
+
+int main(int argc, char** argv) {
+  gflags::ParseCommandLineFlags(&argc, &argv, true);
+  folly::runBenchmarks();
+  return 0;
+}