grpc 1.72.0 → 1.74.0.pre2

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

@@ -21,62 +21,48 @@
 #include "src/core/lib/iomgr/port.h"
 #ifdef GRPC_POSIX_SOCKET_RESOLVE_ADDRESS
 
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 #include <grpc/support/time.h>
 #include <string.h>
 #include <sys/types.h>
 
-#include "src/core/lib/event_engine/default_event_engine.h"
+#include <atomic>
+#include <functional>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 #include "src/core/lib/iomgr/block_annotate.h"
+#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/executor.h"
-#include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/resolve_address_posix.h"
-#include "src/core/lib/iomgr/sockaddr.h"
-#include "src/core/lib/iomgr/unix_sockets_posix.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/transport/error_utils.h"
-#include "src/core/util/crash.h"
 #include "src/core/util/host_port.h"
-#include "src/core/util/string.h"
-#include "src/core/util/thd.h"
+#include "src/core/util/time.h"
 #include "src/core/util/useful.h"
-
 namespace grpc_core {
-namespace {
-
-class NativeDNSRequest {
- public:
-  NativeDNSRequest(
-      absl::string_view name, absl::string_view default_port,
-      std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
-          on_done)
-      : name_(name), default_port_(default_port), on_done_(std::move(on_done)) {
-    GRPC_CLOSURE_INIT(&request_closure_, DoRequestThread, this, nullptr);
-    Executor::Run(&request_closure_, absl::OkStatus(), ExecutorType::RESOLVER);
-  }
-
- private:
-  // Callback to be passed to grpc Executor to asynch-ify
-  // LookupHostnameBlocking
-  static void DoRequestThread(void* rp, grpc_error_handle /*error*/) {
-    NativeDNSRequest* r = static_cast<NativeDNSRequest*>(rp);
-    auto result =
-        GetDNSResolver()->LookupHostnameBlocking(r->name_, r->default_port_);
-    // running inline is safe since we've already been scheduled on the executor
-    r->on_done_(std::move(result));
-    delete r;
-  }
-
-  const std::string name_;
-  const std::string default_port_;
-  const std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
-      on_done_;
-  grpc_closure request_closure_;
-};
 
-}  // namespace
+grpc_event_engine::experimental::EventEngine* NativeDNSResolver::engine() {
+  // Optimistically, if the engine is already created, return it.
+  auto engine_ptr = engine_ptr_.load(std::memory_order_relaxed);
+  if (engine_ptr != nullptr) return engine_ptr;
+  // Otherwise, create the engine under the lock.
+  // This is only if some other thread did not already create it.
+  MutexLock lock(&mu_);
+  if (engine_ != nullptr) return engine_.get();
+  engine_ = grpc_event_engine::experimental::GetDefaultEventEngine();
+  engine_ptr_.store(engine_.get(), std::memory_order_relaxed);
+  return engine_.get();
+}
 
 DNSResolver::TaskHandle NativeDNSResolver::LookupHostname(
     std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
@@ -84,8 +70,12 @@ DNSResolver::TaskHandle NativeDNSResolver::LookupHostname(
     absl::string_view name, absl::string_view default_port,
     Duration /* timeout */, grpc_pollset_set* /* interested_parties */,
     absl::string_view /* name_server */) {
-  // self-deleting class
-  new NativeDNSRequest(name, default_port, std::move(on_done));
+  engine()->Run([on_done = std::move(on_done), name = std::string(name),
+                 default_port = std::string(default_port)]() {
+    ExecCtx exec_ctx;
+    auto result = GetDNSResolver()->LookupHostnameBlocking(name, default_port);
+    on_done(std::move(result));
+  });
   return kNullHandle;
 }
 
@@ -165,12 +155,12 @@ DNSResolver::TaskHandle NativeDNSResolver::LookupSRV(
     absl::string_view /* name */, Duration /* timeout */,
     grpc_pollset_set* /* interested_parties */,
     absl::string_view /* name_server */) {
-  grpc_event_engine::experimental::GetDefaultEventEngine()->Run([on_resolved] {
+  engine()->Run([on_resolved] {
     ExecCtx exec_ctx;
     on_resolved(absl::UnimplementedError(
         "The Native resolver does not support looking up SRV records"));
   });
-  return {-1, -1};
+  return kNullHandle;
 };
 
 DNSResolver::TaskHandle NativeDNSResolver::LookupTXT(
@@ -179,12 +169,12 @@ DNSResolver::TaskHandle NativeDNSResolver::LookupTXT(
     grpc_pollset_set* /* interested_parties */,
     absl::string_view /* name_server */) {
   // Not supported
-  grpc_event_engine::experimental::GetDefaultEventEngine()->Run([on_resolved] {
+  engine()->Run([on_resolved] {
     ExecCtx exec_ctx;
     on_resolved(absl::UnimplementedError(
         "The Native resolver does not support looking up TXT records"));
   });
-  return {-1, -1};
+  return kNullHandle;
 };
 
 bool NativeDNSResolver::Cancel(TaskHandle /*handle*/) { return false; }

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

@@ -20,9 +20,11 @@
 #include <grpc/support/port_platform.h>
 
 #include <functional>
+#include <memory>
 
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/util/sync.h"
 
 namespace grpc_core {
 
@@ -56,6 +58,19 @@ class NativeDNSResolver : public DNSResolver {
 
   // NativeDNSResolver does not support cancellation.
   bool Cancel(TaskHandle handle) override;
+
+ private:
+  // Lazily instantiate and return a pointer to the owned EventEngine.
+  // The engine needs to be lazily instantiated to avoid a mutex reacquisition,
+  // because the NativeDNSResolver is created in grpc_init, and creating an
+  // EventEngine calls grpc_init.
+  grpc_event_engine::experimental::EventEngine* engine();
+
+  Mutex mu_;
+  std::shared_ptr<grpc_event_engine::experimental::EventEngine> engine_
+      ABSL_GUARDED_BY(mu_);
+  std::atomic<grpc_event_engine::experimental::EventEngine*> engine_ptr_{
+      nullptr};
 };
 
 }  // namespace grpc_core

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

@@ -34,7 +34,6 @@
 #include "src/core/lib/event_engine/default_event_engine.h"
 #include "src/core/lib/iomgr/block_annotate.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/resolve_address_windows.h"
@@ -46,41 +45,19 @@
 #include "src/core/util/thd.h"
 
 namespace grpc_core {
-namespace {
-
-class NativeDNSRequest {
- public:
-  NativeDNSRequest(
-      absl::string_view name, absl::string_view default_port,
-      std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
-          on_done)
-      : name_(name), default_port_(default_port), on_done_(std::move(on_done)) {
-    GRPC_CLOSURE_INIT(&request_closure_, DoRequestThread, this, nullptr);
-    Executor::Run(&request_closure_, absl::OkStatus(), ExecutorType::RESOLVER);
-  }
-
- private:
-  // Callback to be passed to grpc Executor to asynch-ify
-  // LookupHostnameBlocking
-  static void DoRequestThread(void* rp, grpc_error_handle /*error*/) {
-    NativeDNSRequest* r = static_cast<NativeDNSRequest*>(rp);
-    auto result =
-        GetDNSResolver()->LookupHostnameBlocking(r->name_, r->default_port_);
-    // running inline is safe since we've already been scheduled on the executor
-    r->on_done_(std::move(result));
-    delete r;
-  }
 
-  const std::string name_;
-  const std::string default_port_;
-  const std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
-      on_done_;
-  grpc_closure request_closure_;
-};
-
-}  // namespace
-
-NativeDNSResolver::NativeDNSResolver() {}
+grpc_event_engine::experimental::EventEngine* NativeDNSResolver::engine() {
+  // Optimistically, if the engine is already created, return it.
+  auto engine_ptr = engine_ptr_.load(std::memory_order_relaxed);
+  if (engine_ptr != nullptr) return engine_ptr;
+  // Otherwise, create the engine under the lock.
+  // This is only if some other thread did not already create it.
+  MutexLock lock(&mu_);
+  if (engine_ != nullptr) return engine_.get();
+  engine_ = grpc_event_engine::experimental::GetDefaultEventEngine();
+  engine_ptr_.store(engine_.get(), std::memory_order_relaxed);
+  return engine_.get();
+}
 
 DNSResolver::TaskHandle NativeDNSResolver::LookupHostname(
     std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
@@ -88,7 +65,12 @@ DNSResolver::TaskHandle NativeDNSResolver::LookupHostname(
     absl::string_view name, absl::string_view default_port,
     Duration /* timeout */, grpc_pollset_set* /* interested_parties */,
     absl::string_view /* name_server */) {
-  new NativeDNSRequest(name, default_port, std::move(on_resolved));
+  engine()->Run([on_resolved = std::move(on_resolved), name = std::string(name),
+                 default_port = std::string(default_port)]() {
+    ExecCtx exec_ctx;
+    auto result = GetDNSResolver()->LookupHostnameBlocking(name, default_port);
+    on_resolved(std::move(result));
+  });
   return kNullHandle;
 }
 
@@ -152,23 +134,18 @@ done:
   return error_result;
 }
 
-void RunCallbackOnDefaultEventEngine(absl::AnyInvocable<void()> f) {
-  auto engine = grpc_event_engine::experimental::GetDefaultEventEngine();
-  engine->Run([f = std::move(f), engine]() mutable { f(); });
-}
-
 DNSResolver::TaskHandle NativeDNSResolver::LookupSRV(
     std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
         on_resolved,
     absl::string_view /* name */, Duration /* deadline */,
     grpc_pollset_set* /* interested_parties */,
     absl::string_view /* name_server */) {
-  RunCallbackOnDefaultEventEngine([on_resolved] {
+  engine()->Run([on_resolved] {
     ExecCtx exec_ctx;
     on_resolved(absl::UnimplementedError(
         "The Native resolver does not support looking up SRV records"));
   });
-  return {-1, -1};
+  return kNullHandle;
 };
 
 DNSResolver::TaskHandle NativeDNSResolver::LookupTXT(
@@ -177,12 +154,12 @@ DNSResolver::TaskHandle NativeDNSResolver::LookupTXT(
     grpc_pollset_set* /* interested_parties */,
     absl::string_view /* name_server */) {
   // Not supported
-  RunCallbackOnDefaultEventEngine([on_resolved] {
+  engine()->Run([on_resolved] {
     ExecCtx exec_ctx;
     on_resolved(absl::UnimplementedError(
         "The Native resolver does not support looking up TXT records"));
   });
-  return {-1, -1};
+  return kNullHandle;
 };
 
 bool NativeDNSResolver::Cancel(TaskHandle /*handle*/) { return false; }

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

@@ -21,15 +21,15 @@
 
 #include <functional>
 
-#include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/util/sync.h"
 
 namespace grpc_core {
 
 // A DNS resolver which uses the native platform's getaddrinfo API.
 class NativeDNSResolver : public DNSResolver {
  public:
-  NativeDNSResolver();
+  NativeDNSResolver() = default;
 
   TaskHandle LookupHostname(
       std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
@@ -56,6 +56,19 @@ class NativeDNSResolver : public DNSResolver {
 
   // NativeDNSResolver does not support cancellation.
   bool Cancel(TaskHandle handle) override;
+
+ private:
+  // Lazily instantiate and return a pointer to the owned EventEngine.
+  // The engine needs to be lazily instantiated to avoid a mutex reacquisition,
+  // because the NativeDNSResolver is created in grpc_init, and creating an
+  // EventEngine calls grpc_init.
+  grpc_event_engine::experimental::EventEngine* engine();
+
+  Mutex mu_;
+  std::shared_ptr<grpc_event_engine::experimental::EventEngine> engine_
+      ABSL_GUARDED_BY(mu_);
+  std::atomic<grpc_event_engine::experimental::EventEngine*> engine_ptr_{
+      nullptr};
 };
 
 }  // namespace grpc_core

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

@@ -18,18 +18,20 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKET_TCP_CLIENT
 
 #include <errno.h>
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/time.h>
 #include <netinet/in.h>
 #include <string.h>
 #include <unistd.h>
 
+#include <memory>
+
 #include "absl/container/flat_hash_map.h"
 #include "absl/log/check.h"
 #include "absl/log/log.h"
@@ -39,7 +41,7 @@
 #include "src/core/lib/event_engine/shim.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/event_engine_shims/tcp_client.h"
-#include "src/core/lib/iomgr/executor.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_mutator.h"
@@ -70,6 +72,7 @@ struct async_connect {
   int64_t connection_handle;
   bool connect_cancelled;
   grpc_core::PosixTcpOptions options;
+  std::shared_ptr<grpc_event_engine::experimental::EventEngine> engine;
 };
 
 struct ConnectionShard {
@@ -270,17 +273,21 @@ finish:
     error =
         grpc_core::AddMessagePrefix("Failed to connect to remote host", error);
   }
+  auto engine = ac->engine;
   if (done) {
     // This is safe even outside the lock, because "done", the sentinel, is
     // populated *inside* the lock.
     gpr_mu_destroy(&ac->mu);
     delete ac;
   }
-  // Push async connect closure to the executor since this may actually be
-  // called during the shutdown process, in which case a deadlock could form
-  // between the core shutdown mu and the connector mu (b/188239051)
+  // Run the connect closure asynchronously since this may actually be called
+  // during the shutdown process, in which case a deadlock could form between
+  // the core shutdown mu and the connector mu (b/188239051)
   if (!connect_cancelled) {
-    grpc_core::Executor::Run(closure, error);
+    engine->Run([closure, error]() {
+      grpc_core::ExecCtx exec_ctx;
+      closure->cb(closure->cb_arg, error);
+    });
   }
 }
 
@@ -367,6 +374,7 @@ int64_t grpc_tcp_client_create_from_prepared_fd(
   ac->addr_str = addr_uri.value();
   ac->connection_handle = connection_id;
   ac->connect_cancelled = false;
+  ac->engine = grpc_event_engine::experimental::GetDefaultEventEngine();
   gpr_mu_init(&ac->mu);
   ac->refs = 2;
   GRPC_CLOSURE_INIT(&ac->write_closure, on_writable, ac,

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

@@ -61,7 +61,6 @@
 #include "src/core/lib/iomgr/buffer_list.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/event_engine_shims/endpoint.h"
-#include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/socket_utils_posix.h"
 #include "src/core/lib/iomgr/tcp_posix.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
@@ -558,7 +557,8 @@ struct grpc_tcp {
 
 struct backup_poller {
   gpr_mu* pollset_mu;
-  grpc_closure run_poller;
+  grpc_closure done_poller;
+  std::shared_ptr<grpc_event_engine::experimental::EventEngine> engine;
 };
 
 void LogCommonIOErrors(absl::string_view prefix, int error_no) {
@@ -619,11 +619,11 @@ static void done_poller(void* bp, grpc_error_handle /*error_ignored*/) {
   backup_poller* p = static_cast<backup_poller*>(bp);
   GRPC_TRACE_LOG(tcp, INFO) << "BACKUP_POLLER:" << p << " destroy";
   grpc_pollset_destroy(BACKUP_POLLER_POLLSET(p));
+  p->engine.reset();
   gpr_free(p);
 }
 
-static void run_poller(void* bp, grpc_error_handle /*error_ignored*/) {
-  backup_poller* p = static_cast<backup_poller*>(bp);
+static void run_poller(backup_poller* p) {
   GRPC_TRACE_LOG(tcp, INFO) << "BACKUP_POLLER:" << p << " run";
   gpr_mu_lock(p->pollset_mu);
   grpc_core::Timestamp deadline =
@@ -641,14 +641,15 @@ static void run_poller(void* bp, grpc_error_handle /*error_ignored*/) {
     g_backup_poller_mu->Unlock();
     GRPC_TRACE_LOG(tcp, INFO) << "BACKUP_POLLER:" << p << " shutdown";
     grpc_pollset_shutdown(BACKUP_POLLER_POLLSET(p),
-                          GRPC_CLOSURE_INIT(&p->run_poller, done_poller, p,
+                          GRPC_CLOSURE_INIT(&p->done_poller, done_poller, p,
                                             grpc_schedule_on_exec_ctx));
   } else {
     g_backup_poller_mu->Unlock();
     GRPC_TRACE_LOG(tcp, INFO) << "BACKUP_POLLER:" << p << " reschedule";
-    grpc_core::Executor::Run(&p->run_poller, absl::OkStatus(),
-                             grpc_core::ExecutorType::DEFAULT,
-                             grpc_core::ExecutorJobType::LONG);
+    p->engine->Run([p]() {
+      grpc_core::ExecCtx exec_ctx;
+      run_poller(p);
+    });
   }
 }
 
@@ -679,14 +680,15 @@ static void cover_self(grpc_tcp* tcp) {
     g_uncovered_notifications_pending = 2;
     p = static_cast<backup_poller*>(
         gpr_zalloc(sizeof(*p) + grpc_pollset_size()));
+    p->engine = grpc_event_engine::experimental::GetDefaultEventEngine();
     g_backup_poller = p;
     grpc_pollset_init(BACKUP_POLLER_POLLSET(p), &p->pollset_mu);
     g_backup_poller_mu->Unlock();
     GRPC_TRACE_LOG(tcp, INFO) << "BACKUP_POLLER:" << p << " create";
-    grpc_core::Executor::Run(
-        GRPC_CLOSURE_INIT(&p->run_poller, run_poller, p, nullptr),
-        absl::OkStatus(), grpc_core::ExecutorType::DEFAULT,
-        grpc_core::ExecutorJobType::LONG);
+    p->engine->Run([p]() {
+      grpc_core::ExecCtx exec_ctx;
+      run_poller(p);
+    });
   } else {
     old_count = g_uncovered_notifications_pending++;
     p = g_backup_poller;
@@ -1793,8 +1795,9 @@ static void tcp_handle_write(void* arg /* grpc_tcp */,
   }
 }
 
-static void tcp_write(grpc_endpoint* ep, grpc_slice_buffer* buf,
-                      grpc_closure* cb, void* arg, int /*max_frame_size*/) {
+static void tcp_write(
+    grpc_endpoint* ep, grpc_slice_buffer* buf, grpc_closure* cb,
+    grpc_event_engine::experimental::EventEngine::Endpoint::WriteArgs args) {
   grpc_tcp* tcp = reinterpret_cast<grpc_tcp*>(ep);
   grpc_error_handle error;
   TcpZerocopySendRecord* zerocopy_send_record = nullptr;
@@ -1833,8 +1836,9 @@ static void tcp_write(grpc_endpoint* ep, grpc_slice_buffer* buf,
     tcp->outgoing_buffer = buf;
     tcp->outgoing_byte_idx = 0;
   }
-  tcp->outgoing_buffer_arg = arg;
-  if (arg) {
+  tcp->outgoing_buffer_arg =
+      args.TakeDeprecatedAndDiscouragedGoogleSpecificPointer();
+  if (tcp->outgoing_buffer_arg) {
     CHECK(grpc_event_engine_can_track_errors());
   }
 
@@ -1913,7 +1917,9 @@ static const grpc_endpoint_vtable vtable = {tcp_read,
 grpc_endpoint* grpc_tcp_create(
     grpc_fd* fd, const grpc_event_engine::experimental::EndpointConfig& config,
     absl::string_view peer_string) {
-  if (grpc_core::IsEventEngineForAllOtherEndpointsEnabled()) {
+  if (grpc_core::IsEventEngineForAllOtherEndpointsEnabled() &&
+      !grpc_event_engine::experimental::
+          EventEngineExperimentDisabledForPython()) {
     // Create an EventEngine endpoint when creating the transport.
     auto* engine =
         reinterpret_cast<grpc_event_engine::experimental::EventEngine*>(
@@ -1941,7 +1947,9 @@ grpc_endpoint* grpc_tcp_create(grpc_fd* em_fd,
   CHECK(!grpc_event_engine::experimental::UsePollsetAlternative())
       << "This function must not be called when the pollset_alternative "
          "experiment is enabled. This is a bug.";
-  CHECK(!grpc_core::IsEventEngineForAllOtherEndpointsEnabled())
+  CHECK(
+      !grpc_core::IsEventEngineForAllOtherEndpointsEnabled() ||
+      grpc_event_engine::experimental::EventEngineExperimentDisabledForPython())
       << "The event_engine_for_all_other_endpoints experiment should prevent "
          "this method from being called. This is a bug.";
   grpc_tcp* tcp = new grpc_tcp(options);

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

@@ -145,15 +145,27 @@ void unlink_if_unix_domain_socket(const grpc_resolved_address* resolved_addr) {
   if (un->sun_path[0] == '\0' && un->sun_path[1] != '\0') {
     return;
   }
+  // Convert UTF-8 path to Unicode.
+  std::wstring wide_path;
+  int needed = MultiByteToWideChar(CP_UTF8, 0, un->sun_path, -1, NULL, 0);
+  if (needed <= 0) {
+    return;
+  }
+  wide_path.resize(needed, L'\0');
+  if (MultiByteToWideChar(CP_UTF8, 0, un->sun_path, -1, wide_path.data(),
+                          needed) == 0) {
+    // Failed to convert UTF-8 path to wide char.
+    return;
+  }
   // For windows we need to remove the file instead of unlink.
-  DWORD attr = ::GetFileAttributesA(un->sun_path);
+  DWORD attr = ::GetFileAttributesW(wide_path.data());
   if (attr == INVALID_FILE_ATTRIBUTES) {
     return;
   }
   if (attr & FILE_ATTRIBUTE_DIRECTORY || attr & FILE_ATTRIBUTE_READONLY) {
     return;
   }
-  ::DeleteFileA(un->sun_path);
+  ::DeleteFileW(wide_path.data());
 #else
   (void)resolved_addr;
 #endif

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

@@ -323,8 +323,9 @@ static void on_write(void* tcpp, grpc_error_handle error) {
 
 // Initiates a write.
 static void win_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                      grpc_closure* cb, void* /* arg */,
-                      int /* max_frame_size */) {
+                      grpc_closure* cb,
+                      grpc_event_engine::experimental::EventEngine::Endpoint::
+                          WriteArgs /*args*/) {
   grpc_tcp* tcp = (grpc_tcp*)ep;
   grpc_winsocket* socket = tcp->socket;
   grpc_winsocket_callback_info* info = &socket->write_info;

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

@@ -122,6 +122,7 @@ class Waker {
   }
 
   std::string DebugString() const {
+    if (is_unwakeable()) return "<unwakeable>";
     return absl::StrFormat("Waker{%p, %d}", wakeable_and_arg_.wakeable,
                            wakeable_and_arg_.wakeup_mask);
   }

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

@@ -48,6 +48,8 @@ template <typename T>
 struct Vtable {
   // Poll the promise, once.
   Poll<T> (*poll_once)(ArgType* arg);
+  // Move the promise to another memory location.
+  void (*move)(ArgType* dst, ArgType* src);
   // Destroy the underlying callable object if there is one.
   // Since we don't delete (the arena owns the memory) but we may need to call a
   // destructor, we expose this for when the ArenaPromise object is destroyed.
@@ -73,11 +75,12 @@ struct Null {
     GPR_UNREACHABLE_CODE(return Pending{});
   }
 
+  static void Move(ArgType*, ArgType*) {}
   static void Destroy(ArgType*) {}
 };
 
 template <typename T>
-const Vtable<T> Null<T>::vtable = {PollOnce, Destroy};
+const Vtable<T> Null<T>::vtable = {PollOnce, Move, Destroy};
 
 // Implementation of ImplInterface for a callable object.
 template <typename T, typename Callable>
@@ -88,11 +91,16 @@ struct AllocatedCallable {
     return poll_cast<T>((*ArgAsPtr<Callable>(arg))());
   }
 
+  static void Move(ArgType* dst, ArgType* src) {
+    ArgAsPtr<Callable>(dst) = ArgAsPtr<Callable>(src);
+  }
+
   static void Destroy(ArgType* arg) { Destruct(ArgAsPtr<Callable>(arg)); }
 };
 
 template <typename T, typename Callable>
-const Vtable<T> AllocatedCallable<T, Callable>::vtable = {PollOnce, Destroy};
+const Vtable<T> AllocatedCallable<T, Callable>::vtable = {PollOnce, Move,
+                                                          Destroy};
 
 // Implementation of ImplInterface for a small callable object (one that fits
 // within the ArgType arg)
@@ -104,13 +112,17 @@ struct Inlined {
     return poll_cast<T>((*reinterpret_cast<Callable*>(arg))());
   }
 
+  static void Move(ArgType* dst, ArgType* src) {
+    new (dst) Callable(reinterpret_cast<Callable&&>(*src));
+  }
+
   static void Destroy(ArgType* arg) {
     Destruct(reinterpret_cast<Callable*>(arg));
   }
 };
 
 template <typename T, typename Callable>
-const Vtable<T> Inlined<T, Callable>::vtable = {PollOnce, Destroy};
+const Vtable<T> Inlined<T, Callable>::vtable = {PollOnce, Move, Destroy};
 
 // If a callable object is empty we can substitute any instance of that callable
 // for the one we call (for how could we tell the difference)?
@@ -129,7 +141,7 @@ struct SharedCallable {
 };
 
 template <typename T, typename Callable>
-const Vtable<T> SharedCallable<T, Callable>::vtable = {PollOnce,
+const Vtable<T> SharedCallable<T, Callable>::vtable = {PollOnce, Null<T>::Move,
                                                        Null<T>::Destroy};
 
 // Redirector type: given a callable type, expose a Make() function that creates
@@ -199,13 +211,17 @@ class ArenaPromise {
   ArenaPromise(const ArenaPromise&) = delete;
   ArenaPromise& operator=(const ArenaPromise&) = delete;
   // ArenaPromise is movable.
-  ArenaPromise(ArenaPromise&& other) noexcept
-      : vtable_and_arg_(other.vtable_and_arg_) {
+  ArenaPromise(ArenaPromise&& other) noexcept {
+    vtable_and_arg_.vtable = other.vtable_and_arg_.vtable;
+    vtable_and_arg_.vtable->move(&vtable_and_arg_.arg,
+                                 &other.vtable_and_arg_.arg);
     other.vtable_and_arg_.vtable = &arena_promise_detail::Null<T>::vtable;
   }
   ArenaPromise& operator=(ArenaPromise&& other) noexcept {
     vtable_and_arg_.vtable->destroy(&vtable_and_arg_.arg);
-    vtable_and_arg_ = other.vtable_and_arg_;
+    vtable_and_arg_.vtable = other.vtable_and_arg_.vtable;
+    vtable_and_arg_.vtable->move(&vtable_and_arg_.arg,
+                                 &other.vtable_and_arg_.arg);
     other.vtable_and_arg_.vtable = &arena_promise_detail::Null<T>::vtable;
     return *this;
   }