Use absl::InsecureBitGen in place of std::random_device in Abseil tests.

PiperOrigin-RevId: 750721356
Change-Id: I84e8a1c2a80335983e557270ef78b8b0b4f1e452

Author: laramiel

absl/algorithm/BUILD.bazel

@@ -83,6 +83,7 @@ cc_test(
         "//absl/base:config",
         "//absl/base:core_headers",
         "//absl/memory",
+        "//absl/random",
         "//absl/types:span",
         "@googletest//:gtest",
         "@googletest//:gtest_main",

absl/algorithm/CMakeLists.txt

@@ -68,6 +68,7 @@ absl_cc_test(
     absl::config
     absl::core_headers
     absl::memory
+    absl::random_random
     absl::span
     GTest::gmock_main
 )

absl/algorithm/container_test.cc

@@ -16,6 +16,7 @@
 
 #include <algorithm>
 #include <array>
+#include <cstddef>
 #include <functional>
 #include <initializer_list>
 #include <iterator>
@@ -35,6 +36,7 @@
 #include "absl/base/config.h"
 #include "absl/base/macros.h"
 #include "absl/memory/memory.h"
+#include "absl/random/random.h"
 #include "absl/types/span.h"
 
 namespace {
@@ -986,25 +988,16 @@ TEST(MutatingTest, RotateCopy) {
   EXPECT_THAT(actual, ElementsAre(3, 4, 1, 2, 5));
 }
 
-template <typename T>
-T RandomlySeededPrng() {
-  std::random_device rdev;
-  std::seed_seq::result_type data[T::state_size];
-  std::generate_n(data, T::state_size, std::ref(rdev));
-  std::seed_seq prng_seed(data, data + T::state_size);
-  return T(prng_seed);
-}
-
 TEST(MutatingTest, Shuffle) {
   std::vector<int> actual = {1, 2, 3, 4, 5};
-  absl::c_shuffle(actual, RandomlySeededPrng<std::mt19937_64>());
+  absl::c_shuffle(actual, absl::InsecureBitGen());
   EXPECT_THAT(actual, UnorderedElementsAre(1, 2, 3, 4, 5));
 }
 
 TEST(MutatingTest, Sample) {
   std::vector<int> actual;
   absl::c_sample(std::vector<int>{1, 2, 3, 4, 5}, std::back_inserter(actual), 3,
-                 RandomlySeededPrng<std::mt19937_64>());
+                 absl::InsecureBitGen());
   EXPECT_THAT(actual, IsSubsetOf({1, 2, 3, 4, 5}));
   EXPECT_THAT(actual, SizeIs(3));
 }

absl/container/BUILD.bazel

@@ -494,6 +494,7 @@ cc_library(
         "//absl/base:no_destructor",
         "//absl/memory",
         "//absl/meta:type_traits",
+        "//absl/random",
         "//absl/strings",
     ],
 )
@@ -625,6 +626,7 @@ cc_test(
         "//absl/base:config",
         "//absl/base:core_headers",
         "//absl/profiling:sample_recorder",
+        "//absl/random",
         "//absl/synchronization",
         "//absl/synchronization:thread_pool",
         "//absl/time",
@@ -785,6 +787,7 @@ cc_test(
         "//absl/memory",
         "//absl/meta:type_traits",
         "//absl/numeric:int128",
+        "//absl/random",
         "//absl/strings",
         "//absl/types:optional",
         "@googletest//:gtest",

absl/container/CMakeLists.txt

@@ -543,6 +543,7 @@ absl_cc_library(
     absl::memory
     absl::meta
     absl::no_destructor
+    absl::random_random
     absl::strings
   TESTONLY
 )
@@ -658,6 +659,7 @@ absl_cc_test(
   DEPS
     absl::config
     absl::hashtablez_sampler
+    absl::random_random
     GTest::gmock_main
 )
 
@@ -824,6 +826,7 @@ absl_cc_test(
     absl::node_hash_set
     absl::optional
     absl::prefetch
+    absl::random_random
     absl::raw_hash_set
     absl::strings
     absl::test_allocator

absl/container/internal/hash_generator_testing.cc

@@ -14,61 +14,39 @@
 
 #include "absl/container/internal/hash_generator_testing.h"
 
+#include <algorithm>
 #include <deque>
+#include <random>
+#include <string>
 
 #include "absl/base/no_destructor.h"
+#include "absl/random/random.h"
+#include "absl/strings/string_view.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 namespace hash_internal {
-namespace {
-
-class RandomDeviceSeedSeq {
- public:
-  using result_type = typename std::random_device::result_type;
-
-  template <class Iterator>
-  void generate(Iterator start, Iterator end) {
-    while (start != end) {
-      *start = gen_();
-      ++start;
-    }
-  }
-
- private:
-  std::random_device gen_;
-};
-
-}  // namespace
-
-std::mt19937_64* GetSharedRng() {
-  static absl::NoDestructor<std::mt19937_64> rng([] {
-    RandomDeviceSeedSeq seed_seq;
-    return std::mt19937_64(seed_seq);
-  }());
-  return rng.get();
-}
 
 std::string Generator<std::string>::operator()() const {
+  absl::InsecureBitGen gen;
   // NOLINTNEXTLINE(runtime/int)
   std::uniform_int_distribution<short> chars(0x20, 0x7E);
   std::string res;
   res.resize(32);
-  std::generate(res.begin(), res.end(),
-                [&]() { return chars(*GetSharedRng()); });
+  std::generate(res.begin(), res.end(), [&]() { return chars(gen); });
   return res;
 }
 
 absl::string_view Generator<absl::string_view>::operator()() const {
   static absl::NoDestructor<std::deque<std::string>> arena;
+  absl::InsecureBitGen gen;
   // NOLINTNEXTLINE(runtime/int)
   std::uniform_int_distribution<short> chars(0x20, 0x7E);
   arena->emplace_back();
   auto& res = arena->back();
   res.resize(32);
-  std::generate(res.begin(), res.end(),
-                [&]() { return chars(*GetSharedRng()); });
+  std::generate(res.begin(), res.end(), [&]() { return chars(gen); });
   return res;
 }
 

absl/container/internal/hash_generator_testing.h

@@ -23,7 +23,9 @@
 #include <algorithm>
 #include <cassert>
 #include <iosfwd>
+#include <memory>
 #include <random>
+#include <string>
 #include <tuple>
 #include <type_traits>
 #include <utility>
@@ -32,6 +34,7 @@
 #include "absl/container/internal/hash_policy_testing.h"
 #include "absl/memory/memory.h"
 #include "absl/meta/type_traits.h"
+#include "absl/random/random.h"
 #include "absl/strings/string_view.h"
 
 namespace absl {
@@ -48,8 +51,6 @@ struct IsMap<Map, absl::void_t<typename Map::mapped_type>> : std::true_type {};
 
 }  // namespace generator_internal
 
-std::mt19937_64* GetSharedRng();
-
 enum Enum : uint64_t {
   kEnumEmpty,
   kEnumDeleted,
@@ -69,29 +70,27 @@ struct Generator;
 
 template <class T>
 struct Generator<T, typename std::enable_if<std::is_integral<T>::value>::type> {
-  T operator()() const {
-    std::uniform_int_distribution<T> dist;
-    return dist(*GetSharedRng());
-  }
+  T operator()() const { return dist(gen); }
+  mutable absl::InsecureBitGen gen;
+  mutable std::uniform_int_distribution<T> dist;
 };
 
 template <>
 struct Generator<Enum> {
-  Enum operator()() const {
-    std::uniform_int_distribution<typename std::underlying_type<Enum>::type>
-        dist;
-    return static_cast<Enum>(dist(*GetSharedRng()));
-  }
+  Enum operator()() const { return static_cast<Enum>(dist(gen)); }
+  mutable absl::InsecureBitGen gen;
+  mutable std::uniform_int_distribution<
+      typename std::underlying_type<Enum>::type>
+      dist;
 };
 
 template <>
 struct Generator<EnumClass> {
-  EnumClass operator()() const {
-    std::uniform_int_distribution<
-        typename std::underlying_type<EnumClass>::type>
-        dist;
-    return static_cast<EnumClass>(dist(*GetSharedRng()));
-  }
+  EnumClass operator()() const { return static_cast<EnumClass>(dist(gen)); }
+  mutable absl::InsecureBitGen gen;
+  mutable std::uniform_int_distribution<
+      typename std::underlying_type<EnumClass>::type>
+      dist;
 };
 
 template <>
@@ -135,17 +134,17 @@ struct Generator<std::unique_ptr<T>> {
 
 template <class U>
 struct Generator<U, absl::void_t<decltype(std::declval<U&>().key()),
-                                decltype(std::declval<U&>().value())>>
+                                 decltype(std::declval<U&>().value())>>
     : Generator<std::pair<
           typename std::decay<decltype(std::declval<U&>().key())>::type,
           typename std::decay<decltype(std::declval<U&>().value())>::type>> {};
 
 template <class Container>
-using GeneratedType = decltype(
-    std::declval<const Generator<
-        typename std::conditional<generator_internal::IsMap<Container>::value,
-                                  typename Container::value_type,
-                                  typename Container::key_type>::type>&>()());
+using GeneratedType =
+    decltype(std::declval<const Generator<typename std::conditional<
+                 generator_internal::IsMap<Container>::value,
+                 typename Container::value_type,
+                 typename Container::key_type>::type>&>()());
 
 // Naive wrapper that performs a linear search of previous values.
 // Beware this is O(SQR), which is reasonable for smaller kMaxValues.

absl/container/internal/hashtablez_sampler_test.cc

@@ -27,6 +27,7 @@
 #include "absl/base/attributes.h"
 #include "absl/base/config.h"
 #include "absl/profiling/internal/sample_recorder.h"
+#include "absl/random/random.h"
 #include "absl/synchronization/blocking_counter.h"
 #include "absl/synchronization/internal/thread_pool.h"
 #include "absl/synchronization/mutex.h"
@@ -439,8 +440,7 @@ TEST(HashtablezSamplerTest, MultiThreaded) {
     const size_t value_size = 13 + i % 5;
     pool.Schedule([&sampler, &stop, sampling_stride, elt_size, key_size,
                    value_size]() {
-      std::random_device rd;
-      std::mt19937 gen(rd());
+      absl::InsecureBitGen gen;
 
       std::vector<HashtablezInfo*> infoz;
       while (!stop.HasBeenNotified()) {

absl/container/internal/raw_hash_set_benchmark.cc

@@ -172,8 +172,7 @@ struct string_generator {
 //
 // On a table of size N, keep deleting the LRU entry and add a random one.
 void BM_CacheInSteadyState(benchmark::State& state) {
-  std::random_device rd;
-  std::mt19937 rng(rd());
+  absl::InsecureBitGen rng;
   string_generator gen{12};
   StringTable t;
   std::deque<std::string> keys;
@@ -250,8 +249,7 @@ void BM_EndComparison(benchmark::State& state) {
 BENCHMARK(BM_EndComparison);
 
 void BM_Iteration(benchmark::State& state) {
-  std::random_device rd;
-  std::mt19937 rng(rd());
+  absl::InsecureBitGen rng;
   string_generator gen{12};
   StringTable t;
 
@@ -293,8 +291,7 @@ BENCHMARK(BM_Iteration)
     ->ArgPair(1000, 10);
 
 void BM_CopyCtorSparseInt(benchmark::State& state) {
-  std::random_device rd;
-  std::mt19937 rng(rd());
+  absl::InsecureBitGen rng;
   IntTable t;
   std::uniform_int_distribution<uint64_t> dist(0, ~uint64_t{});
 
@@ -312,8 +309,7 @@ void BM_CopyCtorSparseInt(benchmark::State& state) {
 BENCHMARK(BM_CopyCtorSparseInt)->Range(1, 4096);
 
 void BM_CopyCtorInt(benchmark::State& state) {
-  std::random_device rd;
-  std::mt19937 rng(rd());
+  absl::InsecureBitGen rng;
   IntTable t;
   std::uniform_int_distribution<uint64_t> dist(0, ~uint64_t{});
 
@@ -330,8 +326,7 @@ void BM_CopyCtorInt(benchmark::State& state) {
 BENCHMARK(BM_CopyCtorInt)->Range(0, 4096);
 
 void BM_CopyCtorString(benchmark::State& state) {
-  std::random_device rd;
-  std::mt19937 rng(rd());
+  absl::InsecureBitGen rng;
   StringTable t;
   std::uniform_int_distribution<uint64_t> dist(0, ~uint64_t{});
 
@@ -348,8 +343,7 @@ void BM_CopyCtorString(benchmark::State& state) {
 BENCHMARK(BM_CopyCtorString)->Range(0, 4096);
 
 void BM_CopyAssign(benchmark::State& state) {
-  std::random_device rd;
-  std::mt19937 rng(rd());
+  absl::InsecureBitGen rng;
   IntTable t;
   std::uniform_int_distribution<uint64_t> dist(0, ~uint64_t{});
   while (t.size() < state.range(0)) {
@@ -365,8 +359,7 @@ void BM_CopyAssign(benchmark::State& state) {
 BENCHMARK(BM_CopyAssign)->Range(128, 4096);
 
 void BM_RangeCtor(benchmark::State& state) {
-  std::random_device rd;
-  std::mt19937 rng(rd());
+  absl::InsecureBitGen rng;
   std::uniform_int_distribution<uint64_t> dist(0, ~uint64_t{});
   std::vector<int> values;
   const size_t desired_size = state.range(0);

absl/container/internal/raw_hash_set_test.cc

@@ -53,6 +53,7 @@
 #include "absl/container/internal/container_memory.h"
 #include "absl/container/internal/hash_function_defaults.h"
 #include "absl/container/internal/hash_policy_testing.h"
+#include "absl/random/random.h"
 // TODO(b/382423690): Separate tests that depend only on
 // hashtable_control_bytes.
 #include "absl/container/internal/hashtable_control_bytes.h"
@@ -1922,8 +1923,7 @@ ProbeStats CollectProbeStatsOnLinearlyTransformedKeys(
     const std::vector<int64_t>& keys, size_t num_iters) {
   ProbeStats stats;
 
-  std::random_device rd;
-  std::mt19937 rng(rd());
+  absl::InsecureBitGen rng;
   auto linear_transform = [](size_t x, size_t y) { return x * 17 + y * 13; };
   std::uniform_int_distribution<size_t> dist(0, keys.size() - 1);
   while (num_iters--) {