fix seeding in folly::Random

Summary: Just generate from the random device directly, bypassing `std::seed_seq`.

Reviewed By: Orvid

Differential Revision: D92200312

fbshipit-source-id: 21ff184f6301673f4a1a5abf1baaadabca66410c

Author: yfeldblum

third-party/folly/src/folly/Random-inl.h

@@ -22,65 +22,28 @@ namespace folly {
 
 namespace detail {
 
-// Return the state size needed by RNG, expressed as a number of uint32_t
-// integers. Specialized for all templates specified in the C++11 standard.
-// For some (mersenne_twister_engine), this is exported as a state_size static
-// data member; for others, the standard shows formulas.
-
-template <class RNG, typename = void>
-struct StateSize {
-  // A sane default.
-  using type = std::integral_constant<size_t, 512>;
-};
-
-template <class RNG>
-struct StateSize<RNG, void_t<decltype(RNG::state_size)>> {
-  using type = std::integral_constant<size_t, RNG::state_size>;
-};
-
-template <class UIntType, UIntType a, UIntType c, UIntType m>
-struct StateSize<std::linear_congruential_engine<UIntType, a, c, m>> {
-  // From the standard [rand.eng.lcong], this is ceil(log2(m) / 32) + 3,
-  // which is the same as ceil(ceil(log2(m) / 32) + 3, and
-  // ceil(log2(m)) <= std::numeric_limits<UIntType>::digits
-  using type = std::integral_constant<
-      size_t,
-      (std::numeric_limits<UIntType>::digits + 31) / 32 + 3>;
-};
-
-template <class UIntType, size_t w, size_t s, size_t r>
-struct StateSize<std::subtract_with_carry_engine<UIntType, w, s, r>> {
-  // [rand.eng.sub]: r * ceil(w / 32)
-  using type = std::integral_constant<size_t, r*((w + 31) / 32)>;
-};
-
-template <typename RNG>
-using StateSizeT = _t<StateSize<RNG>>;
-
-template <class RNG>
-struct SeedData {
-  SeedData() {
-    Random::secureRandom(seedData.data(), seedData.size() * sizeof(uint32_t));
+struct SeedSeqSecureRandom {
+  using result_type = uint32_t;
+  template <typename Word>
+  void generate(Word* b, Word* e) {
+    static_assert(is_non_bool_integral_v<Word>);
+    static_assert(sizeof(Word) >= sizeof(result_type));
+    Random::secureRandom(b, (e - b) * sizeof(Word));
   }
-
-  static constexpr size_t stateSize = StateSizeT<RNG>::value;
-  std::array<uint32_t, stateSize> seedData;
 };
 
 } // namespace detail
 
 template <class RNG, class /* EnableIf */>
 void Random::seed(RNG& rng) {
-  detail::SeedData<RNG> sd;
-  std::seed_seq s(std::begin(sd.seedData), std::end(sd.seedData));
-  rng.seed(s);
+  detail::SeedSeqSecureRandom seq;
+  rng.seed(seq);
 }
 
 template <class RNG, class /* EnableIf */>
 auto Random::create() -> RNG {
-  detail::SeedData<RNG> sd;
-  std::seed_seq s(std::begin(sd.seedData), std::end(sd.seedData));
-  return RNG(s);
+  detail::SeedSeqSecureRandom seq;
+  return RNG(seq);
 }
 
 } // namespace folly

third-party/folly/src/folly/test/RandomTest.cpp

@@ -36,19 +36,6 @@
 
 using namespace folly;
 
-TEST(Random, StateSize) {
-  using namespace folly::detail;
-
-  // uint_fast32_t is uint64_t on x86_64, w00t
-  EXPECT_EQ(
-      sizeof(uint_fast32_t) / 4 + 3, StateSizeT<std::minstd_rand0>::value);
-  EXPECT_EQ(624, StateSizeT<std::mt19937>::value);
-#if FOLLY_HAVE_EXTRANDOM_SFMT19937
-  EXPECT_EQ(624, StateSizeT<__gnu_cxx::sfmt19937>::value);
-#endif
-  EXPECT_EQ(24, StateSizeT<std::ranlux24_base>::value);
-}
-
 TEST(Random, Simple) {
   uint32_t prev = 0, seed = 0;
   for (int i = 0; i < 1024; ++i) {