grpc 1.69.0 → 1.71.0

data/src/core/lib/iomgr/exec_ctx.h

@@ -115,11 +115,6 @@ class GRPC_DLL ExecCtx : public latent_see::ParentScope {
   ExecCtx()
       : latent_see::ParentScope(GRPC_LATENT_SEE_METADATA("ExecCtx")),
         flags_(GRPC_EXEC_CTX_FLAG_IS_FINISHED) {
-#if !TARGET_OS_IPHONE
-    if (!IsTimeCachingInPartyEnabled()) {
-      time_cache_.emplace();
-    }
-#endif
     Fork::IncExecCtxCount();
     Set(this);
   }
@@ -130,11 +125,6 @@ class GRPC_DLL ExecCtx : public latent_see::ParentScope {
 
   explicit ExecCtx(uintptr_t fl, latent_see::Metadata* latent_see_metadata)
       : latent_see::ParentScope(latent_see_metadata), flags_(fl) {
-#if !TARGET_OS_IPHONE
-    if (!IsTimeCachingInPartyEnabled()) {
-      time_cache_.emplace();
-    }
-#endif
     if (!(GRPC_EXEC_CTX_FLAG_IS_INTERNAL_THREAD & flags_)) {
       Fork::IncExecCtxCount();
     }
@@ -241,7 +231,7 @@ class GRPC_DLL ExecCtx : public latent_see::ParentScope {
   CombinerData combiner_data_ = {nullptr, nullptr};
   uintptr_t flags_;
 
-  absl::optional<ScopedTimeCache> time_cache_;
+  std::optional<ScopedTimeCache> time_cache_;
 
 #if !defined(_WIN32) || !defined(_DLL)
   static thread_local ExecCtx* exec_ctx_;
@@ -252,130 +242,9 @@ class GRPC_DLL ExecCtx : public latent_see::ParentScope {
   ExecCtx* last_exec_ctx_ = Get();
 };
 
-/// Application-callback execution context.
-/// A bag of data that collects information along a callstack.
-/// It is created on the stack at core entry points, and stored internally
-/// as a thread-local variable.
-///
-/// There are three key differences between this structure and ExecCtx:
-///   1. ApplicationCallbackExecCtx builds a list of application-level
-///      callbacks, but ExecCtx builds a list of internal callbacks to invoke.
-///   2. ApplicationCallbackExecCtx invokes its callbacks only at destruction;
-///      there is no explicit Flush method.
-///   3. If more than one ApplicationCallbackExecCtx is created on the thread's
-///      stack, only the one closest to the base of the stack is actually
-///      active and this is the only one that enqueues application callbacks.
-///      (Unlike ExecCtx, it is not feasible to prevent multiple of these on the
-///      stack since the executing application callback may itself enter core.
-///      However, the new one created will just pass callbacks through to the
-///      base one and those will not be executed until the return to the
-///      destructor of the base one, preventing unlimited stack growth.)
-///
-/// This structure exists because application callbacks may themselves cause a
-/// core re-entry (e.g., through a public API call) and if that call in turn
-/// causes another application-callback, there could be arbitrarily growing
-/// stacks of core re-entries. Instead, any application callbacks instead should
-/// not be invoked until other core work is done and other application callbacks
-/// have completed. To accomplish this, any application callback should be
-/// enqueued using ApplicationCallbackExecCtx::Enqueue .
-///
-/// CONVENTIONS:
-/// - Instances of this must ALWAYS be constructed on the stack, never
-///   heap allocated.
-/// - Instances of this are generally constructed before ExecCtx when needed.
-///   The only exception is for ExecCtx's that are explicitly flushed and
-///   that survive beyond the scope of the function that can cause application
-///   callbacks to be invoked (e.g., in the timer thread).
-///
-/// Generally, core entry points that may trigger application-level callbacks
-/// will have the following declarations:
-///
-/// ApplicationCallbackExecCtx callback_exec_ctx;
-/// ExecCtx exec_ctx;
-///
-/// This ordering is important to make sure that the ApplicationCallbackExecCtx
-/// is destroyed after the ExecCtx (to prevent the re-entry problem described
-/// above, as well as making sure that ExecCtx core callbacks are invoked first)
-///
-///
-
-class GRPC_DLL ApplicationCallbackExecCtx {
- public:
-  /// Default Constructor
-  ApplicationCallbackExecCtx() { Set(this, flags_); }
-
-  /// Parameterised Constructor
-  explicit ApplicationCallbackExecCtx(uintptr_t fl) : flags_(fl) {
-    Set(this, flags_);
-  }
-
-  ~ApplicationCallbackExecCtx() {
-    if (Get() == this) {
-      while (head_ != nullptr) {
-        auto* f = head_;
-        head_ = f->internal_next;
-        if (f->internal_next == nullptr) {
-          tail_ = nullptr;
-        }
-        (*f->functor_run)(f, f->internal_success);
-      }
-      CALLBACK_EXEC_CTX = nullptr;
-      if (!(GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD & flags_)) {
-        Fork::DecExecCtxCount();
-      }
-    } else {
-      DCHECK_EQ(head_, nullptr);
-      DCHECK_EQ(tail_, nullptr);
-    }
-  }
-
-  uintptr_t Flags() { return flags_; }
-
-  static ApplicationCallbackExecCtx* Get() { return CALLBACK_EXEC_CTX; }
-
-  static void Set(ApplicationCallbackExecCtx* exec_ctx, uintptr_t flags) {
-    if (Get() == nullptr) {
-      if (!(GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD & flags)) {
-        Fork::IncExecCtxCount();
-      }
-      CALLBACK_EXEC_CTX = exec_ctx;
-    }
-  }
-
-  static void Enqueue(grpc_completion_queue_functor* functor, int is_success) {
-    functor->internal_success = is_success;
-    functor->internal_next = nullptr;
-
-    ApplicationCallbackExecCtx* ctx = Get();
-
-    if (ctx->head_ == nullptr) {
-      ctx->head_ = functor;
-    }
-    if (ctx->tail_ != nullptr) {
-      ctx->tail_->internal_next = functor;
-    }
-    ctx->tail_ = functor;
-  }
-
-  static bool Available() { return Get() != nullptr; }
-
- private:
-  uintptr_t flags_{0u};
-  grpc_completion_queue_functor* head_{nullptr};
-  grpc_completion_queue_functor* tail_{nullptr};
-
-#if !defined(_WIN32) || !defined(_DLL)
-  static thread_local ApplicationCallbackExecCtx* callback_exec_ctx_;
-#else
-  // cannot be thread_local data member (e.g. callback_exec_ctx_) on windows
-  static ApplicationCallbackExecCtx*& callback_exec_ctx();
-#endif
-};
-
 template <typename F>
 void EnsureRunInExecCtx(F f) {
   if (ExecCtx::Get() == nullptr) {
-    ApplicationCallbackExecCtx app_ctx;
     ExecCtx exec_ctx;
     f();
   } else {

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

@@ -85,17 +85,6 @@ size_t Executor::RunClosures(const char* executor_name,
                              grpc_closure_list list) {
   size_t n = 0;
 
-  // In the executor, the ExecCtx for the thread is declared in the executor
-  // thread itself, but this is the point where we could start seeing
-  // application-level callbacks. No need to create a new ExecCtx, though,
-  // since there already is one and it is flushed (but not destructed) in this
-  // function itself. The ApplicationCallbackExecCtx will have its callbacks
-  // invoked on its destruction, which will be after completing any closures in
-  // the executor's closure list (which were explicitly scheduled onto the
-  // executor).
-  ApplicationCallbackExecCtx callback_exec_ctx(
-      GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD);
-
   grpc_closure* c = list.head;
   while (c != nullptr) {
     grpc_closure* next = c->next_data.next;

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

@@ -166,7 +166,6 @@ DNSResolver::TaskHandle NativeDNSResolver::LookupSRV(
     grpc_pollset_set* /* interested_parties */,
     absl::string_view /* name_server */) {
   grpc_event_engine::experimental::GetDefaultEventEngine()->Run([on_resolved] {
-    ApplicationCallbackExecCtx app_exec_ctx;
     ExecCtx exec_ctx;
     on_resolved(absl::UnimplementedError(
         "The Native resolver does not support looking up SRV records"));
@@ -181,7 +180,6 @@ DNSResolver::TaskHandle NativeDNSResolver::LookupTXT(
     absl::string_view /* name_server */) {
   // Not supported
   grpc_event_engine::experimental::GetDefaultEventEngine()->Run([on_resolved] {
-    ApplicationCallbackExecCtx app_exec_ctx;
     ExecCtx exec_ctx;
     on_resolved(absl::UnimplementedError(
         "The Native resolver does not support looking up TXT records"));

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

@@ -164,7 +164,6 @@ DNSResolver::TaskHandle NativeDNSResolver::LookupSRV(
     grpc_pollset_set* /* interested_parties */,
     absl::string_view /* name_server */) {
   RunCallbackOnDefaultEventEngine([on_resolved] {
-    ApplicationCallbackExecCtx app_exec_ctx;
     ExecCtx exec_ctx;
     on_resolved(absl::UnimplementedError(
         "The Native resolver does not support looking up SRV records"));
@@ -179,7 +178,6 @@ DNSResolver::TaskHandle NativeDNSResolver::LookupTXT(
     absl::string_view /* name_server */) {
   // Not supported
   RunCallbackOnDefaultEventEngine([on_resolved] {
-    ApplicationCallbackExecCtx app_exec_ctx;
     ExecCtx exec_ctx;
     on_resolved(absl::UnimplementedError(
         "The Native resolver does not support looking up TXT records"));

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

@@ -18,7 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "absl/types/optional.h"
+#include <optional>
+
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKETUTILS
@@ -45,7 +46,7 @@ using ::grpc_core::PosixTcpOptions;
 namespace {
 
 int AdjustValue(int default_value, int min_value, int max_value,
-                absl::optional<int> actual_value) {
+                std::optional<int> actual_value) {
   if (!actual_value.has_value() || *actual_value < min_value ||
       *actual_value > max_value) {
     return default_value;

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

@@ -19,11 +19,12 @@
 #include <grpc/impl/grpc_types.h>
 #include <grpc/support/port_platform.h>
 
+#include <optional>
+
 #include "absl/base/thread_annotations.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/port.h"
 
@@ -815,7 +816,7 @@ static void maybe_post_reclaimer(grpc_tcp* tcp)
     TCP_REF(tcp, "posted_reclaimer");
     tcp->memory_owner.PostReclaimer(
         grpc_core::ReclamationPass::kBenign,
-        [tcp](absl::optional<grpc_core::ReclamationSweep> sweep) {
+        [tcp](std::optional<grpc_core::ReclamationSweep> sweep) {
           if (sweep.has_value()) {
             perform_reclamation(tcp);
           }

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

@@ -126,7 +126,6 @@ static grpc_error_handle CreateEventEngineListener(
         [s](int listener_fd, std::unique_ptr<EventEngine::Endpoint> ep,
             bool is_external, MemoryAllocator /*allocator*/,
             SliceBuffer* pending_data) {
-          grpc_core::ApplicationCallbackExecCtx app_ctx;
           grpc_core::ExecCtx exec_ctx;
           grpc_pollset* read_notifier_pollset;
           grpc_tcp_server_acceptor* acceptor;
@@ -213,7 +212,6 @@ static grpc_error_handle CreateEventEngineListener(
   } else {
     EventEngine::Listener::AcceptCallback accept_cb =
         [s](std::unique_ptr<EventEngine::Endpoint> ep, MemoryAllocator) {
-          grpc_core::ApplicationCallbackExecCtx app_ctx;
           grpc_core::ExecCtx exec_ctx;
           void* cb_arg;
           {
@@ -636,7 +634,7 @@ static grpc_error_handle tcp_server_add_port(grpc_tcp_server* s,
             }
             DCHECK_GT(*listen_fd, 0);
             s->listen_fd_to_index_map.insert_or_assign(
-                *listen_fd, std::make_tuple(s->n_bind_ports, fd_index++));
+                *listen_fd, std::tuple(s->n_bind_ports, fd_index++));
           });
     } else {
       port = s->ee_listener->Bind(

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

@@ -650,7 +650,6 @@ static grpc_error_handle event_engine_create(grpc_closure* shutdown_complete,
   auto accept_cb = [s, on_accept_cb, on_accept_cb_arg](
                        std::unique_ptr<EventEngine::Endpoint> endpoint,
                        MemoryAllocator memory_allocator) {
-    grpc_core::ApplicationCallbackExecCtx app_ctx;
     grpc_core::ExecCtx exec_ctx;
     grpc_tcp_server_acceptor* acceptor =
         static_cast<grpc_tcp_server_acceptor*>(gpr_malloc(sizeof(*acceptor)));

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

@@ -97,14 +97,6 @@ void grpc_timer_manager_tick() {
 }
 
 static void run_some_timers() {
-  // In the case of timers, the ExecCtx for the thread is declared
-  // in the timer thread itself, but this is the point where we
-  // could start seeing application-level callbacks. No need to
-  // create a new ExecCtx, though, since there already is one and it is
-  // flushed (but not destructed) in this function itself
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx(
-      GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD);
-
   // if there's something to execute...
   gpr_mu_lock(&g_mu);
   // remove a waiter from the pool, and start another thread if necessary
@@ -241,7 +233,7 @@ static void timer_main_loop() {
         GRPC_TRACE_LOG(timer_check, INFO)
             << "timers not checked: expect another thread to";
         next = grpc_core::Timestamp::InfFuture();
-        ABSL_FALLTHROUGH_INTENDED;
+        [[fallthrough]];
       case GRPC_TIMERS_CHECKED_AND_EMPTY:
         if (!wait_until(next)) {
           return;

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

@@ -30,7 +30,9 @@ namespace grpc_core {
 ///////////////////////////////////////////////////////////////////////////////
 // GLOBALS
 
+#if !defined(_WIN32) || !defined(_DLL)
 thread_local Activity* Activity::g_current_activity_{nullptr};
+#endif
 
 namespace promise_detail {
 

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

@@ -21,6 +21,7 @@
 #include <algorithm>
 #include <atomic>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 
@@ -28,7 +29,6 @@
 #include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/detail/promise_factory.h"
@@ -121,11 +121,16 @@ class Waker {
     return wakeable_and_arg_.ActivityDebugTag();
   }
 
-  std::string DebugString() {
+  std::string DebugString() const {
     return absl::StrFormat("Waker{%p, %d}", wakeable_and_arg_.wakeable,
                            wakeable_and_arg_.wakeup_mask);
   }
 
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, const Waker& waker) {
+    sink.Append(waker.DebugString());
+  }
+
   // This is for tests to assert that a waker is occupied or not.
   bool is_unwakeable() const {
     return wakeable_and_arg_.wakeable == promise_detail::unwakeable();
@@ -167,6 +172,11 @@ class IntraActivityWaiter {
 
   std::string DebugString() const;
 
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, const IntraActivityWaiter& waker) {
+    sink.Append(waker.DebugString());
+  }
+
  private:
   WakeupMask wakeups_ = 0;
 };
@@ -205,7 +215,7 @@ class Activity : public Orphanable {
   //   locked
   // - back up that assertion with a runtime check in debug builds (it's
   //   prohibitively expensive in non-debug builds)
-  static Activity* current() { return g_current_activity_; }
+  static Activity* current() { return current_ref(); }
 
   // Produce an activity-owning Waker. The produced waker will keep the activity
   // alive until it's awoken or dropped.
@@ -222,17 +232,16 @@ class Activity : public Orphanable {
  protected:
   // Check if this activity is the current activity executing on the current
   // thread.
-  bool is_current() const { return this == g_current_activity_; }
+  bool is_current() const { return this == current(); }
   // Check if there is an activity executing on the current thread.
-  static bool have_current() { return g_current_activity_ != nullptr; }
+  static bool have_current() { return current() != nullptr; }
   // Set the current activity at construction, clean it up at destruction.
   class ScopedActivity {
    public:
-    explicit ScopedActivity(Activity* activity)
-        : prior_activity_(g_current_activity_) {
-      g_current_activity_ = activity;
+    explicit ScopedActivity(Activity* activity) : prior_activity_(current()) {
+      current_ref() = activity;
     }
-    ~ScopedActivity() { g_current_activity_ = prior_activity_; }
+    ~ScopedActivity() { current_ref() = prior_activity_; }
     ScopedActivity(const ScopedActivity&) = delete;
     ScopedActivity& operator=(const ScopedActivity&) = delete;
 
@@ -241,9 +250,21 @@ class Activity : public Orphanable {
   };
 
  private:
+  static Activity*& current_ref() {
+#if !defined(_WIN32) || !defined(_DLL)
+    return g_current_activity_;
+#else
+    // Set during RunLoop to the Activity that's executing.
+    // Being set implies that mu_ is held.
+    static thread_local Activity* current_activity;
+    return current_activity;
+#endif
+  }
+#if !defined(_WIN32) || !defined(_DLL)
   // Set during RunLoop to the Activity that's executing.
   // Being set implies that mu_ is held.
   static thread_local Activity* g_current_activity_;
+#endif
 };
 
 // Owned pointer to one Activity.
@@ -587,7 +608,7 @@ class PromiseActivity final
   // The main body of a step: set the current activity, and any contexts, and
   // then run the main polling loop. Contained in a function by itself in
   // order to keep the scoping rules a little easier in Step().
-  absl::optional<ResultType> RunStep() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu()) {
+  std::optional<ResultType> RunStep() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu()) {
     ScopedActivity scoped_activity(this);
     ScopedContext contexts(this);
     return StepLoop();
@@ -596,7 +617,7 @@ class PromiseActivity final
   // Similarly to RunStep, but additionally construct the promise from a
   // promise factory before entering the main loop. Called once from the
   // constructor.
-  absl::optional<ResultType> Start(Factory promise_factory)
+  std::optional<ResultType> Start(Factory promise_factory)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu()) {
     ScopedActivity scoped_activity(this);
     ScopedContext contexts(this);
@@ -606,7 +627,7 @@ class PromiseActivity final
 
   // Until there are no wakeups from within and the promise is incomplete:
   // poll the promise.
-  absl::optional<ResultType> StepLoop() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu()) {
+  std::optional<ResultType> StepLoop() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu()) {
     CHECK(is_current());
     while (true) {
       // Run the promise.

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

@@ -57,11 +57,8 @@ struct JoinState<Traits, P0, P1> {
     Construct(&promise0, std::forward<P0>(p0));
     Construct(&promise1, std::forward<P1>(p1));
   }
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) {
-    DCHECK(other.ready.none());
-    Construct(&promise0, other.promise0);
-    Construct(&promise1, other.promise1);
-  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) =
+      delete;
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
@@ -163,12 +160,8 @@ struct JoinState<Traits, P0, P1, P2> {
     Construct(&promise1, std::forward<P1>(p1));
     Construct(&promise2, std::forward<P2>(p2));
   }
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) {
-    DCHECK(other.ready.none());
-    Construct(&promise0, other.promise0);
-    Construct(&promise1, other.promise1);
-    Construct(&promise2, other.promise2);
-  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) =
+      delete;
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
@@ -307,13 +300,8 @@ struct JoinState<Traits, P0, P1, P2, P3> {
     Construct(&promise2, std::forward<P2>(p2));
     Construct(&promise3, std::forward<P3>(p3));
   }
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) {
-    DCHECK(other.ready.none());
-    Construct(&promise0, other.promise0);
-    Construct(&promise1, other.promise1);
-    Construct(&promise2, other.promise2);
-    Construct(&promise3, other.promise3);
-  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) =
+      delete;
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
@@ -488,14 +476,8 @@ struct JoinState<Traits, P0, P1, P2, P3, P4> {
     Construct(&promise3, std::forward<P3>(p3));
     Construct(&promise4, std::forward<P4>(p4));
   }
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) {
-    DCHECK(other.ready.none());
-    Construct(&promise0, other.promise0);
-    Construct(&promise1, other.promise1);
-    Construct(&promise2, other.promise2);
-    Construct(&promise3, other.promise3);
-    Construct(&promise4, other.promise4);
-  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) =
+      delete;
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
@@ -706,15 +688,8 @@ struct JoinState<Traits, P0, P1, P2, P3, P4, P5> {
     Construct(&promise4, std::forward<P4>(p4));
     Construct(&promise5, std::forward<P5>(p5));
   }
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) {
-    DCHECK(other.ready.none());
-    Construct(&promise0, other.promise0);
-    Construct(&promise1, other.promise1);
-    Construct(&promise2, other.promise2);
-    Construct(&promise3, other.promise3);
-    Construct(&promise4, other.promise4);
-    Construct(&promise5, other.promise5);
-  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) =
+      delete;
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
@@ -961,16 +936,8 @@ struct JoinState<Traits, P0, P1, P2, P3, P4, P5, P6> {
     Construct(&promise5, std::forward<P5>(p5));
     Construct(&promise6, std::forward<P6>(p6));
   }
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) {
-    DCHECK(other.ready.none());
-    Construct(&promise0, other.promise0);
-    Construct(&promise1, other.promise1);
-    Construct(&promise2, other.promise2);
-    Construct(&promise3, other.promise3);
-    Construct(&promise4, other.promise4);
-    Construct(&promise5, other.promise5);
-    Construct(&promise6, other.promise6);
-  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) =
+      delete;
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
@@ -1253,17 +1220,8 @@ struct JoinState<Traits, P0, P1, P2, P3, P4, P5, P6, P7> {
     Construct(&promise6, std::forward<P6>(p6));
     Construct(&promise7, std::forward<P7>(p7));
   }
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) {
-    DCHECK(other.ready.none());
-    Construct(&promise0, other.promise0);
-    Construct(&promise1, other.promise1);
-    Construct(&promise2, other.promise2);
-    Construct(&promise3, other.promise3);
-    Construct(&promise4, other.promise4);
-    Construct(&promise5, other.promise5);
-    Construct(&promise6, other.promise6);
-    Construct(&promise7, other.promise7);
-  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) =
+      delete;
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
@@ -1581,18 +1539,8 @@ struct JoinState<Traits, P0, P1, P2, P3, P4, P5, P6, P7, P8> {
     Construct(&promise7, std::forward<P7>(p7));
     Construct(&promise8, std::forward<P8>(p8));
   }
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) {
-    DCHECK(other.ready.none());
-    Construct(&promise0, other.promise0);
-    Construct(&promise1, other.promise1);
-    Construct(&promise2, other.promise2);
-    Construct(&promise3, other.promise3);
-    Construct(&promise4, other.promise4);
-    Construct(&promise5, other.promise5);
-    Construct(&promise6, other.promise6);
-    Construct(&promise7, other.promise7);
-    Construct(&promise8, other.promise8);
-  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) =
+      delete;
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {