grpc 1.84.0 → 1.85.0.pre1

data/third_party/abseil-cpp/absl/time/clock.cc

@@ -125,7 +125,7 @@ class UnscaledCycleClockWrapperForGetCurrentTime {
 // spin-delay tuning.
 
 // Acquire seqlock (*seq) and return the value to be written to unlock.
-static inline uint64_t SeqAcquire(std::atomic<uint64_t> *seq) {
+static inline uint64_t SeqAcquire(std::atomic<uint64_t>* seq) {
   uint64_t x = seq->fetch_add(1, std::memory_order_relaxed);
 
   // We put a release fence between update to *seq and writes to shared data.
@@ -135,12 +135,12 @@ static inline uint64_t SeqAcquire(std::atomic<uint64_t> *seq) {
   // fetch_add would be before it, not after.
   std::atomic_thread_fence(std::memory_order_release);
 
-  return x + 2;   // original word plus 2
+  return x + 2;  // original word plus 2
 }
 
 // Release seqlock (*seq) by writing x to it---a value previously returned by
 // SeqAcquire.
-static inline void SeqRelease(std::atomic<uint64_t> *seq, uint64_t x) {
+static inline void SeqRelease(std::atomic<uint64_t>* seq, uint64_t x) {
   // The unlock store to *seq must have release ordering so that all
   // updates to shared data must finish before this store.
   seq->store(x, std::memory_order_release);  // release lock for readers
@@ -160,8 +160,8 @@ static const uint64_t kMinNSBetweenSamples = 2000 << 20;
 // We require that kMinNSBetweenSamples shifted by kScale
 // have at least a bit left over for 64-bit calculations.
 static_assert(((kMinNSBetweenSamples << (kScale + 1)) >> (kScale + 1)) ==
-               kMinNSBetweenSamples,
-               "cannot represent kMaxBetweenSamplesNSScaled");
+                  kMinNSBetweenSamples,
+              "cannot represent kMaxBetweenSamplesNSScaled");
 
 // data from a sample of the kernel's time value
 struct TimeSampleAtomic {
@@ -206,8 +206,7 @@ struct ABSL_CACHELINE_ALIGNED TimeState {
 
   // A reader-writer lock protecting the static locations below.
   // See SeqAcquire() and SeqRelease() above.
-  absl::base_internal::SpinLock lock{absl::kConstInit,
-                                     base_internal::SCHEDULE_KERNEL_ONLY};
+  absl::base_internal::SpinLock lock{base_internal::SCHEDULE_KERNEL_ONLY};
 };
 ABSL_CONST_INIT static TimeState time_state;
 
@@ -219,7 +218,7 @@ ABSL_CONST_INIT static TimeState time_state;
 // assumed to be complete resyncs, which shouldn't happen.  If they do, a full
 // reinitialization of the outer algorithm should occur.)
 static int64_t GetCurrentTimeNanosFromKernel(uint64_t last_cycleclock,
-                                             uint64_t *cycleclock)
+                                             uint64_t* cycleclock)
     ABSL_EXCLUSIVE_LOCKS_REQUIRED(time_state.lock) {
   uint64_t local_approx_syscall_time_in_cycles =  // local copy
       time_state.approx_syscall_time_in_cycles.load(std::memory_order_relaxed);
@@ -275,8 +274,8 @@ static int64_t GetCurrentTimeNanosSlowPath() ABSL_ATTRIBUTE_COLD;
 // Read the contents of *atomic into *sample.
 // Each field is read atomically, but to maintain atomicity between fields,
 // the access must be done under a lock.
-static void ReadTimeSampleAtomic(const struct TimeSampleAtomic *atomic,
-                                 struct TimeSample *sample) {
+static void ReadTimeSampleAtomic(const struct TimeSampleAtomic* atomic,
+                                 struct TimeSample* sample) {
   sample->base_ns = atomic->base_ns.load(std::memory_order_relaxed);
   sample->base_cycles = atomic->base_cycles.load(std::memory_order_relaxed);
   sample->nsscaled_per_cycle =
@@ -339,18 +338,20 @@ int64_t GetCurrentTimeNanos() {
   // to the same shared data.
   seq_read0 = time_state.seq.load(std::memory_order_acquire);
 
-  base_ns = time_state.last_sample.base_ns.load(std::memory_order_relaxed);
+  // The algorithm does not require that the following four loads be ordered
+  // with respect to one another; it requires only that they precede the load of
+  // time_state.seq below them. Nevertheless, we mark each of them as an
+  // acquire-load, rather than using a barrier immediately before the
+  // time_state.seq load, because the former is likely faster on most CPUs of
+  // interest. Architectures that may see a regression because of this approach
+  // include PowerPC and MIPS.
+  base_ns = time_state.last_sample.base_ns.load(std::memory_order_acquire);
   base_cycles =
-      time_state.last_sample.base_cycles.load(std::memory_order_relaxed);
+      time_state.last_sample.base_cycles.load(std::memory_order_acquire);
   nsscaled_per_cycle =
-      time_state.last_sample.nsscaled_per_cycle.load(std::memory_order_relaxed);
+      time_state.last_sample.nsscaled_per_cycle.load(std::memory_order_acquire);
   min_cycles_per_sample = time_state.last_sample.min_cycles_per_sample.load(
-      std::memory_order_relaxed);
-
-  // This acquire fence pairs with the release fence in SeqAcquire.  Since it
-  // is sequenced between reads of shared data and seq_read1, the reads of
-  // shared data are effectively acquiring.
-  std::atomic_thread_fence(std::memory_order_acquire);
+      std::memory_order_acquire);
 
   // The shared-data reads are effectively acquire ordered, and the
   // shared-data writes are effectively release ordered. Therefore if our
@@ -398,7 +399,7 @@ static uint64_t SafeDivideAndScale(uint64_t a, uint64_t b) {
 
 static uint64_t UpdateLastSample(
     uint64_t now_cycles, uint64_t now_ns, uint64_t delta_cycles,
-    const struct TimeSample *sample) ABSL_ATTRIBUTE_COLD;
+    const struct TimeSample* sample) ABSL_ATTRIBUTE_COLD;
 
 // The slow path of GetCurrentTimeNanos().  This is taken while gathering
 // initial samples, when enough time has elapsed since the last sample, and if
@@ -416,7 +417,7 @@ static int64_t GetCurrentTimeNanosSlowPath()
     ABSL_LOCKS_EXCLUDED(time_state.lock) {
   // Serialize access to slow-path.  Fast-path readers are not blocked yet, and
   // code below must not modify last_sample until the seqlock is acquired.
-  time_state.lock.Lock();
+  base_internal::SpinLockHolder l(time_state.lock);
 
   // Sample the kernel time base.  This is the definition of
   // "now" if we take the slow path.
@@ -439,16 +440,14 @@ static int64_t GetCurrentTimeNanosSlowPath()
   if (delta_cycles < sample.min_cycles_per_sample) {
     // Another thread updated the sample.  This path does not take the seqlock
     // so that blocked readers can make progress without blocking new readers.
-    estimated_base_ns = sample.base_ns +
-        ((delta_cycles * sample.nsscaled_per_cycle) >> kScale);
+    estimated_base_ns =
+        sample.base_ns + ((delta_cycles * sample.nsscaled_per_cycle) >> kScale);
     time_state.stats_fast_slow_paths++;
   } else {
     estimated_base_ns =
         UpdateLastSample(now_cycles, now_ns, delta_cycles, &sample);
   }
 
-  time_state.lock.Unlock();
-
   return static_cast<int64_t>(estimated_base_ns);
 }
 
@@ -457,7 +456,7 @@ static int64_t GetCurrentTimeNanosSlowPath()
 // for readers.  Returns the new estimated time.
 static uint64_t UpdateLastSample(uint64_t now_cycles, uint64_t now_ns,
                                  uint64_t delta_cycles,
-                                 const struct TimeSample *sample)
+                                 const struct TimeSample* sample)
     ABSL_EXCLUSIVE_LOCKS_REQUIRED(time_state.lock) {
   uint64_t estimated_base_ns = now_ns;
   uint64_t lock_value =
@@ -494,8 +493,8 @@ static uint64_t UpdateLastSample(uint64_t now_cycles, uint64_t now_ns,
         estimated_scaled_ns = (delta_cycles >> s) * sample->nsscaled_per_cycle;
       } while (estimated_scaled_ns / sample->nsscaled_per_cycle !=
                (delta_cycles >> s));
-      estimated_base_ns = sample->base_ns +
-                          (estimated_scaled_ns >> (kScale - s));
+      estimated_base_ns =
+          sample->base_ns + (estimated_scaled_ns >> (kScale - s));
     }
 
     // Compute the assumed cycle time kMinNSBetweenSamples ns into the future
@@ -522,8 +521,8 @@ static uint64_t UpdateLastSample(uint64_t now_cycles, uint64_t now_ns,
                                diff_ns - (diff_ns / 16));
     uint64_t new_nsscaled_per_cycle =
         SafeDivideAndScale(ns, assumed_next_sample_delta_cycles);
-    if (new_nsscaled_per_cycle != 0 &&
-        diff_ns < 100 * 1000 * 1000 && -diff_ns < 100 * 1000 * 1000) {
+    if (new_nsscaled_per_cycle != 0 && diff_ns < 100 * 1000 * 1000 &&
+        -diff_ns < 100 * 1000 * 1000) {
       // record the cycle time measurement
       time_state.last_sample.nsscaled_per_cycle.store(
           new_nsscaled_per_cycle, std::memory_order_relaxed);

data/third_party/abseil-cpp/absl/time/clock.h

@@ -34,6 +34,9 @@ ABSL_NAMESPACE_BEGIN
 // Now()
 //
 // Returns the current time, expressed as an `absl::Time` absolute time value.
+//
+// To improve testability, consider injecting an absl::Clock and using
+// absl::Clock::TimeNow() instead.
 absl::Time Now();
 
 // GetCurrentTimeNanos()

data/third_party/abseil-cpp/absl/time/duration.cc

@@ -469,7 +469,7 @@ Duration& Duration::operator*=(int64_t r) {
 
 Duration& Duration::operator*=(double r) {
   if (time_internal::IsInfiniteDuration(*this) || !IsFinite(r)) {
-    const bool is_neg = std::signbit(r) != (rep_hi_.Get() < 0);
+    const bool is_neg = std::isnan(r) || std::signbit(r) != (rep_hi_.Get() < 0);
     return *this = is_neg ? -InfiniteDuration() : InfiniteDuration();
   }
   return *this = ScaleDouble<std::multiplies>(*this, r);
@@ -485,7 +485,7 @@ Duration& Duration::operator/=(int64_t r) {
 
 Duration& Duration::operator/=(double r) {
   if (time_internal::IsInfiniteDuration(*this) || !IsValidDivisor(r)) {
-    const bool is_neg = std::signbit(r) != (rep_hi_.Get() < 0);
+    const bool is_neg = std::isnan(r) || std::signbit(r) != (rep_hi_.Get() < 0);
     return *this = is_neg ? -InfiniteDuration() : InfiniteDuration();
   }
   return *this = ScaleDouble<std::divides>(*this, r);

data/third_party/abseil-cpp/absl/time/format.cc

@@ -17,7 +17,7 @@
 #include <cctype>
 #include <cstdint>
 #include <utility>
-
+#include "absl/strings/ascii.h"
 #include "absl/strings/match.h"
 #include "absl/strings/string_view.h"
 #include "absl/time/internal/cctz/include/cctz/time_zone.h"
@@ -99,13 +99,6 @@ bool ParseTime(absl::string_view format, absl::string_view input,
 // the fields with respect to the given TimeZone.
 bool ParseTime(absl::string_view format, absl::string_view input,
                absl::TimeZone tz, absl::Time* time, std::string* err) {
-  auto strip_leading_space = [](absl::string_view* sv) {
-    while (!sv->empty()) {
-      if (!std::isspace(sv->front())) return;
-      sv->remove_prefix(1);
-    }
-  };
-
   // Portable toolchains means we don't get nice constexpr here.
   struct Literal {
     const char* name;
@@ -116,12 +109,12 @@ bool ParseTime(absl::string_view format, absl::string_view input,
       {kInfiniteFutureStr, strlen(kInfiniteFutureStr), InfiniteFuture()},
       {kInfinitePastStr, strlen(kInfinitePastStr), InfinitePast()},
   };
-  strip_leading_space(&input);
+  input = StripLeadingAsciiWhitespace(input);
   for (const auto& lit : literals) {
     if (absl::StartsWith(input, absl::string_view(lit.name, lit.size))) {
       absl::string_view tail = input;
       tail.remove_prefix(lit.size);
-      strip_leading_space(&tail);
+      tail = StripLeadingAsciiWhitespace(tail);
       if (tail.empty()) {
         *time = lit.value;
         return true;

data/third_party/abseil-cpp/absl/time/internal/cctz/include/cctz/civil_time_detail.h

@@ -96,6 +96,18 @@ CONSTEXPR_F int days_per_4years(int yi) noexcept {
 CONSTEXPR_F int days_per_year(year_t y, month_t m) noexcept {
   return is_leap_year(y + (m > 2)) ? 366 : 365;
 }
+// The compiler cannot optimize away the check if we use
+// -fsanitize=array-bounds.
+// m is guaranteed to be in [1:12] in the caller, but the compiler cannot
+// optimize away the check even when this function is inlined into BreakTime.
+// To reduce the overhead, we use no_sanitize to skip the unnecessary
+// -fsanitize=array-bounds check. Remove no_sanitize once the missed
+// optimization is fixed.
+#if defined(__clang__) && defined(__has_cpp_attribute)
+#if __has_cpp_attribute(clang::no_sanitize)
+[[clang::no_sanitize("array-bounds")]]
+#endif
+#endif
 CONSTEXPR_F int days_per_month(year_t y, month_t m) noexcept {
   CONSTEXPR_D int k_days_per_month[1 + 12] = {
       -1, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31  // non leap year