grpc 1.46.3 → 1.53.1

data/third_party/abseil-cpp/absl/random/internal/randen_engine.h

@@ -42,7 +42,7 @@ namespace random_internal {
 // 'Strong' (well-distributed, unpredictable, backtracking-resistant) random
 // generator, faster in some benchmarks than std::mt19937_64 and pcg64_c32.
 template <typename T>
-class alignas(16) randen_engine {
+class alignas(8) randen_engine {
  public:
   // C++11 URBG interface:
   using result_type = T;
@@ -58,7 +58,8 @@ class alignas(16) randen_engine {
     return (std::numeric_limits<result_type>::max)();
   }
 
-  explicit randen_engine(result_type seed_value = 0) { seed(seed_value); }
+  randen_engine() : randen_engine(0) {}
+  explicit randen_engine(result_type seed_value) { seed(seed_value); }
 
   template <class SeedSequence,
             typename = typename absl::enable_if_t<
@@ -67,17 +68,27 @@ class alignas(16) randen_engine {
     seed(seq);
   }
 
-  randen_engine(const randen_engine&) = default;
+  // alignment requirements dictate custom copy and move constructors.
+  randen_engine(const randen_engine& other)
+      : next_(other.next_), impl_(other.impl_) {
+    std::memcpy(state(), other.state(), kStateSizeT * sizeof(result_type));
+  }
+  randen_engine& operator=(const randen_engine& other) {
+    next_ = other.next_;
+    impl_ = other.impl_;
+    std::memcpy(state(), other.state(), kStateSizeT * sizeof(result_type));
+    return *this;
+  }
 
   // Returns random bits from the buffer in units of result_type.
   result_type operator()() {
     // Refill the buffer if needed (unlikely).
+    auto* begin = state();
     if (next_ >= kStateSizeT) {
       next_ = kCapacityT;
-      impl_.Generate(state_);
+      impl_.Generate(begin);
     }
-
-    return little_endian::ToHost(state_[next_++]);
+    return little_endian::ToHost(begin[next_++]);
   }
 
   template <class SeedSequence>
@@ -92,9 +103,10 @@ class alignas(16) randen_engine {
   void seed(result_type seed_value = 0) {
     next_ = kStateSizeT;
     // Zeroes the inner state and fills the outer state with seed_value to
-    // mimics behaviour of reseed
-    std::fill(std::begin(state_), std::begin(state_) + kCapacityT, 0);
-    std::fill(std::begin(state_) + kCapacityT, std::end(state_), seed_value);
+    // mimic the behaviour of reseed
+    auto* begin = state();
+    std::fill(begin, begin + kCapacityT, 0);
+    std::fill(begin + kCapacityT, begin + kStateSizeT, seed_value);
   }
 
   // Inserts entropy into (part of) the state. Calling this periodically with
@@ -105,7 +117,6 @@ class alignas(16) randen_engine {
     using sequence_result_type = typename SeedSequence::result_type;
     static_assert(sizeof(sequence_result_type) == 4,
                   "SeedSequence::result_type must be 32-bit");
-
     constexpr size_t kBufferSize =
         Randen::kSeedBytes / sizeof(sequence_result_type);
     alignas(16) sequence_result_type buffer[kBufferSize];
@@ -119,8 +130,8 @@ class alignas(16) randen_engine {
     if (entropy_size < kBufferSize) {
       // ... and only request that many values, or 256-bits, when unspecified.
       const size_t requested_entropy = (entropy_size == 0) ? 8u : entropy_size;
-      std::fill(std::begin(buffer) + requested_entropy, std::end(buffer), 0);
-      seq.generate(std::begin(buffer), std::begin(buffer) + requested_entropy);
+      std::fill(buffer + requested_entropy, buffer + kBufferSize, 0);
+      seq.generate(buffer, buffer + requested_entropy);
 #ifdef ABSL_IS_BIG_ENDIAN
       // Randen expects the seed buffer to be in Little Endian; reverse it on
       // Big Endian platforms.
@@ -146,9 +157,9 @@ class alignas(16) randen_engine {
         std::swap(buffer[--dst], buffer[--src]);
       }
     } else {
-      seq.generate(std::begin(buffer), std::end(buffer));
+      seq.generate(buffer, buffer + kBufferSize);
     }
-    impl_.Absorb(buffer, state_);
+    impl_.Absorb(buffer, state());
 
     // Generate will be called when operator() is called
     next_ = kStateSizeT;
@@ -159,9 +170,10 @@ class alignas(16) randen_engine {
     count -= step;
 
     constexpr uint64_t kRateT = kStateSizeT - kCapacityT;
+    auto* begin = state();
     while (count > 0) {
       next_ = kCapacityT;
-      impl_.Generate(state_);
+      impl_.Generate(*reinterpret_cast<result_type(*)[kStateSizeT]>(begin));
       step = std::min<uint64_t>(kRateT, count);
       count -= step;
     }
@@ -169,9 +181,9 @@ class alignas(16) randen_engine {
   }
 
   bool operator==(const randen_engine& other) const {
+    const auto* begin = state();
     return next_ == other.next_ &&
-           std::equal(std::begin(state_), std::end(state_),
-                      std::begin(other.state_));
+           std::equal(begin, begin + kStateSizeT, other.state());
   }
 
   bool operator!=(const randen_engine& other) const {
@@ -185,11 +197,12 @@ class alignas(16) randen_engine {
     using numeric_type =
         typename random_internal::stream_format_type<result_type>::type;
     auto saver = random_internal::make_ostream_state_saver(os);
-    for (const auto& elem : engine.state_) {
+    auto* it = engine.state();
+    for (auto* end = it + kStateSizeT; it < end; ++it) {
       // In the case that `elem` is `uint8_t`, it must be cast to something
       // larger so that it prints as an integer rather than a character. For
       // simplicity, apply the cast all circumstances.
-      os << static_cast<numeric_type>(little_endian::FromHost(elem))
+      os << static_cast<numeric_type>(little_endian::FromHost(*it))
          << os.fill();
     }
     os << engine.next_;
@@ -215,7 +228,7 @@ class alignas(16) randen_engine {
     if (is.fail()) {
       return is;
     }
-    std::memcpy(engine.state_, state, sizeof(engine.state_));
+    std::memcpy(engine.state(), state, sizeof(state));
     engine.next_ = next;
     return is;
   }
@@ -226,9 +239,21 @@ class alignas(16) randen_engine {
   static constexpr size_t kCapacityT =
       Randen::kCapacityBytes / sizeof(result_type);
 
-  // First kCapacityT are `inner', the others are accessible random bits.
-  alignas(16) result_type state_[kStateSizeT];
-  size_t next_;  // index within state_
+  // Returns the state array pointer, which is aligned to 16 bytes.
+  // The first kCapacityT are the `inner' sponge; the remainder are available.
+  result_type* state() {
+    return reinterpret_cast<result_type*>(
+        (reinterpret_cast<uintptr_t>(&raw_state_) & 0xf) ? (raw_state_ + 8)
+                                                         : raw_state_);
+  }
+  const result_type* state() const {
+    return const_cast<randen_engine*>(this)->state();
+  }
+
+  // raw state array, manually aligned in state(). This overallocates
+  // by 8 bytes since C++ does not guarantee extended heap alignment.
+  alignas(8) char raw_state_[Randen::kStateBytes + 8];
+  size_t next_;  // index within state()
   Randen impl_;
 };
 

data/third_party/abseil-cpp/absl/random/internal/salted_seed_seq.h

@@ -22,6 +22,7 @@
 #include <memory>
 #include <type_traits>
 #include <utility>
+#include <vector>
 
 #include "absl/container/inlined_vector.h"
 #include "absl/meta/type_traits.h"
@@ -65,15 +66,19 @@ class SaltedSeedSeq {
 
   template <typename RandomAccessIterator>
   void generate(RandomAccessIterator begin, RandomAccessIterator end) {
+    using U = typename std::iterator_traits<RandomAccessIterator>::value_type;
+
     // The common case is that generate is called with ContiguousIterators
     // to uint arrays. Such contiguous memory regions may be optimized,
     // which we detect here.
-    using tag = absl::conditional_t<
-        (std::is_pointer<RandomAccessIterator>::value &&
-         std::is_same<absl::decay_t<decltype(*begin)>, uint32_t>::value),
+    using TagType = absl::conditional_t<
+        (std::is_same<U, uint32_t>::value &&
+         (std::is_pointer<RandomAccessIterator>::value ||
+          std::is_same<RandomAccessIterator,
+                       typename std::vector<U>::iterator>::value)),
         ContiguousAndUint32Tag, DefaultTag>;
     if (begin != end) {
-      generate_impl(begin, end, tag{});
+      generate_impl(TagType{}, begin, end, std::distance(begin, end));
     }
   }
 
@@ -89,8 +94,15 @@ class SaltedSeedSeq {
   struct DefaultTag {};
 
   // Generate which requires the iterators are contiguous pointers to uint32_t.
-  void generate_impl(uint32_t* begin, uint32_t* end, ContiguousAndUint32Tag) {
-    generate_contiguous(absl::MakeSpan(begin, end));
+  // Fills the initial seed buffer the underlying SSeq::generate() call,
+  // then mixes in the salt material.
+  template <typename Contiguous>
+  void generate_impl(ContiguousAndUint32Tag, Contiguous begin, Contiguous end,
+                     size_t n) {
+    seq_->generate(begin, end);
+    const uint32_t salt = absl::random_internal::GetSaltMaterial().value_or(0);
+    auto span = absl::Span<uint32_t>(&*begin, n);
+    MixIntoSeedMaterial(absl::MakeConstSpan(&salt, 1), span);
   }
 
   // The uncommon case for generate is that it is called with iterators over
@@ -98,27 +110,13 @@ class SaltedSeedSeq {
   // case we allocate a temporary 32-bit buffer and then copy-assign back
   // to the initial inputs.
   template <typename RandomAccessIterator>
-  void generate_impl(RandomAccessIterator begin, RandomAccessIterator end,
-                     DefaultTag) {
-    return generate_and_copy(std::distance(begin, end), begin);
-  }
-
-  // Fills the initial seed buffer the underlying SSeq::generate() call,
-  // mixing in the salt material.
-  void generate_contiguous(absl::Span<uint32_t> buffer) {
-    seq_->generate(buffer.begin(), buffer.end());
-    const uint32_t salt = absl::random_internal::GetSaltMaterial().value_or(0);
-    MixIntoSeedMaterial(absl::MakeConstSpan(&salt, 1), buffer);
-  }
-
-  // Allocates a seed buffer of `n` elements, generates the seed, then
-  // copies the result into the `out` iterator.
-  template <typename Iterator>
-  void generate_and_copy(size_t n, Iterator out) {
-    // Allocate a temporary buffer, generate, and then copy.
+  void generate_impl(DefaultTag, RandomAccessIterator begin,
+                     RandomAccessIterator, size_t n) {
+    // Allocates a seed buffer of `n` elements, generates the seed, then
+    // copies the result into the `out` iterator.
     absl::InlinedVector<uint32_t, 8> data(n, 0);
-    generate_contiguous(absl::MakeSpan(data.data(), data.size()));
-    std::copy(data.begin(), data.end(), out);
+    generate_impl(ContiguousAndUint32Tag{}, data.begin(), data.end(), n);
+    std::copy(data.begin(), data.end(), begin);
   }
 
   // Because [rand.req.seedseq] is not required to be copy-constructible,

data/third_party/abseil-cpp/absl/random/internal/seed_material.cc

@@ -173,12 +173,12 @@ bool ReadSeedMaterialFromDevURandom(absl::Span<uint32_t> values) {
   }
 
   while (success && buffer_size > 0) {
-    int bytes_read = read(dev_urandom, buffer, buffer_size);
+    ssize_t bytes_read = read(dev_urandom, buffer, buffer_size);
     int read_error = errno;
     success = (bytes_read > 0);
     if (success) {
       buffer += bytes_read;
-      buffer_size -= bytes_read;
+      buffer_size -= static_cast<size_t>(bytes_read);
     } else if (bytes_read == -1 && read_error == EINTR) {
       success = true;  // Need to try again.
     }

data/third_party/abseil-cpp/absl/random/internal/traits.h

@@ -20,6 +20,8 @@
 #include <type_traits>
 
 #include "absl/base/config.h"
+#include "absl/numeric/bits.h"
+#include "absl/numeric/int128.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
@@ -59,6 +61,31 @@ class is_widening_convertible {
       rank<A>() <= rank<B>();
 };
 
+template <typename T>
+struct IsIntegral : std::is_integral<T> {};
+template <>
+struct IsIntegral<absl::int128> : std::true_type {};
+template <>
+struct IsIntegral<absl::uint128> : std::true_type {};
+
+template <typename T>
+struct MakeUnsigned : std::make_unsigned<T> {};
+template <>
+struct MakeUnsigned<absl::int128> {
+  using type = absl::uint128;
+};
+template <>
+struct MakeUnsigned<absl::uint128> {
+  using type = absl::uint128;
+};
+
+template <typename T>
+struct IsUnsigned : std::is_unsigned<T> {};
+template <>
+struct IsUnsigned<absl::int128> : std::false_type {};
+template <>
+struct IsUnsigned<absl::uint128> : std::true_type {};
+
 // unsigned_bits<N>::type returns the unsigned int type with the indicated
 // number of bits.
 template <size_t N>
@@ -81,19 +108,40 @@ struct unsigned_bits<64> {
   using type = uint64_t;
 };
 
-#ifdef ABSL_HAVE_INTRINSIC_INT128
 template <>
 struct unsigned_bits<128> {
-  using type = __uint128_t;
+  using type = absl::uint128;
+};
+
+// 256-bit wrapper for wide multiplications.
+struct U256 {
+  uint128 hi;
+  uint128 lo;
+};
+template <>
+struct unsigned_bits<256> {
+  using type = U256;
 };
-#endif
 
 template <typename IntType>
 struct make_unsigned_bits {
-  using type = typename unsigned_bits<std::numeric_limits<
-      typename std::make_unsigned<IntType>::type>::digits>::type;
+  using type = typename unsigned_bits<
+      std::numeric_limits<typename MakeUnsigned<IntType>::type>::digits>::type;
 };
 
+template <typename T>
+int BitWidth(T v) {
+  // Workaround for bit_width not supporting int128.
+  // Don't hardcode `64` to make sure this code does not trigger compiler
+  // warnings in smaller types.
+  constexpr int half_bits = sizeof(T) * 8 / 2;
+  if (sizeof(T) == 16 && (v >> half_bits) != 0) {
+    return bit_width(static_cast<uint64_t>(v >> half_bits)) + half_bits;
+  } else {
+    return bit_width(static_cast<uint64_t>(v));
+  }
+}
+
 }  // namespace random_internal
 ABSL_NAMESPACE_END
 }  // namespace absl

data/third_party/abseil-cpp/absl/random/internal/uniform_helper.h

@@ -100,7 +100,7 @@ using uniform_inferred_return_t =
 template <typename IntType, typename Tag>
 typename absl::enable_if_t<
     absl::conjunction<
-        std::is_integral<IntType>,
+        IsIntegral<IntType>,
         absl::disjunction<std::is_same<Tag, IntervalOpenClosedTag>,
                           std::is_same<Tag, IntervalOpenOpenTag>>>::value,
     IntType>
@@ -131,7 +131,7 @@ uniform_lower_bound(Tag, NumType a, NumType) {
 template <typename IntType, typename Tag>
 typename absl::enable_if_t<
     absl::conjunction<
-        std::is_integral<IntType>,
+        IsIntegral<IntType>,
         absl::disjunction<std::is_same<Tag, IntervalClosedOpenTag>,
                           std::is_same<Tag, IntervalOpenOpenTag>>>::value,
     IntType>
@@ -153,7 +153,7 @@ uniform_upper_bound(Tag, FloatType, FloatType b) {
 template <typename IntType, typename Tag>
 typename absl::enable_if_t<
     absl::conjunction<
-        std::is_integral<IntType>,
+        IsIntegral<IntType>,
         absl::disjunction<std::is_same<Tag, IntervalClosedClosedTag>,
                           std::is_same<Tag, IntervalOpenClosedTag>>>::value,
     IntType>
@@ -201,7 +201,7 @@ is_uniform_range_valid(FloatType a, FloatType b) {
 }
 
 template <typename IntType>
-absl::enable_if_t<std::is_integral<IntType>::value, bool>
+absl::enable_if_t<IsIntegral<IntType>::value, bool>
 is_uniform_range_valid(IntType a, IntType b) {
   return a <= b;
 }
@@ -210,7 +210,7 @@ is_uniform_range_valid(IntType a, IntType b) {
 // or absl::uniform_real_distribution depending on the NumType parameter.
 template <typename NumType>
 using UniformDistribution =
-    typename std::conditional<std::is_integral<NumType>::value,
+    typename std::conditional<IsIntegral<NumType>::value,
                               absl::uniform_int_distribution<NumType>,
                               absl::uniform_real_distribution<NumType>>::type;
 

data/third_party/abseil-cpp/absl/random/internal/wide_multiply.h

@@ -34,43 +34,6 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace random_internal {
 
-// Helper object to multiply two 64-bit values to a 128-bit value.
-// MultiplyU64ToU128 multiplies two 64-bit values to a 128-bit value.
-// If an intrinsic is available, it is used, otherwise use native 32-bit
-// multiplies to construct the result.
-inline absl::uint128 MultiplyU64ToU128(uint64_t a, uint64_t b) {
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
-  return absl::uint128(static_cast<__uint128_t>(a) * b);
-#elif defined(ABSL_INTERNAL_USE_UMUL128)
-  // uint64_t * uint64_t => uint128 multiply using imul intrinsic on MSVC.
-  uint64_t high = 0;
-  const uint64_t low = _umul128(a, b, &high);
-  return absl::MakeUint128(high, low);
-#else
-  // uint128(a) * uint128(b) in emulated mode computes a full 128-bit x 128-bit
-  // multiply.  However there are many cases where that is not necessary, and it
-  // is only necessary to support a 64-bit x 64-bit = 128-bit multiply.  This is
-  // for those cases.
-  const uint64_t a00 = static_cast<uint32_t>(a);
-  const uint64_t a32 = a >> 32;
-  const uint64_t b00 = static_cast<uint32_t>(b);
-  const uint64_t b32 = b >> 32;
-
-  const uint64_t c00 = a00 * b00;
-  const uint64_t c32a = a00 * b32;
-  const uint64_t c32b = a32 * b00;
-  const uint64_t c64 = a32 * b32;
-
-  const uint32_t carry =
-      static_cast<uint32_t>(((c00 >> 32) + static_cast<uint32_t>(c32a) +
-                             static_cast<uint32_t>(c32b)) >>
-                            32);
-
-  return absl::MakeUint128(c64 + (c32a >> 32) + (c32b >> 32) + carry,
-                           c00 + (c32a << 32) + (c32b << 32));
-#endif
-}
-
 // wide_multiply<T> multiplies two N-bit values to a 2N-bit result.
 template <typename UIntType>
 struct wide_multiply {
@@ -82,27 +45,49 @@ struct wide_multiply {
     return static_cast<result_type>(a) * b;
   }
 
-  static input_type hi(result_type r) { return r >> kN; }
-  static input_type lo(result_type r) { return r; }
+  static input_type hi(result_type r) {
+    return static_cast<input_type>(r >> kN);
+  }
+  static input_type lo(result_type r) { return static_cast<input_type>(r); }
 
   static_assert(std::is_unsigned<UIntType>::value,
                 "Class-template wide_multiply<> argument must be unsigned.");
 };
 
-#ifndef ABSL_HAVE_INTRINSIC_INT128
+// MultiplyU128ToU256 multiplies two 128-bit values to a 256-bit value.
+inline U256 MultiplyU128ToU256(uint128 a, uint128 b) {
+  const uint128 a00 = static_cast<uint64_t>(a);
+  const uint128 a64 = a >> 64;
+  const uint128 b00 = static_cast<uint64_t>(b);
+  const uint128 b64 = b >> 64;
+
+  const uint128 c00 = a00 * b00;
+  const uint128 c64a = a00 * b64;
+  const uint128 c64b = a64 * b00;
+  const uint128 c128 = a64 * b64;
+
+  const uint64_t carry =
+      static_cast<uint64_t>(((c00 >> 64) + static_cast<uint64_t>(c64a) +
+                             static_cast<uint64_t>(c64b)) >>
+                            64);
+
+  return {c128 + (c64a >> 64) + (c64b >> 64) + carry,
+          c00 + (c64a << 64) + (c64b << 64)};
+}
+
+
 template <>
-struct wide_multiply<uint64_t> {
-  using input_type = uint64_t;
-  using result_type = absl::uint128;
+struct wide_multiply<uint128> {
+  using input_type = uint128;
+  using result_type = U256;
 
-  static result_type multiply(uint64_t a, uint64_t b) {
-    return MultiplyU64ToU128(a, b);
+  static result_type multiply(input_type a, input_type b) {
+    return MultiplyU128ToU256(a, b);
   }
 
-  static uint64_t hi(result_type r) { return absl::Uint128High64(r); }
-  static uint64_t lo(result_type r) { return absl::Uint128Low64(r); }
+  static input_type hi(result_type r) { return r.hi; }
+  static input_type lo(result_type r) { return r.lo; }
 };
-#endif
 
 }  // namespace random_internal
 ABSL_NAMESPACE_END

data/third_party/abseil-cpp/absl/random/log_uniform_int_distribution.h

@@ -69,10 +69,8 @@ class log_uniform_int_distribution {
       if (base_ == 2) {
         // Determine where the first set bit is on range(), giving a log2(range)
         // value which can be used to construct bounds.
-        log_range_ =
-            (std::min)(bit_width(range()),
-                       static_cast<unsigned_type>(
-                           std::numeric_limits<unsigned_type>::digits));
+        log_range_ = (std::min)(random_internal::BitWidth(range()),
+                                std::numeric_limits<unsigned_type>::digits);
       } else {
         // NOTE: Computing the logN(x) introduces error from 2 sources:
         // 1. Conversion of int to double loses precision for values >=
@@ -83,7 +81,7 @@ class log_uniform_int_distribution {
         //
         // Thus a result which should equal K may equal K +/- epsilon,
         // which can eliminate some values depending on where the bounds fall.
-        const double inv_log_base = 1.0 / std::log(base_);
+        const double inv_log_base = 1.0 / std::log(static_cast<double>(base_));
         const double log_range = std::log(static_cast<double>(range()) + 0.5);
         log_range_ = static_cast<int>(std::ceil(inv_log_base * log_range));
       }
@@ -113,7 +111,7 @@ class log_uniform_int_distribution {
     unsigned_type range_;  // max - min
     int log_range_;        // ceil(logN(range_))
 
-    static_assert(std::is_integral<IntType>::value,
+    static_assert(random_internal::IsIntegral<IntType>::value,
                   "Class-template absl::log_uniform_int_distribution<> must be "
                   "parameterized using an integral type.");
   };
@@ -139,7 +137,7 @@ class log_uniform_int_distribution {
   template <typename URBG>
   result_type operator()(URBG& g,  // NOLINT(runtime/references)
                          const param_type& p) {
-    return (p.min)() + Generate(g, p);
+    return static_cast<result_type>((p.min)() + Generate(g, p));
   }
 
   result_type(min)() const { return (param_.min)(); }
@@ -193,8 +191,8 @@ log_uniform_int_distribution<IntType>::Generate(
                 ? (std::numeric_limits<unsigned_type>::max)()
                 : (static_cast<unsigned_type>(1) << e) - 1;
   } else {
-    const double r = std::pow(p.base(), d);
-    const double s = (r * p.base()) - 1.0;
+    const double r = std::pow(static_cast<double>(p.base()), d);
+    const double s = (r * static_cast<double>(p.base())) - 1.0;
 
     base_e =
         (r > static_cast<double>((std::numeric_limits<unsigned_type>::max)()))
@@ -211,7 +209,8 @@ log_uniform_int_distribution<IntType>::Generate(
   const unsigned_type hi = (top_e >= p.range()) ? p.range() : top_e;
 
   // choose uniformly over [lo, hi]
-  return absl::uniform_int_distribution<result_type>(lo, hi)(g);
+  return absl::uniform_int_distribution<result_type>(
+      static_cast<result_type>(lo), static_cast<result_type>(hi))(g);
 }
 
 template <typename CharT, typename Traits, typename IntType>

data/third_party/abseil-cpp/absl/random/poisson_distribution.h

@@ -26,6 +26,7 @@
 #include "absl/random/internal/fastmath.h"
 #include "absl/random/internal/generate_real.h"
 #include "absl/random/internal/iostream_state_saver.h"
+#include "absl/random/internal/traits.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
@@ -80,7 +81,7 @@ class poisson_distribution {
     double log_k_;
     int split_;
 
-    static_assert(std::is_integral<IntType>::value,
+    static_assert(random_internal::IsIntegral<IntType>::value,
                   "Class-template absl::poisson_distribution<> must be "
                   "parameterized using an integral type.");
   };
@@ -133,7 +134,8 @@ template <typename IntType>
 poisson_distribution<IntType>::param_type::param_type(double mean)
     : mean_(mean), split_(0) {
   assert(mean >= 0);
-  assert(mean <= (std::numeric_limits<result_type>::max)());
+  assert(mean <=
+         static_cast<double>((std::numeric_limits<result_type>::max)()));
   // As a defensive measure, avoid large values of the mean.  The rejection
   // algorithm used does not support very large values well.  It my be worth
   // changing algorithms to better deal with these cases.
@@ -222,8 +224,9 @@ poisson_distribution<IntType>::operator()(
     // clang-format on
     const double lhs = 2.0 * std::log(u) + p.log_k_ + s;
     if (lhs < rhs) {
-      return x > (max)() ? (max)()
-                         : static_cast<result_type>(x);  // f(x)/k >= u^2
+      return x > static_cast<double>((max)())
+                 ? (max)()
+                 : static_cast<result_type>(x);  // f(x)/k >= u^2
     }
   }
 }

data/third_party/abseil-cpp/absl/random/random.h

@@ -68,7 +68,7 @@ ABSL_NAMESPACE_BEGIN
 //
 // `absl::BitGen` may be constructed with an optional seed sequence type,
 // conforming to [rand.req.seed_seq], which will be mixed with additional
-// non-deterministic data.
+// non-deterministic data as detailed below.
 //
 // Example:
 //
@@ -79,16 +79,16 @@ ABSL_NAMESPACE_BEGIN
 //  // Generate an integer value in the closed interval [1,6]
 //  int die_roll2 = absl::uniform_int_distribution<int>(1, 6)(gen_with_seed);
 //
+// Constructing two `absl::BitGen`s with the same seed sequence in the same
+// process will produce the same sequence of variates, but need not do so across
+// multiple processes even if they're executing the same binary.
+//
 // `absl::BitGen` meets the requirements of the Uniform Random Bit Generator
 // (URBG) concept as per the C++17 standard [rand.req.urng] though differs
 // slightly with [rand.req.eng]. Like its standard library equivalents (e.g.
 // `std::mersenne_twister_engine`) `absl::BitGen` is not cryptographically
 // secure.
 //
-// Constructing two `absl::BitGen`s with the same seed sequence in the same
-// binary will produce the same sequence of variates within the same binary, but
-// need not do so across multiple binary invocations.
-//
 // This type has been optimized to perform better than Mersenne Twister
 // (https://en.wikipedia.org/wiki/Mersenne_Twister) and many other complex URBG
 // types on modern x86, ARM, and PPC architectures.
@@ -147,7 +147,7 @@ using BitGen = random_internal::NonsecureURBGBase<
 //
 // `absl::InsecureBitGen` may be constructed with an optional seed sequence
 // type, conforming to [rand.req.seed_seq], which will be mixed with additional
-// non-deterministic data. (See std_seed_seq.h for more information.)
+// non-deterministic data, as detailed in the `absl::BitGen` comment.
 //
 // `absl::InsecureBitGen` meets the requirements of the Uniform Random Bit
 // Generator (URBG) concept as per the C++17 standard [rand.req.urng] though

data/third_party/abseil-cpp/absl/random/seed_sequences.h

@@ -28,6 +28,7 @@
 #include <iterator>
 #include <random>
 
+#include "absl/base/config.h"
 #include "absl/random/internal/salted_seed_seq.h"
 #include "absl/random/internal/seed_material.h"
 #include "absl/random/seed_gen_exception.h"

data/third_party/abseil-cpp/absl/random/uniform_int_distribution.h

@@ -97,7 +97,7 @@ class uniform_int_distribution {
     result_type lo_;
     unsigned_type range_;
 
-    static_assert(std::is_integral<result_type>::value,
+    static_assert(random_internal::IsIntegral<result_type>::value,
                   "Class-template absl::uniform_int_distribution<> must be "
                   "parameterized using an integral type.");
   };  // param_type
@@ -125,7 +125,7 @@ class uniform_int_distribution {
   template <typename URBG>
   result_type operator()(
       URBG& gen, const param_type& param) {  // NOLINT(runtime/references)
-    return param.a() + Generate(gen, param.range());
+    return static_cast<result_type>(param.a() + Generate(gen, param.range()));
   }
 
   result_type a() const { return param_.a(); }