grpc 1.44.0.pre2 → 1.45.0

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

@@ -28,14 +28,16 @@ namespace grpc_core {
 GPR_THREAD_LOCAL(Activity*) Activity::g_current_activity_{nullptr};
 Waker::Unwakeable Waker::unwakeable_;
 
+namespace promise_detail {
+
 ///////////////////////////////////////////////////////////////////////////////
 // HELPER TYPES
 
 // Weak handle to an Activity.
 // Handle can persist while Activity goes away.
-class Activity::Handle final : public Wakeable {
+class FreestandingActivity::Handle final : public Wakeable {
  public:
-  explicit Handle(Activity* activity) : activity_(activity) {}
+  explicit Handle(FreestandingActivity* activity) : activity_(activity) {}
 
   // Ref the Handle (not the activity).
   void Ref() { refs_.fetch_add(1, std::memory_order_relaxed); }
@@ -57,7 +59,7 @@ class Activity::Handle final : public Wakeable {
     // against DropActivity, so we need to only increase activities refcount if
     // it is non-zero.
     if (activity_ && activity_->RefIfNonzero()) {
-      Activity* activity = activity_;
+      FreestandingActivity* activity = activity_;
       mu_.Unlock();
       // Activity still exists and we have a reference: wake it up, which will
       // drop the ref.
@@ -85,15 +87,15 @@ class Activity::Handle final : public Wakeable {
   // activity.
   std::atomic<size_t> refs_{2};
   Mutex mu_ ABSL_ACQUIRED_AFTER(activity_->mu_);
-  Activity* activity_ ABSL_GUARDED_BY(mu_);
+  FreestandingActivity* activity_ ABSL_GUARDED_BY(mu_);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // ACTIVITY IMPLEMENTATION
 
-bool Activity::RefIfNonzero() { return IncrementIfNonzero(&refs_); }
+bool FreestandingActivity::RefIfNonzero() { return IncrementIfNonzero(&refs_); }
 
-Activity::Handle* Activity::RefHandle() {
+FreestandingActivity::Handle* FreestandingActivity::RefHandle() {
   if (handle_ == nullptr) {
     // No handle created yet - construct it and return it.
     handle_ = new Handle(this);
@@ -105,11 +107,15 @@ Activity::Handle* Activity::RefHandle() {
   }
 }
 
-void Activity::DropHandle() {
+void FreestandingActivity::DropHandle() {
   handle_->DropActivity();
   handle_ = nullptr;
 }
 
-Waker Activity::MakeNonOwningWaker() { return Waker(RefHandle()); }
+Waker FreestandingActivity::MakeNonOwningWaker() {
+  mu_.AssertHeld();
+  return Waker(RefHandle());
+}
 
+}  // namespace promise_detail
 }  // namespace grpc_core

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

@@ -37,6 +37,7 @@
 
 #include "src/core/lib/gpr/tls.h"
 #include "src/core/lib/gprpp/construct_destruct.h"
+#include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/detail/promise_factory.h"
@@ -110,22 +111,8 @@ class Waker {
 // Activity execution may be cancelled by simply deleting the activity. In such
 // a case, if execution had not already finished, the done callback would be
 // called with absl::CancelledError().
-class Activity : private Wakeable {
+class Activity : public Orphanable {
  public:
-  // Cancel execution of the underlying promise.
-  virtual void Cancel() ABSL_LOCKS_EXCLUDED(mu_) = 0;
-
-  // Destroy the Activity - used for the type alias ActivityPtr.
-  struct Deleter {
-    void operator()(Activity* activity) {
-      activity->Cancel();
-      activity->Unref();
-    }
-  };
-
-  // Fetch the size of the implementation of this activity.
-  virtual size_t Size() = 0;
-
   // Force wakeup from the outside.
   // This should be rarely needed, and usages should be accompanied with a note
   // on why it's not possible to wakeup with a Waker object.
@@ -133,11 +120,8 @@ class Activity : private Wakeable {
   // an Activity to repoll.
   void ForceWakeup() { MakeOwningWaker().Wakeup(); }
 
-  // Wakeup the current threads activity - will force a subsequent poll after
-  // the one that's running.
-  static void WakeupCurrent() {
-    current()->SetActionDuringRun(ActionDuringRun::kWakeup);
-  }
+  // Force the current activity to immediately repoll if it doesn't complete.
+  virtual void ForceImmediateRepoll() = 0;
 
   // Return the current activity.
   // Additionally:
@@ -146,58 +130,23 @@ class Activity : private Wakeable {
   //   locked
   // - back up that assertation with a runtime check in debug builds (it's
   //   prohibitively expensive in non-debug builds)
-  static Activity* current() ABSL_ASSERT_EXCLUSIVE_LOCK(current()->mu_) {
-#ifndef NDEBUG
-    GPR_ASSERT(g_current_activity_);
-    if (g_current_activity_ != nullptr) {
-      g_current_activity_->mu_.AssertHeld();
-    }
-#endif
-    return g_current_activity_;
-  }
+  static Activity* current() { return g_current_activity_; }
 
   // Produce an activity-owning Waker. The produced waker will keep the activity
   // alive until it's awoken or dropped.
-  Waker MakeOwningWaker() {
-    Ref();
-    return Waker(this);
-  }
+  virtual Waker MakeOwningWaker() = 0;
 
   // Produce a non-owning Waker. The waker will own a small heap allocated weak
   // pointer to this activity. This is more suitable for wakeups that may not be
   // delivered until long after the activity should be destroyed.
-  Waker MakeNonOwningWaker() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  virtual Waker MakeNonOwningWaker() = 0;
 
  protected:
-  // Action received during a run, in priority order.
-  // If more than one action is received during a run, we use max() to resolve
-  // which one to report (so Cancel overrides Wakeup).
-  enum class ActionDuringRun : uint8_t {
-    kNone,    // No action occured during run.
-    kWakeup,  // A wakeup occured during run.
-    kCancel,  // Cancel was called during run.
-  };
-
-  inline virtual ~Activity() {
-    if (handle_) {
-      DropHandle();
-    }
-  }
-
-  // All promise execution occurs under this mutex.
-  Mutex mu_;
-
   // Check if this activity is the current activity executing on the current
   // thread.
   bool is_current() const { return this == g_current_activity_; }
   // Check if there is an activity executing on the current thread.
   static bool have_current() { return g_current_activity_ != nullptr; }
-  // Check if we got an internal wakeup since the last time this function was
-  // called.
-  ActionDuringRun GotActionDuringRun() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
-    return absl::exchange(action_during_run_, ActionDuringRun::kNone);
-  }
-
   // Set the current activity at construction, clean it up at destruction.
   class ScopedActivity {
    public:
@@ -210,58 +159,14 @@ class Activity : private Wakeable {
     ScopedActivity& operator=(const ScopedActivity&) = delete;
   };
 
-  // Implementors of Wakeable::Wakeup should call this after the wakeup has
-  // completed.
-  void WakeupComplete() { Unref(); }
-
-  // Mark the current activity as being cancelled (so we can actually cancel it
-  // after polling).
-  void CancelCurrent() {
-    current()->SetActionDuringRun(ActionDuringRun::kCancel);
-  }
-
  private:
-  class Handle;
-
-  void Ref() { refs_.fetch_add(1, std::memory_order_relaxed); }
-  void Unref() {
-    if (1 == refs_.fetch_sub(1, std::memory_order_acq_rel)) {
-      delete this;
-    }
-  }
-
-  // Return a Handle instance with a ref so that it can be stored waiting for
-  // some wakeup.
-  Handle* RefHandle() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
-  // If our refcount is non-zero, ref and return true.
-  // Otherwise, return false.
-  bool RefIfNonzero();
-  // Drop the (proved existing) wait handle.
-  void DropHandle() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
-  // Set the action that occured during this run.
-  // We use max to combine actions so that cancellation overrides wakeups.
-  void SetActionDuringRun(ActionDuringRun action)
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
-    action_during_run_ = std::max(action_during_run_, action);
-  }
-
-  // Current refcount.
-  std::atomic<uint32_t> refs_{1};
-  // If wakeup is called during Promise polling, we set this to Wakeup and
-  // repoll. If cancel is called during Promise polling, we set this to Cancel
-  // and cancel at the end of polling.
-  ActionDuringRun action_during_run_ ABSL_GUARDED_BY(mu_) =
-      ActionDuringRun::kNone;
-  // Handle for long waits. Allows a very small weak pointer type object to
-  // queue for wakeups while Activity may be deleted earlier.
-  Handle* handle_ ABSL_GUARDED_BY(mu_) = nullptr;
   // Set during RunLoop to the Activity that's executing.
   // Being set implies that mu_ is held.
   static GPR_THREAD_LOCAL(Activity*) g_current_activity_;
 };
 
 // Owned pointer to one Activity.
-using ActivityPtr = std::unique_ptr<Activity, Activity::Deleter>;
+using ActivityPtr = OrphanablePtr<Activity>;
 
 namespace promise_detail {
 
@@ -320,6 +225,107 @@ class ActivityContexts : public ContextHolder<Contexts>... {
   };
 };
 
+// A free standing activity: an activity that owns its own synchronization and
+// memory.
+// The alternative is an activity that's somehow tied into another system, for
+// instance the type seen in promise_based_filter.h as we're transitioning from
+// the old filter stack to the new system.
+// FreestandingActivity is-a Wakeable, but needs to increment a refcount before
+// returning that Wakeable interface. Additionally, we want to keep
+// FreestandingActivity as small as is possible, since it will be used
+// everywhere. So we use inheritance to provide the Wakeable interface: this
+// makes it zero sized, and we make the inheritance private to prevent
+// accidental casting.
+class FreestandingActivity : public Activity, private Wakeable {
+ public:
+  Waker MakeOwningWaker() final {
+    Ref();
+    return Waker(this);
+  }
+  Waker MakeNonOwningWaker() final;
+
+  void Orphan() final {
+    Cancel();
+    Unref();
+  }
+
+  void ForceImmediateRepoll() final {
+    mu_.AssertHeld();
+    SetActionDuringRun(ActionDuringRun::kWakeup);
+  }
+
+ protected:
+  // Action received during a run, in priority order.
+  // If more than one action is received during a run, we use max() to resolve
+  // which one to report (so Cancel overrides Wakeup).
+  enum class ActionDuringRun : uint8_t {
+    kNone,    // No action occured during run.
+    kWakeup,  // A wakeup occured during run.
+    kCancel,  // Cancel was called during run.
+  };
+
+  inline ~FreestandingActivity() override {
+    if (handle_) {
+      DropHandle();
+    }
+  }
+
+  // Check if we got an internal wakeup since the last time this function was
+  // called.
+  ActionDuringRun GotActionDuringRun() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+    return absl::exchange(action_during_run_, ActionDuringRun::kNone);
+  }
+
+  // Implementors of Wakeable::Wakeup should call this after the wakeup has
+  // completed.
+  void WakeupComplete() { Unref(); }
+
+  // Set the action that occured during this run.
+  // We use max to combine actions so that cancellation overrides wakeups.
+  void SetActionDuringRun(ActionDuringRun action)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+    action_during_run_ = std::max(action_during_run_, action);
+  }
+
+  Mutex* mu() ABSL_LOCK_RETURNED(mu_) { return &mu_; }
+
+ private:
+  class Handle;
+
+  // Cancel execution of the underlying promise.
+  virtual void Cancel() = 0;
+
+  void Ref() { refs_.fetch_add(1, std::memory_order_relaxed); }
+  void Unref() {
+    if (1 == refs_.fetch_sub(1, std::memory_order_acq_rel)) {
+      delete this;
+    }
+  }
+
+  // Return a Handle instance with a ref so that it can be stored waiting for
+  // some wakeup.
+  Handle* RefHandle() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  // If our refcount is non-zero, ref and return true.
+  // Otherwise, return false.
+  bool RefIfNonzero();
+  // Drop the (proved existing) wait handle.
+  void DropHandle() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  // All promise execution occurs under this mutex.
+  Mutex mu_;
+
+  // Current refcount.
+  std::atomic<uint32_t> refs_{1};
+  // If wakeup is called during Promise polling, we set this to Wakeup and
+  // repoll. If cancel is called during Promise polling, we set this to Cancel
+  // and cancel at the end of polling.
+  ActionDuringRun action_during_run_ ABSL_GUARDED_BY(mu_) =
+      ActionDuringRun::kNone;
+  // Handle for long waits. Allows a very small weak pointer type object to
+  // queue for wakeups while Activity may be deleted earlier.
+  Handle* handle_ ABSL_GUARDED_BY(mu_) = nullptr;
+};
+
 // Implementation details for an Activity of an arbitrary type of promise.
 // There should exist a static function:
 // struct WakeupScheduler {
@@ -331,14 +337,20 @@ class ActivityContexts : public ContextHolder<Contexts>... {
 // It can assume that activity will remain live until RunScheduledWakeup() is
 // invoked, and that a given activity will not be concurrently scheduled again
 // until its RunScheduledWakeup() has been invoked.
+// We use private inheritance here as a way of getting private members for
+// each of the contexts.
+// TODO(ctiller): We can probably reconsider the private inheritance here
+// when we move away from C++11 and have more powerful template features.
 template <class F, class WakeupScheduler, class OnDone, typename... Contexts>
-class PromiseActivity final : public Activity,
+class PromiseActivity final : public FreestandingActivity,
                               private ActivityContexts<Contexts...> {
  public:
   using Factory = PromiseFactory<void, F>;
+  using ResultType = typename Factory::Promise::Result;
+
   PromiseActivity(F promise_factory, WakeupScheduler wakeup_scheduler,
                   OnDone on_done, Contexts&&... contexts)
-      : Activity(),
+      : FreestandingActivity(),
         ActivityContexts<Contexts...>(std::forward<Contexts>(contexts)...),
         wakeup_scheduler_(std::move(wakeup_scheduler)),
         on_done_(std::move(on_done)) {
@@ -346,9 +358,9 @@ class PromiseActivity final : public Activity,
     // This may hit a waiter, which could expose our this pointer to other
     // threads, meaning we do need to hold this mutex even though we're still
     // constructing.
-    mu_.Lock();
+    mu()->Lock();
     auto status = Start(Factory(std::move(promise_factory)));
-    mu_.Unlock();
+    mu()->Unlock();
     // We may complete immediately.
     if (status.has_value()) {
       on_done_(std::move(*status));
@@ -362,16 +374,24 @@ class PromiseActivity final : public Activity,
     GPR_ASSERT(done_);
   }
 
-  size_t Size() override { return sizeof(*this); }
+  void RunScheduledWakeup() {
+    GPR_ASSERT(wakeup_scheduled_.exchange(false, std::memory_order_acq_rel));
+    Step();
+    WakeupComplete();
+  }
+
+ private:
+  using typename ActivityContexts<Contexts...>::ScopedContext;
 
   void Cancel() final {
     if (Activity::is_current()) {
-      CancelCurrent();
+      mu()->AssertHeld();
+      SetActionDuringRun(ActionDuringRun::kCancel);
       return;
     }
     bool was_done;
     {
-      MutexLock lock(&mu_);
+      MutexLock lock(mu());
       // Check if we were done, and flag done.
       was_done = done_;
       if (!done_) MarkDone();
@@ -382,15 +402,6 @@ class PromiseActivity final : public Activity,
     }
   }
 
-  void RunScheduledWakeup() {
-    GPR_ASSERT(wakeup_scheduled_.exchange(false, std::memory_order_acq_rel));
-    Step();
-    WakeupComplete();
-  }
-
- private:
-  using typename ActivityContexts<Contexts...>::ScopedContext;
-
   // Wakeup this activity. Arrange to poll the activity again at a convenient
   // time: this could be inline if it's deemed safe, or it could be by passing
   // the activity to an external threadpool to run. If the activity is already
@@ -400,7 +411,8 @@ class PromiseActivity final : public Activity,
     // 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()) {
-      WakeupCurrent();
+      mu()->AssertHeld();
+      SetActionDuringRun(ActionDuringRun::kWakeup);
       WakeupComplete();
       return;
     }
@@ -418,7 +430,7 @@ class PromiseActivity final : public Activity,
 
   // Notification that we're no longer executing - it's ok to destruct the
   // promise.
-  void MarkDone() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+  void MarkDone() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu()) {
     GPR_ASSERT(!done_);
     done_ = true;
     Destruct(&promise_holder_.promise);
@@ -426,16 +438,16 @@ class PromiseActivity final : public Activity,
 
   // In response to Wakeup, run the Promise state machine again until it
   // settles. Then check for completion, and if we have completed, call on_done.
-  void Step() ABSL_LOCKS_EXCLUDED(mu_) {
+  void Step() ABSL_LOCKS_EXCLUDED(mu()) {
     // Poll the promise until things settle out under a lock.
-    mu_.Lock();
+    mu()->Lock();
     if (done_) {
       // We might get some spurious wakeups after finishing.
-      mu_.Unlock();
+      mu()->Unlock();
       return;
     }
     auto status = RunStep();
-    mu_.Unlock();
+    mu()->Unlock();
     if (status.has_value()) {
       on_done_(std::move(*status));
     }
@@ -444,7 +456,7 @@ class PromiseActivity final : public Activity,
   // 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<absl::Status> RunStep() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+  absl::optional<ResultType> RunStep() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu()) {
     ScopedActivity scoped_activity(this);
     ScopedContext contexts(this);
     return StepLoop();
@@ -453,8 +465,8 @@ class PromiseActivity final : public Activity,
   // Similarly to RunStep, but additionally construct the promise from a
   // promise factory before entering the main loop. Called once from the
   // constructor.
-  absl::optional<absl::Status> Start(Factory promise_factory)
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+  absl::optional<ResultType> Start(Factory promise_factory)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu()) {
     ScopedActivity scoped_activity(this);
     ScopedContext contexts(this);
     Construct(&promise_holder_.promise, promise_factory.Once());
@@ -463,7 +475,7 @@ class PromiseActivity final : public Activity,
 
   // Until there are no wakeups from within and the promise is incomplete:
   // poll the promise.
-  absl::optional<absl::Status> StepLoop() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+  absl::optional<ResultType> StepLoop() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu()) {
     GPR_ASSERT(is_current());
     while (true) {
       // Run the promise.
@@ -493,7 +505,7 @@ class PromiseActivity final : public Activity,
   // Callback on completion of the promise.
   GPR_NO_UNIQUE_ADDRESS OnDone on_done_;
   // Has execution completed?
-  GPR_NO_UNIQUE_ADDRESS bool done_ ABSL_GUARDED_BY(mu_) = false;
+  GPR_NO_UNIQUE_ADDRESS bool done_ ABSL_GUARDED_BY(mu()) = false;
   // Is there a wakeup scheduled?
   GPR_NO_UNIQUE_ADDRESS std::atomic<bool> wakeup_scheduled_{false};
   // We wrap the promise in a union to allow control over the construction
@@ -504,7 +516,7 @@ class PromiseActivity final : public Activity,
     ~PromiseHolder() {}
     GPR_NO_UNIQUE_ADDRESS Promise promise;
   };
-  GPR_NO_UNIQUE_ADDRESS PromiseHolder promise_holder_ ABSL_GUARDED_BY(mu_);
+  GPR_NO_UNIQUE_ADDRESS PromiseHolder promise_holder_ ABSL_GUARDED_BY(mu());
 };
 
 }  // namespace promise_detail

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

@@ -0,0 +1,188 @@
+// Copyright 2021 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_CORE_LIB_PROMISE_ARENA_PROMISE_H
+#define GRPC_CORE_LIB_PROMISE_ARENA_PROMISE_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/support/log.h>
+
+#include "src/core/lib/promise/poll.h"
+#include "src/core/lib/resource_quota/arena.h"
+
+namespace grpc_core {
+
+namespace arena_promise_detail {
+
+// Type erased promise stored in the arena.
+template <typename T>
+class ImplInterface {
+ public:
+  // Poll the promise, once.
+  virtual Poll<T> PollOnce() = 0;
+  // 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.
+  virtual void Destroy() = 0;
+
+ protected:
+  ~ImplInterface() = default;
+};
+
+// Implementation of ImplInterface for an empty object.
+// Used when an empty ArenaPromise is created, or when the ArenaPromise is moved
+// from. Since in either case these objects should not be polled, we simply
+// crash if it is.
+template <typename T>
+class NullImpl final : public ImplInterface<T> {
+ public:
+  Poll<T> PollOnce() override {
+    abort();
+    GPR_UNREACHABLE_CODE(return Pending{});
+  }
+  void Destroy() override {}
+
+  static ImplInterface<T>* Get() {
+    static NullImpl<T> instance;
+    return &instance;
+  }
+
+ private:
+  ~NullImpl() = default;
+};
+
+// Implementation of ImplInterface for a callable object.
+template <typename T, typename Callable>
+class CallableImpl final : public ImplInterface<T> {
+ public:
+  explicit CallableImpl(Callable&& callable) : callable_(std::move(callable)) {}
+  // Forward polls to the callable object.
+  Poll<T> PollOnce() override { return poll_cast<T>(callable_()); }
+  // Destroy destructs the callable object.
+  void Destroy() override { this->~CallableImpl(); }
+
+ private:
+  // Should only be called by Destroy().
+  ~CallableImpl() = default;
+
+  Callable callable_;
+};
+
+// 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)?
+// Since this corresponds to a lambda with no fields, and we expect these to be
+// reasonably common, we can elide the arena allocation entirely and simply poll
+// a global shared instance.
+// (this comes up often when the promise only accesses context data from the
+// containing activity).
+template <typename T, typename Callable>
+class SharedImpl final : public ImplInterface<T>, private Callable {
+ public:
+  // Call the callable, or at least an exact duplicate of it - if you have no
+  // members, all your instances look the same.
+  Poll<T> PollOnce() override { return Callable::operator()(); }
+  // Nothing to destroy.
+  void Destroy() override {}
+  // Return a pointer to the shared instance - these are singletons, and are
+  // needed just to get the vtable in place.
+  static SharedImpl* Get(Callable&& callable) {
+    static_assert(sizeof(SharedImpl) == sizeof(void*),
+                  "SharedImpl should be pointer sized");
+    static SharedImpl impl(std::forward<Callable>(callable));
+    return &impl;
+  }
+
+ private:
+  explicit SharedImpl(Callable&& callable)
+      : Callable(std::forward<Callable>(callable)) {}
+  ~SharedImpl() = default;
+};
+
+// Redirector type: given a callable type, expose a Make() function that creates
+// the appropriate underlying implementation.
+template <typename T, typename Callable, typename Ignored = void>
+struct ChooseImplForCallable;
+
+template <typename T, typename Callable>
+struct ChooseImplForCallable<
+    T, Callable, absl::enable_if_t<!std::is_empty<Callable>::value>> {
+  static ImplInterface<T>* Make(Callable&& callable) {
+    return GetContext<Arena>()->template New<CallableImpl<T, Callable>>(
+        std::forward<Callable>(callable));
+  }
+};
+
+template <typename T, typename Callable>
+struct ChooseImplForCallable<
+    T, Callable, absl::enable_if_t<std::is_empty<Callable>::value>> {
+  static ImplInterface<T>* Make(Callable&& callable) {
+    return SharedImpl<T, Callable>::Get(std::forward<Callable>(callable));
+  }
+};
+
+// Wrap ChooseImplForCallable with a friend approachable syntax.
+template <typename T, typename Callable>
+ImplInterface<T>* MakeImplForCallable(Callable&& callable) {
+  return ChooseImplForCallable<T, Callable>::Make(
+      std::forward<Callable>(callable));
+}
+
+}  // namespace arena_promise_detail
+
+// A promise for which the state memory is allocated from an arena.
+template <typename T>
+class ArenaPromise {
+ public:
+  // Construct an empty, uncallable, invalid ArenaPromise.
+  ArenaPromise() = default;
+
+  // Construct an ArenaPromise that will call the given callable when polled.
+  template <typename Callable,
+            typename Ignored =
+                absl::enable_if_t<!std::is_same<Callable, ArenaPromise>::value>>
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  ArenaPromise(Callable&& callable)
+      : impl_(arena_promise_detail::MakeImplForCallable<T>(
+            std::forward<Callable>(callable))) {}
+
+  // ArenaPromise is not copyable.
+  ArenaPromise(const ArenaPromise&) = delete;
+  ArenaPromise& operator=(const ArenaPromise&) = delete;
+  // ArenaPromise is movable.
+  ArenaPromise(ArenaPromise&& other) noexcept : impl_(other.impl_) {
+    other.impl_ = arena_promise_detail::NullImpl<T>::Get();
+  }
+  ArenaPromise& operator=(ArenaPromise&& other) noexcept {
+    impl_->Destroy();
+    impl_ = other.impl_;
+    other.impl_ = arena_promise_detail::NullImpl<T>::Get();
+    return *this;
+  }
+
+  // Destruction => call Destroy on the underlying impl object.
+  ~ArenaPromise() { impl_->Destroy(); }
+
+  // Expose the promise interface: a call operator that returns Poll<T>.
+  Poll<T> operator()() { return impl_->PollOnce(); }
+
+ private:
+  // Underlying impl object.
+  arena_promise_detail::ImplInterface<T>* impl_ =
+      arena_promise_detail::NullImpl<T>::Get();
+};
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_LIB_PROMISE_ARENA_PROMISE_H */