grpc 1.75.0.pre1 → 1.76.0.pre1

data/src/core/lib/iomgr/tcp_server_windows.cc

@@ -35,7 +35,6 @@
 
 #include <vector>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
@@ -58,6 +57,7 @@
 #include "src/core/lib/resource_quota/resource_quota.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 
 #define MIN_SAFE_ACCEPT_QUEUE_SIZE 100
 
@@ -123,6 +123,9 @@ struct grpc_tcp_server {
   // List of closures passed to shutdown_starting_add().
   grpc_closure_list shutdown_starting;
 
+  // List of closures passed to shutdown_ending_add().
+  grpc_closure_list shutdown_ending;
+
   // shutdown callback
   grpc_closure* shutdown_complete;
 
@@ -188,6 +191,8 @@ static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
   s->tail = NULL;
   s->shutdown_starting.head = NULL;
   s->shutdown_starting.tail = NULL;
+  s->shutdown_ending.head = NULL;
+  s->shutdown_ending.tail = NULL;
   s->shutdown_complete = shutdown_complete;
   new (&s->ee_listener) std::unique_ptr<EventEngine::Listener>(nullptr);
   *server = s;
@@ -219,6 +224,7 @@ static void finish_shutdown_locked(grpc_tcp_server* s) {
                             absl::OkStatus());
   }
 
+  grpc_core::ExecCtx::RunList(DEBUG_LOCATION, &s->shutdown_ending);
   grpc_core::ExecCtx::Run(
       DEBUG_LOCATION,
       GRPC_CLOSURE_CREATE(destroy_server, s, grpc_schedule_on_exec_ctx),
@@ -238,6 +244,14 @@ static void tcp_server_shutdown_starting_add(grpc_tcp_server* s,
   gpr_mu_unlock(&s->mu);
 }
 
+static void tcp_server_shutdown_ending_add(grpc_tcp_server* s,
+                                           grpc_closure* shutdown_ending) {
+  gpr_mu_lock(&s->mu);
+  grpc_closure_list_append(&s->shutdown_ending, shutdown_ending,
+                           absl::OkStatus());
+  gpr_mu_unlock(&s->mu);
+}
+
 static void tcp_server_destroy(grpc_tcp_server* s) {
   grpc_tcp_listener* sp;
   gpr_mu_lock(&s->mu);
@@ -303,7 +317,7 @@ static grpc_error_handle prepare_socket(SOCKET sock,
   return absl::OkStatus();
 
 failure:
-  CHECK(!error.ok());
+  GRPC_CHECK(!error.ok());
   error = GRPC_ERROR_CREATE_REFERENCING("Failed to prepare server socket",
                                         &error, 1);
   if (sock != INVALID_SOCKET) closesocket(sock);
@@ -312,7 +326,7 @@ failure:
 
 static void decrement_active_ports_and_notify_locked(grpc_tcp_listener* sp) {
   sp->shutting_down = 0;
-  CHECK_GT(sp->server->active_ports, 0u);
+  GRPC_CHECK_GT(sp->server->active_ports, 0u);
   if (0 == --sp->server->active_ports) {
     finish_shutdown_locked(sp->server);
   }
@@ -370,7 +384,7 @@ static grpc_error_handle start_accept_locked(grpc_tcp_listener* port) {
   return error;
 
 failure:
-  CHECK(!error.ok());
+  GRPC_CHECK(!error.ok());
   if (sock != INVALID_SOCKET) closesocket(sock);
   return error;
 }
@@ -463,7 +477,7 @@ static void on_accept(void* arg, grpc_error_handle error) {
   // the former socked we created has now either been destroy or assigned
   // to the new connection. We need to create a new one for the next
   // connection.
-  CHECK(GRPC_LOG_IF_ERROR("start_accept", start_accept_locked(sp)));
+  GRPC_CHECK(GRPC_LOG_IF_ERROR("start_accept", start_accept_locked(sp)));
   if (0 == --sp->outstanding_calls) {
     decrement_active_ports_and_notify_locked(sp);
   }
@@ -499,7 +513,7 @@ static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, SOCKET sock,
     return error;
   }
 
-  CHECK_GE(port, 0);
+  GRPC_CHECK_GE(port, 0);
   gpr_mu_lock(&s->mu);
   sp = (grpc_tcp_listener*)gpr_malloc(sizeof(grpc_tcp_listener));
   sp->next = NULL;
@@ -519,7 +533,7 @@ static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, SOCKET sock,
   sp->port = port;
   sp->port_index = port_index;
   GRPC_CLOSURE_INIT(&sp->on_accept, on_accept, sp, grpc_schedule_on_exec_ctx);
-  CHECK(sp->socket);
+  GRPC_CHECK(sp->socket);
   gpr_mu_unlock(&s->mu);
   *listener = sp;
 
@@ -596,7 +610,7 @@ done:
     error = error_out;
     *port = -1;
   } else {
-    CHECK(sp != NULL);
+    GRPC_CHECK(sp != NULL);
     *port = sp->port;
   }
   return error;
@@ -606,9 +620,9 @@ static void tcp_server_start(grpc_tcp_server* s,
                              const std::vector<grpc_pollset*>* /*pollsets*/) {
   grpc_tcp_listener* sp;
   gpr_mu_lock(&s->mu);
-  CHECK_EQ(s->active_ports, 0u);
+  GRPC_CHECK_EQ(s->active_ports, 0u);
   for (sp = s->head; sp; sp = sp->next) {
-    CHECK(GRPC_LOG_IF_ERROR("start_accept", start_accept_locked(sp)));
+    GRPC_CHECK(GRPC_LOG_IF_ERROR("start_accept", start_accept_locked(sp)));
     s->active_ports++;
   }
   gpr_mu_unlock(&s->mu);
@@ -637,12 +651,19 @@ static int tcp_pre_allocated_fd(grpc_tcp_server* /* s */) { return -1; }
 static void tcp_set_pre_allocated_fd(grpc_tcp_server* /* s */, int /* fd */) {}
 
 grpc_tcp_server_vtable grpc_windows_tcp_server_vtable = {
-    tcp_server_create,        tcp_server_start,
-    tcp_server_add_port,      tcp_server_create_fd_handler,
-    tcp_server_port_fd_count, tcp_server_port_fd,
-    tcp_server_ref,           tcp_server_shutdown_starting_add,
-    tcp_server_unref,         tcp_server_shutdown_listeners,
-    tcp_pre_allocated_fd,     tcp_set_pre_allocated_fd};
+    tcp_server_create,
+    tcp_server_start,
+    tcp_server_add_port,
+    tcp_server_create_fd_handler,
+    tcp_server_port_fd_count,
+    tcp_server_port_fd,
+    tcp_server_ref,
+    tcp_server_shutdown_starting_add,
+    tcp_server_shutdown_ending_add,
+    tcp_server_unref,
+    tcp_server_shutdown_listeners,
+    tcp_pre_allocated_fd,
+    tcp_set_pre_allocated_fd};
 
 // ---- EventEngine shim ------------------------------------------------------
 
@@ -655,7 +676,7 @@ static grpc_error_handle event_engine_create(grpc_closure* shutdown_complete,
                                              grpc_tcp_server** server) {
   grpc_tcp_server* s = (grpc_tcp_server*)gpr_malloc(sizeof(grpc_tcp_server));
   new (&s->ee_listener) std::unique_ptr<EventEngine::Listener>(nullptr);
-  CHECK_NE(on_accept_cb, nullptr);
+  GRPC_CHECK_NE(on_accept_cb, nullptr);
   auto accept_cb = [s, on_accept_cb, on_accept_cb_arg](
                        std::unique_ptr<EventEngine::Endpoint> endpoint,
                        MemoryAllocator memory_allocator) {
@@ -677,7 +698,7 @@ static grpc_error_handle event_engine_create(grpc_closure* shutdown_complete,
   grpc_core::RefCountedPtr<grpc_core::ResourceQuota> resource_quota;
   {
     void* tmp_quota = config.GetVoidPointer(GRPC_ARG_RESOURCE_QUOTA);
-    CHECK_NE(tmp_quota, nullptr);
+    GRPC_CHECK_NE(tmp_quota, nullptr);
     resource_quota =
         reinterpret_cast<grpc_core::ResourceQuota*>(tmp_quota)->Ref();
   }
@@ -685,13 +706,13 @@ static grpc_error_handle event_engine_create(grpc_closure* shutdown_complete,
   gpr_mu_init(&s->mu);
   EventEngine* engine = reinterpret_cast<EventEngine*>(
       config.GetVoidPointer(GRPC_INTERNAL_ARG_EVENT_ENGINE));
-  CHECK_NE(engine, nullptr);
+  GRPC_CHECK_NE(engine, nullptr);
   auto listener = engine->CreateListener(
       std::move(accept_cb), std::move(on_shutdown), config,
       std::make_unique<MemoryQuotaBasedMemoryAllocatorFactory>(
           resource_quota->memory_quota()));
   GRPC_RETURN_IF_ERROR(listener.status());
-  CHECK_NE(listener->get(), nullptr);
+  GRPC_CHECK_NE(listener->get(), nullptr);
   GRPC_TRACE_LOG(event_engine, INFO)
       << "EventEngine::" << engine << ": created Listener::" << listener->get();
   s->ee_listener = std::move(*listener);
@@ -706,6 +727,8 @@ static grpc_error_handle event_engine_create(grpc_closure* shutdown_complete,
   s->tail = nullptr;
   s->shutdown_starting.head = nullptr;
   s->shutdown_starting.tail = nullptr;
+  s->shutdown_ending.head = nullptr;
+  s->shutdown_ending.tail = nullptr;
   s->shutdown_complete = grpc_core::NewClosure([](absl::Status) {
     grpc_core::Crash("iomgr shutdown_complete callback should be unused");
   });
@@ -715,13 +738,13 @@ static grpc_error_handle event_engine_create(grpc_closure* shutdown_complete,
 
 static void event_engine_start(grpc_tcp_server* s,
                                const std::vector<grpc_pollset*>* /*pollsets*/) {
-  CHECK(s->ee_listener->Start().ok());
+  GRPC_CHECK(s->ee_listener->Start().ok());
 }
 
 static grpc_error_handle event_engine_add_port(
     grpc_tcp_server* s, const grpc_resolved_address* addr, int* port) {
-  CHECK_NE(addr, nullptr);
-  CHECK_NE(port, nullptr);
+  GRPC_CHECK_NE(addr, nullptr);
+  GRPC_CHECK_NE(port, nullptr);
   auto ee_addr = CreateResolvedAddress(*addr);
   auto out_port = s->ee_listener->Bind(ee_addr);
   *port = out_port.ok() ? *out_port : -1;
@@ -767,6 +790,7 @@ static void event_engine_unref(grpc_tcp_server* s) {
     gpr_mu_unlock(&s->mu);
     gpr_mu_destroy(&s->mu);
     std::destroy_at(&s->ee_listener);
+    grpc_core::ExecCtx::RunList(DEBUG_LOCATION, &s->shutdown_ending);
     gpr_free(s);
   }
 }
@@ -779,14 +803,29 @@ static void event_engine_shutdown_starting_add(
   gpr_mu_unlock(&s->mu);
 }
 
+static void event_engine_shutdown_ending_add(grpc_tcp_server* s,
+                                             grpc_closure* shutdown_ending) {
+  gpr_mu_lock(&s->mu);
+  grpc_closure_list_append(&s->shutdown_ending, shutdown_ending,
+                           absl::OkStatus());
+  gpr_mu_unlock(&s->mu);
+}
+
 }  // namespace
 
 grpc_tcp_server_vtable grpc_windows_event_engine_tcp_server_vtable = {
-    event_engine_create,        event_engine_start,
-    event_engine_add_port,      event_engine_create_fd_handler,
-    event_engine_port_fd_count, event_engine_port_fd,
-    event_engine_ref,           event_engine_shutdown_starting_add,
-    event_engine_unref,         event_engine_shutdown_listeners,
-    tcp_pre_allocated_fd,       tcp_set_pre_allocated_fd};
+    event_engine_create,
+    event_engine_start,
+    event_engine_add_port,
+    event_engine_create_fd_handler,
+    event_engine_port_fd_count,
+    event_engine_port_fd,
+    event_engine_ref,
+    event_engine_shutdown_starting_add,
+    event_engine_shutdown_ending_add,
+    event_engine_unref,
+    event_engine_shutdown_listeners,
+    tcp_pre_allocated_fd,
+    tcp_set_pre_allocated_fd};
 
 #endif  // GRPC_WINSOCK_SOCKET

data/src/core/lib/iomgr/tcp_windows.cc

@@ -27,7 +27,6 @@
 #include <grpc/support/string_util.h>
 #include <limits.h>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/iomgr/iocp_windows.h"
@@ -40,6 +39,7 @@
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/string.h"
 #include "src/core/util/useful.h"
 
@@ -182,7 +182,7 @@ static void on_read(void* tcpp, grpc_error_handle error) {
       grpc_slice_buffer_reset_and_unref(tcp->read_slices);
     } else {
       if (info->bytes_transferred != 0 && !tcp->shutting_down) {
-        CHECK((size_t)info->bytes_transferred <= tcp->read_slices->length);
+        GRPC_CHECK((size_t)info->bytes_transferred <= tcp->read_slices->length);
         if (static_cast<size_t>(info->bytes_transferred) !=
             tcp->read_slices->length) {
           grpc_slice_buffer_trim_end(
@@ -191,7 +191,7 @@ static void on_read(void* tcpp, grpc_error_handle error) {
                   static_cast<size_t>(info->bytes_transferred),
               &tcp->last_read_buffer);
         }
-        CHECK((size_t)info->bytes_transferred == tcp->read_slices->length);
+        GRPC_CHECK((size_t)info->bytes_transferred == tcp->read_slices->length);
 
         if (GRPC_TRACE_FLAG_ENABLED(tcp) && ABSL_VLOG_IS_ON(2)) {
           size_t i;
@@ -256,7 +256,7 @@ static void win_read(grpc_endpoint* ep, grpc_slice_buffer* read_slices,
                           GRPC_SLICE_MALLOC(DEFAULT_TARGET_READ_SIZE));
   }
 
-  CHECK(tcp->read_slices->count <= MAX_WSABUF_COUNT);
+  GRPC_CHECK(tcp->read_slices->count <= MAX_WSABUF_COUNT);
   for (i = 0; i < tcp->read_slices->count; i++) {
     buffers[i].len = (ULONG)GRPC_SLICE_LENGTH(
         tcp->read_slices->slices[i]);  // we know slice size fits in 32bit.
@@ -313,7 +313,7 @@ static void on_write(void* tcpp, grpc_error_handle error) {
     if (info->wsa_error != 0) {
       error = GRPC_WSA_ERROR(info->wsa_error, "WSASend");
     } else {
-      CHECK(info->bytes_transferred <= tcp->write_slices->length);
+      GRPC_CHECK(info->bytes_transferred <= tcp->write_slices->length);
     }
   }
 
@@ -359,7 +359,7 @@ static void win_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
 
   tcp->write_cb = cb;
   tcp->write_slices = slices;
-  CHECK(tcp->write_slices->count <= UINT_MAX);
+  GRPC_CHECK(tcp->write_slices->count <= UINT_MAX);
   if (tcp->write_slices->count > GPR_ARRAY_SIZE(local_buffers)) {
     buffers = (WSABUF*)gpr_malloc(sizeof(WSABUF) * tcp->write_slices->count);
     allocated = buffers;
@@ -367,7 +367,7 @@ static void win_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
 
   for (i = 0; i < tcp->write_slices->count; i++) {
     len = GRPC_SLICE_LENGTH(tcp->write_slices->slices[i]);
-    CHECK(len <= ULONG_MAX);
+    GRPC_CHECK(len <= ULONG_MAX);
     buffers[i].len = (ULONG)len;
     buffers[i].buf = (char*)GRPC_SLICE_START_PTR(tcp->write_slices->slices[i]);
   }

data/src/core/lib/iomgr/timer_generic.cc

@@ -24,7 +24,6 @@
 
 #include <string>
 
-#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/iomgr/timer.h"
 #include "src/core/lib/iomgr/timer_heap.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/manual_constructor.h"
 #include "src/core/util/spinlock.h"
 #include "src/core/util/time.h"
@@ -116,7 +116,7 @@ static bool is_in_ht(grpc_timer* t) {
 }
 
 static void add_to_ht(grpc_timer* t) {
-  CHECK(!t->hash_table_next);
+  GRPC_CHECK(!t->hash_table_next);
   size_t i = grpc_core::HashPointer(t, NUM_HASH_BUCKETS);
 
   gpr_mu_lock(&g_hash_mu[i]);

data/src/core/lib/iomgr/timer_manager.cc

@@ -22,11 +22,11 @@
 #include <grpc/support/port_platform.h>
 #include <inttypes.h>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/thd.h"
 
 struct completed_thread {
@@ -80,7 +80,7 @@ static void gc_completed_threads(void) {
 }
 
 static void start_timer_thread_and_unlock(void) {
-  CHECK(g_threaded);
+  GRPC_CHECK(g_threaded);
   ++g_waiter_count;
   ++g_thread_count;
   gpr_mu_unlock(&g_mu);

data/src/core/lib/iomgr/unix_sockets_posix.cc

@@ -35,20 +35,20 @@
 
 #include <grpc/support/alloc.h>
 
-#include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
 #include "src/core/lib/transport/error_utils.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/useful.h"
 
 void grpc_create_socketpair_if_unix(int sv[2]) {
 #ifdef GPR_WINDOWS
   grpc_core::Crash("AF_UNIX socket pairs are not supported on Windows");
 #else
-  CHECK_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, sv), 0);
+  GRPC_CHECK_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, sv), 0);
 #endif
 }
 

data/src/core/lib/iomgr/unix_sockets_posix_noop.cc

@@ -24,13 +24,13 @@
 
 #include <string>
 
-#include "absl/log/check.h"
+#include "src/core/util/grpc_check.h"
 
 void grpc_create_socketpair_if_unix(int /* sv */[2]) {
   // TODO: Either implement this for the non-Unix socket case or make
   // sure that it is never called in any such case. Until then, leave an
   // assertion to notify if this gets called inadvertently
-  CHECK(0);
+  GRPC_CHECK(0);
 }
 
 absl::StatusOr<std::vector<grpc_resolved_address>>

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

@@ -19,11 +19,11 @@
 
 #include <vector>
 
-#include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 #include "src/core/util/atomic_utils.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -55,7 +55,7 @@ class FreestandingActivity::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(activity_, nullptr);
+    GRPC_CHECK_NE(activity_, nullptr);
     activity_ = nullptr;
     mu_.Unlock();
     Unref();

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

@@ -26,7 +26,6 @@
 #include <utility>
 
 #include "absl/base/thread_annotations.h"
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "src/core/lib/debug/trace.h"
@@ -36,6 +35,7 @@
 #include "src/core/lib/promise/poll.h"
 #include "src/core/util/construct_destruct.h"
 #include "src/core/util/dump_args.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/latent_see.h"
 #include "src/core/util/no_destruct.h"
 #include "src/core/util/orphanable.h"
@@ -512,11 +512,11 @@ class PromiseActivity final
     // We shouldn't destruct without calling Cancel() first, and that must get
     // us to be done_, so we assume that and have no logic to destruct the
     // promise here.
-    CHECK(done_);
+    GRPC_CHECK(done_);
   }
 
   void RunScheduledWakeup() {
-    CHECK(wakeup_scheduled_.exchange(false, std::memory_order_acq_rel));
+    GRPC_CHECK(wakeup_scheduled_.exchange(false, std::memory_order_acq_rel));
     Step();
     WakeupComplete();
   }
@@ -582,7 +582,7 @@ class PromiseActivity final
   // Notification that we're no longer executing - it's ok to destruct the
   // promise.
   void MarkDone() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu()) {
-    CHECK(!std::exchange(done_, true));
+    GRPC_CHECK(!std::exchange(done_, true));
     ScopedContext contexts(this);
     Destruct(&promise_holder_.promise);
   }
@@ -629,10 +629,10 @@ class PromiseActivity final
   // Until there are no wakeups from within and the promise is incomplete:
   // poll the promise.
   std::optional<ResultType> StepLoop() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu()) {
-    CHECK(is_current());
+    GRPC_CHECK(is_current());
     while (true) {
       // Run the promise.
-      CHECK(!done_);
+      GRPC_CHECK(!done_);
       auto r = promise_holder_.promise();
       if (auto* status = r.value_if_ready()) {
         // If complete, destroy the promise, flag done, and exit this loop.

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

@@ -19,9 +19,9 @@
 
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/meta/type_traits.h"
 #include "src/core/util/down_cast.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -113,7 +113,7 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline bool HasContext() {
 template <typename T>
 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline T* GetContext() {
   auto* p = promise_detail::Context<T>::get();
-  DCHECK_NE(p, nullptr);
+  GRPC_DCHECK_NE(p, nullptr);
   return p;
 }
 

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

@@ -23,13 +23,13 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/promise/detail/promise_like.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/util/bitset.h"
 #include "src/core/util/construct_destruct.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 namespace promise_detail {
@@ -62,7 +62,7 @@ struct JoinState<Traits, P0, P1> {
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
-    DCHECK(other.ready.none());
+    GRPC_DCHECK(other.ready.none());
     Construct(&promise0, std::move(other.promise0));
     Construct(&promise1, std::move(other.promise1));
   }
@@ -165,7 +165,7 @@ struct JoinState<Traits, P0, P1, P2> {
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
-    DCHECK(other.ready.none());
+    GRPC_DCHECK(other.ready.none());
     Construct(&promise0, std::move(other.promise0));
     Construct(&promise1, std::move(other.promise1));
     Construct(&promise2, std::move(other.promise2));
@@ -305,7 +305,7 @@ struct JoinState<Traits, P0, P1, P2, P3> {
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
-    DCHECK(other.ready.none());
+    GRPC_DCHECK(other.ready.none());
     Construct(&promise0, std::move(other.promise0));
     Construct(&promise1, std::move(other.promise1));
     Construct(&promise2, std::move(other.promise2));
@@ -481,7 +481,7 @@ struct JoinState<Traits, P0, P1, P2, P3, P4> {
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
-    DCHECK(other.ready.none());
+    GRPC_DCHECK(other.ready.none());
     Construct(&promise0, std::move(other.promise0));
     Construct(&promise1, std::move(other.promise1));
     Construct(&promise2, std::move(other.promise2));
@@ -693,7 +693,7 @@ struct JoinState<Traits, P0, P1, P2, P3, P4, P5> {
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
-    DCHECK(other.ready.none());
+    GRPC_DCHECK(other.ready.none());
     Construct(&promise0, std::move(other.promise0));
     Construct(&promise1, std::move(other.promise1));
     Construct(&promise2, std::move(other.promise2));
@@ -941,7 +941,7 @@ struct JoinState<Traits, P0, P1, P2, P3, P4, P5, P6> {
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
-    DCHECK(other.ready.none());
+    GRPC_DCHECK(other.ready.none());
     Construct(&promise0, std::move(other.promise0));
     Construct(&promise1, std::move(other.promise1));
     Construct(&promise2, std::move(other.promise2));
@@ -1225,7 +1225,7 @@ struct JoinState<Traits, P0, P1, P2, P3, P4, P5, P6, P7> {
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
-    DCHECK(other.ready.none());
+    GRPC_DCHECK(other.ready.none());
     Construct(&promise0, std::move(other.promise0));
     Construct(&promise1, std::move(other.promise1));
     Construct(&promise2, std::move(other.promise2));
@@ -1544,7 +1544,7 @@ struct JoinState<Traits, P0, P1, P2, P3, P4, P5, P6, P7, P8> {
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
-    DCHECK(other.ready.none());
+    GRPC_DCHECK(other.ready.none());
     Construct(&promise0, std::move(other.promise0));
     Construct(&promise1, std::move(other.promise1));
     Construct(&promise2, std::move(other.promise2));