grpc 1.75.0 → 1.78.1

data/src/core/lib/promise/detail/status.h

@@ -19,7 +19,7 @@
 
 #include <utility>
 
-#include "absl/log/check.h"
+#include "src/core/util/grpc_check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 
@@ -128,7 +128,7 @@ struct FailureStatusCastImpl<absl::StatusOr<T>, const absl::Status&> {
 
 template <typename To, typename From>
 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline To FailureStatusCast(From&& from) {
-  DCHECK(!IsStatusOk(from));
+  GRPC_DCHECK(!IsStatusOk(from));
   return FailureStatusCastImpl<To, From>::Cast(std::forward<From>(from));
 }
 

data/src/core/lib/promise/exec_ctx_wakeup_scheduler.h

@@ -17,11 +17,11 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "absl/status/status.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/util/debug_location.h"
+#include "absl/status/status.h"
 
 namespace grpc_core {
 

data/src/core/lib/promise/for_each.h

@@ -21,10 +21,6 @@
 #include <string>
 #include <utility>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/detail/promise_factory.h"
@@ -32,6 +28,10 @@
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/status_flag.h"
 #include "src/core/util/construct_destruct.h"
+#include "src/core/util/grpc_check.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
 
 namespace grpc_core {
 
@@ -145,13 +145,13 @@ class ForEach {
       : reader_(std::move(other.reader_)),
         action_factory_(std::move(other.action_factory_)),
         whence_(other.whence_) {
-    DCHECK(reading_next_);
-    DCHECK(other.reading_next_);
+    GRPC_DCHECK(reading_next_);
+    GRPC_DCHECK(other.reading_next_);
     Construct(&reader_next_, std::move(other.reader_next_));
   }
   ForEach& operator=(ForEach&& other) noexcept {
-    DCHECK(reading_next_);
-    DCHECK(other.reading_next_);
+    GRPC_DCHECK(reading_next_);
+    GRPC_DCHECK(other.reading_next_);
     reader_ = std::move(other.reader_);
     action_factory_ = std::move(other.action_factory_);
     reader_next_ = std::move(other.reader_next_);

data/src/core/lib/promise/if.h

@@ -21,11 +21,11 @@
 #include <utility>
 #include <variant>
 
-#include "absl/status/statusor.h"
 #include "src/core/lib/promise/detail/promise_factory.h"
 #include "src/core/lib/promise/detail/promise_like.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/util/construct_destruct.h"
+#include "absl/status/statusor.h"
 
 namespace grpc_core {
 

data/src/core/lib/promise/inter_activity_latch.h

@@ -20,14 +20,14 @@
 
 #include <string>
 
-#include "absl/base/thread_annotations.h"
-#include "absl/log/log.h"
-#include "absl/strings/str_cat.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/wait_set.h"
 #include "src/core/util/sync.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/log/log.h"
+#include "absl/strings/str_cat.h"
 
 namespace grpc_core {
 

data/src/core/lib/promise/inter_activity_mutex.h

@@ -18,11 +18,11 @@
 #include <atomic>
 #include <utility>
 
-#include "absl/log/log.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/util/dump_args.h"
+#include "absl/log/log.h"
 
 namespace grpc_core {
 

data/src/core/lib/promise/interceptor_list.h

@@ -24,16 +24,16 @@
 #include <string>
 #include <utility>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/detail/promise_factory.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/util/construct_destruct.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
+#include "absl/log/log.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
 
 namespace grpc_core {
 
@@ -64,7 +64,7 @@ class InterceptorList {
     // Update the next pointer stored with this map.
     // This is only valid to call once, and only before the map is used.
     void SetNext(Map* next) {
-      DCHECK_EQ(next_, nullptr);
+      GRPC_DCHECK_EQ(next_, nullptr);
       next_ = next;
     }
 

data/src/core/lib/promise/latch.h

@@ -22,12 +22,12 @@
 #include <string>
 #include <utility>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/strings/str_cat.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/poll.h"
+#include "src/core/util/grpc_check.h"
+#include "absl/log/log.h"
+#include "absl/strings/str_cat.h"
 
 namespace grpc_core {
 
@@ -54,12 +54,12 @@ class Latch {
   Latch(Latch&& other) noexcept
       : value_(std::move(other.value_)), has_value_(other.has_value_) {
 #ifndef NDEBUG
-    DCHECK(!other.has_had_waiters_);
+    GRPC_DCHECK(!other.has_had_waiters_);
 #endif
   }
   Latch& operator=(Latch&& other) noexcept {
 #ifndef NDEBUG
-    DCHECK(!other.has_had_waiters_);
+    GRPC_DCHECK(!other.has_had_waiters_);
 #endif
     value_ = std::move(other.value_);
     has_value_ = other.has_value_;
@@ -104,7 +104,7 @@ class Latch {
   void Set(T value) {
     GRPC_TRACE_LOG(promise_primitives, INFO)
         << DebugTag() << "Set " << StateString();
-    DCHECK(!has_value_);
+    GRPC_DCHECK(!has_value_);
     value_ = std::move(value);
     has_value_ = true;
     waiter_.Wake();
@@ -147,12 +147,12 @@ class Latch<void> {
   Latch& operator=(const Latch&) = delete;
   Latch(Latch&& other) noexcept : is_set_(other.is_set_) {
 #ifndef NDEBUG
-    DCHECK(!other.has_had_waiters_);
+    GRPC_DCHECK(!other.has_had_waiters_);
 #endif
   }
   Latch& operator=(Latch&& other) noexcept {
 #ifndef NDEBUG
-    DCHECK(!other.has_had_waiters_);
+    GRPC_DCHECK(!other.has_had_waiters_);
 #endif
     is_set_ = other.is_set_;
     return *this;
@@ -178,7 +178,7 @@ class Latch<void> {
   void Set() {
     GRPC_TRACE_LOG(promise_primitives, INFO)
         << DebugTag() << "Set " << StateString();
-    DCHECK(!is_set_);
+    GRPC_DCHECK(!is_set_);
     is_set_ = true;
     waiter_.Wake();
   }

data/src/core/lib/promise/loop.h

@@ -20,14 +20,14 @@
 #include <utility>
 #include <variant>
 
-#include "absl/status/status.h"
-#include "absl/status/statusor.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/detail/promise_factory.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/seq.h"
 #include "src/core/util/construct_destruct.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
 
 namespace grpc_core {
 

data/src/core/lib/promise/map.h

@@ -22,11 +22,11 @@
 #include <type_traits>
 #include <utility>
 
+#include "src/core/lib/promise/detail/promise_like.h"
+#include "src/core/lib/promise/poll.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
-#include "src/core/lib/promise/detail/promise_like.h"
-#include "src/core/lib/promise/poll.h"
 
 namespace grpc_core {
 

data/src/core/lib/promise/mpsc.cc

@@ -17,9 +17,9 @@
 #include <atomic>
 #include <cstdint>
 
-#include "absl/log/check.h"
 #include "src/core/channelz/property_list.h"
 #include "src/core/lib/promise/activity.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/sync.h"
 
 namespace grpc_core::mpscpipe_detail {
@@ -51,7 +51,7 @@ void Mpsc::Enqueue(Node* node) {
   } else {
     node->state_.store(2 /*refs*/, std::memory_order_release);
   }
-  DCHECK_EQ(node->next_.load(std::memory_order_relaxed), 0u);
+  GRPC_DCHECK_EQ(node->next_.load(std::memory_order_relaxed), 0u);
   Node* prev = head_.exchange(node, std::memory_order_acq_rel);
   uintptr_t prev_next = prev->next_.exchange(reinterpret_cast<uintptr_t>(node),
                                              std::memory_order_acq_rel);
@@ -59,9 +59,9 @@ void Mpsc::Enqueue(Node* node) {
     DrainMpsc();
   }
   if (prev_next == 0) return;
-  DCHECK_NE(prev_next & Node::kWakerPtr, 0u);
+  GRPC_DCHECK_NE(prev_next & Node::kWakerPtr, 0u);
   Waker* waker = reinterpret_cast<Waker*>(prev_next & ~Node::kWakerPtr);
-  DCHECK_NE(waker, nullptr);
+  GRPC_DCHECK_NE(waker, nullptr);
   waker->Wakeup();
   delete waker;
 }
@@ -89,9 +89,9 @@ StatusFlag Mpsc::UnbufferedImmediateSend(Node* node) {
     DrainMpsc();
   }
   if (prev_next == 0) return Success{};
-  DCHECK_NE(prev_next & Node::kWakerPtr, 0u);
+  GRPC_DCHECK_NE(prev_next & Node::kWakerPtr, 0u);
   Waker* waker = reinterpret_cast<Waker*>(prev_next & ~Node::kWakerPtr);
-  DCHECK_NE(waker, nullptr);
+  GRPC_DCHECK_NE(waker, nullptr);
   waker->Wakeup();
   delete waker;
   return Success{};
@@ -131,13 +131,13 @@ Poll<ValueOrFailure<Mpsc::Node*>> Mpsc::PollNext() {
   auto r = Dequeue();
   if (r.pending()) return Pending{};
   accepted_head = r.value();
-  DCHECK_NE(accepted_head, &stub_);
+  GRPC_DCHECK_NE(accepted_head, &stub_);
   accepted_head->spsc_next_ = nullptr;
   if (AcceptNode(accepted_head)) {
     Node* accepted_tail = accepted_head;
     while (true) {
       Node* node = DequeueImmediate();
-      DCHECK_NE(node, &stub_);
+      GRPC_DCHECK_NE(node, &stub_);
       if (node == nullptr) break;
       node->spsc_next_ = nullptr;
       accepted_tail->spsc_next_ = node;
@@ -151,7 +151,7 @@ Poll<ValueOrFailure<Mpsc::Node*>> Mpsc::PollNext() {
 
 bool Mpsc::AcceptNode(Node* node) {
   GRPC_LATENT_SEE_SCOPE("Mpsc::AcceptNode");
-  DCHECK_NE(node, nullptr);
+  GRPC_DCHECK_NE(node, nullptr);
   if (node->state_.fetch_and(255 - Node::kBlockedState,
                              std::memory_order_relaxed) &
       Node::kBlockedState) {
@@ -191,7 +191,7 @@ bool Mpsc::CheckActiveTokens() {
 void Mpsc::DrainMpsc() {
   GRPC_LATENT_SEE_SCOPE("Mpsc::DrainMpsc");
 #ifndef NDEBUG
-  DCHECK(!drained);
+  GRPC_DCHECK(!drained);
   drained = true;
 #endif
   while (true) {
@@ -232,7 +232,7 @@ retry_all:
     }
     if (next & Node::kWakerPtr) {
       // null next waker => list closed
-      DCHECK_NE(next, Node::kWakerPtr);
+      GRPC_DCHECK_NE(next, Node::kWakerPtr);
       // List is (ephemerally) empty - but we've already asked to be notified
       // when non-empty.
       return Pending{};  // pending
@@ -246,7 +246,7 @@ retry_all:
     return tail;
   }
   Node* head = head_.load(std::memory_order_acquire);
-  DCHECK_NE(head, nullptr);
+  GRPC_DCHECK_NE(head, nullptr);
   if (tail != head) {
     auto tail_next = tail->next_.load(std::memory_order_acquire);
     while (true) {
@@ -257,11 +257,11 @@ retry_all:
       }
       if (tail_next & Node::kWakerPtr) {
         // null next waker => list closed
-        DCHECK_NE(tail_next, Node::kWakerPtr);
+        GRPC_DCHECK_NE(tail_next, Node::kWakerPtr);
         // Node still being added, and we've already asked to be notified.
         return Pending{};  // pending
       }
-      DCHECK_EQ(tail_next, 0u);
+      GRPC_DCHECK_EQ(tail_next, 0u);
       Waker* waker = new Waker(GetContext<Activity>()->MakeNonOwningWaker());
       // Inform the adder we'd like to be woken up.
       if (!tail->next_.compare_exchange_weak(
@@ -284,7 +284,7 @@ retry_all:
     // Node still being added, and we've already asked to be notified.
     return Pending{};  // pending
   }
-  DCHECK_EQ(next, 0u);
+  GRPC_DCHECK_EQ(next, 0u);
   Waker* waker = new Waker(GetContext<Activity>()->MakeNonOwningWaker());
   if (!tail->next_.compare_exchange_weak(
           next, reinterpret_cast<uintptr_t>(waker) | Node::kWakerPtr,
@@ -298,7 +298,7 @@ retry_all:
 void Mpsc::PushStub() {
   stub_.next_.store(0, std::memory_order_relaxed);
   Node* prev = head_.exchange(&stub_, std::memory_order_acq_rel);
-  DCHECK_NE(prev, nullptr);
+  GRPC_DCHECK_NE(prev, nullptr);
   prev->next_.store(reinterpret_cast<uintptr_t>(&stub_),
                     std::memory_order_release);
 }
@@ -314,7 +314,7 @@ Mpsc::Node* Mpsc::DequeueImmediate() {
     }
     if (next & Node::kWakerPtr) {
       // null next waker => list closed
-      DCHECK_NE(next, Node::kWakerPtr);
+      GRPC_DCHECK_NE(next, Node::kWakerPtr);
       // List is (ephemerally) empty - but we've already asked to be notified
       // when non-empty.
       return nullptr;  // pending
@@ -362,21 +362,21 @@ void Mpsc::Close(bool wake_reader) {
 void Mpsc::ReleaseTokens(Node* node) {
   auto prev_queued =
       queued_tokens_.fetch_sub(node->tokens_, std::memory_order_relaxed);
-  DCHECK_GE(prev_queued, node->tokens_);
+  GRPC_DCHECK_GE(prev_queued, node->tokens_);
   ReleaseActiveTokens(true, node->tokens_);
   node->Unref();
 }
 
 void Mpsc::ReleaseTokensAndClose(Node* node) {
-  DCHECK_NE(node, &stub_);
+  GRPC_DCHECK_NE(node, &stub_);
   auto prev_queued =
       queued_tokens_.fetch_sub(node->tokens_, std::memory_order_relaxed);
-  DCHECK_GE(prev_queued, node->tokens_);
+  GRPC_DCHECK_GE(prev_queued, node->tokens_);
   // Called when the node has not yet been dequeued -- so we don't need to
   // decrement active tokens_.
   uint8_t state = node->state_.load(std::memory_order_relaxed);
   while (true) {
-    DCHECK_EQ(state & Node::kClosedState, 0) << int(state);
+    GRPC_DCHECK_EQ(state & Node::kClosedState, 0) << int(state);
     uint8_t new_state = state;
     new_state &= ~Node::kBlockedState;
     new_state |= Node::kClosedState;
@@ -391,22 +391,23 @@ void Mpsc::ReleaseTokensAndClose(Node* node) {
 }
 
 void Mpsc::ReleaseActiveTokens(bool wake_reader, uint64_t tokens) {
-  DCHECK_EQ(tokens & kActiveTokensMask, tokens);
+  GRPC_DCHECK_EQ(tokens & kActiveTokensMask, tokens);
   auto prev_active =
       active_tokens_.fetch_sub(tokens, std::memory_order_relaxed);
-  DCHECK_GE(prev_active & kActiveTokensMask, tokens);
-  while ((prev_active & kActiveTokensWakerBit) != 0 &&
-         (prev_active & kActiveTokensMask) - tokens <= max_queued_) {
+  GRPC_DCHECK_GE(prev_active & kActiveTokensMask, tokens);
+  auto cur_active = prev_active - tokens;
+  while ((cur_active & kActiveTokensWakerBit) != 0 &&
+         (cur_active & kActiveTokensMask) <= max_queued_) {
     if (active_tokens_.compare_exchange_weak(
-            prev_active,
-            (prev_active & kActiveTokensMask) | kActiveTokensWakingBit,
+            cur_active,
+            (cur_active & kActiveTokensMask) | kActiveTokensWakingBit,
             std::memory_order_acquire, std::memory_order_relaxed)) {
       auto waker = std::move(active_tokens_waker_);
-      DCHECK(!waker.is_unwakeable());
+      GRPC_DCHECK(!waker.is_unwakeable());
       auto prev = active_tokens_.fetch_and(kActiveTokensMask,
                                            std::memory_order_release);
-      DCHECK_EQ(prev & (kActiveTokensWakerBit | kActiveTokensWakingBit),
-                kActiveTokensWakingBit)
+      GRPC_DCHECK_EQ(prev & (kActiveTokensWakerBit | kActiveTokensWakingBit),
+                     kActiveTokensWakingBit)
           << prev;
       if (wake_reader) waker.Wakeup();
       return;

data/src/core/lib/promise/mpsc.h

@@ -23,12 +23,12 @@
 #include <cstdint>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "src/core/channelz/property_list.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/map.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/status_flag.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 
@@ -181,7 +181,7 @@ class Mpsc {
 
  public:
   auto Send(Node* node) {
-    DCHECK(node->waker_.is_unwakeable());
+    GRPC_DCHECK(node->waker_.is_unwakeable());
     // Enqueue the node immediately; this means that Send() must be called
     // from the same activity that will poll the result.
     Enqueue(node);

data/src/core/lib/promise/observable.h

@@ -17,12 +17,12 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "absl/container/flat_hash_set.h"
-#include "absl/functional/any_invocable.h"
-#include "absl/log/check.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/poll.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/sync.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/functional/any_invocable.h"
 
 namespace grpc_core {
 
@@ -123,9 +123,9 @@ class Observable {
     Observer(const Observer&) = delete;
     Observer& operator=(const Observer&) = delete;
     Observer(Observer&& other) noexcept : state_(std::move(other.state_)) {
-      CHECK(other.waker_.is_unwakeable());
-      DCHECK(waker_.is_unwakeable());
-      CHECK(!other.saw_pending_);
+      GRPC_CHECK(other.waker_.is_unwakeable());
+      GRPC_DCHECK(waker_.is_unwakeable());
+      GRPC_CHECK(!other.saw_pending_);
     }
     Observer& operator=(Observer&& other) noexcept = delete;