grpc 1.68.1 → 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/iomgr.cc

@@ -27,7 +27,7 @@
 #include <string.h>
 
 #include "absl/log/log.h"
-#include "src/core/lib/config/config_vars.h"
+#include "src/core/config/config_vars.h"
 #include "src/core/lib/iomgr/buffer_list.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/executor.h"

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

@@ -85,7 +85,8 @@ void grpc_set_default_iomgr_platform() {
 }
 
 bool grpc_iomgr_run_in_background() {
-  return grpc_event_engine_run_in_background();
+  return grpc_core::IsEventEngineCallbackCqEnabled() ||
+         grpc_event_engine_run_in_background();
 }
 
 #endif  // GRPC_POSIX_SOCKET_IOMGR

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

@@ -107,6 +107,8 @@ void grpc_set_default_iomgr_platform() {
   grpc_set_iomgr_platform_vtable(&vtable);
 }
 
-bool grpc_iomgr_run_in_background() { return false; }
+bool grpc_iomgr_run_in_background() {
+  return grpc_core::IsEventEngineCallbackCqEnabled();
+}
 
 #endif  // GRPC_WINSOCK_SOCKET

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

@@ -82,7 +82,7 @@ typedef enum __ns_type {
   ns_t_cert = 37,      // Certification record
   ns_t_a6 = 38,        // IPv6 address (deprecates AAAA)
   ns_t_dname = 39,     // Non-terminal DNAME (for IPv6)
-  ns_t_sink = 40,      // Kitchen sink (experimentatl)
+  ns_t_sink = 40,      // Kitchen sink (experimental)
   ns_t_opt = 41,       // EDNS0 option (meta-RR)
   ns_t_apl = 42,       // Address prefix list (RFC3123)
   ns_t_ds = 43,        // Delegation Signer (RFC4034)

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_client_posix.cc

@@ -346,7 +346,7 @@ int64_t grpc_tcp_client_create_from_prepared_fd(
   }
 
   if (err >= 0) {
-    // Connection already succeded. Return 0 to discourage any cancellation
+    // Connection already succeeded. Return 0 to discourage any cancellation
     // attempts.
     *ep = grpc_tcp_client_create_from_fd(fdobj, options, *addr_uri);
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, absl::OkStatus());
@@ -459,7 +459,7 @@ static bool tcp_cancel_connect(int64_t connection_handle) {
     ac->connect_cancelled = true;
     // Shutdown the fd. This would cause on_writable to run as soon as possible.
     // We dont need to pass a custom error here because it wont be used since
-    // the on_connect_closure is not run if connect cancellation is successfull.
+    // the on_connect_closure is not run if connect cancellation is successful.
     grpc_fd_shutdown(ac->fd, absl::OkStatus());
   }
   bool done = (--ac->refs == 0);

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

@@ -96,12 +96,12 @@ static void on_connect(void* acp, grpc_error_handle error) {
 
   if (error.ok()) {
     if (socket != NULL) {
-      DWORD transfered_bytes = 0;
+      DWORD transferred_bytes = 0;
       DWORD flags;
       BOOL wsa_success =
           WSAGetOverlappedResult(socket->socket, &socket->write_info.overlapped,
-                                 &transfered_bytes, FALSE, &flags);
-      CHECK_EQ(transfered_bytes, 0);
+                                 &transferred_bytes, FALSE, &flags);
+      CHECK_EQ(transferred_bytes, 0);
       if (!wsa_success) {
         error = GRPC_WSA_ERROR(WSAGetLastError(), "ConnectEx");
         closesocket(socket->socket);

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"
 
@@ -325,7 +326,7 @@ class TcpZerocopySendCtx {
   size_t threshold_bytes() const { return threshold_bytes_; }
 
   // Expected to be called by handler reading messages from the err queue.
-  // It is used to indicate that some OMem meory is now available. It returns
+  // It is used to indicate that some OMem memory is now available. It returns
   // true to tell the caller to mark the file descriptor as immediately
   // writable.
   //
@@ -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_posix.h

@@ -38,7 +38,7 @@
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/socket_utils_posix.h"
 
-/// Create a tcp endpoint given a file desciptor and a read slice size.
+/// Create a tcp endpoint given a file descriptor and a read slice size.
 /// Takes ownership of \a fd. Takes ownership of the \a slice_allocator.
 grpc_endpoint* grpc_tcp_create(grpc_fd* fd,
                                const grpc_core::PosixTcpOptions& options,

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_utils_posix_ifaddrs.cc

@@ -88,7 +88,7 @@ static grpc_error_handle get_unused_port(int* port) {
   return *port <= 0 ? GRPC_ERROR_CREATE("Bad port") : absl::OkStatus();
 }
 
-static bool grpc_is_ipv4_availabile() {
+static bool grpc_is_ipv4_available() {
   const int fd = socket(AF_INET, SOCK_DGRAM, 0);
   if (fd >= 0) close(fd);
   return fd >= 0;
@@ -116,7 +116,7 @@ grpc_error_handle grpc_tcp_server_add_all_local_addrs(grpc_tcp_server* s,
     VLOG(2) << "Picked unused port " << requested_port;
   }
 
-  static bool v4_available = grpc_is_ipv4_availabile();
+  static bool v4_available = grpc_is_ipv4_available();
 
   if (getifaddrs(&ifa) != 0 || ifa == nullptr) {
     return GRPC_OS_ERROR(errno, "getifaddrs");

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

@@ -371,7 +371,7 @@ static void on_accept(void* arg, grpc_error_handle error) {
   grpc_winsocket_callback_info* info = &sp->socket->read_info;
   grpc_endpoint* ep = NULL;
   grpc_resolved_address peer_name;
-  DWORD transfered_bytes;
+  DWORD transferred_bytes;
   DWORD flags;
   BOOL wsa_success;
   int err;
@@ -392,9 +392,9 @@ static void on_accept(void* arg, grpc_error_handle error) {
   }
   // The IOCP notified us of a completed operation. Let's grab the results,
   // and act accordingly.
-  transfered_bytes = 0;
+  transferred_bytes = 0;
   wsa_success = WSAGetOverlappedResult(sock, &info->overlapped,
-                                       &transfered_bytes, FALSE, &flags);
+                                       &transferred_bytes, FALSE, &flags);
   if (!wsa_success) {
     if (!sp->shutting_down) {
       char* utf8_message = gpr_format_message(WSAGetLastError());
@@ -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_generic.cc

@@ -405,7 +405,7 @@ static void timer_init(grpc_timer* timer, grpc_core::Timestamp deadline,
 #else
         // On 32-bit systems, gpr_atm_no_barrier_store does not work on 64-bit
         // types (like grpc_core::Timestamp). So all reads and writes to
-        // g_shared_mutables.min_timer varialbe under g_shared_mutables.mu
+        // g_shared_mutables.min_timer variable under g_shared_mutables.mu
         g_shared_mutables.min_timer = deadline;
 #endif
         grpc_kick_poller();

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

@@ -48,7 +48,7 @@ static void adjust_upwards(grpc_timer** first, uint32_t i, grpc_timer* t) {
 static void adjust_downwards(grpc_timer** first, uint32_t i, uint32_t length,
                              grpc_timer* t) {
   for (;;) {
-    uint32_t left_child = 1u + 2u * i;
+    uint32_t left_child = 1u + (2u * i);
     if (left_child >= length) break;
     uint32_t right_child = left_child + 1;
     uint32_t next_i = right_child < length && first[left_child]->deadline >

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/iomgr/wakeup_fd_pipe.cc

@@ -98,4 +98,4 @@ const grpc_wakeup_fd_vtable grpc_pipe_wakeup_fd_vtable = {
     pipe_init, pipe_consume, pipe_wakeup, pipe_destroy,
     pipe_check_availability};
 
-#endif  // GPR_POSIX_WAKUP_FD
+#endif  // GRPC_POSIX_WAKEUP_FD

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;
 };
@@ -203,9 +213,9 @@ class Activity : public Orphanable {
   // - assert that there is a current activity (and catch bugs if there's not)
   // - indicate to thread safety analysis that the current activity is indeed
   //   locked
-  // - back up that assertation with a runtime check in debug builds (it's
+  // - 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.