grpc 1.52.0.pre2 → 1.53.0.pre2

data/src/core/lib/surface/call.cc

@@ -26,6 +26,7 @@
 
 #include <algorithm>
 #include <atomic>
+#include <initializer_list>
 #include <memory>
 #include <new>
 #include <string>
@@ -83,7 +84,7 @@
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/promise/context.h"
-#include "src/core/lib/promise/latch.h"
+#include "src/core/lib/promise/detail/basic_seq.h"
 #include "src/core/lib/promise/pipe.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/resource_quota/arena.h"
@@ -102,7 +103,7 @@
 grpc_core::TraceFlag grpc_call_error_trace(false, "call_error");
 grpc_core::TraceFlag grpc_compression_trace(false, "compression");
 grpc_core::TraceFlag grpc_call_trace(false, "call");
-grpc_core::TraceFlag grpc_call_refcount_trace(false, "call_refcount");
+grpc_core::DebugOnlyTraceFlag grpc_call_refcount_trace(false, "call_refcount");
 
 namespace grpc_core {
 
@@ -347,7 +348,8 @@ void Call::DeleteThis() {
   RefCountedPtr<Channel> channel = std::move(channel_);
   Arena* arena = arena_;
   this->~Call();
-  channel->UpdateCallSizeEstimate(arena->Destroy());
+  channel->UpdateCallSizeEstimate(arena->TotalUsedBytes());
+  arena->Destroy();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -451,6 +453,31 @@ class FilterStackCall final : public Call {
   static constexpr gpr_atm kRecvNone = 0;
   static constexpr gpr_atm kRecvInitialMetadataFirst = 1;
 
+  enum class PendingOp {
+    kRecvMessage,
+    kRecvInitialMetadata,
+    kRecvTrailingMetadata,
+    kSends
+  };
+  static intptr_t PendingOpMask(PendingOp op) {
+    return static_cast<intptr_t>(1) << static_cast<intptr_t>(op);
+  }
+  static std::string PendingOpString(intptr_t pending_ops) {
+    std::vector<absl::string_view> pending_op_strings;
+    if (pending_ops & PendingOpMask(PendingOp::kRecvMessage)) {
+      pending_op_strings.push_back("kRecvMessage");
+    }
+    if (pending_ops & PendingOpMask(PendingOp::kRecvInitialMetadata)) {
+      pending_op_strings.push_back("kRecvInitialMetadata");
+    }
+    if (pending_ops & PendingOpMask(PendingOp::kRecvTrailingMetadata)) {
+      pending_op_strings.push_back("kRecvTrailingMetadata");
+    }
+    if (pending_ops & PendingOpMask(PendingOp::kSends)) {
+      pending_op_strings.push_back("kSends");
+    }
+    return absl::StrCat("{", absl::StrJoin(pending_op_strings, ","), "}");
+  }
   struct BatchControl {
     FilterStackCall* call_ = nullptr;
     grpc_transport_stream_op_batch op_;
@@ -475,17 +502,26 @@ class FilterStackCall final : public Call {
     } completion_data_;
     grpc_closure start_batch_;
     grpc_closure finish_batch_;
-    std::atomic<intptr_t> steps_to_complete_{0};
+    std::atomic<intptr_t> ops_pending_{0};
     AtomicError batch_error_;
-    void set_num_steps_to_complete(uintptr_t steps) {
-      steps_to_complete_.store(steps, std::memory_order_release);
+    void set_pending_ops(uintptr_t ops) {
+      ops_pending_.store(ops, std::memory_order_release);
     }
-    bool completed_batch_step() {
-      return steps_to_complete_.fetch_sub(1, std::memory_order_acq_rel) == 1;
+    bool completed_batch_step(PendingOp op) {
+      auto mask = PendingOpMask(op);
+      auto r = ops_pending_.fetch_sub(mask, std::memory_order_acq_rel);
+      if (grpc_call_trace.enabled()) {
+        gpr_log(GPR_DEBUG, "BATCH:%p COMPLETE:%s REMAINING:%s (tag:%p)", this,
+                PendingOpString(mask).c_str(),
+                PendingOpString(r & ~mask).c_str(),
+                completion_data_.notify_tag.tag);
+      }
+      GPR_ASSERT((r & mask) != 0);
+      return r == mask;
     }
 
     void PostCompletion();
-    void FinishStep();
+    void FinishStep(PendingOp op);
     void ProcessDataAfterMetadata();
     void ReceivingStreamReady(grpc_error_handle error);
     void ValidateFilteredMetadata();
@@ -1104,6 +1140,10 @@ FilterStackCall::BatchControl* FilterStackCall::ReuseOrAllocateBatchControl(
 void FilterStackCall::BatchControl::PostCompletion() {
   FilterStackCall* call = call_;
   grpc_error_handle error = batch_error_.get();
+  if (grpc_call_trace.enabled()) {
+    gpr_log(GPR_DEBUG, "tag:%p batch_error=%s", completion_data_.notify_tag.tag,
+            error.ToString().c_str());
+  }
 
   if (op_.send_initial_metadata) {
     call->send_initial_metadata_.Clear();
@@ -1133,14 +1173,12 @@ void FilterStackCall::BatchControl::PostCompletion() {
   batch_error_.set(absl::OkStatus());
 
   if (completion_data_.notify_tag.is_closure) {
-    // unrefs error
     call_ = nullptr;
     Closure::Run(DEBUG_LOCATION,
                  static_cast<grpc_closure*>(completion_data_.notify_tag.tag),
                  error);
     call->InternalUnref("completion");
   } else {
-    // unrefs error
     grpc_cq_end_op(
         call->cq_, completion_data_.notify_tag.tag, error,
         [](void* user_data, grpc_cq_completion* /*storage*/) {
@@ -1153,8 +1191,8 @@ void FilterStackCall::BatchControl::PostCompletion() {
   }
 }
 
-void FilterStackCall::BatchControl::FinishStep() {
-  if (GPR_UNLIKELY(completed_batch_step())) {
+void FilterStackCall::BatchControl::FinishStep(PendingOp op) {
+  if (GPR_UNLIKELY(completed_batch_step(op))) {
     PostCompletion();
   }
 }
@@ -1164,7 +1202,7 @@ void FilterStackCall::BatchControl::ProcessDataAfterMetadata() {
   if (!call->receiving_slice_buffer_.has_value()) {
     *call->receiving_buffer_ = nullptr;
     call->receiving_message_ = false;
-    FinishStep();
+    FinishStep(PendingOp::kRecvMessage);
   } else {
     call->test_only_last_message_flags_ = call->receiving_stream_flags_;
     if ((call->receiving_stream_flags_ & GRPC_WRITE_INTERNAL_COMPRESS) &&
@@ -1179,12 +1217,20 @@ void FilterStackCall::BatchControl::ProcessDataAfterMetadata() {
         &(*call->receiving_buffer_)->data.raw.slice_buffer);
     call->receiving_message_ = false;
     call->receiving_slice_buffer_.reset();
-    FinishStep();
+    FinishStep(PendingOp::kRecvMessage);
   }
 }
 
 void FilterStackCall::BatchControl::ReceivingStreamReady(
     grpc_error_handle error) {
+  if (grpc_call_trace.enabled()) {
+    gpr_log(GPR_DEBUG,
+            "tag:%p ReceivingStreamReady error=%s "
+            "receiving_slice_buffer.has_value=%d recv_state=%" PRIdPTR,
+            completion_data_.notify_tag.tag, error.ToString().c_str(),
+            call_->receiving_slice_buffer_.has_value(),
+            gpr_atm_no_barrier_load(&call_->recv_state_));
+  }
   FilterStackCall* call = call_;
   if (!error.ok()) {
     call->receiving_slice_buffer_.reset();
@@ -1302,7 +1348,7 @@ void FilterStackCall::BatchControl::ReceivingInitialMetadataReady(
     Closure::Run(DEBUG_LOCATION, saved_rsr_closure, error);
   }
 
-  FinishStep();
+  FinishStep(PendingOp::kRecvInitialMetadata);
 }
 
 void FilterStackCall::BatchControl::ReceivingTrailingMetadataReady(
@@ -1311,7 +1357,7 @@ void FilterStackCall::BatchControl::ReceivingTrailingMetadataReady(
                           "recv_trailing_metadata_ready");
   grpc_metadata_batch* md = &call_->recv_trailing_metadata_;
   call_->RecvTrailingFilter(md, error);
-  FinishStep();
+  FinishStep(PendingOp::kRecvTrailingMetadata);
 }
 
 void FilterStackCall::BatchControl::FinishBatch(grpc_error_handle error) {
@@ -1322,7 +1368,7 @@ void FilterStackCall::BatchControl::FinishBatch(grpc_error_handle error) {
   if (!error.ok()) {
     call_->CancelWithError(error);
   }
-  FinishStep();
+  FinishStep(PendingOp::kSends);
 }
 
 namespace {
@@ -1349,12 +1395,11 @@ grpc_call_error FilterStackCall::StartBatch(const grpc_op* ops, size_t nops,
   size_t i;
   const grpc_op* op;
   BatchControl* bctl;
-  bool has_send_ops = false;
-  int num_recv_ops = 0;
   grpc_call_error error = GRPC_CALL_OK;
   grpc_transport_stream_op_batch* stream_op;
   grpc_transport_stream_op_batch_payload* stream_op_payload;
   uint32_t seen_ops = 0;
+  intptr_t pending_ops = 0;
 
   for (i = 0; i < nops; i++) {
     if (seen_ops & (1u << ops[i].op)) {
@@ -1471,7 +1516,7 @@ grpc_call_error FilterStackCall::StartBatch(const grpc_op* ops, size_t nops,
           stream_op_payload->send_initial_metadata.peer_string =
               peer_string_atm_ptr();
         }
-        has_send_ops = true;
+        pending_ops |= PendingOpMask(PendingOp::kSends);
         break;
       }
       case GRPC_OP_SEND_MESSAGE: {
@@ -1503,7 +1548,7 @@ grpc_call_error FilterStackCall::StartBatch(const grpc_op* ops, size_t nops,
             send_slice_buffer_.c_slice_buffer());
         stream_op_payload->send_message.flags = flags;
         stream_op_payload->send_message.send_message = &send_slice_buffer_;
-        has_send_ops = true;
+        pending_ops |= PendingOpMask(PendingOp::kSends);
         break;
       }
       case GRPC_OP_SEND_CLOSE_FROM_CLIENT: {
@@ -1524,7 +1569,7 @@ grpc_call_error FilterStackCall::StartBatch(const grpc_op* ops, size_t nops,
         sent_final_op_ = true;
         stream_op_payload->send_trailing_metadata.send_trailing_metadata =
             &send_trailing_metadata_;
-        has_send_ops = true;
+        pending_ops |= PendingOpMask(PendingOp::kSends);
         break;
       }
       case GRPC_OP_SEND_STATUS_FROM_SERVER: {
@@ -1588,7 +1633,7 @@ grpc_call_error FilterStackCall::StartBatch(const grpc_op* ops, size_t nops,
             &send_trailing_metadata_;
         stream_op_payload->send_trailing_metadata.sent =
             &sent_server_trailing_metadata_;
-        has_send_ops = true;
+        pending_ops |= PendingOpMask(PendingOp::kSends);
         break;
       }
       case GRPC_OP_RECV_INITIAL_METADATA: {
@@ -1623,7 +1668,7 @@ grpc_call_error FilterStackCall::StartBatch(const grpc_op* ops, size_t nops,
           stream_op_payload->recv_initial_metadata.peer_string =
               peer_string_atm_ptr();
         }
-        ++num_recv_ops;
+        pending_ops |= PendingOpMask(PendingOp::kRecvInitialMetadata);
         break;
       }
       case GRPC_OP_RECV_MESSAGE: {
@@ -1659,7 +1704,7 @@ grpc_call_error FilterStackCall::StartBatch(const grpc_op* ops, size_t nops,
             bctl, grpc_schedule_on_exec_ctx);
         stream_op_payload->recv_message.recv_message_ready =
             &receiving_stream_ready_;
-        ++num_recv_ops;
+        pending_ops |= PendingOpMask(PendingOp::kRecvMessage);
         break;
       }
       case GRPC_OP_RECV_STATUS_ON_CLIENT: {
@@ -1698,7 +1743,7 @@ grpc_call_error FilterStackCall::StartBatch(const grpc_op* ops, size_t nops,
             bctl, grpc_schedule_on_exec_ctx);
         stream_op_payload->recv_trailing_metadata.recv_trailing_metadata_ready =
             &receiving_trailing_metadata_ready_;
-        ++num_recv_ops;
+        pending_ops |= PendingOpMask(PendingOp::kRecvTrailingMetadata);
         break;
       }
       case GRPC_OP_RECV_CLOSE_ON_SERVER: {
@@ -1731,7 +1776,7 @@ grpc_call_error FilterStackCall::StartBatch(const grpc_op* ops, size_t nops,
             bctl, grpc_schedule_on_exec_ctx);
         stream_op_payload->recv_trailing_metadata.recv_trailing_metadata_ready =
             &receiving_trailing_metadata_ready_;
-        ++num_recv_ops;
+        pending_ops |= PendingOpMask(PendingOp::kRecvTrailingMetadata);
         break;
       }
     }
@@ -1741,9 +1786,9 @@ grpc_call_error FilterStackCall::StartBatch(const grpc_op* ops, size_t nops,
   if (!is_notify_tag_closure) {
     GPR_ASSERT(grpc_cq_begin_op(cq_, notify_tag));
   }
-  bctl->set_num_steps_to_complete((has_send_ops ? 1 : 0) + num_recv_ops);
+  bctl->set_pending_ops(pending_ops);
 
-  if (has_send_ops) {
+  if (pending_ops & PendingOpMask(PendingOp::kSends)) {
     GRPC_CLOSURE_INIT(
         &bctl->finish_batch_,
         [](void* bctl, grpc_error_handle error) {
@@ -1753,6 +1798,13 @@ grpc_call_error FilterStackCall::StartBatch(const grpc_op* ops, size_t nops,
     stream_op->on_complete = &bctl->finish_batch_;
   }
 
+  if (grpc_call_trace.enabled()) {
+    gpr_log(GPR_DEBUG, "BATCH:%p START:%s BATCH:%s (tag:%p)", bctl,
+            PendingOpString(pending_ops).c_str(),
+            grpc_transport_stream_op_batch_string(stream_op).c_str(),
+            bctl->completion_data_.notify_tag.tag);
+  }
+
   ExecuteBatch(stream_op, &bctl->start_batch_);
 
 done:
@@ -1826,21 +1878,52 @@ class PromiseBasedCall : public Call,
                          public grpc_event_engine::experimental::EventEngine::
                              Closure /* for deadlines */ {
  public:
-  PromiseBasedCall(Arena* arena, const grpc_call_create_args& args);
+  PromiseBasedCall(Arena* arena, uint32_t initial_external_refs,
+                   const grpc_call_create_args& args);
 
   void ContextSet(grpc_context_index elem, void* value,
                   void (*destroy)(void* value)) override;
   void* ContextGet(grpc_context_index elem) const override;
   void SetCompletionQueue(grpc_completion_queue* cq) override;
+  void SetCompletionQueueLocked(grpc_completion_queue* cq)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  void CancelWithError(absl::Status error) final ABSL_LOCKS_EXCLUDED(mu_) {
+    MutexLock lock(&mu_);
+    CancelWithErrorLocked(std::move(error));
+  }
+  virtual void CancelWithErrorLocked(absl::Status error)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) = 0;
+  bool Completed() final ABSL_LOCKS_EXCLUDED(mu_) {
+    MutexLock lock(&mu_);
+    return completed_;
+  }
+
+  void Orphan() final {
+    MutexLock lock(&mu_);
+    if (!completed_) {
+      CancelWithErrorLocked(absl::CancelledError("Call orphaned"));
+    }
+  }
 
   // Implementation of call refcounting: move this to DualRefCounted once we
   // don't need to maintain FilterStackCall compatibility
   void ExternalRef() final {
-    refs_.fetch_add(MakeRefPair(1, 0), std::memory_order_relaxed);
+    const uint64_t prev_ref_pair =
+        refs_.fetch_add(MakeRefPair(1, 0), std::memory_order_relaxed);
+    if (grpc_call_refcount_trace.enabled()) {
+      gpr_log(GPR_DEBUG, "%s EXTERNAL_REF: %d:%d->%d:%d", DebugTag().c_str(),
+              GetStrongRefs(prev_ref_pair), GetWeakRefs(prev_ref_pair),
+              GetStrongRefs(prev_ref_pair) + 1, GetWeakRefs(prev_ref_pair));
+    }
   }
   void ExternalUnref() final {
     const uint64_t prev_ref_pair =
         refs_.fetch_add(MakeRefPair(-1, 1), std::memory_order_acq_rel);
+    if (grpc_call_refcount_trace.enabled()) {
+      gpr_log(GPR_DEBUG, "%s EXTERNAL_UNREF: %d:%d->%d:%d", DebugTag().c_str(),
+              GetStrongRefs(prev_ref_pair), GetWeakRefs(prev_ref_pair),
+              GetStrongRefs(prev_ref_pair) - 1, GetWeakRefs(prev_ref_pair) + 1);
+    }
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
     if (GPR_UNLIKELY(strong_refs == 1)) {
       Orphan();
@@ -1848,12 +1931,22 @@ class PromiseBasedCall : public Call,
     // Now drop the weak ref.
     InternalUnref("external_ref");
   }
-  void InternalRef(const char*) final {
-    refs_.fetch_add(MakeRefPair(0, 1), std::memory_order_relaxed);
+  void InternalRef(const char* reason) final {
+    uint64_t n = refs_.fetch_add(MakeRefPair(0, 1), std::memory_order_relaxed);
+    if (grpc_call_refcount_trace.enabled()) {
+      gpr_log(GPR_DEBUG, "%s REF: %s %d:%d->%d:%d", DebugTag().c_str(), reason,
+              GetStrongRefs(n), GetWeakRefs(n), GetStrongRefs(n),
+              GetWeakRefs(n) + 1);
+    }
   }
-  void InternalUnref(const char*) final {
+  void InternalUnref(const char* reason) final {
     const uint64_t prev_ref_pair =
         refs_.fetch_sub(MakeRefPair(0, 1), std::memory_order_acq_rel);
+    if (grpc_call_refcount_trace.enabled()) {
+      gpr_log(GPR_DEBUG, "%s UNREF: %s %d:%d->%d:%d", DebugTag().c_str(),
+              reason, GetStrongRefs(prev_ref_pair), GetWeakRefs(prev_ref_pair),
+              GetStrongRefs(prev_ref_pair), GetWeakRefs(prev_ref_pair) - 1);
+    }
     if (GPR_UNLIKELY(prev_ref_pair == MakeRefPair(0, 1))) {
       DeleteThis();
     }
@@ -1877,34 +1970,34 @@ class PromiseBasedCall : public Call,
      public:
       explicit AsanWaker(PromiseBasedCall* call) : call_(call) {}
 
-      void Wakeup() override {
-        call_->Wakeup();
+      void Wakeup(void*) override {
+        call_->Wakeup(nullptr);
         delete this;
       }
 
-      void Drop() override {
-        call_->Drop();
+      void Drop(void*) override {
+        call_->Drop(nullptr);
         delete this;
       }
 
-      std::string ActivityDebugTag() const override {
+      std::string ActivityDebugTag(void*) const override {
         return call_->DebugTag();
       }
 
      private:
       PromiseBasedCall* call_;
     };
-    return Waker(new AsanWaker(this));
+    return Waker(new AsanWaker(this), nullptr);
 #endif
 #endif
 #ifndef GRPC_CALL_USES_ASAN_WAKER
-    return Waker(this);
+    return Waker(this, nullptr);
 #endif
   }
   Waker MakeNonOwningWaker() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) override;
 
   // Wakeable methods
-  void Wakeup() override {
+  void Wakeup(void*) override {
     channel()->event_engine()->Run([this] {
       ApplicationCallbackExecCtx app_exec_ctx;
       ExecCtx exec_ctx;
@@ -1916,7 +2009,7 @@ class PromiseBasedCall : public Call,
       InternalUnref("wakeup");
     });
   }
-  void Drop() override { InternalUnref("wakeup"); }
+  void Drop(void*) override { InternalUnref("wakeup"); }
 
   void RunInContext(absl::AnyInvocable<void()> fn) {
     if (Activity::current() == this) {
@@ -1953,9 +2046,12 @@ class PromiseBasedCall : public Call,
 
   void UpdateDeadline(Timestamp deadline);
   void ResetDeadline();
+
   // Implementation of EventEngine::Closure, called when deadline expires
   void Run() override;
 
+  virtual ServerCallContext* server_call_context() { return nullptr; }
+
  protected:
   class ScopedContext
       : public ScopedActivity,
@@ -1993,11 +2089,6 @@ class PromiseBasedCall : public Call,
     uint8_t TakeIndex() { return std::exchange(index_, kNullIndex); }
     bool has_value() const { return index_ != kNullIndex; }
 
-    std::string ToString() const {
-      return index_ == kNullIndex ? "null"
-                                  : std::to_string(static_cast<int>(index_));
-    }
-
    private:
     enum : uint8_t { kNullIndex = 0xff };
     uint8_t index_;
@@ -2015,22 +2106,27 @@ class PromiseBasedCall : public Call,
     // The following correspond with the batch operations from above
     kReceiveInitialMetadata,
     kReceiveStatusOnClient,
+    kReceiveCloseOnServer = kReceiveStatusOnClient,
     kSendMessage,
     kReceiveMessage,
+    kSendStatusFromServer,
+    kSendCloseFromClient = kSendStatusFromServer,
   };
 
-  static constexpr const char* PendingOpString(PendingOp reason) {
+  const char* PendingOpString(PendingOp reason) const {
     switch (reason) {
       case PendingOp::kStartingBatch:
         return "StartingBatch";
       case PendingOp::kReceiveInitialMetadata:
         return "ReceiveInitialMetadata";
       case PendingOp::kReceiveStatusOnClient:
-        return "ReceiveStatusOnClient";
+        return is_client() ? "ReceiveStatusOnClient" : "ReceiveCloseOnServer";
       case PendingOp::kSendMessage:
         return "SendMessage";
       case PendingOp::kReceiveMessage:
         return "ReceiveMessage";
+      case PendingOp::kSendStatusFromServer:
+        return is_client() ? "SendCloseFromClient" : "SendStatusFromServer";
     }
     return "Unknown";
   }
@@ -2040,7 +2136,6 @@ class PromiseBasedCall : public Call,
   }
 
   Mutex* mu() const ABSL_LOCK_RETURNED(mu_) { return &mu_; }
-
   // Begin work on a completion, recording the tag/closure to notify.
   // Use the op selected in \a ops to determine the index to allocate into.
   // Starts the "StartingBatch" PendingOp immediately.
@@ -2050,12 +2145,21 @@ class PromiseBasedCall : public Call,
   // Add one pending op to the completion, and return it.
   Completion AddOpToCompletion(const Completion& completion, PendingOp reason)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  // Stringify a completion
+  std::string CompletionString(const Completion& completion) const {
+    return completion.has_value()
+               ? absl::StrFormat(
+                     "%d:tag=%p", static_cast<int>(completion.index()),
+                     completion_info_[completion.index()].pending.tag)
+               : "no-completion";
+  }
   // Finish one op on the completion. Must have been previously been added.
   // The completion as a whole finishes when all pending ops finish.
   void FinishOpOnCompletion(Completion* completion, PendingOp reason)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
   // Mark the completion as failed. Does not finish it.
-  void FailCompletion(const Completion& completion);
+  void FailCompletion(const Completion& completion,
+                      SourceLocation source_location = {});
   // Run the promise polling loop until it stalls.
   void Update() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
   // Update the promise state once.
@@ -2075,7 +2179,7 @@ class PromiseBasedCall : public Call,
   void CToMetadata(grpc_metadata* metadata, size_t count,
                    grpc_metadata_batch* batch);
 
-  std::string ActivityDebugTag() const override { return DebugTag(); }
+  std::string ActivityDebugTag(void*) const override { return DebugTag(); }
 
   // At the end of the call run any finalization actions.
   void RunFinalization(grpc_status_code status, const char* status_details) {
@@ -2086,6 +2190,56 @@ class PromiseBasedCall : public Call,
     finalization_.Run(&final_info);
   }
 
+  std::string PresentAndCompletionText(const char* caption, bool has,
+                                       const Completion& completion) const {
+    if (has) {
+      if (completion.has_value()) {
+        return absl::StrCat(caption, ":", CompletionString(completion), " ");
+      } else {
+        return absl::StrCat(caption,
+                            ":!!BUG:operation is present, no completion!! ");
+      }
+    } else {
+      if (!completion.has_value()) {
+        return "";
+      } else {
+        return absl::StrCat(caption, ":no-op:", CompletionString(completion),
+                            " ");
+      }
+    }
+  }
+
+  std::string PollStateDebugString() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+    return absl::StrCat(PresentAndCompletionText("outstanding_send",
+                                                 outstanding_send_.has_value(),
+                                                 send_message_completion_)
+                            .c_str(),
+                        PresentAndCompletionText("outstanding_recv",
+                                                 outstanding_recv_.has_value(),
+                                                 recv_message_completion_)
+                            .c_str());
+  }
+
+  void StartRecvMessage(const grpc_op& op, const Completion& completion,
+                        PipeReceiver<MessageHandle>* receiver)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  void PollRecvMessage(grpc_compression_algorithm compression_algorithm)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  void CancelRecvMessage() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  void StartSendMessage(const grpc_op& op, const Completion& completion,
+                        PipeSender<MessageHandle>* sender)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  bool PollSendMessage() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  void CancelSendMessage() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  bool completed() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+    return completed_;
+  }
+  void set_completed() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) { completed_ = true; }
+  bool is_sending() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+    return outstanding_send_.has_value();
+  }
+
  private:
   union CompletionInfo {
     struct Pending {
@@ -2116,7 +2270,7 @@ class PromiseBasedCall : public Call,
 
     // Activity needs to wake up (if it still exists!) - wake it up, and drop
     // the ref that was kept for this handle.
-    void Wakeup() override ABSL_LOCKS_EXCLUDED(mu_) {
+    void Wakeup(void*) override ABSL_LOCKS_EXCLUDED(mu_) {
       // Drop the ref to the handle at end of scope (we have one ref = one
       // wakeup semantics).
       auto unref = absl::MakeCleanup([this]() { Unref(); });
@@ -2124,21 +2278,21 @@ class PromiseBasedCall : public Call,
       // 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 it is non-zero.
-      if (call_ != nullptr && call_->RefIfNonZero()) {
-        PromiseBasedCall* call = call_;
+      PromiseBasedCall* call = call_;
+      if (call != nullptr && call->RefIfNonZero()) {
         lock.Release();
         // Activity still exists and we have a reference: wake it up, which will
         // drop the ref.
-        call->Wakeup();
+        call->Wakeup(nullptr);
       }
     }
 
-    std::string ActivityDebugTag() const override {
+    std::string ActivityDebugTag(void*) const override {
       MutexLock lock(&mu_);
       return call_ == nullptr ? "<unknown>" : call_->DebugTag();
     }
 
-    void Drop() override { Unref(); }
+    void Drop(void*) override { Unref(); }
 
    private:
     // Unref the Handle (not the activity).
@@ -2185,7 +2339,7 @@ class PromiseBasedCall : public Call,
   }
 
   mutable Mutex mu_;
-  std::atomic<uint64_t> refs_{MakeRefPair(1, 0)};
+  std::atomic<uint64_t> refs_;
   CallContext call_context_{this};
   bool keep_polling_ ABSL_GUARDED_BY(mu()) = false;
 
@@ -2199,6 +2353,14 @@ class PromiseBasedCall : public Call,
   // Current deadline.
   Timestamp deadline_ = Timestamp::InfFuture();
   grpc_event_engine::experimental::EventEngine::TaskHandle deadline_task_;
+  absl::optional<PipeSender<MessageHandle>::PushType> outstanding_send_
+      ABSL_GUARDED_BY(mu_);
+  absl::optional<PipeReceiverNextType<MessageHandle>> outstanding_recv_
+      ABSL_GUARDED_BY(mu_);
+  grpc_byte_buffer** recv_message_ ABSL_GUARDED_BY(mu_) = nullptr;
+  Completion send_message_completion_ ABSL_GUARDED_BY(mu_);
+  Completion recv_message_completion_ ABSL_GUARDED_BY(mu_);
+  bool completed_ ABSL_GUARDED_BY(mu_) = false;
 };
 
 template <typename T>
@@ -2214,10 +2376,11 @@ grpc_error_handle MakePromiseBasedCall(grpc_call_create_args* args,
   return absl::OkStatus();
 }
 
-PromiseBasedCall::PromiseBasedCall(Arena* arena,
+PromiseBasedCall::PromiseBasedCall(Arena* arena, uint32_t initial_external_refs,
                                    const grpc_call_create_args& args)
     : Call(arena, args.server_transport_data == nullptr, args.send_deadline,
            args.channel->Ref()),
+      refs_(MakeRefPair(initial_external_refs, 0)),
       cq_(args.cq) {
   if (args.cq != nullptr) {
     GPR_ASSERT(args.pollset_set_alternative == nullptr &&
@@ -2239,7 +2402,7 @@ Waker PromiseBasedCall::MakeNonOwningWaker() {
   } else {
     non_owning_wakeable_->Ref();
   }
-  return Waker(non_owning_wakeable_);
+  return Waker(non_owning_wakeable_, nullptr);
 }
 
 void PromiseBasedCall::CToMetadata(grpc_metadata* metadata, size_t count,
@@ -2277,8 +2440,8 @@ PromiseBasedCall::Completion PromiseBasedCall::StartCompletion(
     void* tag, bool is_closure, const grpc_op* ops) {
   Completion c(BatchSlotForOp(ops[0].op));
   if (grpc_call_trace.enabled()) {
-    gpr_log(GPR_INFO, "%sStartCompletion %s tag=%p", DebugTag().c_str(),
-            c.ToString().c_str(), tag);
+    gpr_log(GPR_INFO, "%s[call] StartCompletion %s tag=%p", DebugTag().c_str(),
+            CompletionString(c).c_str(), tag);
   }
   if (!is_closure) {
     grpc_cq_begin_op(cq(), tag);
@@ -2291,9 +2454,10 @@ PromiseBasedCall::Completion PromiseBasedCall::StartCompletion(
 PromiseBasedCall::Completion PromiseBasedCall::AddOpToCompletion(
     const Completion& completion, PendingOp reason) {
   if (grpc_call_trace.enabled()) {
-    gpr_log(GPR_INFO, "%sAddOpToCompletion %s %s", DebugTag().c_str(),
-            completion.ToString().c_str(), PendingOpString(reason));
+    gpr_log(GPR_INFO, "%s[call] AddOpToCompletion %s %s", DebugTag().c_str(),
+            CompletionString(completion).c_str(), PendingOpString(reason));
   }
+  GPR_ASSERT(completion.has_value());
   auto& pending_op_bits =
       completion_info_[completion.index()].pending.pending_op_bits;
   GPR_ASSERT((pending_op_bits & PendingOpBit(reason)) == 0);
@@ -2301,10 +2465,12 @@ PromiseBasedCall::Completion PromiseBasedCall::AddOpToCompletion(
   return Completion(completion.index());
 }
 
-void PromiseBasedCall::FailCompletion(const Completion& completion) {
+void PromiseBasedCall::FailCompletion(const Completion& completion,
+                                      SourceLocation location) {
   if (grpc_call_trace.enabled()) {
-    gpr_log(GPR_INFO, "%sFailCompletion %s", DebugTag().c_str(),
-            completion.ToString().c_str());
+    gpr_log(location.file(), location.line(), GPR_LOG_SEVERITY_ERROR,
+            "%s[call] FailCompletion %s", DebugTag().c_str(),
+            CompletionString(completion).c_str());
   }
   completion_info_[completion.index()].pending.success = false;
 }
@@ -2323,8 +2489,9 @@ void PromiseBasedCall::FinishOpOnCompletion(Completion* completion,
       }
     }
     gpr_log(
-        GPR_INFO, "%sFinishOpOnCompletion %s %s %s", DebugTag().c_str(),
-        completion->ToString().c_str(), PendingOpString(reason),
+        GPR_INFO, "%s[call] FinishOpOnCompletion tag:%p %s %s %s",
+        DebugTag().c_str(), completion_info_[completion->index()].pending.tag,
+        CompletionString(*completion).c_str(), PendingOpString(reason),
         (pending.empty()
              ? (success ? std::string("done") : std::string("failed"))
              : absl::StrFormat("pending_ops={%s}", absl::StrJoin(pending, ",")))
@@ -2359,6 +2526,10 @@ void PromiseBasedCall::ForceImmediateRepoll() { keep_polling_ = true; }
 
 void PromiseBasedCall::SetCompletionQueue(grpc_completion_queue* cq) {
   MutexLock lock(&mu_);
+  SetCompletionQueueLocked(cq);
+}
+
+void PromiseBasedCall::SetCompletionQueueLocked(grpc_completion_queue* cq) {
   cq_ = cq;
   GRPC_CQ_INTERNAL_REF(cq, "bind");
   call_context_.pollent_ =
@@ -2391,6 +2562,121 @@ void PromiseBasedCall::Run() {
   InternalUnref("deadline");
 }
 
+void PromiseBasedCall::StartSendMessage(const grpc_op& op,
+                                        const Completion& completion,
+                                        PipeSender<MessageHandle>* sender) {
+  GPR_ASSERT(!outstanding_send_.has_value());
+  if (!completed_) {
+    send_message_completion_ =
+        AddOpToCompletion(completion, PendingOp::kSendMessage);
+    SliceBuffer send;
+    grpc_slice_buffer_swap(
+        &op.data.send_message.send_message->data.raw.slice_buffer,
+        send.c_slice_buffer());
+    outstanding_send_.emplace(sender->Push(
+        GetContext<Arena>()->MakePooled<Message>(std::move(send), op.flags)));
+  } else {
+    FailCompletion(completion);
+  }
+}
+
+bool PromiseBasedCall::PollSendMessage() {
+  if (!outstanding_send_.has_value()) return true;
+  Poll<bool> r = (*outstanding_send_)();
+  if (const bool* result = r.value_if_ready()) {
+    if (grpc_call_trace.enabled()) {
+      gpr_log(GPR_DEBUG, "%sPollSendMessage completes %s", DebugTag().c_str(),
+              *result ? "successfully" : "with failure");
+    }
+    if (!*result) {
+      FailCompletion(send_message_completion_);
+      return false;
+    }
+    FinishOpOnCompletion(&send_message_completion_, PendingOp::kSendMessage);
+    outstanding_send_.reset();
+  }
+  return true;
+}
+
+void PromiseBasedCall::CancelSendMessage() {
+  if (!outstanding_send_.has_value()) return;
+  FinishOpOnCompletion(&send_message_completion_, PendingOp::kSendMessage);
+  outstanding_send_.reset();
+}
+
+void PromiseBasedCall::StartRecvMessage(const grpc_op& op,
+                                        const Completion& completion,
+                                        PipeReceiver<MessageHandle>* receiver) {
+  GPR_ASSERT(!outstanding_recv_.has_value());
+  recv_message_ = op.data.recv_message.recv_message;
+  recv_message_completion_ =
+      AddOpToCompletion(completion, PendingOp::kReceiveMessage);
+  outstanding_recv_.emplace(receiver->Next());
+}
+
+void PromiseBasedCall::PollRecvMessage(
+    grpc_compression_algorithm incoming_compression_algorithm) {
+  if (!outstanding_recv_.has_value()) return;
+  Poll<NextResult<MessageHandle>> r = (*outstanding_recv_)();
+  if (auto* result = r.value_if_ready()) {
+    outstanding_recv_.reset();
+    if (result->has_value()) {
+      MessageHandle& message = **result;
+      if ((message->flags() & GRPC_WRITE_INTERNAL_COMPRESS) &&
+          (incoming_compression_algorithm != GRPC_COMPRESS_NONE)) {
+        *recv_message_ = grpc_raw_compressed_byte_buffer_create(
+            nullptr, 0, incoming_compression_algorithm);
+      } else {
+        *recv_message_ = grpc_raw_byte_buffer_create(nullptr, 0);
+      }
+      grpc_slice_buffer_move_into(message->payload()->c_slice_buffer(),
+                                  &(*recv_message_)->data.raw.slice_buffer);
+      if (grpc_call_trace.enabled()) {
+        gpr_log(GPR_INFO,
+                "%s[call] PollRecvMessage: outstanding_recv finishes: received "
+                "%" PRIdPTR " byte message",
+                DebugTag().c_str(),
+                (*recv_message_)->data.raw.slice_buffer.length);
+      }
+    } else if (result->cancelled()) {
+      if (grpc_call_trace.enabled()) {
+        gpr_log(GPR_INFO,
+                "%s[call] PollRecvMessage: outstanding_recv finishes: received "
+                "end-of-stream with error",
+                DebugTag().c_str());
+      }
+      FailCompletion(recv_message_completion_);
+      *recv_message_ = nullptr;
+    } else {
+      if (grpc_call_trace.enabled()) {
+        gpr_log(GPR_INFO,
+                "%s[call] PollRecvMessage: outstanding_recv finishes: received "
+                "end-of-stream",
+                DebugTag().c_str());
+      }
+      *recv_message_ = nullptr;
+    }
+    FinishOpOnCompletion(&recv_message_completion_, PendingOp::kReceiveMessage);
+  } else if (completed_) {
+    if (grpc_call_trace.enabled()) {
+      gpr_log(GPR_INFO,
+              "%s[call] UpdateOnce: outstanding_recv finishes: promise has "
+              "completed without queuing a message, forcing end-of-stream",
+              DebugTag().c_str());
+    }
+    outstanding_recv_.reset();
+    *recv_message_ = nullptr;
+    FinishOpOnCompletion(&recv_message_completion_, PendingOp::kReceiveMessage);
+  }
+}
+
+void PromiseBasedCall::CancelRecvMessage() {
+  if (!outstanding_recv_.has_value()) return;
+  *recv_message_ = nullptr;
+  outstanding_recv_.reset();
+  FinishOpOnCompletion(&recv_message_completion_, PendingOp::kReceiveMessage);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // CallContext
 
@@ -2404,17 +2690,43 @@ void CallContext::IncrementRefCount(const char* reason) {
 
 void CallContext::Unref(const char* reason) { call_->InternalUnref(reason); }
 
+gpr_atm* CallContext::peer_string_atm_ptr() {
+  return call_->peer_string_atm_ptr();
+}
+
 void CallContext::UpdateDeadline(Timestamp deadline) {
   call_->UpdateDeadline(deadline);
 }
 
+ServerCallContext* CallContext::server_call_context() {
+  return call_->server_call_context();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// PublishMetadataArray
+
+namespace {
+void PublishMetadataArray(grpc_metadata_batch* md, grpc_metadata_array* array) {
+  const auto md_count = md->count();
+  if (md_count > array->capacity) {
+    array->capacity =
+        std::max(array->capacity + md->count(), array->capacity * 3 / 2);
+    array->metadata = static_cast<grpc_metadata*>(
+        gpr_realloc(array->metadata, sizeof(grpc_metadata) * array->capacity));
+  }
+  PublishToAppEncoder encoder(array);
+  md->Encode(&encoder);
+}
+}  // namespace
+
 ///////////////////////////////////////////////////////////////////////////////
 // ClientPromiseBasedCall
 
+#ifdef GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_CLIENT_CALL
 class ClientPromiseBasedCall final : public PromiseBasedCall {
  public:
   ClientPromiseBasedCall(Arena* arena, grpc_call_create_args* args)
-      : PromiseBasedCall(arena, *args) {
+      : PromiseBasedCall(arena, 1, *args) {
     global_stats().IncrementClientCallsCreated();
     ScopedContext context(this);
     send_initial_metadata_ =
@@ -2442,16 +2754,12 @@ class ClientPromiseBasedCall final : public PromiseBasedCall {
     // before context.
     auto c2s = std::move(client_to_server_messages_);
     auto s2c = std::move(server_to_client_messages_);
+    auto sim = std::move(server_initial_metadata_);
   }
 
   absl::string_view GetServerAuthority() const override { abort(); }
-  void CancelWithError(grpc_error_handle error) override;
-  bool Completed() override;
-  void Orphan() override {
-    MutexLock lock(mu());
-    ScopedContext ctx(this);
-    if (!completed_) Finish(ServerMetadataFromStatus(absl::CancelledError()));
-  }
+  void CancelWithErrorLocked(grpc_error_handle error) override
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu());
   bool is_trailers_only() const override {
     MutexLock lock(mu());
     return is_trailers_only_;
@@ -2481,9 +2789,6 @@ class ClientPromiseBasedCall final : public PromiseBasedCall {
   // Start the underlying promise.
   void StartPromise(ClientMetadataHandle client_initial_metadata)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu());
-  // Publish some metadata out to the application.
-  static void PublishMetadataArray(grpc_metadata_array* array,
-                                   ServerMetadata* md);
   // Publish status out to the application.
   void PublishStatus(
       grpc_op::grpc_op_data::grpc_op_recv_status_on_client op_args,
@@ -2494,29 +2799,23 @@ class ClientPromiseBasedCall final : public PromiseBasedCall {
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu());
 
   ArenaPromise<ServerMetadataHandle> promise_ ABSL_GUARDED_BY(mu());
-  Latch<ServerMetadata*> server_initial_metadata_ ABSL_GUARDED_BY(mu());
+  Pipe<ServerMetadataHandle> server_initial_metadata_ ABSL_GUARDED_BY(mu()){
+      arena()};
   Pipe<MessageHandle> client_to_server_messages_ ABSL_GUARDED_BY(mu()){arena()};
   Pipe<MessageHandle> server_to_client_messages_ ABSL_GUARDED_BY(mu()){arena()};
 
   ClientMetadataHandle send_initial_metadata_;
   grpc_metadata_array* recv_initial_metadata_ ABSL_GUARDED_BY(mu()) = nullptr;
-  grpc_byte_buffer** recv_message_ ABSL_GUARDED_BY(mu()) = nullptr;
   absl::variant<absl::monostate,
                 grpc_op::grpc_op_data::grpc_op_recv_status_on_client,
                 ServerMetadataHandle>
       recv_status_on_client_ ABSL_GUARDED_BY(mu());
-  absl::optional<PipeSender<MessageHandle>::PushType> outstanding_send_
-      ABSL_GUARDED_BY(mu());
-  absl::optional<PipeReceiver<MessageHandle>::NextType> outstanding_recv_
-      ABSL_GUARDED_BY(mu());
-  absl::optional<LatchWaitPromise<ServerMetadata*>>
+  absl::optional<PipeReceiverNextType<ServerMetadataHandle>>
       server_initial_metadata_ready_;
   absl::optional<grpc_compression_algorithm> incoming_compression_algorithm_;
   Completion recv_initial_metadata_completion_ ABSL_GUARDED_BY(mu());
   Completion recv_status_on_client_completion_ ABSL_GUARDED_BY(mu());
-  Completion send_message_completion_ ABSL_GUARDED_BY(mu());
-  Completion recv_message_completion_ ABSL_GUARDED_BY(mu());
-  bool completed_ ABSL_GUARDED_BY(mu()) = false;
+  Completion close_send_completion_ ABSL_GUARDED_BY(mu());
   bool is_trailers_only_ ABSL_GUARDED_BY(mu());
 };
 
@@ -2525,14 +2824,13 @@ void ClientPromiseBasedCall::StartPromise(
   GPR_ASSERT(!promise_.has_value());
   promise_ = channel()->channel_stack()->MakeClientCallPromise(CallArgs{
       std::move(client_initial_metadata),
-      &server_initial_metadata_,
+      &server_initial_metadata_.sender,
       &client_to_server_messages_.receiver,
       &server_to_client_messages_.sender,
   });
 }
 
-void ClientPromiseBasedCall::CancelWithError(grpc_error_handle error) {
-  MutexLock lock(mu());
+void ClientPromiseBasedCall::CancelWithErrorLocked(grpc_error_handle error) {
   ScopedContext context(this);
   Finish(ServerMetadataFromStatus(grpc_error_to_absl_status(error)));
 }
@@ -2582,7 +2880,7 @@ void ClientPromiseBasedCall::CommitBatch(const grpc_op* ops, size_t nops,
         // compression not implemented
         GPR_ASSERT(
             !op.data.send_initial_metadata.maybe_compression_level.is_set);
-        if (!completed_) {
+        if (!completed()) {
           CToMetadata(op.data.send_initial_metadata.metadata,
                       op.data.send_initial_metadata.count,
                       send_initial_metadata_.get());
@@ -2592,7 +2890,8 @@ void ClientPromiseBasedCall::CommitBatch(const grpc_op* ops, size_t nops,
       case GRPC_OP_RECV_INITIAL_METADATA: {
         recv_initial_metadata_ =
             op.data.recv_initial_metadata.recv_initial_metadata;
-        server_initial_metadata_ready_.emplace(server_initial_metadata_.Wait());
+        server_initial_metadata_ready_.emplace(
+            server_initial_metadata_.receiver.Next());
         recv_initial_metadata_completion_ =
             AddOpToCompletion(completion, PendingOp::kReceiveInitialMetadata);
       } break;
@@ -2607,32 +2906,17 @@ void ClientPromiseBasedCall::CommitBatch(const grpc_op* ops, size_t nops,
           recv_status_on_client_ = op.data.recv_status_on_client;
         }
       } break;
-      case GRPC_OP_SEND_MESSAGE: {
-        GPR_ASSERT(!outstanding_send_.has_value());
-        if (!completed_) {
-          send_message_completion_ =
-              AddOpToCompletion(completion, PendingOp::kSendMessage);
-          SliceBuffer send;
-          grpc_slice_buffer_swap(
-              &op.data.send_message.send_message->data.raw.slice_buffer,
-              send.c_slice_buffer());
-          outstanding_send_.emplace(client_to_server_messages_.sender.Push(
-              GetContext<Arena>()->MakePooled<Message>(std::move(send),
-                                                       op.flags)));
-        } else {
-          FailCompletion(completion);
-        }
-      } break;
-      case GRPC_OP_RECV_MESSAGE: {
-        GPR_ASSERT(!outstanding_recv_.has_value());
-        recv_message_ = op.data.recv_message.recv_message;
-        recv_message_completion_ =
-            AddOpToCompletion(completion, PendingOp::kReceiveMessage);
-        outstanding_recv_.emplace(server_to_client_messages_.receiver.Next());
-      } break;
-      case GRPC_OP_SEND_CLOSE_FROM_CLIENT: {
-        client_to_server_messages_.sender.Close();
-      } break;
+      case GRPC_OP_SEND_MESSAGE:
+        StartSendMessage(op, completion, &client_to_server_messages_.sender);
+        break;
+      case GRPC_OP_RECV_MESSAGE:
+        StartRecvMessage(op, completion, &server_to_client_messages_.receiver);
+        break;
+      case GRPC_OP_SEND_CLOSE_FROM_CLIENT:
+        close_send_completion_ =
+            AddOpToCompletion(completion, PendingOp::kSendCloseFromClient);
+        GPR_ASSERT(close_send_completion_.has_value());
+        break;
       case GRPC_OP_SEND_STATUS_FROM_SERVER:
       case GRPC_OP_RECV_CLOSE_ON_SERVER:
         abort();  // unreachable
@@ -2667,153 +2951,83 @@ void ClientPromiseBasedCall::PublishInitialMetadata(ServerMetadata* metadata) {
       metadata->Take(GrpcEncodingMetadata()).value_or(GRPC_COMPRESS_NONE);
   server_initial_metadata_ready_.reset();
   GPR_ASSERT(recv_initial_metadata_ != nullptr);
-  PublishMetadataArray(std::exchange(recv_initial_metadata_, nullptr),
-                       metadata);
+  PublishMetadataArray(metadata,
+                       std::exchange(recv_initial_metadata_, nullptr));
   FinishOpOnCompletion(&recv_initial_metadata_completion_,
                        PendingOp::kReceiveInitialMetadata);
 }
 
 void ClientPromiseBasedCall::UpdateOnce() {
   if (grpc_call_trace.enabled()) {
-    auto present_and_completion_text =
-        [](const char* caption, bool has,
-           const Completion& completion) -> std::string {
-      if (has) {
-        if (completion.has_value()) {
-          return absl::StrCat(caption, ":",
-                              static_cast<int>(completion.index()), " ");
-        } else {
-          return absl::StrCat(caption,
-                              ":!!BUG:operation is present, no completion!! ");
-        }
-      } else {
-        if (!completion.has_value()) {
-          return "";
-        } else {
-          return absl::StrCat(
-              caption, ":no-op:", static_cast<int>(completion.index()), " ");
-        }
-      }
-    };
-    gpr_log(
-        GPR_INFO, "%sUpdateOnce: %s%s%shas_promise=%s", DebugTag().c_str(),
-        present_and_completion_text("server_initial_metadata_ready",
-                                    server_initial_metadata_ready_.has_value(),
-                                    recv_initial_metadata_completion_)
-            .c_str(),
-        present_and_completion_text("outstanding_send",
-                                    outstanding_send_.has_value(),
-                                    send_message_completion_)
-            .c_str(),
-        present_and_completion_text("outstanding_recv",
-                                    outstanding_recv_.has_value(),
-                                    recv_message_completion_)
-            .c_str(),
-        promise_.has_value() ? "true" : "false");
-  }
-  if (send_message_completion_.has_value()) {
-    FinishOpOnCompletion(&send_message_completion_, PendingOp::kSendMessage);
+    gpr_log(GPR_INFO, "%s[call] UpdateOnce: %s%shas_promise=%s",
+            DebugTag().c_str(),
+            PresentAndCompletionText("server_initial_metadata_ready",
+                                     server_initial_metadata_ready_.has_value(),
+                                     recv_initial_metadata_completion_)
+                .c_str(),
+            PollStateDebugString().c_str(),
+            promise_.has_value() ? "true" : "false");
   }
   if (server_initial_metadata_ready_.has_value()) {
-    Poll<ServerMetadata**> r = (*server_initial_metadata_ready_)();
-    if (ServerMetadata*** server_initial_metadata =
-            absl::get_if<ServerMetadata**>(&r)) {
-      PublishInitialMetadata(**server_initial_metadata);
-    } else if (completed_) {
+    Poll<NextResult<ServerMetadataHandle>> r =
+        (*server_initial_metadata_ready_)();
+    if (auto* server_initial_metadata = r.value_if_ready()) {
+      PublishInitialMetadata(server_initial_metadata->value().get());
+    } else if (completed()) {
       ServerMetadata no_metadata{GetContext<Arena>()};
       PublishInitialMetadata(&no_metadata);
     }
   }
-  if (outstanding_send_.has_value()) {
-    Poll<bool> r = (*outstanding_send_)();
-    if (const bool* result = absl::get_if<bool>(&r)) {
-      outstanding_send_.reset();
-      if (!*result) {
-        FailCompletion(send_message_completion_);
-        Finish(ServerMetadataFromStatus(absl::Status(
-            absl::StatusCode::kInternal, "Failed to send message to server")));
-      }
-    }
+  if (!PollSendMessage()) {
+    Finish(ServerMetadataFromStatus(absl::Status(
+        absl::StatusCode::kInternal, "Failed to send message to server")));
+  }
+  if (!is_sending() && close_send_completion_.has_value()) {
+    client_to_server_messages_.sender.Close();
+    FinishOpOnCompletion(&close_send_completion_,
+                         PendingOp::kSendCloseFromClient);
   }
   if (promise_.has_value()) {
     Poll<ServerMetadataHandle> r = promise_();
     if (grpc_call_trace.enabled()) {
-      gpr_log(GPR_INFO, "%sUpdateOnce: promise returns %s", DebugTag().c_str(),
+      gpr_log(GPR_INFO, "%s[call] UpdateOnce: promise returns %s",
+              DebugTag().c_str(),
               PollToString(r, [](const ServerMetadataHandle& h) {
                 return h->DebugString();
               }).c_str());
     }
-    if (auto* result = absl::get_if<ServerMetadataHandle>(&r)) {
+    if (auto* result = r.value_if_ready()) {
       AcceptTransportStatsFromContext();
       Finish(std::move(*result));
     }
   }
-  if (incoming_compression_algorithm_.has_value() &&
-      outstanding_recv_.has_value()) {
-    Poll<NextResult<MessageHandle>> r = (*outstanding_recv_)();
-    if (auto* result = absl::get_if<NextResult<MessageHandle>>(&r)) {
-      outstanding_recv_.reset();
-      if (result->has_value()) {
-        MessageHandle& message = **result;
-        if ((message->flags() & GRPC_WRITE_INTERNAL_COMPRESS) &&
-            (incoming_compression_algorithm_ != GRPC_COMPRESS_NONE)) {
-          *recv_message_ = grpc_raw_compressed_byte_buffer_create(
-              nullptr, 0, *incoming_compression_algorithm_);
-        } else {
-          *recv_message_ = grpc_raw_byte_buffer_create(nullptr, 0);
-        }
-        grpc_slice_buffer_move_into(message->payload()->c_slice_buffer(),
-                                    &(*recv_message_)->data.raw.slice_buffer);
-        if (grpc_call_trace.enabled()) {
-          gpr_log(GPR_INFO,
-                  "%sUpdateOnce: outstanding_recv finishes: received %" PRIdPTR
-                  " byte message",
-                  DebugTag().c_str(),
-                  (*recv_message_)->data.raw.slice_buffer.length);
-        }
-      } else {
-        if (grpc_call_trace.enabled()) {
-          gpr_log(
-              GPR_INFO,
-              "%sUpdateOnce: outstanding_recv finishes: received end-of-stream",
-              DebugTag().c_str());
-        }
-        *recv_message_ = nullptr;
-      }
-      FinishOpOnCompletion(&recv_message_completion_,
-                           PendingOp::kReceiveMessage);
-    } else if (completed_) {
-      if (grpc_call_trace.enabled()) {
-        gpr_log(GPR_INFO,
-                "%sUpdateOnce: outstanding_recv finishes: promise has "
-                "completed without queuing a message, forcing end-of-stream",
-                DebugTag().c_str());
-      }
-      outstanding_recv_.reset();
-      *recv_message_ = nullptr;
-      FinishOpOnCompletion(&recv_message_completion_,
-                           PendingOp::kReceiveMessage);
-    }
+  if (incoming_compression_algorithm_.has_value()) {
+    PollRecvMessage(*incoming_compression_algorithm_);
   }
 }
 
 void ClientPromiseBasedCall::Finish(ServerMetadataHandle trailing_metadata) {
   if (grpc_call_trace.enabled()) {
-    gpr_log(GPR_INFO, "%sFinish: %s", DebugTag().c_str(),
+    gpr_log(GPR_INFO, "%s[call] Finish: %s", DebugTag().c_str(),
             trailing_metadata->DebugString().c_str());
   }
   promise_ = ArenaPromise<ServerMetadataHandle>();
   ResetDeadline();
-  completed_ = true;
+  set_completed();
   if (recv_initial_metadata_ != nullptr) {
     ForceImmediateRepoll();
   }
   const bool pending_initial_metadata =
       server_initial_metadata_ready_.has_value();
+  if (!pending_initial_metadata) {
+    server_initial_metadata_ready_.emplace(
+        server_initial_metadata_.receiver.Next());
+  }
+  Poll<NextResult<ServerMetadataHandle>> r =
+      (*server_initial_metadata_ready_)();
   server_initial_metadata_ready_.reset();
-  Poll<ServerMetadata**> r = server_initial_metadata_.Wait()();
-  if (auto* result = absl::get_if<ServerMetadata**>(&r)) {
-    if (pending_initial_metadata) PublishInitialMetadata(**result);
+  if (auto* result = r.value_if_ready()) {
+    if (pending_initial_metadata) PublishInitialMetadata(result->value().get());
     is_trailers_only_ = false;
   } else {
     if (pending_initial_metadata) {
@@ -2885,36 +3099,429 @@ void ClientPromiseBasedCall::PublishStatus(
     *op_args.error_string =
         gpr_strdup(MakeErrorString(trailing_metadata.get()).c_str());
   }
-  PublishMetadataArray(op_args.trailing_metadata, trailing_metadata.get());
+  PublishMetadataArray(trailing_metadata.get(), op_args.trailing_metadata);
   // Clear state saying we have a RECV_STATUS_ON_CLIENT outstanding
   // (so we don't call through twice)
   recv_status_on_client_ = absl::monostate();
   FinishOpOnCompletion(&recv_status_on_client_completion_,
                        PendingOp::kReceiveStatusOnClient);
 }
+#endif
 
-void ClientPromiseBasedCall::PublishMetadataArray(grpc_metadata_array* array,
-                                                  ServerMetadata* md) {
-  const auto md_count = md->count();
-  if (md_count > array->capacity) {
-    array->capacity =
-        std::max(array->capacity + md->count(), array->capacity * 3 / 2);
-    array->metadata = static_cast<grpc_metadata*>(
-        gpr_realloc(array->metadata, sizeof(grpc_metadata) * array->capacity));
+///////////////////////////////////////////////////////////////////////////////
+// ServerPromiseBasedCall
+
+#ifdef GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_SERVER_CALL
+
+class ServerPromiseBasedCall final : public PromiseBasedCall {
+ public:
+  ServerPromiseBasedCall(Arena* arena, grpc_call_create_args* args);
+
+  void CancelWithErrorLocked(grpc_error_handle) override
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu());
+  grpc_call_error StartBatch(const grpc_op* ops, size_t nops, void* notify_tag,
+                             bool is_notify_tag_closure) override;
+  bool failed_before_recv_message() const override { abort(); }
+  bool is_trailers_only() const override { abort(); }
+  absl::string_view GetServerAuthority() const override { return ""; }
+
+  // Polling order for the server promise stack:
+  //
+  // │ ┌───────────────────────────────────────┐
+  // │ │ ServerPromiseBasedCall::UpdateOnce    ├──► Lifetime management,
+  // │ ├───────────────────────────────────────┤    signal call end to app
+  // │ │ ConnectedChannel                      ├─┐
+  // │ ├───────────────────────────────────────┤ └► Interactions with the
+  // │ │ ... closest to transport filter       │    transport - send/recv msgs
+  // │ ├───────────────────────────────────────┤    and metadata, call phase
+  // │ │ ...                                   │    ordering
+  // │ ├───────────────────────────────────────┤
+  // │ │ ... closest to app filter             │ ┌► Request matching, initial
+  // │ ├───────────────────────────────────────┤ │  setup, publishing call to
+  // │ │ Server::ChannelData::MakeCallPromise  ├─┘  application
+  // │ ├───────────────────────────────────────┤
+  // │ │ ServerPromiseBasedCall::PollTopOfCall ├──► Application interactions,
+  // ▼ └───────────────────────────────────────┘    forwarding messages,
+  // Polling &                                      sending trailing metadata
+  // instantiation
+  // order
+
+  void UpdateOnce() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu()) override;
+  Poll<ServerMetadataHandle> PollTopOfCall()
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu());
+
+  std::string DebugTag() const override {
+    return absl::StrFormat("SERVER_CALL[%p]: ", this);
   }
-  PublishToAppEncoder encoder(array);
-  md->Encode(&encoder);
+
+  ServerCallContext* server_call_context() override { return &call_context_; }
+
+ private:
+  class RecvCloseOpCancelState {
+   public:
+    // Request that receiver be filled in per grpc_op_recv_close_on_server.
+    // Returns true if the request can be fulfilled immediately.
+    // Returns false if the request will be fulfilled later.
+    bool ReceiveCloseOnServerOpStarted(int* receiver) {
+      switch (state_) {
+        case kUnset:
+          state_ = reinterpret_cast<uintptr_t>(receiver);
+          return false;
+        case kFinishedWithFailure:
+          *receiver = 1;
+          return true;
+        case kFinishedWithSuccess:
+          *receiver = 0;
+          return true;
+        default:
+          abort();  // unreachable
+      }
+    }
+
+    // Mark the call as having completed.
+    // Returns true if this finishes a previous RequestReceiveCloseOnServer.
+    bool CompleteCall(bool success) {
+      switch (state_) {
+        case kUnset:
+          state_ = success ? kFinishedWithSuccess : kFinishedWithFailure;
+          return false;
+        case kFinishedWithFailure:
+        case kFinishedWithSuccess:
+          abort();  // unreachable
+        default:
+          *reinterpret_cast<int*>(state_) = success ? 0 : 1;
+          state_ = success ? kFinishedWithSuccess : kFinishedWithFailure;
+          return true;
+      }
+    }
+
+    std::string ToString() const {
+      switch (state_) {
+        case kUnset:
+          return "Unset";
+        case kFinishedWithFailure:
+          return "FinishedWithFailure";
+        case kFinishedWithSuccess:
+          return "FinishedWithSuccess";
+        default:
+          return absl::StrFormat("WaitingForReceiver(%p)",
+                                 reinterpret_cast<void*>(state_));
+      }
+    }
+
+   private:
+    static constexpr uintptr_t kUnset = 0;
+    static constexpr uintptr_t kFinishedWithFailure = 1;
+    static constexpr uintptr_t kFinishedWithSuccess = 2;
+    // Holds one of kUnset, kFinishedWithFailure, or kFinishedWithSuccess
+    // OR an int* that wants to receive the final status.
+    uintptr_t state_ = kUnset;
+  };
+
+  grpc_call_error ValidateBatch(const grpc_op* ops, size_t nops) const;
+  void CommitBatch(const grpc_op* ops, size_t nops,
+                   const Completion& completion)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu());
+
+  friend class ServerCallContext;
+  ServerCallContext call_context_;
+  Server* const server_;
+  ArenaPromise<ServerMetadataHandle> promise_ ABSL_GUARDED_BY(mu());
+  PipeSender<MessageHandle>* server_to_client_messages_ ABSL_GUARDED_BY(mu()) =
+      nullptr;
+  PipeReceiver<MessageHandle>* client_to_server_messages_
+      ABSL_GUARDED_BY(mu()) = nullptr;
+  using SendInitialMetadataState =
+      absl::variant<absl::monostate, PipeSender<ServerMetadataHandle>*,
+                    typename PipeSender<ServerMetadataHandle>::PushType>;
+  SendInitialMetadataState send_initial_metadata_state_ ABSL_GUARDED_BY(mu()) =
+      absl::monostate{};
+  ServerMetadataHandle send_trailing_metadata_ ABSL_GUARDED_BY(mu());
+  grpc_compression_algorithm incoming_compression_algorithm_
+      ABSL_GUARDED_BY(mu());
+  RecvCloseOpCancelState recv_close_op_cancel_state_ ABSL_GUARDED_BY(mu());
+  Completion recv_close_completion_ ABSL_GUARDED_BY(mu());
+  bool cancel_send_and_receive_ ABSL_GUARDED_BY(mu()) = false;
+  Completion send_status_from_server_completion_ ABSL_GUARDED_BY(mu());
+  ClientMetadataHandle client_initial_metadata_ ABSL_GUARDED_BY(mu());
+};
+
+ServerPromiseBasedCall::ServerPromiseBasedCall(Arena* arena,
+                                               grpc_call_create_args* args)
+    : PromiseBasedCall(arena, 0, *args),
+      call_context_(this, args->server_transport_data),
+      server_(args->server) {
+  global_stats().IncrementServerCallsCreated();
+  channelz::ServerNode* channelz_node = server_->channelz_node();
+  if (channelz_node != nullptr) {
+    channelz_node->RecordCallStarted();
+  }
+  MutexLock lock(mu());
+  ScopedContext activity_context(this);
+  promise_ = channel()->channel_stack()->MakeServerCallPromise(
+      CallArgs{nullptr, nullptr, nullptr, nullptr});
 }
 
-bool ClientPromiseBasedCall::Completed() {
+Poll<ServerMetadataHandle> ServerPromiseBasedCall::PollTopOfCall() {
+  if (grpc_call_trace.enabled()) {
+    gpr_log(GPR_INFO, "%s[call] PollTopOfCall: %s%s%s", DebugTag().c_str(),
+            cancel_send_and_receive_ ? "force-" : "",
+            send_trailing_metadata_ != nullptr
+                ? absl::StrCat("send-metadata:",
+                               send_trailing_metadata_->DebugString(), " ")
+                      .c_str()
+                : " ",
+            PollStateDebugString().c_str());
+  }
+
+  if (cancel_send_and_receive_) {
+    CancelSendMessage();
+    CancelRecvMessage();
+  }
+
+  PollSendMessage();
+  PollRecvMessage(incoming_compression_algorithm_);
+
+  if (!is_sending() && send_trailing_metadata_ != nullptr) {
+    server_to_client_messages_->Close();
+    return std::move(send_trailing_metadata_);
+  }
+
+  return Pending{};
+}
+
+void ServerPromiseBasedCall::UpdateOnce() {
+  if (grpc_call_trace.enabled()) {
+    gpr_log(
+        GPR_INFO, "%s[call] UpdateOnce: recv_close:%s%s %s%shas_promise=%s",
+        DebugTag().c_str(), recv_close_op_cancel_state_.ToString().c_str(),
+        recv_close_completion_.has_value()
+            ? absl::StrCat(":", CompletionString(recv_close_completion_))
+                  .c_str()
+            : "",
+        send_status_from_server_completion_.has_value()
+            ? absl::StrCat(
+                  "send_status:",
+                  CompletionString(send_status_from_server_completion_), " ")
+                  .c_str()
+            : "",
+        PollStateDebugString().c_str(),
+        promise_.has_value() ? "true" : "false");
+  }
+  if (auto* p =
+          absl::get_if<typename PipeSender<ServerMetadataHandle>::PushType>(
+              &send_initial_metadata_state_)) {
+    if ((*p)().ready()) {
+      send_initial_metadata_state_ = absl::monostate{};
+    }
+  }
+  if (promise_.has_value()) {
+    auto r = promise_();
+    if (grpc_call_trace.enabled()) {
+      gpr_log(GPR_INFO, "%s[call] UpdateOnce: promise returns %s",
+              DebugTag().c_str(),
+              PollToString(r, [](const ServerMetadataHandle& h) {
+                return h->DebugString();
+              }).c_str());
+    }
+    if (auto* result = r.value_if_ready()) {
+      if (grpc_call_trace.enabled()) {
+        gpr_log(GPR_INFO, "%s[call] UpdateOnce: GotResult %s result:%s",
+                DebugTag().c_str(),
+                recv_close_op_cancel_state_.ToString().c_str(),
+                (*result)->DebugString().c_str());
+      }
+      if (recv_close_op_cancel_state_.CompleteCall(
+              (*result)->get(GrpcStatusFromWire()).value_or(false))) {
+        FinishOpOnCompletion(&recv_close_completion_,
+                             PendingOp::kReceiveCloseOnServer);
+      }
+      channelz::ServerNode* channelz_node = server_->channelz_node();
+      if (channelz_node != nullptr) {
+        if ((*result)
+                ->get(GrpcStatusMetadata())
+                .value_or(GRPC_STATUS_UNKNOWN) == GRPC_STATUS_OK) {
+          channelz_node->RecordCallSucceeded();
+        } else {
+          channelz_node->RecordCallFailed();
+        }
+      }
+      if (send_status_from_server_completion_.has_value()) {
+        FinishOpOnCompletion(&send_status_from_server_completion_,
+                             PendingOp::kSendStatusFromServer);
+      }
+      CancelSendMessage();
+      CancelRecvMessage();
+      set_completed();
+      promise_ = ArenaPromise<ServerMetadataHandle>();
+    }
+  }
+}
+
+grpc_call_error ServerPromiseBasedCall::ValidateBatch(const grpc_op* ops,
+                                                      size_t nops) const {
+  BitSet<8> got_ops;
+  for (size_t op_idx = 0; op_idx < nops; op_idx++) {
+    const grpc_op& op = ops[op_idx];
+    switch (op.op) {
+      case GRPC_OP_SEND_INITIAL_METADATA:
+        if (!AreInitialMetadataFlagsValid(op.flags)) {
+          return GRPC_CALL_ERROR_INVALID_FLAGS;
+        }
+        if (!ValidateMetadata(op.data.send_initial_metadata.count,
+                              op.data.send_initial_metadata.metadata)) {
+          return GRPC_CALL_ERROR_INVALID_METADATA;
+        }
+        break;
+      case GRPC_OP_SEND_MESSAGE:
+        if (!AreWriteFlagsValid(op.flags)) {
+          return GRPC_CALL_ERROR_INVALID_FLAGS;
+        }
+        break;
+      case GRPC_OP_RECV_MESSAGE:
+      case GRPC_OP_RECV_CLOSE_ON_SERVER:
+      case GRPC_OP_SEND_STATUS_FROM_SERVER:
+        if (op.flags != 0) return GRPC_CALL_ERROR_INVALID_FLAGS;
+        break;
+      case GRPC_OP_RECV_INITIAL_METADATA:
+      case GRPC_OP_SEND_CLOSE_FROM_CLIENT:
+      case GRPC_OP_RECV_STATUS_ON_CLIENT:
+        return GRPC_CALL_ERROR_NOT_ON_SERVER;
+    }
+    if (got_ops.is_set(op.op)) return GRPC_CALL_ERROR_TOO_MANY_OPERATIONS;
+    got_ops.set(op.op);
+  }
+  return GRPC_CALL_OK;
+}
+
+void ServerPromiseBasedCall::CommitBatch(const grpc_op* ops, size_t nops,
+                                         const Completion& completion) {
+  for (size_t op_idx = 0; op_idx < nops; op_idx++) {
+    const grpc_op& op = ops[op_idx];
+    switch (op.op) {
+      case GRPC_OP_SEND_INITIAL_METADATA: {
+        // compression not implemented
+        GPR_ASSERT(
+            !op.data.send_initial_metadata.maybe_compression_level.is_set);
+        if (!completed()) {
+          auto metadata = arena()->MakePooled<ServerMetadata>(arena());
+          CToMetadata(op.data.send_initial_metadata.metadata,
+                      op.data.send_initial_metadata.count, metadata.get());
+          if (grpc_call_trace.enabled()) {
+            gpr_log(GPR_INFO, "%s[call] Send initial metadata",
+                    DebugTag().c_str());
+          }
+          auto* pipe = absl::get<PipeSender<ServerMetadataHandle>*>(
+              send_initial_metadata_state_);
+          send_initial_metadata_state_ = pipe->Push(std::move(metadata));
+        }
+      } break;
+      case GRPC_OP_SEND_MESSAGE:
+        StartSendMessage(op, completion, server_to_client_messages_);
+        break;
+      case GRPC_OP_RECV_MESSAGE:
+        StartRecvMessage(op, completion, client_to_server_messages_);
+        break;
+      case GRPC_OP_SEND_STATUS_FROM_SERVER:
+        send_trailing_metadata_ = arena()->MakePooled<ServerMetadata>(arena());
+        CToMetadata(op.data.send_status_from_server.trailing_metadata,
+                    op.data.send_status_from_server.trailing_metadata_count,
+                    send_trailing_metadata_.get());
+        send_trailing_metadata_->Set(GrpcStatusMetadata(),
+                                     op.data.send_status_from_server.status);
+        if (auto* details = op.data.send_status_from_server.status_details) {
+          send_trailing_metadata_->Set(GrpcMessageMetadata(),
+                                       Slice(CSliceRef(*details)));
+        }
+        send_status_from_server_completion_ =
+            AddOpToCompletion(completion, PendingOp::kSendStatusFromServer);
+        break;
+      case GRPC_OP_RECV_CLOSE_ON_SERVER:
+        if (grpc_call_trace.enabled()) {
+          gpr_log(GPR_INFO, "%s[call] StartBatch: RecvClose %s",
+                  DebugTag().c_str(),
+                  recv_close_op_cancel_state_.ToString().c_str());
+        }
+        if (!recv_close_op_cancel_state_.ReceiveCloseOnServerOpStarted(
+                op.data.recv_close_on_server.cancelled)) {
+          recv_close_completion_ =
+              AddOpToCompletion(completion, PendingOp::kReceiveCloseOnServer);
+        }
+        break;
+      case GRPC_OP_RECV_STATUS_ON_CLIENT:
+      case GRPC_OP_SEND_CLOSE_FROM_CLIENT:
+      case GRPC_OP_RECV_INITIAL_METADATA:
+        abort();  // unreachable
+    }
+  }
+}
+
+grpc_call_error ServerPromiseBasedCall::StartBatch(const grpc_op* ops,
+                                                   size_t nops,
+                                                   void* notify_tag,
+                                                   bool is_notify_tag_closure) {
   MutexLock lock(mu());
-  return completed_;
+  ScopedContext activity_context(this);
+  if (nops == 0) {
+    EndOpImmediately(cq(), notify_tag, is_notify_tag_closure);
+    return GRPC_CALL_OK;
+  }
+  const grpc_call_error validation_result = ValidateBatch(ops, nops);
+  if (validation_result != GRPC_CALL_OK) {
+    return validation_result;
+  }
+  Completion completion =
+      StartCompletion(notify_tag, is_notify_tag_closure, ops);
+  CommitBatch(ops, nops, completion);
+  Update();
+  FinishOpOnCompletion(&completion, PendingOp::kStartingBatch);
+  return GRPC_CALL_OK;
 }
 
-gpr_atm* CallContext::peer_string_atm_ptr() {
-  return call_->peer_string_atm_ptr();
+void ServerPromiseBasedCall::CancelWithErrorLocked(absl::Status error) {
+  if (!promise_.has_value()) return;
+  cancel_send_and_receive_ = true;
+  send_trailing_metadata_ = ServerMetadataFromStatus(error, arena());
+  ForceWakeup();
 }
 
+#endif
+
+#ifdef GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_SERVER_CALL
+ArenaPromise<ServerMetadataHandle>
+ServerCallContext::MakeTopOfServerCallPromise(
+    CallArgs call_args, grpc_completion_queue* cq,
+    grpc_metadata_array* publish_initial_metadata,
+    absl::FunctionRef<void(grpc_call* call)> publish) {
+  call_->mu()->AssertHeld();
+  call_->SetCompletionQueueLocked(cq);
+  call_->server_to_client_messages_ = call_args.server_to_client_messages;
+  call_->client_to_server_messages_ = call_args.client_to_server_messages;
+  call_->send_initial_metadata_state_ = call_args.server_initial_metadata;
+  call_->incoming_compression_algorithm_ =
+      call_args.client_initial_metadata->get(GrpcEncodingMetadata())
+          .value_or(GRPC_COMPRESS_NONE);
+  call_->client_initial_metadata_ =
+      std::move(call_args.client_initial_metadata);
+  PublishMetadataArray(call_->client_initial_metadata_.get(),
+                       publish_initial_metadata);
+  call_->ExternalRef();
+  publish(call_->c_ptr());
+  return [this]() {
+    call_->mu()->AssertHeld();
+    return call_->PollTopOfCall();
+  };
+}
+#else
+ArenaPromise<ServerMetadataHandle>
+ServerCallContext::MakeTopOfServerCallPromise(
+    CallArgs, grpc_completion_queue*, grpc_metadata_array*,
+    absl::FunctionRef<void(grpc_call*)>) {
+  (void)call_;
+  Crash("Promise-based server call is not enabled");
+}
+#endif
+
 }  // namespace grpc_core
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -2931,13 +3538,20 @@ size_t grpc_call_get_initial_size_estimate() {
 
 grpc_error_handle grpc_call_create(grpc_call_create_args* args,
                                    grpc_call** out_call) {
+#ifdef GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_CLIENT_CALL
   if (grpc_core::IsPromiseBasedClientCallEnabled() &&
-      args->channel->is_promising()) {
-    if (args->server_transport_data == nullptr) {
-      return grpc_core::MakePromiseBasedCall<grpc_core::ClientPromiseBasedCall>(
-          args, out_call);
-    }
+      args->server_transport_data == nullptr && args->channel->is_promising()) {
+    return grpc_core::MakePromiseBasedCall<grpc_core::ClientPromiseBasedCall>(
+        args, out_call);
   }
+#endif
+#ifdef GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_SERVER_CALL
+  if (grpc_core::IsPromiseBasedServerCallEnabled() &&
+      args->server_transport_data != nullptr && args->channel->is_promising()) {
+    return grpc_core::MakePromiseBasedCall<grpc_core::ServerPromiseBasedCall>(
+        args, out_call);
+  }
+#endif
   return grpc_core::FilterStackCall::Create(args, out_call);
 }