grpc 1.78.0 → 1.80.0.pre1

data/src/core/ext/transport/chttp2/transport/stream_data_queue.h

@@ -28,6 +28,7 @@
 #include <optional>
 #include <queue>
 #include <string>
+#include <type_traits>
 #include <utility>
 #include <variant>
 #include <vector>
@@ -39,9 +40,11 @@
 #include "src/core/ext/transport/chttp2/transport/http2_status.h"
 #include "src/core/ext/transport/chttp2/transport/message_assembler.h"
 #include "src/core/ext/transport/chttp2/transport/transport_common.h"
+#include "src/core/ext/transport/chttp2/transport/write_cycle.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/poll.h"
+#include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted.h"
@@ -59,7 +62,8 @@ namespace http2 {
 template <typename T>
 class SimpleQueue {
  public:
-  explicit SimpleQueue(const uint32_t max_tokens) : max_tokens_(max_tokens) {}
+  explicit SimpleQueue(Arena* arena, const uint32_t max_tokens)
+      : queue_(arena), max_tokens_(max_tokens) {}
   SimpleQueue(SimpleQueue&& rhs) = delete;
   SimpleQueue& operator=(SimpleQueue&& rhs) = delete;
   SimpleQueue(const SimpleQueue&) = delete;
@@ -99,13 +103,18 @@ class SimpleQueue {
   }
 
   // Returns true if the queue is empty. This function is NOT thread safe.
-  bool IsEmpty() const { return queue_.empty(); }
+  inline bool IsEmpty() { return queue_.Peek() == nullptr; }
+
   // Clears the queue. This function is NOT thread safe.
-  void Clear() { std::queue<Entry>().swap(queue_); }
+  void Clear() {
+    while (queue_.Pop().has_value()) {
+    }
+    GRPC_DCHECK(IsEmpty());
+  }
 
-  inline std::optional<uint32_t> GetNextEntryTokens() const {
-    return queue_.empty() ? std::nullopt
-                          : std::make_optional(queue_.front().tokens);
+  inline std::optional<uint32_t> GetNextEntryTokens() {
+    Entry* front = queue_.Peek();
+    return front == nullptr ? std::nullopt : std::make_optional(front->tokens);
   }
 
  private:
@@ -116,11 +125,12 @@ class SimpleQueue {
     if (tokens_consumed_ == 0 ||
         tokens_consumed_ <= max_tokens_consumed_threshold) {
       tokens_consumed_ += tokens;
-      queue_.emplace(Entry{std::move(data), tokens});
+      const bool was_empty = IsEmpty();
+      queue_.Push(Entry{std::move(data), tokens});
       GRPC_STREAM_DATA_QUEUE_DEBUG
           << "Enqueue successful. Data tokens: " << tokens
           << " Current tokens consumed: " << tokens_consumed_;
-      return /*became_non_empty=*/(queue_.size() == 1);
+      return /*became_non_empty=*/was_empty;
     }
 
     GRPC_STREAM_DATA_QUEUE_DEBUG
@@ -139,33 +149,35 @@ class SimpleQueue {
       return absl::InternalError("Tokens consumed overflowed.");
     }
     tokens_consumed_ += tokens;
-    queue_.emplace(Entry{std::move(data), tokens});
+    const bool was_empty = IsEmpty();
+    queue_.Push(Entry{std::move(data), tokens});
     GRPC_STREAM_DATA_QUEUE_DEBUG
         << "Immediate enqueue successful. Data tokens: " << tokens
         << " Current tokens consumed: " << tokens_consumed_;
-    return /*became_non_empty*/ (queue_.size() == 1);
+    return /*became_non_empty*/ was_empty;
   }
 
   std::optional<T> DequeueInternal(const uint32_t allowed_dequeue_tokens,
                                    const bool allow_oversized_dequeue) {
-    if (queue_.empty() || (queue_.front().tokens > allowed_dequeue_tokens &&
-                           !allow_oversized_dequeue)) {
+    Entry* front = queue_.Peek();
+    if (front == nullptr ||
+        (front->tokens > allowed_dequeue_tokens && !allow_oversized_dequeue)) {
       GRPC_STREAM_DATA_QUEUE_DEBUG
-          << "Dequeueing data. Queue size: " << queue_.size()
+          << "Dequeueing data."
           << " Max allowed dequeue tokens: " << allowed_dequeue_tokens
           << " Front tokens: "
-          << (!queue_.empty() ? std::to_string(queue_.front().tokens)
-                              : std::string("NA"))
+          << (front != nullptr ? std::to_string(front->tokens)
+                               : std::string("NA"))
           << " Allow oversized dequeue: " << allow_oversized_dequeue;
       return std::nullopt;
     }
 
-    auto entry = std::move(queue_.front());
-    queue_.pop();
-    tokens_consumed_ -= entry.tokens;
+    std::optional<Entry> entry = queue_.Pop();
+    GRPC_DCHECK(entry.has_value());
+    tokens_consumed_ -= entry->tokens;
     auto waker = std::move(waker_);
     GRPC_STREAM_DATA_QUEUE_DEBUG
-        << "Dequeue successful. Data tokens released: " << entry.tokens
+        << "Dequeue successful. Data tokens released: " << entry->tokens
         << " Current tokens consumed: " << tokens_consumed_;
 
     // TODO(akshitpatel) : [PH2][P2] : Investigate a mechanism to only wake up
@@ -173,7 +185,7 @@ class SimpleQueue {
     // this queue is revamped soon and so not spending time on optimization
     // right now.
     waker.Wakeup();
-    return std::move(entry.data);
+    return std::move(entry->data);
   }
 
   struct Entry {
@@ -181,7 +193,7 @@ class SimpleQueue {
     uint32_t tokens;
   };
 
-  std::queue<Entry> queue_;
+  ArenaSpsc<Entry> queue_;
   // The maximum number of tokens that can be enqueued. This limit is used to
   // exert back pressure on the sender. If the sender tries to enqueue more
   // tokens than this limit, the enqueue promise will not resolve until the
@@ -196,16 +208,58 @@ class SimpleQueue {
   Waker waker_;
 };
 
+// DequeueFlags is a wrapper class for the dequeue flags. The flags can only
+// be set from within the StreamDataQueue class.
+class DequeueFlags {
+ public:
+  static constexpr uint8_t kResetStreamDequeued = 0x01u;
+  static constexpr uint8_t kHalfCloseDequeued = 0x02u;
+  static constexpr uint8_t kInitialMetadataDequeued = 0x04u;
+  static constexpr uint8_t kMessageDequeued = 0x08u;
+  static constexpr uint8_t kTrailingMetadataDequeued = 0x10u;
+
+  DequeueFlags() = default;
+
+  bool IsResetStreamDequeued() const {
+    return (flags_ & kResetStreamDequeued) != 0u;
+  }
+  bool IsHalfCloseDequeued() const {
+    return (flags_ & kHalfCloseDequeued) != 0u;
+  }
+  bool IsInitialMetadataDequeued() const {
+    return (flags_ & kInitialMetadataDequeued) != 0u;
+  }
+  bool IsMessageDequeued() const { return (flags_ & kMessageDequeued) != 0u; }
+  bool IsTrailingMetadataDequeued() const {
+    return (flags_ & kTrailingMetadataDequeued) != 0u;
+  }
+
+  bool operator==(uint8_t flags) const { return flags_ == flags; }
+
+ private:
+  template <typename MetadataHandle>
+  friend class StreamDataQueue;
+
+  void set_reset_stream_dequeued() { flags_ |= kResetStreamDequeued; }
+  void set_half_close_dequeued() { flags_ |= kHalfCloseDequeued; }
+  void set_initial_metadata_dequeued() { flags_ |= kInitialMetadataDequeued; }
+  void set_message_dequeued() { flags_ |= kMessageDequeued; }
+  void set_trailing_metadata_dequeued() { flags_ |= kTrailingMetadataDequeued; }
+
+  uint8_t flags_ = 0u;
+};
+
 // StreamDataQueue is a thread safe.
 // Note: StreamDataQueue is a single producer single
 // consumer queue.
 template <typename MetadataHandle>
 class StreamDataQueue : public RefCounted<StreamDataQueue<MetadataHandle>> {
  public:
-  explicit StreamDataQueue(const bool is_client, const uint32_t queue_size)
+  explicit StreamDataQueue(Arena* arena, const bool is_client,
+                           const uint32_t queue_size)
       : stream_id_(0),
         is_client_(is_client),
-        queue_(queue_size),
+        queue_(arena, queue_size),
         initial_metadata_disassembler_(/*is_trailing_metadata=*/false),
         trailing_metadata_disassembler_(/*is_trailing_metadata=*/true) {};
   ~StreamDataQueue() = default;
@@ -259,7 +313,14 @@ class StreamDataQueue : public RefCounted<StreamDataQueue<MetadataHandle>> {
     GRPC_DCHECK(!is_initial_metadata_queued_);
     GRPC_DCHECK(!is_trailing_metadata_or_half_close_queued_);
     GRPC_DCHECK(metadata != nullptr);
-    GRPC_DCHECK(reset_stream_state_ == RstStreamState::kNotQueued);
+
+    // Stream closed before initial metadata is enqueued. This is possible
+    // if the stream is cancelled between stream creation and
+    // PullClientInitialMetadata resolving.
+    if (IsEnqueueClosed()) {
+      return StreamWritabilityUpdate{/*became_writable=*/false,
+                                     WritableStreamPriority::kStreamClosed};
+    }
 
     is_initial_metadata_queued_ = true;
     absl::StatusOr<bool> result = queue_.ImmediateEnqueue(
@@ -376,12 +437,14 @@ class StreamDataQueue : public RefCounted<StreamDataQueue<MetadataHandle>> {
   }
 
   // Enqueue Reset Stream.
-  // 1. MUST be called at most once.
-  // 3. This function is thread safe.
+  // 1. This function is thread safe.
+  // 2. ResetStream frame can be enqueued at any point after the creation of the
+  //    stream.
+  // 3. Once ResetStream is enqueued, any enqueue calls after this will be
+  //    ignored.
   absl::StatusOr<StreamWritabilityUpdate> EnqueueResetStream(
       const uint32_t error_code) {
     MutexLock lock(&mu_);
-    GRPC_DCHECK(is_initial_metadata_queued_);
 
     // This can happen when the transport tries to close the stream and the
     // stream is cancelled from the call stack.
@@ -407,35 +470,22 @@ class StreamDataQueue : public RefCounted<StreamDataQueue<MetadataHandle>> {
 
   //////////////////////////////////////////////////////////////////////////////
   // Dequeue Helpers
-
-  static constexpr uint8_t kResetStreamDequeued = 0x1;
-  static constexpr uint8_t kHalfCloseDequeued = 0x2;
-  static constexpr uint8_t kInitialMetadataDequeued = 0x4;
-
   struct DequeueResult {
-    std::vector<Http2Frame> frames;
     bool is_writable;
     WritableStreamPriority priority;
-    // Maybe not be extremely accurate but should be good enough for our
-    // purposes.
-    size_t total_bytes_consumed = 0u;
     size_t flow_control_tokens_consumed = 0u;
     // Bitmask of the dequeue flags.
-    uint8_t flags = 0u;
+    DequeueFlags flags;
 
     // Returns true if the reset stream was dequeued.
-    bool ResetStreamDequeued() const {
-      return (flags & kResetStreamDequeued) != 0u;
-    }
+    bool IsResetStreamDequeued() const { return flags.IsResetStreamDequeued(); }
 
     // Returns true if the half close was dequeued.
-    bool HalfCloseDequeued() const {
-      return (flags & kHalfCloseDequeued) != 0u;
-    }
+    bool IsHalfCloseDequeued() const { return flags.IsHalfCloseDequeued(); }
 
     // Returns true if the initial metadata was dequeued.
-    bool InitialMetadataDequeued() const {
-      return (flags & kInitialMetadataDequeued) != 0u;
+    bool IsInitialMetadataDequeued() const {
+      return flags.IsInitialMetadataDequeued();
     }
   };
 
@@ -462,6 +512,7 @@ class StreamDataQueue : public RefCounted<StreamDataQueue<MetadataHandle>> {
                               const uint32_t max_frame_length,
                               const uint32_t stream_fc_tokens,
                               HPackCompressor& encoder,
+                              FrameSender& frame_sender,
                               const bool can_send_reset_stream) {
     MutexLock lock(&mu_);
     GRPC_STREAM_DATA_QUEUE_DEBUG
@@ -478,12 +529,12 @@ class StreamDataQueue : public RefCounted<StreamDataQueue<MetadataHandle>> {
     // metadata enqueued has not reached HPACK encoder, so it is safe to drop
     // all frames.
     if (std::optional<DequeueResult> result =
-            HandleResetStreamLocked(can_send_reset_stream)) {
+            HandleResetStreamLocked(can_send_reset_stream, frame_sender)) {
       return std::move(*result);
     }
 
     HandleDequeue handle_dequeue(max_fc_tokens, max_frame_length, encoder,
-                                 *this);
+                                 frame_sender, *this);
     while (message_disassembler_.GetBufferedLength() <= max_fc_tokens) {
       const uint32_t tokens_to_dequeue =
           max_fc_tokens - message_disassembler_.GetBufferedLength();
@@ -502,14 +553,15 @@ class StreamDataQueue : public RefCounted<StreamDataQueue<MetadataHandle>> {
     GRPC_DCHECK_GE(stream_fc_tokens,
                    handle_dequeue.GetFlowControlTokensConsumed());
 
+    handle_dequeue.AppendBufferedFrames();
+
     return DequeueResult{
-        handle_dequeue.GetFrames(),
         UpdateWritableStateDequeueLocked(
             stream_fc_tokens - handle_dequeue.GetFlowControlTokensConsumed()),
         priority_,
-        handle_dequeue.GetTotalBytesConsumed(),
+        /*flow_control_tokens_consumed=*/
         handle_dequeue.GetFlowControlTokensConsumed(),
-        handle_dequeue.GetDequeueFlags()};
+        /*flags=*/handle_dequeue.GetDequeueFlags()};
   }
 
   // TODO(tjagtap) : [PH2][P1][FlowControl] : Call this while processing
@@ -550,18 +602,20 @@ class StreamDataQueue : public RefCounted<StreamDataQueue<MetadataHandle>> {
   class HandleDequeue {
    public:
     HandleDequeue(const uint32_t max_tokens, const uint32_t max_frame_length,
-                  HPackCompressor& encoder, StreamDataQueue& queue)
+                  HPackCompressor& encoder, FrameSender& frame_sender,
+                  StreamDataQueue& queue)
         : queue_(queue),
           max_frame_length_(max_frame_length),
           max_tokens_available_(max_tokens),
           flow_control_tokens_consumed_(0),
-          encoder_(encoder) {}
+          encoder_(encoder),
+          frame_sender_(frame_sender) {}
 
     void operator()(InitialMetadataType initial_metadata) {
       GRPC_STREAM_DATA_QUEUE_DEBUG << "Preparing initial metadata for sending";
       queue_.initial_metadata_disassembler_.PrepareForSending(
           std::move(initial_metadata.metadata), encoder_);
-      dequeue_flags_ |= kInitialMetadataDequeued;
+      dequeue_flags_.set_initial_metadata_dequeued();
       MaybeAppendInitialMetadataFrames();
     }
 
@@ -569,6 +623,7 @@ class StreamDataQueue : public RefCounted<StreamDataQueue<MetadataHandle>> {
       GRPC_STREAM_DATA_QUEUE_DEBUG << "Preparing trailing metadata for sending";
       queue_.trailing_metadata_disassembler_.PrepareForSending(
           std::move(trailing_metadata.metadata), encoder_);
+      dequeue_flags_.set_trailing_metadata_dequeued();
     }
 
     void operator()(MessageHandle message) {
@@ -579,10 +634,10 @@ class StreamDataQueue : public RefCounted<StreamDataQueue<MetadataHandle>> {
 
     void operator()(GRPC_UNUSED HalfClosed half_closed) {
       GRPC_STREAM_DATA_QUEUE_DEBUG << "Preparing end of stream for sending";
-      dequeue_flags_ |= kHalfCloseDequeued;
+      dequeue_flags_.set_half_close_dequeued();
     }
 
-    std::vector<Http2Frame> GetFrames() {
+    void AppendBufferedFrames() {
       // TODO(akshitpatel) : [PH2][P3] : There is a second option here. We can
       //  only append messages here. Additionally, when Trailing
       //  Metadata/HalfClose/ResetStream is dequeued, we can first flush the
@@ -594,20 +649,18 @@ class StreamDataQueue : public RefCounted<StreamDataQueue<MetadataHandle>> {
       MaybeAppendMessageFrames();
       MaybeAppendEndOfStreamFrame();
       MaybeAppendTrailingMetadataFrames();
-      return std::move(frames_);
     }
 
-    size_t GetTotalBytesConsumed() const { return total_bytes_consumed_; }
     size_t GetFlowControlTokensConsumed() const {
       return flow_control_tokens_consumed_;
     }
-    uint8_t GetDequeueFlags() const { return dequeue_flags_; }
+    DequeueFlags GetDequeueFlags() const { return dequeue_flags_; }
 
    private:
     inline void MaybeAppendInitialMetadataFrames() {
       while (queue_.initial_metadata_disassembler_.HasMoreData()) {
-        GRPC_DCHECK(!(dequeue_flags_ & kHalfCloseDequeued));
-        GRPC_DCHECK(!(dequeue_flags_ & kResetStreamDequeued));
+        GRPC_DCHECK(!dequeue_flags_.IsHalfCloseDequeued());
+        GRPC_DCHECK(!dequeue_flags_.IsResetStreamDequeued());
         // TODO(akshitpatel) : [PH2][P2] : I do not think we need this.
         // HasMoreData() should be enough.
         bool is_end_headers = false;
@@ -618,7 +671,7 @@ class StreamDataQueue : public RefCounted<StreamDataQueue<MetadataHandle>> {
 
     inline void MaybeAppendTrailingMetadataFrames() {
       while (queue_.trailing_metadata_disassembler_.HasMoreData()) {
-        GRPC_DCHECK(!(dequeue_flags_ & kHalfCloseDequeued));
+        GRPC_DCHECK(!dequeue_flags_.IsHalfCloseDequeued());
         GRPC_DCHECK_EQ(queue_.message_disassembler_.GetBufferedLength(), 0u);
         GRPC_DCHECK_EQ(
             queue_.initial_metadata_disassembler_.GetBufferedLength(), 0u);
@@ -631,12 +684,31 @@ class StreamDataQueue : public RefCounted<StreamDataQueue<MetadataHandle>> {
     }
 
     inline void MaybeAppendEndOfStreamFrame() {
-      if (dequeue_flags_ & kHalfCloseDequeued) {
+      if (dequeue_flags_.IsHalfCloseDequeued()) {
         GRPC_DCHECK_EQ(queue_.message_disassembler_.GetBufferedLength(), 0u);
         GRPC_DCHECK_EQ(
             queue_.initial_metadata_disassembler_.GetBufferedLength(), 0u);
         GRPC_DCHECK_EQ(
             queue_.trailing_metadata_disassembler_.GetBufferedLength(), 0u);
+        Http2Frame* last_frame = frame_sender_.MutableLastRegularFrame();
+
+        // On the Server side, trailing metadata acts as end of stream and is
+        // always sent with END_STREAM flag set.
+        // To be inline with CHTTP2, InitialMetadata is always sent with
+        // END_STREAM flag false.
+        if (last_frame != nullptr && dequeue_flags_.IsMessageDequeued()) {
+          bool merged = std::visit(
+              [](auto& frame) -> bool {
+                using F = std::decay_t<decltype(frame)>;
+                if constexpr (std::is_same_v<F, Http2DataFrame>) {
+                  frame.end_stream = true;
+                  return true;
+                }
+                return false;
+              },
+              *last_frame);
+          if (merged) return;
+        }
         AppendFrame(Http2DataFrame{/*stream_id=*/queue_.stream_id_,
                                    /*end_stream=*/true,
                                    /*payload=*/SliceBuffer()});
@@ -658,11 +730,12 @@ class StreamDataQueue : public RefCounted<StreamDataQueue<MetadataHandle>> {
             << " Consumed tokens: " << flow_control_tokens_consumed_
             << " Max tokens: " << max_tokens_available_;
         AppendFrame(std::move(frame));
+        dequeue_flags_.set_message_dequeued();
       }
     }
 
     inline void MaybeAppendResetStreamFrame() {
-      if (dequeue_flags_ & kResetStreamDequeued) {
+      if (dequeue_flags_.IsResetStreamDequeued()) {
         // TODO(akshitpatel) : [PH2][P2] : Consider if we can send reset stream
         // frame without flushing all the messages enqueued until now.
         GRPC_DCHECK_EQ(queue_.message_disassembler_.GetBufferedLength(), 0u);
@@ -675,8 +748,10 @@ class StreamDataQueue : public RefCounted<StreamDataQueue<MetadataHandle>> {
     }
 
     inline void AppendFrame(Http2Frame&& frame) {
-      total_bytes_consumed_ += GetFrameMemoryUsage(frame);
-      frames_.emplace_back(std::move(frame));
+      // FrameSender automatically accounts for the frame size in write quota.
+      // Maybe not be extremely accurate but should be good enough for our
+      // purposes.
+      frame_sender_.AddRegularFrame(std::forward<Http2Frame>(frame));
     }
 
     StreamDataQueue& queue_;
@@ -684,10 +759,9 @@ class StreamDataQueue : public RefCounted<StreamDataQueue<MetadataHandle>> {
     const uint32_t max_tokens_available_;
     uint32_t flow_control_tokens_consumed_;
     uint32_t error_code_ = static_cast<uint32_t>(Http2ErrorCode::kNoError);
-    std::vector<Http2Frame> frames_;
     HPackCompressor& encoder_;
-    size_t total_bytes_consumed_ = 0u;
-    uint8_t dequeue_flags_ = 0u;
+    FrameSender& frame_sender_;
+    DequeueFlags dequeue_flags_;
   };
 
   // Updates the writable state and priority of the stream. MUST only be called
@@ -765,8 +839,9 @@ class StreamDataQueue : public RefCounted<StreamDataQueue<MetadataHandle>> {
     return is_writable_;
   }
 
-  inline bool IsNextQueueEntryMessage() const {
-    return (!queue_.IsEmpty() && queue_.GetNextEntryTokens().value() > 0);
+  inline bool IsNextQueueEntryMessage() {
+    std::optional<size_t> next_entry_tokens = queue_.GetNextEntryTokens();
+    return next_entry_tokens.has_value() && *next_entry_tokens > 0;
   }
 
   // Handles the case where a reset stream is queued.
@@ -774,37 +849,32 @@ class StreamDataQueue : public RefCounted<StreamDataQueue<MetadataHandle>> {
   // DequeueResult. Otherwise, it returns std::nullopt.
   // This function must be called with mu_ held.
   std::optional<DequeueResult> HandleResetStreamLocked(
-      const bool can_send_reset_stream) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+      const bool can_send_reset_stream, FrameSender& frame_sender)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
     switch (reset_stream_state_) {
       case RstStreamState::kDequeued:
         GRPC_STREAM_DATA_QUEUE_DEBUG
             << "Reset stream is already dequeued. Returning empty frames.";
         GRPC_DCHECK(queue_.IsEmpty());
         is_writable_ = false;
-        return DequeueResult{
-            std::vector<Http2Frame>(),           is_writable_, priority_,
-            /*total_bytes_consumed=*/0u,
-            /*flow_control_tokens_consumed=*/0u, /*flags=*/0u};
+        return DequeueResult{is_writable_, priority_,
+                             /*flow_control_tokens_consumed=*/0u,
+                             /*flags=*/DequeueFlags{}};
       case RstStreamState::kQueued: {
         GRPC_STREAM_DATA_QUEUE_DEBUG
             << "Reset stream is queued. Skipping all frames (if any) for "
                "dequeuing.";
         is_writable_ = false;
-        std::vector<Http2Frame> frames;
-        uint8_t flags = 0u;
+        DequeueFlags flags;
         if (can_send_reset_stream) {
-          frames.emplace_back(
+          frame_sender.AddRegularFrame(
               Http2RstStreamFrame{stream_id_, reset_stream_error_code_});
-          flags = kResetStreamDequeued;
+          flags.set_reset_stream_dequeued();
         }
         queue_.Clear();
         reset_stream_state_ = RstStreamState::kDequeued;
-        return DequeueResult{std::move(frames),
-                             is_writable_,
-                             priority_,
-                             /*total_bytes_consumed=*/0u,
-                             /*flow_control_tokens_consumed=*/0u,
-                             flags};
+        return DequeueResult{is_writable_, priority_,
+                             /*flow_control_tokens_consumed=*/0u, flags};
       }
       case RstStreamState::kNotQueued:
         return std::nullopt;

data/src/core/ext/transport/chttp2/transport/transport_common.h

@@ -39,11 +39,6 @@
 #define GRPC_ARG_MAX_CONCURRENT_STREAMS_OVERLOAD_PROTECTION \
   "grpc.http.overload_protection"
 
-// EXPERIMENTAL: Fail requests at the client if the client is over max
-// concurrent streams, so they may be retried elsewhere.
-#define GRPC_ARG_MAX_CONCURRENT_STREAMS_REJECT_ON_CLIENT \
-  "grpc.http.max_concurrent_streams_reject_on_client"
-
 #define KEEPALIVE_TIME_BACKOFF_MULTIPLIER 2
 
 #define GRPC_CHTTP2_PING_TIMEOUT_STR "ping timeout"

data/src/core/ext/transport/chttp2/transport/writable_streams.h

@@ -74,19 +74,19 @@ class WritableStreams {
   WritableStreams(WritableStreams&&) = delete;
   WritableStreams& operator=(WritableStreams&&) = delete;
 
-  absl::Status EnqueueWrapper(const StreamPtr stream,
+  absl::Status EnqueueWrapper(StreamPtr stream,
                               const WritableStreamPriority priority,
                               bool transport_tokens_available) {
     if (transport_tokens_available) {
-      return Enqueue(stream, priority);
+      return Enqueue(std::move(stream), priority);
     } else {
-      return BlockedOnTransportFlowControl(stream);
+      return BlockedOnTransportFlowControl(std::move(stream));
     }
   }
 
   // Enqueues a stream id with the given priority.
   // If this returns error, transport MUST be closed.
-  absl::Status Enqueue(const StreamPtr stream,
+  absl::Status Enqueue(StreamPtr stream,
                        const WritableStreamPriority priority) {
     // Streams waiting for transport flow control MUST not be added to list of
     // writable streams via this API, instead they MUST be added via
@@ -96,7 +96,7 @@ class WritableStreams {
     GRPC_DCHECK(priority !=
                 WritableStreamPriority::kWaitForTransportFlowControl);
     StatusFlag status = sender_.UnbufferedImmediateSend(
-        StreamIDAndPriority{stream, priority}, /*tokens*/ 1);
+        StreamIDAndPriority{std::move(stream), priority}, /*tokens*/ 1);
     GRPC_WRITABLE_STREAMS_DEBUG
         << "UnbufferedImmediateEnqueue stream with priority "
         << GetWritableStreamPriorityString(priority) << " status " << status;
@@ -109,9 +109,10 @@ class WritableStreams {
 
   // A synchronous function to add a stream id to the transport flow control
   // wait list.
-  absl::Status BlockedOnTransportFlowControl(const StreamPtr stream) {
+  absl::Status BlockedOnTransportFlowControl(StreamPtr stream) {
     prioritized_queue_.Push(
-        stream, WritableStreamPriority::kWaitForTransportFlowControl);
+        std::move(stream),
+        WritableStreamPriority::kWaitForTransportFlowControl);
     GRPC_WRITABLE_STREAMS_DEBUG << "Enqueuing a stream with priority "
                                    "kWaitForTransportFlowControl ";
     return absl::OkStatus();

data/src/core/ext/transport/chttp2/transport/write_cycle.cc

@@ -0,0 +1,86 @@
+//
+//
+// Copyright 2026 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.
+//
+//
+
+#include "src/core/ext/transport/chttp2/transport/write_cycle.h"
+
+#include <grpc/support/port_platform.h>
+
+#include <string>
+
+#include "src/core/ext/transport/chttp2/transport/frame.h"
+#include "src/core/ext/transport/chttp2/transport/http2_settings.h"
+#include "src/core/lib/transport/promise_endpoint.h"
+#include "absl/container/inlined_vector.h"
+#include "absl/strings/str_cat.h"
+
+namespace grpc_core {
+namespace http2 {
+
+// WriteQuota
+
+std::string WriteQuota::DebugString() const {
+  return absl::StrCat("WriteQuota{target=", target_write_size_,
+                      ", consumed=", bytes_consumed_, "}");
+}
+
+// WriteBufferTracker
+std::string WriteBufferTracker::DebugString() const {
+  return absl::StrCat(
+      "WriteBufferTracker{regular_frames_count=", regular_frames_.size(),
+      ", urgent_frames_count=", urgent_frames_.size(),
+      ", is_first_write=", is_first_write_, "}");
+}
+
+// WriteCycle
+
+absl::InlinedVector<Http2Frame, WriteBufferTracker::kInlinedRegularFramesSize>&
+WriteCycle::TestOnlyRegularFrames() {
+  return write_buffer_tracker_.TestOnlyRegularFrames();
+}
+
+absl::InlinedVector<Http2Frame, WriteBufferTracker::kInlinedUrgentFramesSize>&
+WriteCycle::TestOnlyUrgentFrames() {
+  return write_buffer_tracker_.TestOnlyUrgentFrames();
+}
+
+std::string WriteCycle::DebugString() const {
+  return absl::StrCat("WriteCycle{quota=", write_quota_.DebugString(),
+                      ", tracker=", write_buffer_tracker_.DebugString(), "}");
+}
+
+// TransportWriteContext
+
+std::string TransportWriteContext::DebugString() const {
+  return absl::StrCat("TransportWriteContext{is_first_write=", is_first_write_,
+                      "} ",
+                      write_cycle_ ? write_cycle_->DebugString() : "null");
+}
+
+PromiseEndpoint::WriteArgs TransportWriteContext::GetWriteArgs(
+    const Http2Settings& peer_settings) {
+  PromiseEndpoint::WriteArgs args;
+  int max_frame_size = peer_settings.preferred_receive_crypto_message_size();
+  if (max_frame_size == 0) {
+    max_frame_size = INT_MAX;
+  }
+  args.set_max_frame_size(max_frame_size);
+  return args;
+}
+
+}  // namespace http2
+}  // namespace grpc_core