grpc 1.53.0.pre2 → 1.54.0

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

@@ -30,6 +30,8 @@
 #include "absl/strings/str_cat.h"
 
 #include <grpc/event_engine/endpoint_config.h>
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/event_engine/memory_allocator.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/log_windows.h>
@@ -38,7 +40,15 @@
 #include <grpc/support/time.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/event_engine/memory_allocator_factory.h"
+#include "src/core/lib/event_engine/resolved_address_internal.h"
+#include "src/core/lib/event_engine/tcp_socket_utils.h"
+#include "src/core/lib/event_engine/windows/windows_engine.h"
+#include "src/core/lib/event_engine/windows/windows_listener.h"
 #include "src/core/lib/gprpp/crash.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/event_engine_shims/closure.h"
+#include "src/core/lib/iomgr/event_engine_shims/endpoint.h"
 #include "src/core/lib/iomgr/iocp_windows.h"
 #include "src/core/lib/iomgr/pollset_windows.h"
 #include "src/core/lib/iomgr/resolve_address.h"
@@ -47,11 +57,23 @@
 #include "src/core/lib/iomgr/tcp_server.h"
 #include "src/core/lib/iomgr/tcp_windows.h"
 #include "src/core/lib/resource_quota/api.h"
+#include "src/core/lib/resource_quota/resource_quota.h"
 #include "src/core/lib/slice/slice_internal.h"
 
 #define MIN_SAFE_ACCEPT_QUEUE_SIZE 100
 
+namespace {
+using ::grpc_event_engine::experimental::CreateResolvedAddress;
 using ::grpc_event_engine::experimental::EndpointConfig;
+using ::grpc_event_engine::experimental::EventEngine;
+using ::grpc_event_engine::experimental::grpc_event_engine_endpoint_create;
+using ::grpc_event_engine::experimental::MemoryAllocator;
+using ::grpc_event_engine::experimental::MemoryQuotaBasedMemoryAllocatorFactory;
+using ::grpc_event_engine::experimental::ResolvedAddressSetPort;
+using ::grpc_event_engine::experimental::RunEventEngineClosure;
+using ::grpc_event_engine::experimental::WindowsEventEngine;
+using ::grpc_event_engine::experimental::WindowsEventEngineListener;
+}  // namespace
 
 // one listening port
 typedef struct grpc_tcp_listener grpc_tcp_listener;
@@ -98,12 +120,15 @@ struct grpc_tcp_server {
 
   // shutdown callback
   grpc_closure* shutdown_complete;
+
+  // used for the EventEngine shim
+  WindowsEventEngineListener* ee_listener;
 };
 
 // Public function. Allocates the proper data structures to hold a
 // grpc_tcp_server.
 static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
-                                           const EndpointConfig& config,
+                                           const EndpointConfig& /* config */,
                                            grpc_tcp_server_cb on_accept_cb,
                                            void* on_accept_cb_arg,
                                            grpc_tcp_server** server) {
@@ -122,7 +147,7 @@ static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
   return absl::OkStatus();
 }
 
-static void destroy_server(void* arg, grpc_error_handle error) {
+static void destroy_server(void* arg, grpc_error_handle /* error */) {
   grpc_tcp_server* s = (grpc_tcp_server*)arg;
 
   // Now that the accepts have been aborted, we can destroy the sockets.
@@ -533,27 +558,169 @@ static void tcp_server_start(grpc_tcp_server* s,
   gpr_mu_unlock(&s->mu);
 }
 
-static unsigned tcp_server_port_fd_count(grpc_tcp_server* s,
-                                         unsigned port_index) {
+static unsigned tcp_server_port_fd_count(grpc_tcp_server* /* s */,
+                                         unsigned /* port_index */) {
   return 0;
 }
 
-static int tcp_server_port_fd(grpc_tcp_server* s, unsigned port_index,
-                              unsigned fd_index) {
+static int tcp_server_port_fd(grpc_tcp_server* /* s */,
+                              unsigned /* port_index */,
+                              unsigned /* fd_index */) {
   return -1;
 }
 
 static grpc_core::TcpServerFdHandler* tcp_server_create_fd_handler(
-    grpc_tcp_server* s) {
+    grpc_tcp_server* /* s */) {
   return nullptr;
 }
 
-static void tcp_server_shutdown_listeners(grpc_tcp_server* s) {}
+static void tcp_server_shutdown_listeners(grpc_tcp_server* /* s */) {}
+
+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_server_unref,         tcp_server_shutdown_listeners,
+    tcp_pre_allocated_fd,     tcp_set_pre_allocated_fd};
+
+// ---- EventEngine shim ------------------------------------------------------
+
+namespace {
+
+static grpc_error_handle event_engine_create(grpc_closure* shutdown_complete,
+                                             const EndpointConfig& config,
+                                             grpc_tcp_server_cb on_accept_cb,
+                                             void* on_accept_cb_arg,
+                                             grpc_tcp_server** server) {
+  // On Windows, the event_engine_listener experiment only supports the
+  // default engine
+  WindowsEventEngine* engine_ptr = reinterpret_cast<WindowsEventEngine*>(
+      config.GetVoidPointer(GRPC_INTERNAL_ARG_EVENT_ENGINE));
+  grpc_tcp_server* s = (grpc_tcp_server*)gpr_malloc(sizeof(grpc_tcp_server));
+  GPR_ASSERT(on_accept_cb != nullptr);
+  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)));
+    acceptor->from_server = s;
+    acceptor->port_index = -1;
+    acceptor->fd_index = -1;
+    acceptor->external_connection = false;
+    on_accept_cb(on_accept_cb_arg,
+                 grpc_event_engine_endpoint_create(std::move(endpoint)),
+                 nullptr, acceptor);
+  };
+  auto on_shutdown = [shutdown_complete](absl::Status status) {
+    RunEventEngineClosure(shutdown_complete, status);
+  };
+  grpc_core::RefCountedPtr<grpc_core::ResourceQuota> resource_quota;
+  {
+    void* tmp_quota = config.GetVoidPointer(GRPC_ARG_RESOURCE_QUOTA);
+    GPR_ASSERT(tmp_quota != nullptr);
+    resource_quota =
+        reinterpret_cast<grpc_core::ResourceQuota*>(tmp_quota)->Ref();
+  }
+  gpr_ref_init(&s->refs, 1);
+  gpr_mu_init(&s->mu);
+  s->ee_listener = new WindowsEventEngineListener(
+      engine_ptr->poller(), std::move(accept_cb), std::move(on_shutdown),
+      std::make_unique<MemoryQuotaBasedMemoryAllocatorFactory>(
+          resource_quota->memory_quota()),
+      engine_ptr->shared_from_this(), engine_ptr->executor(), config);
+  s->active_ports = -1;
+  s->on_accept_cb = [](void* /* arg */, grpc_endpoint* /* ep */,
+                       grpc_pollset* /* accepting_pollset */,
+                       grpc_tcp_server_acceptor* /* acceptor */) {
+    grpc_core::Crash("iomgr on_accept_cb callback should be unused");
+  };
+  s->on_accept_cb_arg = nullptr;
+  s->head = nullptr;
+  s->tail = nullptr;
+  s->shutdown_starting.head = nullptr;
+  s->shutdown_starting.tail = nullptr;
+  s->shutdown_complete = grpc_core::NewClosure([](absl::Status) {
+    grpc_core::Crash("iomgr shutdown_complete callback should be unused");
+  });
+  *server = s;
+  return absl::OkStatus();
+}
+
+static void event_engine_start(grpc_tcp_server* s,
+                               const std::vector<grpc_pollset*>* /*pollsets*/) {
+  GPR_ASSERT(s->ee_listener->Start().ok());
+}
+
+static grpc_error_handle event_engine_add_port(
+    grpc_tcp_server* s, const grpc_resolved_address* addr, int* port) {
+  GPR_ASSERT(addr != nullptr);
+  GPR_ASSERT(port != nullptr);
+  auto ee_addr = CreateResolvedAddress(*addr);
+  auto out_port = s->ee_listener->Bind(ee_addr);
+  *port = out_port.ok() ? *out_port : -1;
+  return out_port.status();
+}
+
+static grpc_core::TcpServerFdHandler* event_engine_create_fd_handler(
+    grpc_tcp_server* /* s */) {
+  return nullptr;
+}
+
+static unsigned event_engine_port_fd_count(grpc_tcp_server* /* s */,
+                                           unsigned /* port_index */) {
+  return 0;
+}
+
+static int event_engine_port_fd(grpc_tcp_server* /* s */,
+                                unsigned /* port_index */,
+                                unsigned /* fd_index */) {
+  return -1;
+}
+
+static grpc_tcp_server* event_engine_ref(grpc_tcp_server* s) {
+  gpr_ref_non_zero(&s->refs);
+  return s;
+}
+
+static void event_engine_shutdown_listeners(grpc_tcp_server* s) {
+  s->ee_listener->ShutdownListeners();
+}
+
+static void event_engine_unref(grpc_tcp_server* s) {
+  if (gpr_unref(&s->refs)) {
+    event_engine_shutdown_listeners(s);
+    gpr_mu_lock(&s->mu);
+    grpc_core::ExecCtx::RunList(DEBUG_LOCATION, &s->shutdown_starting);
+    gpr_mu_unlock(&s->mu);
+    gpr_mu_destroy(&s->mu);
+    delete s->ee_listener;
+    gpr_free(s);
+  }
+}
+
+static void event_engine_shutdown_starting_add(
+    grpc_tcp_server* s, grpc_closure* shutdown_starting) {
+  gpr_mu_lock(&s->mu);
+  grpc_closure_list_append(&s->shutdown_starting, shutdown_starting,
+                           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};
+
 #endif  // GRPC_WINSOCK_SOCKET

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

@@ -203,7 +203,8 @@ static void on_read(void* tcpp, grpc_error_handle error) {
         }
         GPR_ASSERT((size_t)info->bytes_transferred == tcp->read_slices->length);
 
-        if (grpc_tcp_trace.enabled()) {
+        if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace) &&
+            gpr_should_log(GPR_LOG_SEVERITY_INFO)) {
           size_t i;
           for (i = 0; i < tcp->read_slices->count; i++) {
             char* dump = grpc_dump_slice(tcp->read_slices->slices[i],
@@ -236,7 +237,8 @@ static void on_read(void* tcpp, grpc_error_handle error) {
 #define DEFAULT_TARGET_READ_SIZE 8192
 #define MAX_WSABUF_COUNT 16
 static void win_read(grpc_endpoint* ep, grpc_slice_buffer* read_slices,
-                     grpc_closure* cb, bool urgent, int /*min_progress_size*/) {
+                     grpc_closure* cb, bool /* urgent */,
+                     int /* min_progress_size */) {
   grpc_tcp* tcp = (grpc_tcp*)ep;
   grpc_winsocket* handle = tcp->socket;
   grpc_winsocket_callback_info* info = &handle->read_info;
@@ -341,7 +343,8 @@ 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, void* /* arg */,
+                      int /* max_frame_size */) {
   grpc_tcp* tcp = (grpc_tcp*)ep;
   grpc_winsocket* socket = tcp->socket;
   grpc_winsocket_callback_info* info = &socket->write_info;
@@ -353,7 +356,8 @@ static void win_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
   WSABUF* buffers = local_buffers;
   size_t len, async_buffers_offset = 0;
 
-  if (grpc_tcp_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace) &&
+      gpr_should_log(GPR_LOG_SEVERITY_INFO)) {
     size_t i;
     for (i = 0; i < slices->count; i++) {
       char* data =
@@ -466,8 +470,8 @@ static void win_add_to_pollset_set(grpc_endpoint* ep, grpc_pollset_set* pss) {
   grpc_iocp_add_socket(tcp->socket);
 }
 
-static void win_delete_from_pollset_set(grpc_endpoint* ep,
-                                        grpc_pollset_set* pss) {}
+static void win_delete_from_pollset_set(grpc_endpoint* /* ep */,
+                                        grpc_pollset_set* /* pss */) {}
 
 // Initiates a shutdown of the TCP endpoint. This will queue abort callbacks
 // for the potential read and write operations. It is up to the caller to
@@ -504,9 +508,9 @@ static absl::string_view win_get_local_address(grpc_endpoint* ep) {
   return tcp->local_address;
 }
 
-static int win_get_fd(grpc_endpoint* ep) { return -1; }
+static int win_get_fd(grpc_endpoint* /* ep */) { return -1; }
 
-static bool win_can_track_err(grpc_endpoint* ep) { return false; }
+static bool win_can_track_err(grpc_endpoint* /* ep */) { return false; }
 
 static grpc_endpoint_vtable vtable = {win_read,
                                       win_write,

data/src/core/lib/load_balancing/lb_policy.cc

@@ -69,19 +69,15 @@ LoadBalancingPolicy::SubchannelPicker::SubchannelPicker()
 LoadBalancingPolicy::PickResult LoadBalancingPolicy::QueuePicker::Pick(
     PickArgs /*args*/) {
   // We invoke the parent's ExitIdleLocked() via a closure instead
-  // of doing it directly here, for two reasons:
-  // 1. ExitIdleLocked() may cause the policy's state to change and
-  //    a new picker to be delivered to the channel.  If that new
-  //    picker is delivered before ExitIdleLocked() returns, then by
-  //    the time this function returns, the pick will already have
-  //    been processed, and we'll be trying to re-process the same
-  //    pick again, leading to a crash.
-  // 2. We are currently running in the data plane mutex, but we
-  //    need to bounce into the control plane work_serializer to call
-  //    ExitIdleLocked().
-  if (!exit_idle_called_ && parent_ != nullptr) {
-    exit_idle_called_ = true;
-    auto* parent = parent_->Ref().release();  // ref held by lambda.
+  // of doing it directly here because ExitIdleLocked() may cause the
+  // policy's state to change and a new picker to be delivered to the
+  // channel.  If that new picker is delivered before ExitIdleLocked()
+  // returns, then by the time this function returns, the pick will already
+  // have been processed, and we'll be trying to re-process the same pick
+  // again, leading to a crash.
+  MutexLock lock(&mu_);
+  if (parent_ != nullptr) {
+    auto* parent = parent_.release();  // ref held by lambda.
     ExecCtx::Run(DEBUG_LOCATION,
                  GRPC_CLOSURE_CREATE(
                      [](void* arg, grpc_error_handle /*error*/) {

data/src/core/lib/load_balancing/lb_policy.h

@@ -27,6 +27,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/base/thread_annotations.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
@@ -44,6 +45,7 @@
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/load_balancing/subchannel_interface.h"
@@ -392,8 +394,8 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     PickResult Pick(PickArgs args) override;
 
    private:
-    RefCountedPtr<LoadBalancingPolicy> parent_;
-    bool exit_idle_called_ = false;
+    Mutex mu_;
+    RefCountedPtr<LoadBalancingPolicy> parent_ ABSL_GUARDED_BY(&mu_);
   };
 
   // A picker that returns PickResult::Fail for all picks.

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

@@ -19,8 +19,11 @@
 #include <stddef.h>
 
 #include <initializer_list>
+#include <vector>
 
+#include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
 
 #include "src/core/lib/gprpp/atomic_utils.h"
 
@@ -36,7 +39,9 @@ namespace promise_detail {
 ///////////////////////////////////////////////////////////////////////////////
 // HELPER TYPES
 
-std::string Unwakeable::ActivityDebugTag(void*) const { return "<unknown>"; }
+std::string Unwakeable::ActivityDebugTag(WakeupMask) const {
+  return "<unknown>";
+}
 
 // Weak handle to an Activity.
 // Handle can persist while Activity goes away.
@@ -58,7 +63,7 @@ class FreestandingActivity::Handle final : public Wakeable {
 
   // Activity needs to wake up (if it still exists!) - wake it up, and drop the
   // ref that was kept for this handle.
-  void Wakeup(void*) override ABSL_LOCKS_EXCLUDED(mu_) {
+  void Wakeup(WakeupMask) override ABSL_LOCKS_EXCLUDED(mu_) {
     mu_.Lock();
     // Note that activity refcount can drop to zero, but we could win the lock
     // against DropActivity, so we need to only increase activities refcount if
@@ -68,7 +73,7 @@ class FreestandingActivity::Handle final : public Wakeable {
       mu_.Unlock();
       // Activity still exists and we have a reference: wake it up, which will
       // drop the ref.
-      activity->Wakeup(nullptr);
+      activity->Wakeup(0);
     } else {
       // Could not get the activity - it's either gone or going. No need to wake
       // it up!
@@ -78,9 +83,9 @@ class FreestandingActivity::Handle final : public Wakeable {
     Unref();
   }
 
-  void Drop(void*) override { Unref(); }
+  void Drop(WakeupMask) override { Unref(); }
 
-  std::string ActivityDebugTag(void*) const override {
+  std::string ActivityDebugTag(WakeupMask) const override {
     MutexLock lock(&mu_);
     return activity_ == nullptr ? "<unknown>" : activity_->DebugTag();
   }
@@ -124,7 +129,7 @@ void FreestandingActivity::DropHandle() {
 
 Waker FreestandingActivity::MakeNonOwningWaker() {
   mu_.AssertHeld();
-  return Waker(RefHandle(), nullptr);
+  return Waker(RefHandle(), 0);
 }
 
 }  // namespace promise_detail
@@ -133,4 +138,15 @@ std::string Activity::DebugTag() const {
   return absl::StrFormat("ACTIVITY[%p]", this);
 }
 
+///////////////////////////////////////////////////////////////////////////////
+// INTRA ACTIVITY WAKER IMPLEMENTATION
+
+std::string IntraActivityWaiter::DebugString() const {
+  std::vector<int> bits;
+  for (size_t i = 0; i < 8 * sizeof(WakeupMask); i++) {
+    if (wakeups_ & (1 << i)) bits.push_back(i);
+  }
+  return absl::StrCat("{", absl::StrJoin(bits, ","), "}");
+}
+
 }  // namespace grpc_core

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

@@ -38,24 +38,29 @@
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/detail/promise_factory.h"
 #include "src/core/lib/promise/detail/status.h"
+#include "src/core/lib/promise/poll.h"
 
 namespace grpc_core {
 
 class Activity;
 
+// WakeupMask is a bitfield representing which parts of an activity should be
+// woken up.
+using WakeupMask = uint16_t;
+
 // A Wakeable object is used by queues to wake activities.
 class Wakeable {
  public:
   // Wake up the underlying activity.
   // After calling, this Wakeable cannot be used again.
-  // arg comes from the Waker object and allows one Wakeable instance to be used
-  // for multiple disjoint subparts of an Activity.
-  virtual void Wakeup(void* arg) = 0;
+  // WakeupMask comes from the activity that created this Wakeable and specifies
+  // the set of promises that should be awoken.
+  virtual void Wakeup(WakeupMask wakeup_mask) = 0;
   // Drop this wakeable without waking up the underlying activity.
-  virtual void Drop(void* arg) = 0;
+  virtual void Drop(WakeupMask wakeup_mask) = 0;
 
   // Return the underlying activity debug tag, or "<unknown>" if not available.
-  virtual std::string ActivityDebugTag(void* arg) const = 0;
+  virtual std::string ActivityDebugTag(WakeupMask wakeup_mask) const = 0;
 
  protected:
   inline ~Wakeable() {}
@@ -63,9 +68,9 @@ class Wakeable {
 
 namespace promise_detail {
 struct Unwakeable final : public Wakeable {
-  void Wakeup(void*) override {}
-  void Drop(void*) override {}
-  std::string ActivityDebugTag(void*) const override;
+  void Wakeup(WakeupMask) override {}
+  void Drop(WakeupMask) override {}
+  std::string ActivityDebugTag(WakeupMask) const override;
 };
 static Unwakeable* unwakeable() {
   return NoDestructSingleton<Unwakeable>::Get();
@@ -76,8 +81,9 @@ static Unwakeable* unwakeable() {
 // This type is non-copyable but movable.
 class Waker {
  public:
-  Waker(Wakeable* wakeable, void* arg) : wakeable_and_arg_{wakeable, arg} {}
-  Waker() : Waker(promise_detail::unwakeable(), nullptr) {}
+  Waker(Wakeable* wakeable, WakeupMask wakeup_mask)
+      : wakeable_and_arg_{wakeable, wakeup_mask} {}
+  Waker() : Waker(promise_detail::unwakeable(), 0) {}
   ~Waker() { wakeable_and_arg_.Drop(); }
   Waker(const Waker&) = delete;
   Waker& operator=(const Waker&) = delete;
@@ -93,7 +99,7 @@ class Waker {
   template <typename H>
   friend H AbslHashValue(H h, const Waker& w) {
     return H::combine(H::combine(std::move(h), w.wakeable_and_arg_.wakeable),
-                      w.wakeable_and_arg_.arg);
+                      w.wakeable_and_arg_.wakeup_mask);
   }
 
   bool operator==(const Waker& other) const noexcept {
@@ -116,27 +122,42 @@ class Waker {
  private:
   struct WakeableAndArg {
     Wakeable* wakeable;
-    void* arg;
+    WakeupMask wakeup_mask;
 
-    void Wakeup() { wakeable->Wakeup(arg); }
-    void Drop() { wakeable->Drop(arg); }
+    void Wakeup() { wakeable->Wakeup(wakeup_mask); }
+    void Drop() { wakeable->Drop(wakeup_mask); }
     std::string ActivityDebugTag() const {
       return wakeable == nullptr ? "<unknown>"
-                                 : wakeable->ActivityDebugTag(arg);
+                                 : wakeable->ActivityDebugTag(wakeup_mask);
     }
     bool operator==(const WakeableAndArg& other) const noexcept {
-      return wakeable == other.wakeable && arg == other.arg;
+      return wakeable == other.wakeable && wakeup_mask == other.wakeup_mask;
     }
   };
 
   WakeableAndArg Take() {
-    return std::exchange(wakeable_and_arg_,
-                         {promise_detail::unwakeable(), nullptr});
+    return std::exchange(wakeable_and_arg_, {promise_detail::unwakeable(), 0});
   }
 
   WakeableAndArg wakeable_and_arg_;
 };
 
+// Helper type to track wakeups between objects in the same activity.
+// Can be fairly fast as no ref counting or locking needs to occur.
+class IntraActivityWaiter {
+ public:
+  // Register for wakeup, return Pending(). If state is not ready to proceed,
+  // Promises should bottom out here.
+  Pending pending();
+  // Wake the activity
+  void Wake();
+
+  std::string DebugString() const;
+
+ private:
+  WakeupMask wakeups_ = 0;
+};
+
 // An Activity tracks execution of a single promise.
 // It executes the promise under a mutex.
 // When the promise stalls, it registers the containing activity to be woken up
@@ -156,7 +177,13 @@ class Activity : public Orphanable {
   void ForceWakeup() { MakeOwningWaker().Wakeup(); }
 
   // Force the current activity to immediately repoll if it doesn't complete.
-  virtual void ForceImmediateRepoll() = 0;
+  virtual void ForceImmediateRepoll(WakeupMask mask) = 0;
+  // Legacy version of ForceImmediateRepoll() that uses the current participant.
+  // Will go away once Party gets merged with Activity. New usage is banned.
+  void ForceImmediateRepoll() { ForceImmediateRepoll(CurrentParticipant()); }
+
+  // Return the current part of the activity as a bitmask
+  virtual WakeupMask CurrentParticipant() const { return 1; }
 
   // Return the current activity.
   // Additionally:
@@ -284,7 +311,7 @@ class FreestandingActivity : public Activity, private Wakeable {
  public:
   Waker MakeOwningWaker() final {
     Ref();
-    return Waker(this, nullptr);
+    return Waker(this, 0);
   }
   Waker MakeNonOwningWaker() final;
 
@@ -293,7 +320,7 @@ class FreestandingActivity : public Activity, private Wakeable {
     Unref();
   }
 
-  void ForceImmediateRepoll() final {
+  void ForceImmediateRepoll(WakeupMask) final {
     mu_.AssertHeld();
     SetActionDuringRun(ActionDuringRun::kWakeup);
   }
@@ -333,7 +360,7 @@ class FreestandingActivity : public Activity, private Wakeable {
 
   Mutex* mu() ABSL_LOCK_RETURNED(mu_) { return &mu_; }
 
-  std::string ActivityDebugTag(void*) const override { return DebugTag(); }
+  std::string ActivityDebugTag(WakeupMask) const override { return DebugTag(); }
 
  private:
   class Handle;
@@ -467,7 +494,7 @@ class PromiseActivity final
   // the activity to an external threadpool to run. If the activity is already
   // running on this thread, a note is taken of such and the activity is
   // repolled if it doesn't complete.
-  void Wakeup(void*) final {
+  void Wakeup(WakeupMask) final {
     // If there is an active activity, but hey it's us, flag that and we'll loop
     // in RunLoop (that's calling from above here!).
     if (Activity::is_current()) {
@@ -486,7 +513,7 @@ class PromiseActivity final
   }
 
   // Drop a wakeup
-  void Drop(void*) final { this->WakeupComplete(); }
+  void Drop(WakeupMask) final { this->WakeupComplete(); }
 
   // Notification that we're no longer executing - it's ok to destruct the
   // promise.
@@ -593,6 +620,16 @@ ActivityPtr MakeActivity(Factory promise_factory,
           std::move(on_done), std::forward<Contexts>(contexts)...));
 }
 
+inline Pending IntraActivityWaiter::pending() {
+  wakeups_ |= Activity::current()->CurrentParticipant();
+  return Pending();
+}
+
+inline void IntraActivityWaiter::Wake() {
+  if (wakeups_ == 0) return;
+  Activity::current()->ForceImmediateRepoll(std::exchange(wakeups_, 0));
+}
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_PROMISE_ACTIVITY_H