react-native-windows 0.85.0-preview.1 → 0.85.0

package/external/folly/folly/detail/test/StaticSingletonManagerTest.cpp

@@ -0,0 +1,121 @@
+/*
+ * 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/detail/StaticSingletonManager.h>
+
+#include <folly/lang/Keep.h>
+#include <folly/portability/GTest.h>
+
+namespace folly {
+namespace detail {
+
+FOLLY_ATTR_WEAK void check_doit() {}
+
+namespace {
+template <bool Noexcept>
+struct MayThrow {
+  FOLLY_NOINLINE MayThrow() noexcept(Noexcept) { check_doit(); }
+  FOLLY_NOINLINE ~MayThrow() { check_doit(); }
+};
+} // namespace
+
+extern "C" FOLLY_KEEP int* check() {
+  return &createGlobal<int, void>();
+}
+
+extern "C" FOLLY_KEEP void* check_throw() {
+  return &createGlobal<MayThrow<false>, void>();
+}
+
+extern "C" FOLLY_KEEP void* check_nothrow() {
+  return &createGlobal<MayThrow<true>, void>();
+}
+
+template <typename Impl>
+struct StaticSingletonManagerTest : public testing::TestWithParam<Impl> {};
+TYPED_TEST_SUITE_P(StaticSingletonManagerTest);
+
+template <typename Impl, typename T>
+struct Tag {};
+
+template <int I>
+using Int = std::integral_constant<int, I>;
+
+TYPED_TEST_P(StaticSingletonManagerTest, example) {
+  using K = TypeParam;
+
+  using T = std::integral_constant<int, 3>;
+
+  auto& i = K::template create<T, Tag<K, char>>();
+  EXPECT_EQ(T::value, i);
+
+  auto& j = K::template create<T, Tag<K, char>>();
+  EXPECT_EQ(&i, &j);
+  EXPECT_EQ(T::value, j);
+
+  auto& k = K::template create<T, Tag<K, char*>>();
+  EXPECT_NE(&i, &k);
+  EXPECT_EQ(T::value, k);
+
+  typename K::template ArgCreate<true> m_arg{tag<T, Tag<K, int>>};
+  EXPECT_EQ(nullptr, K::template get_existing_cached<T>(m_arg));
+  EXPECT_EQ(nullptr, K::template get_existing<T>(m_arg));
+
+  auto& m = K::template create<T>(m_arg);
+  EXPECT_NE(&i, &m);
+  EXPECT_EQ(T::value, m);
+  EXPECT_EQ(&m, K::template get_existing_cached<T>(m_arg));
+  EXPECT_EQ(&m, K::template get_existing<T>(m_arg));
+
+  typename K::template ArgCreate<true> n_arg{tag<T, Tag<K, int>>};
+  EXPECT_EQ(nullptr, K::template get_existing_cached<T>(n_arg));
+  EXPECT_EQ(&m, K::template get_existing<T>(n_arg));
+  EXPECT_EQ(&m, &K::template create<T>(n_arg));
+}
+
+REGISTER_TYPED_TEST_SUITE_P( //
+    StaticSingletonManagerTest,
+    example);
+
+INSTANTIATE_TYPED_TEST_SUITE_P(
+    sans_rtti, StaticSingletonManagerTest, StaticSingletonManagerSansRtti);
+#if FOLLY_HAS_RTTI
+INSTANTIATE_TYPED_TEST_SUITE_P(
+    with_rtti, StaticSingletonManagerTest, StaticSingletonManagerWithRtti);
+#endif
+struct StaticSingletonManagerTestType : StaticSingletonManager {};
+INSTANTIATE_TYPED_TEST_SUITE_P(
+    selection, StaticSingletonManagerTest, StaticSingletonManagerTestType);
+
+struct CreateGlobalTest : testing::Test {};
+
+TEST_F(CreateGlobalTest, example) {
+  using T = std::integral_constant<int, 3>;
+
+  auto& i = createGlobal<T, Tag<void, char>>();
+  EXPECT_EQ(T::value, i);
+
+  auto& j = createGlobal<T, Tag<void, char>>();
+  EXPECT_EQ(&i, &j);
+  EXPECT_EQ(T::value, j);
+
+  auto& k = createGlobal<T, Tag<void, char*>>();
+  EXPECT_NE(&i, &k);
+  EXPECT_EQ(T::value, k);
+}
+
+} // namespace detail
+} // namespace folly

package/external/folly/folly/detail/test/ThreadLocalBenchmark.cpp

@@ -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.
+ */
+
+#include <thread>
+
+#include <folly/Benchmark.h>
+#include <folly/ThreadLocal.h>
+#include <folly/synchronization/test/Barrier.h>
+
+using namespace folly;
+
+namespace folly {
+namespace threadlocal_detail {
+
+template <typename Tag>
+struct ThreadLocalTestHelper {
+  using Meta = StaticMeta<Tag, void>;
+  using TLElem = ThreadLocal<int, Tag>;
+  std::vector<TLElem> elements;
+};
+
+void measureAccessAllThreads(
+    int iters, uint32_t totalThreads, uint32_t tlCount, uint32_t spreadPerTL) {
+  struct Tag {};
+
+  ThreadLocalTestHelper<Tag> helper;
+
+  std::vector<std::thread> threads;
+  std::vector<std::unique_ptr<test::Barrier>> threadBarriers;
+  test::Barrier allThreadsBarriers{static_cast<size_t>(totalThreads + 1)};
+
+  BENCHMARK_SUSPEND {
+    helper.elements.reserve(tlCount);
+    for (uint32_t i = 0; i < tlCount; ++i) {
+      helper.elements.push_back({});
+    }
+    for (uint32_t i = 0; i < totalThreads; ++i) {
+      threadBarriers.push_back(std::make_unique<test::Barrier>(2));
+      threads.push_back(std::thread([&, index = i]() {
+        for (uint32_t tlIdx = 0; tlIdx < tlCount; ++tlIdx) {
+          uint32_t startIndex = tlIdx % totalThreads;
+          uint32_t endIndex = (tlIdx + spreadPerTL) % totalThreads;
+          if (startIndex < endIndex) {
+            if (index >= startIndex && index <= endIndex) {
+              *helper.elements[tlIdx] = tlIdx;
+            }
+          } else {
+            if (!(index >= endIndex && index <= startIndex)) {
+              *helper.elements[tlIdx] = tlIdx;
+            }
+          }
+        }
+        allThreadsBarriers.wait();
+        threadBarriers[index]->wait();
+      }));
+    }
+
+    // Wait for all threads to start.
+    allThreadsBarriers.wait();
+  }
+
+  [[maybe_unused]] uint64_t countFound = 0;
+  [[maybe_unused]] uint64_t sum = 0;
+  for (int32_t k = 0; k < iters; k++) {
+    for (uint32_t i = 0; i < tlCount; ++i) {
+      for (auto& elem : helper.elements[i].accessAllThreads()) {
+        sum += elem;
+        countFound++;
+      }
+    }
+  }
+
+  BENCHMARK_SUSPEND {
+    while (!threads.empty()) {
+      threadBarriers.back()->wait();
+      threads.back().join();
+      threads.pop_back();
+      threadBarriers.pop_back();
+    }
+  }
+}
+
+} // namespace threadlocal_detail
+} // namespace folly
+
+void accessAllThreads(
+    int iters, uint32_t totalThreads, uint32_t tlCount, uint32_t spreadPerTL) {
+  folly::threadlocal_detail::measureAccessAllThreads(
+      iters, totalThreads, tlCount, spreadPerTL);
+}
+
+BENCHMARK_DRAW_LINE();
+BENCHMARK_NAMED_PARAM(accessAllThreads, 100t_100c_1s, 100, 100, 1)
+BENCHMARK_NAMED_PARAM(accessAllThreads, 100t_10000c_10s, 100, 10000, 10)
+BENCHMARK_NAMED_PARAM(accessAllThreads, 1000t_1000c_25s, 1000, 1000, 25)
+BENCHMARK_NAMED_PARAM(accessAllThreads, 2000t_20000c_50s, 2000, 20000, 50)
+BENCHMARK_DRAW_LINE();
+
+int main(int argc, char* argv[]) {
+  gflags::ParseCommandLineFlags(&argc, &argv, true);
+  folly::runBenchmarks();
+  return 0;
+}

package/external/folly/folly/detail/test/ThreadLocalDetailTest.cpp

@@ -0,0 +1,194 @@
+/*
+ * 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 <thread>
+#include <folly/Synchronized.h>
+#include <folly/ThreadLocal.h>
+#include <folly/portability/GTest.h>
+#include <folly/synchronization/test/Barrier.h>
+
+namespace folly {
+namespace threadlocal_detail {
+
+class ThreadLocalDetailTest : public ::testing::Test {};
+
+template <typename Tag>
+struct ThreadLocalTestHelper {
+  using Meta = StaticMeta<Tag, void>;
+  using TLElem = ThreadLocal<int, Tag>;
+  std::vector<TLElem> elements;
+};
+
+TEST_F(ThreadLocalDetailTest, Basic) {
+  struct Tag {};
+
+  ThreadLocalTestHelper<Tag> helper;
+  auto& meta = ThreadLocalTestHelper<Tag>::Meta::instance();
+
+  // No TL object created. Count should be 0.
+  ASSERT_EQ(meta.totalElementWrappers_.load(), 0);
+
+  const int32_t count = 16;
+  helper.elements.reserve(count);
+  for (int32_t i = 0; i < count; ++i) {
+    helper.elements.push_back({});
+  }
+
+  // TL wrapper obejcts created but no thread has accessed its
+  // local copy. Wrappers should still be 0.
+  ASSERT_EQ(meta.totalElementWrappers_.load(), 0);
+
+  // Access 1st element. A wrapper array will be allocated. One for
+  // the current thread. Vector growth is not precise to minimize churn. Can
+  // only check it should be >= 1.
+  *helper.elements[0] = 0;
+  ASSERT_GE(meta.totalElementWrappers_.load(), 1);
+  ;
+
+  for (int32_t i = 0; i < count; ++i) {
+    *helper.elements[i] = i;
+  }
+  ASSERT_GE(meta.totalElementWrappers_.load(), count);
+  ;
+}
+
+// Test the totalElementWrappers_ grows and shrinks as threads come and go.
+TEST_F(ThreadLocalDetailTest, MultiThreadedTest) {
+  struct Tag {};
+
+  ThreadLocalTestHelper<Tag> helper;
+  auto& meta = ThreadLocalTestHelper<Tag>::Meta::instance();
+
+  const int32_t count = 1000;
+  helper.elements.reserve(count);
+  for (int32_t i = 0; i < count; ++i) {
+    helper.elements.push_back({});
+  }
+  ASSERT_EQ(meta.totalElementWrappers_.load(), 0);
+
+  for (int32_t i = 0; i < count; ++i) {
+    *helper.elements[i] = i;
+  }
+  ASSERT_GE(meta.totalElementWrappers_.load(), count);
+
+  std::vector<std::thread> threads;
+  std::vector<std::unique_ptr<test::Barrier>> threadBarriers(count);
+  test::Barrier allThreadsBarriers{count + 1};
+
+  for (int32_t i = 0; i < count; ++i) {
+    threadBarriers[i] = std::make_unique<test::Barrier>(2);
+    threads.push_back(std::thread([&, index = i]() {
+      // This thread's vector will sized to have index elements at least.
+      *helper.elements[index] = index;
+      allThreadsBarriers.wait();
+      threadBarriers[index]->wait();
+    }));
+  }
+
+  // Wait for all threads to start.
+  allThreadsBarriers.wait();
+
+  // check totalElementWrappers_ is within expected range. Due to vector growth,
+  // we cannot assume precise counts but can use a crude range. Thread i touches
+  // thread local with index i, and its array should be a bit over i in size.
+  // Total count will be count (baseline) plus summation(i) for i over
+  // range(num threads).
+  auto lowerBound = [](int32_t numThreads) {
+    return numThreads * (numThreads - 1) / 2 + (count);
+  };
+
+  auto upperBound = [](int32_t numThreads) { return (numThreads + 2) * count; };
+
+  int32_t threadBarriersIndex = count - 1;
+  while (!threads.empty()) {
+    ASSERT_GE(meta.totalElementWrappers_.load(), lowerBound(threads.size()));
+    ASSERT_LE(meta.totalElementWrappers_.load(), upperBound(threads.size()));
+    threadBarriers[threadBarriersIndex]->wait();
+    threads.back().join();
+    threads.pop_back();
+    threadBarriersIndex -= 1;
+  }
+}
+
+// Test the totalElementWrappers_ is stable if TL variables come and go.
+TEST_F(ThreadLocalDetailTest, TLObjectsChurn) {
+  struct Tag {};
+
+  Synchronized<ThreadLocalTestHelper<Tag>> helper;
+  auto& meta = ThreadLocalTestHelper<Tag>::Meta::instance();
+
+  const int32_t count = 1000;
+  helper.wlock()->elements.reserve(count);
+  for (int32_t i = 0; i < count; ++i) {
+    helper.wlock()->elements.push_back({});
+  }
+  ASSERT_EQ(meta.totalElementWrappers_.load(), 0);
+
+  for (int32_t i = 0; i < count; ++i) {
+    *helper.wlock()->elements[i] = i;
+  }
+  ASSERT_GE(meta.totalElementWrappers_.load(), count);
+
+  std::vector<std::thread> threads;
+  std::vector<std::unique_ptr<test::Barrier>> threadBarriers;
+  test::Barrier allThreadsBarriers{count + 1};
+
+  for (int32_t i = 0; i < count; ++i) {
+    threadBarriers.push_back(std::make_unique<test::Barrier>(2));
+    threads.push_back(std::thread([&, index = i]() {
+      *helper.wlock()->elements[index] = index;
+      allThreadsBarriers.wait();
+
+      // wait once for main thread to replace the index entry with a new TL
+      // variable.
+      threadBarriers[index]->wait();
+      // This thread's vector will sized to have index elements at least.
+      *helper.wlock()->elements[index] = index;
+      // Wait to exit.
+      allThreadsBarriers.wait();
+    }));
+  }
+
+  // Wait for all threads to start.
+  allThreadsBarriers.wait();
+
+  auto lowerBound = [](int32_t numThreads) {
+    return numThreads * (numThreads - 1) / 2 + (count);
+  };
+
+  auto upperBound = [](int32_t numThreads) { return (numThreads + 2) * count; };
+
+  // Replace each element with a new one. Overall wrappers should stay stable as
+  // freed up id get recycled.
+  for (int32_t i = 0; i < count; ++i) {
+    helper.wlock()->elements[i] = {};
+    *helper.wlock()->elements[i] = 0;
+    ASSERT_EQ(meta.nextId_, count + 1);
+    threadBarriers[i]->wait();
+    ASSERT_GE(meta.totalElementWrappers_.load(), lowerBound(threads.size()));
+    ASSERT_LE(meta.totalElementWrappers_.load(), upperBound(threads.size()));
+  }
+
+  allThreadsBarriers.wait();
+  for (int32_t i = 0; i < count; ++i) {
+    threads[i].join();
+  }
+  threads.clear();
+  threadBarriers.clear();
+}
+
+} // namespace threadlocal_detail
+} // namespace folly

package/external/folly/folly/detail/test/TrapOnAvx512TestNegative.cpp

@@ -0,0 +1,29 @@
+/*
+ * 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/detail/TrapOnAvx512.h>
+
+#include <folly/portability/GTest.h>
+
+namespace folly::detail {
+
+// This target is not built with BOLT `--trap-avx512`, so it should always
+// return false (including on non-x64 platforms).
+TEST(TrapOnAvx512TestNegative, Basic) {
+  ASSERT_FALSE(hasTrapOnAvx512());
+}
+
+} // namespace folly::detail

package/external/folly/folly/detail/test/UniqueInstanceTest.cpp

@@ -0,0 +1,60 @@
+/*
+ * 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/detail/UniqueInstance.h>
+
+#include <tuple>
+
+#include <folly/String.h>
+#include <folly/Traits.h>
+#include <folly/portability/GTest.h>
+
+struct Key1;
+struct Key2;
+struct TagA;
+struct TagB;
+
+template <typename...>
+struct Template0 {};
+template <typename...>
+struct Template1 {};
+
+namespace folly {
+namespace detail {
+
+class UniqueInstanceDeathTest : public testing::Test {};
+
+template <template <typename...> class Z, typename... Key, typename... Mapped>
+static void make(tag_t<Key...> key, tag_t<Mapped...> mapped) {
+  std::ignore = UniqueInstance{tag<Z<Key..., Mapped...>>, key, mapped};
+}
+
+TEST_F(UniqueInstanceDeathTest, basic) {
+  make<Template0>(tag<Key1, Key2>, tag<TagA, TagB>);
+  make<Template0>(tag<Key1, Key2>, tag<TagA, TagB>); // same everything
+  make<Template1>(tag<Key1, Key2>, tag<TagA, TagB>); // different name
+  make<Template0>(tag<Key2, Key1>, tag<TagA, TagB>); // different key
+  EXPECT_DEATH( // different mapped
+      make<Template0>(tag<Key1, Key2>, tag<TagB, TagA>),
+      stripLeftMargin(R"MESSAGE(
+        Overloaded unique instance over <Key1, Key2, ...> with differing trailing arguments:
+          Template0<Key1, Key2, TagA, TagB>
+          Template0<Key1, Key2, TagB, TagA>
+      )MESSAGE"));
+}
+
+} // namespace detail
+} // namespace folly

package/external/folly/folly/detail/thread_local_globals.cpp

@@ -0,0 +1,69 @@
+/*
+ * 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/detail/thread_local_globals.h>
+
+#include <system_error>
+
+#include <folly/detail/StaticSingletonManager.h>
+#include <folly/lang/Exception.h>
+#include <folly/portability/PThread.h>
+
+namespace folly::detail {
+
+namespace {
+
+/// thread_is_dying_global
+///
+/// This is a hack. The C runtime library provides no indication that a thread
+/// has ended the phase where thread_local variables may be destroyed. Were it
+/// to provide that indication, that would be used instead. Relies on library
+/// facilities which have signal to mark that a thread is dying.
+///
+/// In glibc, in the shutdown phase, start_thread first calls __call_tls_dtors,
+/// which runs destructors of thread_local variables, and then immediately calls
+/// __nptl_deallocate_tsd, which runs destructors of pthread thread-specific
+/// variables. There is no other indication of state change in the current
+/// thread.
+///
+/// https://github.com/bminor/glibc/blob/glibc-2.39/nptl/pthread_create.c#L451-L455
+struct thread_is_dying_global {
+  pthread_key_t key{};
+
+  thread_is_dying_global() {
+    int ret = pthread_key_create(&key, nullptr);
+    if (ret != 0) {
+      throw_exception<std::system_error>(
+          ret, std::generic_category(), "pthread_key_create failed");
+    }
+  }
+};
+
+} // namespace
+
+bool thread_is_dying() {
+  auto& global = createGlobal<thread_is_dying_global, void>();
+  return !!pthread_getspecific(global.key);
+}
+
+void thread_is_dying_mark() {
+  auto& global = createGlobal<thread_is_dying_global, void>();
+  if (!pthread_getspecific(global.key)) {
+    pthread_setspecific(global.key, &global.key);
+  }
+}
+
+} // namespace folly::detail

package/external/folly/folly/detail/thread_local_globals.h

@@ -0,0 +1,36 @@
+/*
+ * 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
+
+namespace folly::detail {
+
+/// thread_is_dying
+///
+/// Queries whether the current thread is dying, as marked by companion function
+/// thread_is_dying_mark.
+///
+/// Useful to avoid constructing non-trivially-destructible thread_local
+/// variables, since they must later be destroyed.
+[[nodiscard]] bool thread_is_dying();
+
+/// thread_is_dying_mark
+///
+/// Marks the current thread as dying, to be queried by companion function
+/// thread_is_dying.
+void thread_is_dying_mark();
+
+} // namespace folly::detail