grpc 1.75.0 → 1.78.1

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

@@ -20,13 +20,13 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/util/bitset.h"
+#include "src/core/util/grpc_check.h"
+#include "absl/log/log.h"
 
 static const char* stream_list_id_string(grpc_chttp2_stream_list_id id) {
   switch (id) {
@@ -59,7 +59,7 @@ static bool stream_list_pop(grpc_chttp2_transport* t,
   grpc_chttp2_stream* s = t->lists[id].head;
   if (s) {
     grpc_chttp2_stream* new_head = s->links[id].next;
-    CHECK(s->included.is_set(id));
+    GRPC_CHECK(s->included.is_set(id));
     if (new_head) {
       t->lists[id].head = new_head;
       new_head->links[id].prev = nullptr;
@@ -79,12 +79,12 @@ static bool stream_list_pop(grpc_chttp2_transport* t,
 
 static void stream_list_remove(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
                                grpc_chttp2_stream_list_id id) {
-  CHECK(s->included.is_set(id));
+  GRPC_CHECK(s->included.is_set(id));
   s->included.clear(id);
   if (s->links[id].prev) {
     s->links[id].prev->links[id].next = s->links[id].next;
   } else {
-    CHECK(t->lists[id].head == s);
+    GRPC_CHECK(t->lists[id].head == s);
     t->lists[id].head = s->links[id].next;
   }
   if (s->links[id].next) {
@@ -112,7 +112,7 @@ static void stream_list_add_tail(grpc_chttp2_transport* t,
                                  grpc_chttp2_stream* s,
                                  grpc_chttp2_stream_list_id id) {
   grpc_chttp2_stream* old_tail;
-  CHECK(!s->included.is_set(id));
+  GRPC_CHECK(!s->included.is_set(id));
   old_tail = t->lists[id].tail;
   s->links[id].next = nullptr;
   s->links[id].prev = old_tail;
@@ -132,7 +132,7 @@ static void stream_list_add_head(grpc_chttp2_transport* t,
                                  grpc_chttp2_stream* s,
                                  grpc_chttp2_stream_list_id id) {
   grpc_chttp2_stream* old_head;
-  CHECK(!s->included.is_set(id));
+  GRPC_CHECK(!s->included.is_set(id));
   old_head = t->lists[id].head;
   s->links[id].next = old_head;
   s->links[id].prev = nullptr;
@@ -170,7 +170,7 @@ static bool stream_list_prepend(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
 
 bool grpc_chttp2_list_add_writable_stream(grpc_chttp2_transport* t,
                                           grpc_chttp2_stream* s) {
-  CHECK_NE(s->id, 0u);
+  GRPC_CHECK_NE(s->id, 0u);
   if (grpc_core::IsPrioritizeFinishedRequestsEnabled() &&
       s->send_trailing_metadata != nullptr) {
     return stream_list_prepend(t, s, GRPC_CHTTP2_LIST_WRITABLE);

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

@@ -16,4 +16,20 @@
 //
 //
 
-namespace grpc_core {}  // namespace grpc_core
+#include "src/core/ext/transport/chttp2/transport/transport_common.h"
+
+#include <cstdint>
+
+#include "src/core/util/shared_bit_gen.h"
+#include "src/core/util/time.h"
+#include "absl/random/random.h"
+
+namespace grpc_core {
+
+Duration TarpitDuration(const int min_tarpit_duration_ms,
+                        const int max_tarpit_duration_ms) {
+  return Duration::Milliseconds(absl::LogUniform<int>(
+      SharedBitGen(), min_tarpit_duration_ms, max_tarpit_duration_ms));
+}
+
+}  // namespace grpc_core

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

@@ -19,9 +19,66 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_TRANSPORT_COMMON_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_TRANSPORT_COMMON_H
 
+#include <cstdint>
+
+#include "src/core/util/time.h"
+
 // For an HTTP2 connection, this must be sent before the settings frame is sent.
 #define GRPC_CHTTP2_CLIENT_CONNECT_STRING "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"
 #define GRPC_CHTTP2_CLIENT_CONNECT_STRLEN \
   (sizeof(GRPC_CHTTP2_CLIENT_CONNECT_STRING) - 1)
 
+// EXPERIMENTAL: control tarpitting in chttp2
+#define GRPC_ARG_HTTP_ALLOW_TARPIT "grpc.http.tarpit"
+#define GRPC_ARG_HTTP_TARPIT_MIN_DURATION_MS "grpc.http.tarpit_min_duration_ms"
+#define GRPC_ARG_HTTP_TARPIT_MAX_DURATION_MS "grpc.http.tarpit_max_duration_ms"
+
+// EXPERIMENTAL: provide protection against overloading a server with too many
+// requests: wait for streams to be deallocated before they stop counting
+// against MAX_CONCURRENT_STREAMS
+#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"
+#define GRPC_CHTTP2_KEEPALIVE_TIMEOUT_STR "keepalive timeout"
+
+namespace grpc_core {
+
+Duration TarpitDuration(int min_tarpit_duration_ms, int max_tarpit_duration_ms);
+
+namespace http2 {
+enum class WritableStreamPriority : uint8_t {
+  // Highest priority
+  kStreamClosed = 0,
+  kWaitForTransportFlowControl,
+  // Lowest Priority
+  kDefault,
+  kLastPriority
+};
+
+// Debug helper function to convert a WritableStreamPriority to a string.
+inline std::string GetWritableStreamPriorityString(
+    const WritableStreamPriority priority) {
+  switch (priority) {
+    case WritableStreamPriority::kStreamClosed:
+      return "StreamClosed";
+    case WritableStreamPriority::kWaitForTransportFlowControl:
+      return "WaitForTransportFlowControl";
+    case WritableStreamPriority::kDefault:
+      return "Default";
+    default:
+      return "unknown";
+  }
+}
+}  // namespace http2
+
+}  // namespace grpc_core
+
 #endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_TRANSPORT_COMMON_H

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

@@ -23,7 +23,7 @@
 #include <stdint.h>
 #include <stdlib.h>
 
-#include "absl/log/check.h"
+#include "src/core/util/grpc_check.h"
 
 // Helpers for hpack varint encoding
 
@@ -49,7 +49,7 @@ class VarintWriter {
   explicit VarintWriter(size_t value)
       : value_(value),
         length_(value < kMaxInPrefix ? 1 : VarintLength(value - kMaxInPrefix)) {
-    CHECK(value <= UINT32_MAX);
+    GRPC_CHECK(value <= UINT32_MAX);
   }
 
   size_t value() const { return value_; }

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

@@ -19,30 +19,51 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_WRITABLE_STREAMS_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_WRITABLE_STREAMS_H
 
+#include <cstdint>
+#include <limits>
+#include <optional>
 #include <queue>
+#include <vector>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
+#include "src/core/ext/transport/chttp2/transport/transport_common.h"
 #include "src/core/lib/promise/if.h"
 #include "src/core/lib/promise/mpsc.h"
 #include "src/core/lib/promise/race.h"
+#include "src/core/lib/promise/status_flag.h"
 #include "src/core/lib/promise/try_seq.h"
+#include "src/core/util/grpc_check.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
 
 namespace grpc_core {
 namespace http2 {
 
+namespace writable_streams_internal {
+template <typename StreamPtr, typename = void>
+struct HasGetStreamId {
+  static constexpr bool value = false;
+};
+
+template <typename StreamPtr>
+struct HasGetStreamId<
+    StreamPtr,
+    absl::void_t<decltype(std::declval<StreamPtr>()->GetStreamId())>> {
+  static constexpr bool value =
+      std::is_same_v<decltype(std::declval<StreamPtr>()->GetStreamId()),
+                     uint32_t>;
+};
+
+}  // namespace writable_streams_internal
+
 #define GRPC_WRITABLE_STREAMS_DEBUG VLOG(2)
 
+template <typename StreamPtr>
 class WritableStreams {
+  static_assert(writable_streams_internal::HasGetStreamId<StreamPtr>::value,
+                "StreamPtr must have a GetStreamId() function");
+
  public:
-  enum class StreamPriority : uint8_t {
-    // Highest priority
-    kStreamClosed = 0,
-    kWaitForTransportFlowControl,
-    // Lowest Priority
-    kDefault,
-    kLastPriority
-  };
   explicit WritableStreams(
       const uint32_t max_queue_size = std::numeric_limits<uint32_t>::max())
       : queue_(max_queue_size), sender_(queue_.MakeSender()) {}
@@ -53,34 +74,46 @@ class WritableStreams {
   WritableStreams(WritableStreams&&) = delete;
   WritableStreams& operator=(WritableStreams&&) = delete;
 
+  absl::Status EnqueueWrapper(const StreamPtr stream,
+                              const WritableStreamPriority priority,
+                              bool transport_tokens_available) {
+    if (transport_tokens_available) {
+      return Enqueue(stream, priority);
+    } else {
+      return BlockedOnTransportFlowControl(stream);
+    }
+  }
+
   // Enqueues a stream id with the given priority.
   // If this returns error, transport MUST be closed.
-  absl::Status Enqueue(const uint32_t stream_id,
-                       const StreamPriority priority) {
+  absl::Status Enqueue(const 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
     // BlockedOnTransportFlowControl. The reason being there is no merit in
     // re-adding the stream to mpsc queue while it can be immediately enqueued
     // to the prioritized queue.
-    DCHECK(priority != StreamPriority::kWaitForTransportFlowControl);
+    GRPC_DCHECK(priority !=
+                WritableStreamPriority::kWaitForTransportFlowControl);
     StatusFlag status = sender_.UnbufferedImmediateSend(
-        StreamIDAndPriority{stream_id, priority}, /*tokens*/ 1);
-    GRPC_WRITABLE_STREAMS_DEBUG << "UnbufferedImmediateEnqueue stream id "
-                                << stream_id << " with priority "
-                                << GetPriorityString(priority) << " status "
-                                << status;
-    return (status.ok()) ? absl::OkStatus()
-                         : absl::InternalError(absl::StrCat(
-                               "Failed to enqueue stream id ", stream_id));
+        StreamIDAndPriority{stream, priority}, /*tokens*/ 1);
+    GRPC_WRITABLE_STREAMS_DEBUG
+        << "UnbufferedImmediateEnqueue stream with priority "
+        << GetWritableStreamPriorityString(priority) << " status " << status;
+
+    return (status.ok())
+               ? absl::OkStatus()
+               : absl::InternalError(absl::StrCat(
+                     "Failed to enqueue stream to list of writable streams "));
   }
 
   // A synchronous function to add a stream id to the transport flow control
   // wait list.
-  absl::Status BlockedOnTransportFlowControl(const uint32_t stream_id) {
-    prioritized_queue_.Push(stream_id,
-                            StreamPriority::kWaitForTransportFlowControl);
-    GRPC_WRITABLE_STREAMS_DEBUG << "BlockedOnTransportFlowControl stream id "
-                                << stream_id;
+  absl::Status BlockedOnTransportFlowControl(const StreamPtr stream) {
+    prioritized_queue_.Push(
+        stream, WritableStreamPriority::kWaitForTransportFlowControl);
+    GRPC_WRITABLE_STREAMS_DEBUG << "Enqueuing a stream with priority "
+                                   "kWaitForTransportFlowControl ";
     return absl::OkStatus();
   }
 
@@ -100,29 +133,33 @@ class WritableStreams {
   //    prioritized queue.
   // 6. Return the stream id with the highest priority.
   // If this returns error, transport MUST be closed.
+  // TODO(akshitpatel) : [PH2][P2] - This will be deprecated in favor of
+  // WaitForReady.
   auto Next(const bool transport_tokens_available) {
     // TODO(akshitpatel) : [PH2][P2] - Need to add an immediate dequeue option
     // for the mpsc queue in favor of the race.
 
-    return AssertResultType<absl::StatusOr<uint32_t>>(TrySeq(
+    return AssertResultType<absl::StatusOr<StreamPtr>>(TrySeq(
         // The current MPSC queue does not have a version of NextBatch that
         // resolves immediately. So we made this Race to ensure that the
         // "Dequeue" from the mpsc resolves immediately - Either with data , or
         // empty.
-        Race(queue_.NextBatch(kMaxBatchSize),
-             Immediate(ValueOrFailure<std::vector<StreamIDAndPriority>>(
-                 std::vector<StreamIDAndPriority>()))),
-        [this,
-         transport_tokens_available](std::vector<StreamIDAndPriority> batch) {
+        Race(
+            queue_.NextBatch(kMaxBatchSize),
+            Immediate(
+                ValueOrFailure<std::vector<std::optional<StreamIDAndPriority>>>(
+                    std::vector<std::optional<StreamIDAndPriority>>()))),
+        [this, transport_tokens_available](
+            std::vector<std::optional<StreamIDAndPriority>> batch) {
           AddToPrioritizedQueue(batch);
-          std::optional<uint32_t> stream_id =
+          std::optional<StreamPtr> stream =
               prioritized_queue_.Pop(transport_tokens_available);
           return If(
-              stream_id.has_value(),
-              [stream_id]() -> absl::StatusOr<uint32_t> {
-                GRPC_WRITABLE_STREAMS_DEBUG << "Next stream id "
-                                            << stream_id.value();
-                return stream_id.value();
+              stream.has_value(),
+              [stream]() -> absl::StatusOr<StreamPtr> {
+                GRPC_WRITABLE_STREAMS_DEBUG << "Next stream id: "
+                                            << (*stream)->GetStreamId();
+                return stream.value();
               },
               [this, transport_tokens_available] {
                 GRPC_WRITABLE_STREAMS_DEBUG << "Query queue for next batch";
@@ -131,22 +168,24 @@ class WritableStreams {
                     // on mpsc queue to get a new batch of stream ids.
                     queue_.NextBatch(kMaxBatchSize),
                     [this, transport_tokens_available](
-                        ValueOrFailure<std::vector<StreamIDAndPriority>> batch)
-                        -> absl::StatusOr<uint32_t> {
+                        ValueOrFailure<
+                            std::vector<std::optional<StreamIDAndPriority>>>
+                            batch) -> absl::StatusOr<StreamPtr> {
                       if (batch.ok()) {
                         GRPC_WRITABLE_STREAMS_DEBUG << "Next batch size "
                                                     << batch.value().size();
                         AddToPrioritizedQueue(batch.value());
-                        std::optional<uint32_t> stream_id =
+                        std::optional<StreamPtr> stream =
                             prioritized_queue_.Pop(transport_tokens_available);
-                        // TODO(akshitpatel) : [PH2][P4] - This DCHECK should
-                        // ideally be fine. But in case if queue_.NextBatch
-                        // spuriously returns an empty batch, move to a Loop
-                        // to avoid this.
-                        DCHECK(stream_id.has_value());
-                        GRPC_WRITABLE_STREAMS_DEBUG << "Next stream id "
-                                                    << stream_id.value();
-                        return stream_id.value();
+                        // TODO(akshitpatel) : [PH2][P4] - This GRPC_DCHECK
+                        // should ideally be fine. But in case if
+                        // queue_.NextBatch spuriously returns an empty batch,
+                        // move to a Loop to avoid this.
+                        GRPC_DCHECK(stream.has_value());
+                        GRPC_WRITABLE_STREAMS_DEBUG
+                            << "Next stream id: "
+                            << stream.value()->GetStreamId();
+                        return stream.value();
                       }
                       return absl::InternalError("Failed to read from queue");
                     });
@@ -154,18 +193,55 @@ class WritableStreams {
         }));
   }
 
-  // Debug helper function to convert a StreamPriority to a string.
-  static inline std::string GetPriorityString(const StreamPriority priority) {
-    switch (priority) {
-      case StreamPriority::kStreamClosed:
-        return "StreamClosed";
-      case StreamPriority::kWaitForTransportFlowControl:
-        return "WaitForTransportFlowControl";
-      case StreamPriority::kDefault:
-        return "Default";
-      default:
-        return "unknown";
-    }
+  // Wait for a stream to be ready to be dequeued. This is a blocking call.
+  // This returns a promise that resolves when there is a writeable stream ready
+  // to be dequeued or ForceReadyForWrite() is called.
+  auto WaitForReady(const bool transport_tokens_available) {
+    return TrySeq(
+        If(
+            PrioritizedQueueHasWritableStreams(transport_tokens_available),
+            [this]() {
+              // TODO(akshitpatel) : [PH2][P3] - This is temporary. Replace with
+              // native MPSC::ImmediateNextBatch.
+              // We already have writable streams in the prioritized queue.
+              // We check for any newly added streams to the un-prioritised
+              // queue. We dequeue to honor the priority of any newly enqueued
+              // streams.
+              return Race(
+                  queue_.NextBatch(kMaxBatchSize),
+                  Immediate(ValueOrFailure<
+                            std::vector<std::optional<StreamIDAndPriority>>>(
+                      std::vector<std::optional<StreamIDAndPriority>>())));
+            },
+            // The prioritised queue is empty. So we wait for something to
+            // enter the un-prioritised queue and then dequeue it.
+            [this]() { return queue_.NextBatch(kMaxBatchSize); }),
+        [this](std::vector<std::optional<StreamIDAndPriority>> batch) {
+          AddToPrioritizedQueue(batch);
+          return Empty{};
+        });
+  }
+
+  // Synchronously drain the prioritized queue.
+  std::optional<StreamPtr> ImmediateNext(
+      const bool transport_tokens_available) {
+    return prioritized_queue_.Pop(transport_tokens_available);
+  }
+
+  // Force resolve WaitForReady. This is used to induce a write cycle on the
+  // transport.
+  absl::Status ForceReadyForWrite() {
+    StatusFlag status =
+        sender_.UnbufferedImmediateSend(std::nullopt, /*tokens*/ 1);
+    GRPC_WRITABLE_STREAMS_DEBUG << "ForceReadyForWrite status " << status;
+    return (status.ok()) ? absl::OkStatus()
+                         : absl::InternalError(
+                               "Failed to enqueue to list of writable streams");
+  }
+
+  bool TestOnlyPriorityQueueHasWritableStreams(
+      const bool transport_tokens_available) const {
+    return !prioritized_queue_.HasNoWritableStreams(transport_tokens_available);
   }
 
  private:
@@ -176,21 +252,26 @@ class WritableStreams {
     // Pushes a stream id with the given priority to the queue. Sorting is done
     // based on the priority. If the priority is higher than the max priority,
     // it will be set to the default priority.
-    void Push(const uint32_t stream_id, StreamPriority priority) {
-      if (priority >= StreamPriority::kLastPriority) {
-        priority = StreamPriority::kDefault;
+    void Push(const StreamPtr stream, WritableStreamPriority priority) {
+      if (priority >= WritableStreamPriority::kLastPriority) {
+        priority = WritableStreamPriority::kDefault;
       }
 
-      GRPC_WRITABLE_STREAMS_DEBUG << "Pushing stream id " << stream_id
-                                  << " with priority "
-                                  << GetPriorityString(priority);
-      buckets_[static_cast<uint8_t>(priority)].push(stream_id);
+      total_streams_++;
+      GRPC_WRITABLE_STREAMS_DEBUG
+          << "Pushing stream id: " << stream->GetStreamId() << " with priority "
+          << GetWritableStreamPriorityString(priority) << " with total streams "
+          << total_streams_;
+      buckets_[static_cast<uint8_t>(priority)].push(stream);
     }
 
     // Pops a stream id from the queue based on the priority. If the priority is
     // kWaitForTransportFlowControl, transport_tokens_available is checked to
     // see if the stream id can be popped.
-    std::optional<uint32_t> Pop(const bool transport_tokens_available) {
+    std::optional<StreamPtr> Pop(const bool transport_tokens_available) {
+      if (HasNoWritableStreams(transport_tokens_available)) {
+        return std::nullopt;
+      }
       for (uint8_t i = 0; i < buckets_.size(); ++i) {
         auto& bucket = buckets_[i];
         if (!bucket.empty()) {
@@ -202,36 +283,73 @@ class WritableStreams {
             continue;
           }
 
-          uint32_t stream_id = bucket.front();
+          StreamPtr stream = bucket.front();
           bucket.pop();
+          total_streams_--;
           GRPC_WRITABLE_STREAMS_DEBUG
-              << "Popping stream id " << stream_id << " from priority "
-              << GetPriorityString(static_cast<StreamPriority>(i));
-          return stream_id;
+              << "Popping stream id: " << stream->GetStreamId()
+              << " from priority "
+              << GetWritableStreamPriorityString(
+                     static_cast<WritableStreamPriority>(i))
+              << " with " << total_streams_ << " streams remaining";
+          return stream;
         }
       }
       return std::nullopt;
     }
 
+    // Returns true if the queue does not have any stream that can be popped.
+    // If transport_tokens_available is false, streams with priority of
+    // kWaitForTransportFlowControl are not considered.
+    inline bool HasNoWritableStreams(
+        const bool transport_tokens_available) const {
+      return (transport_tokens_available)
+                 ? (total_streams_ == 0)
+                 : (total_streams_ -
+                        buckets_[kWaitForTransportFlowControlIndex].size() ==
+                    0);
+    }
+
     static constexpr uint8_t kLastPriority =
-        static_cast<uint8_t>(StreamPriority::kLastPriority);
+        static_cast<uint8_t>(WritableStreamPriority::kLastPriority);
     static constexpr uint8_t kWaitForTransportFlowControlIndex =
-        static_cast<uint8_t>(StreamPriority::kWaitForTransportFlowControl);
-    std::vector<std::queue<uint32_t>> buckets_;
+        static_cast<uint8_t>(
+            WritableStreamPriority::kWaitForTransportFlowControl);
+    std::vector<std::queue<StreamPtr>> buckets_;
+    uint32_t total_streams_ = 0u;
   };
 
   struct StreamIDAndPriority {
-    const uint32_t stream_id;
-    const StreamPriority priority;
+    const StreamPtr stream;
+    const WritableStreamPriority priority;
   };
 
-  void AddToPrioritizedQueue(const std::vector<StreamIDAndPriority>& batch) {
-    for (auto stream_id_priority : batch) {
-      prioritized_queue_.Push(stream_id_priority.stream_id,
-                              stream_id_priority.priority);
+  void AddToPrioritizedQueue(
+      const std::vector<std::optional<StreamIDAndPriority>>& batch) {
+    GRPC_WRITABLE_STREAMS_DEBUG << "AddToPrioritizedQueue batch size "
+                                << batch.size();
+    for (const std::optional<StreamIDAndPriority>& stream_id_priority : batch) {
+      // Ignore stream id kInvalidStreamID. These are used to force resolve
+      // WaitForReady().
+      if (!stream_id_priority.has_value()) {
+        GRPC_WRITABLE_STREAMS_DEBUG << "Skipping nullopt from batch";
+        continue;
+      }
+      prioritized_queue_.Push(stream_id_priority->stream,
+                              stream_id_priority->priority);
     }
   }
 
+  // Returns true if the prioritized queue has any stream that can be popped.
+  bool PrioritizedQueueHasWritableStreams(
+      const bool transport_tokens_available) const {
+    GRPC_WRITABLE_STREAMS_DEBUG
+        << "PrioritizedQueueHasWritableStreams "
+        << !prioritized_queue_.HasNoWritableStreams(transport_tokens_available)
+        << " transport_tokens_available " << transport_tokens_available;
+    return !prioritized_queue_.HasNoWritableStreams(transport_tokens_available);
+  }
+
   // TODO(akshitpatel) : [PH2][P4] - Verify if this works for large number of
   // active streams based on the load tests. The reasoning to use max uint32_t
   // is that even when the streams are dequeued from the queue, the streams
@@ -243,8 +361,8 @@ class WritableStreams {
   static constexpr uint32_t kMaxBatchSize =
       std::numeric_limits<uint32_t>::max();
 
-  MpscReceiver<StreamIDAndPriority> queue_;
-  MpscSender<StreamIDAndPriority> sender_;
+  MpscReceiver<std::optional<StreamIDAndPriority>> queue_;
+  MpscSender<std::optional<StreamIDAndPriority>> sender_;
   PrioritizedQueue prioritized_queue_;
 };
 

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

@@ -18,14 +18,14 @@
 
 #include <algorithm>
 
-#include "absl/log/check.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
 size_t Chttp2WriteSizePolicy::WriteTargetSize() { return current_target_; }
 
 void Chttp2WriteSizePolicy::BeginWrite(size_t size) {
-  CHECK(experiment_start_time_ == Timestamp::InfFuture());
+  GRPC_CHECK_EQ(experiment_start_time_, Timestamp::InfFuture());
   if (size < current_target_ * 7 / 10) {
     // If we were trending fast but stopped getting enough data to verify, then
     // reset back to the default state.

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

@@ -30,10 +30,6 @@
 #include <string>
 #include <utility>
 
-#include "absl/container/flat_hash_map.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/status/status.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/ext/transport/chttp2/transport/call_tracer_wrapper.h"
@@ -69,12 +65,16 @@
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"
 #include "src/core/telemetry/tcp_tracer.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/match.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/time.h"
 #include "src/core/util/useful.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
 
 // IWYU pragma: no_include "src/core/util/orphanable.h"
 
@@ -273,7 +273,7 @@ class WriteContext {
       grpc_core::Http2Frame frame(std::move(*update));
       Serialize(absl::Span<grpc_core::Http2Frame>(&frame, 1), t_->outbuf);
       if (t_->keepalive_timeout != grpc_core::Duration::Infinity()) {
-        CHECK(
+        GRPC_CHECK(
             t_->settings_ack_watchdog ==
             grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid);
         // We base settings timeout on keepalive timeout, but double it to allow
@@ -293,7 +293,7 @@ class WriteContext {
     // simple writes are queued to qbuf, and flushed here
     grpc_slice_buffer_move_into(&t_->qbuf, t_->outbuf.c_slice_buffer());
     t_->num_pending_induced_frames = 0;
-    CHECK_EQ(t_->qbuf.count, 0u);
+    GRPC_CHECK_EQ(t_->qbuf.count, 0u);
   }
 
   void FlushWindowUpdates() {