fix accidentally-quadratic complexity of ThreadEntrySet ops in debug

Summary:
`ThreadEntrySet::basicSanity()` is linear in the size of the entry-set, and is invoked on every mutation to (and test of!) the entry-set in debug. A sequence of `N` ops then has quadratic complexity `O(N^2)`.

As one possible resolution, we scan the entry-set once once every `log(N) / N` times, so that `N` ops has complexity `O(N log(N))` rather than `O(N^2)`. And we randomize the scan so that deterministic bugs may be surfaced that would evade a deterministic scan algorithm.

Differential Revision: D66733958

fbshipit-source-id: fb91bf834e6a9221ef012fc8f8cad064b2a8c26c

folly/detail/BUCK

@@ -311,6 +311,8 @@ cpp_library(
     headers = ["ThreadLocalDetail.h"],
     deps = [
         ":thread_local_globals",
+        "//folly:constexpr_math",
+        "//folly:utility",
         "//folly/lang:hint",
         "//folly/memory:sanitize_leak",
         "//folly/synchronization:call_once",

folly/detail/ThreadLocalDetail.cpp

@@ -19,7 +19,10 @@
 #include <algorithm>
 #include <list>
 #include <mutex>
+#include <random>
 
+#include <folly/ConstexprMath.h>
+#include <folly/Utility.h>
 #include <folly/detail/thread_local_globals.h>
 #include <folly/lang/Hint.h>
 #include <folly/memory/SanitizeLeak.h>
@@ -31,6 +34,13 @@ constexpr auto kBigGrowthFactor = 1.7;
 namespace folly {
 namespace threadlocal_detail {
 
+struct rand_engine {
+  using result_type = unsigned int;
+  result_type operator()() { return to_unsigned(std::rand()); }
+  static constexpr result_type min() { return 0; }
+  static constexpr result_type max() { return RAND_MAX; }
+};
+
 SharedPtrDeleter::SharedPtrDeleter(std::shared_ptr<void> const& ts) noexcept
     : ts_{ts} {}
 SharedPtrDeleter::SharedPtrDeleter(SharedPtrDeleter const& that) noexcept
@@ -48,8 +58,22 @@ uintptr_t ElementWrapper::castForgetAlign(DeleterFunType* f) noexcept {
 }
 
 bool ThreadEntrySet::basicSanity() const {
+  if constexpr (!kIsDebug) {
+    return true;
+  }
+  if (threadEntries.empty() && entryToVectorSlot.empty()) {
+    return true;
+  }
+  if (threadEntries.size() != entryToVectorSlot.size()) {
+    return false;
+  }
+  auto const size = threadEntries.size();
+  rand_engine rng;
+  std::uniform_int_distribution<size_t> dist{0, size - 1};
+  if (dist(rng) < constexpr_log2(size)) {
+    return true;
+  }
   return //
-      threadEntries.size() == entryToVectorSlot.size() &&
       std::all_of(
           entryToVectorSlot.begin(),
           entryToVectorSlot.end(),