grpc 1.75.0.pre1 → 1.76.0.pre1

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

@@ -23,7 +23,6 @@
 #include <utility>
 
 #include "absl/base/attributes.h"
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "src/core/lib/debug/trace.h"
@@ -33,6 +32,7 @@
 #include "src/core/lib/promise/promise.h"
 #include "src/core/util/construct_destruct.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 
 // A sequence under some traits for some set of callables P, Fs.
 // P should be a promise-like object that yields a value.
@@ -124,7 +124,7 @@ struct SeqState<Traits, P, F0> {
   SeqState& operator=(const SeqState& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept
       : state(other.state), whence(other.whence) {
-    DCHECK(state == State::kState0);
+    GRPC_DCHECK(state == State::kState0);
     Construct(&prior.current_promise, std::move(other.prior.current_promise));
     Construct(&prior.next_factory, std::move(other.prior.next_factory));
   }
@@ -272,7 +272,7 @@ struct SeqState<Traits, P, F0, F1> {
   SeqState& operator=(const SeqState& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept
       : state(other.state), whence(other.whence) {
-    DCHECK(state == State::kState0);
+    GRPC_DCHECK(state == State::kState0);
     Construct(&prior.prior.current_promise,
               std::move(other.prior.prior.current_promise));
     Construct(&prior.prior.next_factory,
@@ -479,7 +479,7 @@ struct SeqState<Traits, P, F0, F1, F2> {
   SeqState& operator=(const SeqState& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept
       : state(other.state), whence(other.whence) {
-    DCHECK(state == State::kState0);
+    GRPC_DCHECK(state == State::kState0);
     Construct(&prior.prior.prior.current_promise,
               std::move(other.prior.prior.prior.current_promise));
     Construct(&prior.prior.prior.next_factory,
@@ -743,7 +743,7 @@ struct SeqState<Traits, P, F0, F1, F2, F3> {
   SeqState& operator=(const SeqState& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept
       : state(other.state), whence(other.whence) {
-    DCHECK(state == State::kState0);
+    GRPC_DCHECK(state == State::kState0);
     Construct(&prior.prior.prior.prior.current_promise,
               std::move(other.prior.prior.prior.prior.current_promise));
     Construct(&prior.prior.prior.prior.next_factory,
@@ -1073,7 +1073,7 @@ struct SeqState<Traits, P, F0, F1, F2, F3, F4> {
   SeqState& operator=(const SeqState& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept
       : state(other.state), whence(other.whence) {
-    DCHECK(state == State::kState0);
+    GRPC_DCHECK(state == State::kState0);
     Construct(&prior.prior.prior.prior.prior.current_promise,
               std::move(other.prior.prior.prior.prior.prior.current_promise));
     Construct(&prior.prior.prior.prior.prior.next_factory,
@@ -1464,7 +1464,7 @@ struct SeqState<Traits, P, F0, F1, F2, F3, F4, F5> {
   SeqState& operator=(const SeqState& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept
       : state(other.state), whence(other.whence) {
-    DCHECK(state == State::kState0);
+    GRPC_DCHECK(state == State::kState0);
     Construct(
         &prior.prior.prior.prior.prior.prior.current_promise,
         std::move(other.prior.prior.prior.prior.prior.prior.current_promise));
@@ -1918,7 +1918,7 @@ struct SeqState<Traits, P, F0, F1, F2, F3, F4, F5, F6> {
   SeqState& operator=(const SeqState& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept
       : state(other.state), whence(other.whence) {
-    DCHECK(state == State::kState0);
+    GRPC_DCHECK(state == State::kState0);
     Construct(
         &prior.prior.prior.prior.prior.prior.prior.current_promise,
         std::move(
@@ -2438,7 +2438,7 @@ struct SeqState<Traits, P, F0, F1, F2, F3, F4, F5, F6, F7> {
   SeqState& operator=(const SeqState& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept
       : state(other.state), whence(other.whence) {
-    DCHECK(state == State::kState0);
+    GRPC_DCHECK(state == State::kState0);
     Construct(&prior.prior.prior.prior.prior.prior.prior.prior.current_promise,
               std::move(other.prior.prior.prior.prior.prior.prior.prior.prior
                             .current_promise));
@@ -3027,7 +3027,7 @@ struct SeqState<Traits, P, F0, F1, F2, F3, F4, F5, F6, F7, F8> {
   SeqState& operator=(const SeqState& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept
       : state(other.state), whence(other.whence) {
-    DCHECK(state == State::kState0);
+    GRPC_DCHECK(state == State::kState0);
     Construct(
         &prior.prior.prior.prior.prior.prior.prior.prior.prior.current_promise,
         std::move(other.prior.prior.prior.prior.prior.prior.prior.prior.prior
@@ -3688,7 +3688,7 @@ struct SeqState<Traits, P, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9> {
   SeqState& operator=(const SeqState& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept
       : state(other.state), whence(other.whence) {
-    DCHECK(state == State::kState0);
+    GRPC_DCHECK(state == State::kState0);
     Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior
                    .current_promise,
               std::move(other.prior.prior.prior.prior.prior.prior.prior.prior
@@ -4421,7 +4421,7 @@ struct SeqState<Traits, P, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> {
   SeqState& operator=(const SeqState& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept
       : state(other.state), whence(other.whence) {
-    DCHECK(state == State::kState0);
+    GRPC_DCHECK(state == State::kState0);
     Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior
                    .current_promise,
               std::move(other.prior.prior.prior.prior.prior.prior.prior.prior
@@ -5229,7 +5229,7 @@ struct SeqState<Traits, P, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11> {
   SeqState& operator=(const SeqState& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept
       : state(other.state), whence(other.whence) {
-    DCHECK(state == State::kState0);
+    GRPC_DCHECK(state == State::kState0);
     Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior
                    .prior.current_promise,
               std::move(other.prior.prior.prior.prior.prior.prior.prior.prior

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

@@ -19,9 +19,9 @@
 
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "src/core/util/grpc_check.h"
 
 // Helpers for dealing with absl::Status/StatusOr generically
 
@@ -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/for_each.h

@@ -21,7 +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"
@@ -32,6 +31,7 @@
 #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"
 
 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/interceptor_list.h

@@ -24,7 +24,6 @@
 #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"
@@ -34,6 +33,7 @@
 #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"
 
 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"
 
 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/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,10 +391,10 @@ 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);
+  GRPC_DCHECK_GE(prev_active & kActiveTokensMask, tokens);
   while ((prev_active & kActiveTokensWakerBit) != 0 &&
          (prev_active & kActiveTokensMask) - tokens <= max_queued_) {
     if (active_tokens_.compare_exchange_weak(
@@ -402,11 +402,11 @@ void Mpsc::ReleaseActiveTokens(bool wake_reader, uint64_t tokens) {
             (prev_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

@@ -19,9 +19,9 @@
 
 #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"
 
 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;
 

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

@@ -21,12 +21,13 @@
 #include <limits>
 
 #include "absl/base/thread_annotations.h"
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/strings/str_format.h"
+#include "src/core/channelz/property_list.h"
 #include "src/core/lib/event_engine/event_engine_context.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/promise/activity.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/json/json_writer.h"
 #include "src/core/util/latent_see.h"
 #include "src/core/util/sync.h"
@@ -73,7 +74,7 @@ class Party::Handle final : public Wakeable {
   // Activity is going away... drop its reference and sever the connection back.
   void DropActivity() ABSL_LOCKS_EXCLUDED(mu_) {
     mu_.Lock();
-    CHECK_NE(party_, nullptr);
+    GRPC_CHECK_NE(party_, nullptr);
     party_ = nullptr;
     mu_.Unlock();
     Unref();
@@ -202,13 +203,17 @@ void Party::ToJson(absl::AnyInvocable<void(Json::Object)> f) {
 }
 
 void Party::ExportToChannelz(std::string name, channelz::DataSink sink) {
-  Spawn(
-      "export-to-channelz",
-      [name = std::move(name), sink = std::move(sink), self = Ref()]() mutable {
-        sink.AddData(std::move(name), self->ChannelzPropertiesLocked());
-        return absl::OkStatus();
-      },
-      [](absl::Status) {});
+  arena()->GetContext<grpc_event_engine::experimental::EventEngine>()->Run(
+      [self = Ref(), name = std::move(name), sink = std::move(sink)]() mutable {
+        ExecCtx exec_ctx;
+        self->Spawn(
+            "export-to-channelz",
+            [name = std::move(name), sink = std::move(sink), self]() mutable {
+              sink.AddData(std::move(name), self->ChannelzPropertiesLocked());
+              return absl::OkStatus();
+            },
+            [](absl::Status) {});
+      });
 }
 
 channelz::PropertyList Party::ChannelzPropertiesLocked() {
@@ -226,7 +231,8 @@ channelz::PropertyList Party::ChannelzPropertiesLocked() {
         for (size_t i = 0; i < party_detail::kMaxParticipants; i++) {
           if (auto* p = participants_[i].load(std::memory_order_acquire);
               p != nullptr) {
-            table.AppendRow(p->ChannelzProperties());
+            table.AppendRow(channelz::PropertyList().Set(
+                "participant", p->ChannelzProperties()));
           }
         }
         return table;
@@ -259,13 +265,13 @@ std::string Party::ActivityDebugTag(WakeupMask wakeup_mask) const {
 }
 
 Waker Party::MakeOwningWaker() {
-  DCHECK(currently_polling_ != kNotPolling);
+  GRPC_DCHECK(currently_polling_ != kNotPolling);
   IncrementRefCount();
   return Waker(this, 1u << currently_polling_);
 }
 
 Waker Party::MakeNonOwningWaker() {
-  DCHECK(currently_polling_ != kNotPolling);
+  GRPC_DCHECK(currently_polling_ != kNotPolling);
   return Waker(participants_[currently_polling_]
                    .load(std::memory_order_relaxed)
                    ->MakeNonOwningWakeable(this),
@@ -273,7 +279,7 @@ Waker Party::MakeNonOwningWaker() {
 }
 
 void Party::ForceImmediateRepoll(WakeupMask mask) {
-  DCHECK(is_current());
+  GRPC_DCHECK(is_current());
   wakeup_mask_ |= mask;
 }
 
@@ -306,11 +312,11 @@ void Party::RunLockedAndUnref(Party* party, uint64_t prev_state) {
       g_run_state = this;
       do {
         GRPC_LATENT_SEE_SCOPE("run_one_party");
-        CHECK(first.party != nullptr);
+        GRPC_CHECK(first.party != nullptr);
         first.party->RunPartyAndUnref(first.prev_state);
         first = std::exchange(next, PartyWakeup{});
       } while (first.party != nullptr);
-      DCHECK(g_run_state == this);
+      GRPC_DCHECK(g_run_state == this);
       g_run_state = nullptr;
     }
   };
@@ -338,10 +344,11 @@ void Party::RunLockedAndUnref(Party* party, uint64_t prev_state) {
       auto wakeup =
           std::exchange(g_run_state->next, PartyWakeup{party, prev_state});
       auto arena = wakeup.party->arena_.get();
-      CHECK(arena != nullptr);
+      GRPC_CHECK(arena != nullptr);
       auto* event_engine =
           arena->GetContext<grpc_event_engine::experimental::EventEngine>();
-      CHECK(event_engine != nullptr) << "; " << GRPC_DUMP_ARGS(party, arena);
+      GRPC_CHECK(event_engine != nullptr)
+          << "; " << GRPC_DUMP_ARGS(party, arena);
       GRPC_LATENT_SEE_SCOPE("offload_one_party");
       event_engine->Run([wakeup]() {
         GRPC_LATENT_SEE_SCOPE("Party::RunLocked offload");
@@ -360,11 +367,11 @@ void Party::RunLockedAndUnref(Party* party, uint64_t prev_state) {
 void Party::RunPartyAndUnref(uint64_t prev_state) {
   ScopedActivity activity(this);
   promise_detail::Context<Arena> arena_ctx(arena_.get());
-  DCHECK_EQ(prev_state & kLocked, 0u)
+  GRPC_DCHECK_EQ(prev_state & kLocked, 0u)
       << "Party should be unlocked prior to first wakeup";
-  DCHECK_GE(prev_state & kRefMask, kOneRef);
+  GRPC_DCHECK_GE(prev_state & kRefMask, kOneRef);
   // Now update prev_state to be what we want the CAS to see below.
-  DCHECK_EQ(prev_state & ~(kRefMask | kAllocatedMask), 0u)
+  GRPC_DCHECK_EQ(prev_state & ~(kRefMask | kAllocatedMask), 0u)
       << "Party should have contained no wakeups on lock";
   prev_state |= kLocked;
 #if !TARGET_OS_IPHONE
@@ -432,9 +439,9 @@ void Party::RunPartyAndUnref(uint64_t prev_state) {
     }
     LogStateChange("Run:Continue", prev_state,
                    prev_state & (kRefMask | kLocked | keep_allocated_mask));
-    DCHECK(prev_state & kLocked)
+    GRPC_DCHECK(prev_state & kLocked)
         << "Party should be locked; prev_state=" << prev_state;
-    DCHECK_GE(prev_state & kRefMask, kOneRef);
+    GRPC_DCHECK_GE(prev_state & kRefMask, kOneRef);
     // From the previous state, extract which participants we're to wakeup.
     wakeup_mask_ |= prev_state & kWakeupMask;
     // Now update prev_state to be what we want the CAS to see once wakeups
@@ -457,7 +464,7 @@ uint64_t Party::NextAllocationMask(uint64_t current_allocation_mask) {
 }
 #else
 uint64_t Party::NextAllocationMask(uint64_t current_allocation_mask) {
-  CHECK_EQ(current_allocation_mask & ~kWakeupMask, 0);
+  GRPC_CHECK_EQ(current_allocation_mask & ~kWakeupMask, 0);
   if (current_allocation_mask == kWakeupMask) return kWakeupMask + 1;
   // Count number of unset bits in the wakeup mask
   size_t unset_bits = 0;
@@ -465,7 +472,7 @@ uint64_t Party::NextAllocationMask(uint64_t current_allocation_mask) {
     if (current_allocation_mask & (1ull << i)) continue;
     ++unset_bits;
   }
-  CHECK_GT(unset_bits, 0);
+  GRPC_CHECK_GT(unset_bits, 0);
   absl::BitGen bitgen;
   size_t selected = absl::Uniform<size_t>(bitgen, 0, unset_bits);
   for (size_t i = 0; i < party_detail::kMaxParticipants; i++) {
@@ -494,7 +501,7 @@ size_t Party::AddParticipant(Participant* participant) {
     if (GPR_UNLIKELY((wakeup_mask & kWakeupMask) == 0)) {
       return std::numeric_limits<size_t>::max();
     }
-    DCHECK_NE(wakeup_mask & kWakeupMask, 0u)
+    GRPC_DCHECK_NE(wakeup_mask & kWakeupMask, 0u)
         << "No available slots for new participant; allocated=" << allocated
         << " state=" << state << " wakeup_mask=" << wakeup_mask;
     allocated |= wakeup_mask;