grpc 1.59.0 → 1.59.2

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

@@ -21,8 +21,12 @@
 #include <inttypes.h>
 #include <string.h>
 
+#include <atomic>
 #include <initializer_list>
+#include <limits>
+#include <memory>
 #include <string>
+#include <utility>
 
 #include "absl/base/attributes.h"
 #include "absl/container/flat_hash_map.h"
@@ -31,8 +35,11 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/variant.h"
 
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/slice.h>
+#include <grpc/slice_buffer.h>
 #include <grpc/support/log.h>
 
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
@@ -48,11 +55,14 @@
 #include "src/core/ext/transport/chttp2/transport/http_trace.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
+#include "src/core/ext/transport/chttp2/transport/max_concurrent_streams_policy.h"
 #include "src/core/ext/transport/chttp2/transport/ping_rate_policy.h"
+#include "src/core/lib/backoff/random_early_detection.h"
 #include "src/core/lib/channel/call_tracer.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -70,9 +80,11 @@ using grpc_core::HPackParser;
 
 grpc_core::TraceFlag grpc_trace_chttp2_new_stream(false, "chttp2_new_stream");
 
-static grpc_error_handle init_frame_parser(grpc_chttp2_transport* t);
+static grpc_error_handle init_frame_parser(grpc_chttp2_transport* t,
+                                           size_t& requests_started);
 static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
-                                                  int is_continuation);
+                                                  int is_continuation,
+                                                  size_t& requests_started);
 static grpc_error_handle init_data_frame_parser(grpc_chttp2_transport* t);
 static grpc_error_handle init_rst_stream_parser(grpc_chttp2_transport* t);
 static grpc_error_handle init_settings_frame_parser(grpc_chttp2_transport* t);
@@ -194,8 +206,9 @@ std::string FrameTypeString(uint8_t frame_type, uint8_t flags) {
 }
 }  // namespace
 
-grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
-                                           const grpc_slice& slice) {
+absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
+    grpc_chttp2_transport* t, const grpc_slice& slice,
+    size_t& requests_started) {
   const uint8_t* beg = GRPC_SLICE_START_PTR(slice);
   const uint8_t* end = GRPC_SLICE_END_PTR(slice);
   const uint8_t* cur = beg;
@@ -249,6 +262,10 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
         return absl::OkStatus();
       }
     dts_fh_0:
+      if (requests_started >= t->max_requests_per_read) {
+        t->deframe_state = GRPC_DTS_FH_0;
+        return static_cast<size_t>(cur - beg);
+      }
       ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FH_0:
       GPR_DEBUG_ASSERT(cur < end);
@@ -324,7 +341,7 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
                 t->incoming_frame_size, t->incoming_stream_id);
       }
       t->deframe_state = GRPC_DTS_FRAME;
-      err = init_frame_parser(t);
+      err = init_frame_parser(t, requests_started);
       if (!err.ok()) {
         return err;
       }
@@ -378,6 +395,10 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
         }
         cur += t->incoming_frame_size;
         t->incoming_stream = nullptr;
+        if (t->incoming_frame_type == GRPC_CHTTP2_FRAME_RST_STREAM &&
+            grpc_core::IsChttp2OffloadOnRstStreamEnabled()) {
+          requests_started = std::numeric_limits<size_t>::max();
+        }
         goto dts_fh_0;  // loop
       } else {
         err = parse_frame_slice(
@@ -397,7 +418,8 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
   GPR_UNREACHABLE_CODE(return absl::OkStatus());
 }
 
-static grpc_error_handle init_frame_parser(grpc_chttp2_transport* t) {
+static grpc_error_handle init_frame_parser(grpc_chttp2_transport* t,
+                                           size_t& requests_started) {
   if (t->is_first_frame &&
       t->incoming_frame_type != GRPC_CHTTP2_FRAME_SETTINGS) {
     return GRPC_ERROR_CREATE(absl::StrCat(
@@ -417,13 +439,13 @@ static grpc_error_handle init_frame_parser(grpc_chttp2_transport* t) {
           "grpc_chttp2_stream %08x",
           t->expect_continuation_stream_id, t->incoming_stream_id));
     }
-    return init_header_frame_parser(t, 1);
+    return init_header_frame_parser(t, 1, requests_started);
   }
   switch (t->incoming_frame_type) {
     case GRPC_CHTTP2_FRAME_DATA:
       return init_data_frame_parser(t);
     case GRPC_CHTTP2_FRAME_HEADER:
-      return init_header_frame_parser(t, 0);
+      return init_header_frame_parser(t, 0, requests_started);
     case GRPC_CHTTP2_FRAME_CONTINUATION:
       return GRPC_ERROR_CREATE("Unexpected CONTINUATION frame");
     case GRPC_CHTTP2_FRAME_RST_STREAM:
@@ -567,7 +589,8 @@ error_handler:
 }
 
 static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
-                                                  int is_continuation) {
+                                                  int is_continuation,
+                                                  size_t& requests_started) {
   const bool is_eoh =
       (t->incoming_frame_flags & GRPC_CHTTP2_DATA_FLAG_END_HEADERS) != 0;
   grpc_chttp2_stream* s;
@@ -625,10 +648,40 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
           t->incoming_stream_id));
       return init_header_skip_frame_parser(t, priority_type, is_eoh);
     } else if (GPR_UNLIKELY(
-                   t->stream_map.size() >=
+                   t->stream_map.size() + t->extra_streams >=
                    t->settings[GRPC_ACKED_SETTINGS]
                               [GRPC_CHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS])) {
       return GRPC_ERROR_CREATE("Max stream count exceeded");
+    } else if (GPR_UNLIKELY(
+                   grpc_core::IsOverloadProtectionEnabled() &&
+                   t->streams_allocated.load(std::memory_order_relaxed) >
+                       t->max_concurrent_streams_policy.AdvertiseValue())) {
+      // We have more streams allocated than we'd like, so apply some pushback
+      // by refusing this stream.
+      ++t->num_pending_induced_frames;
+      grpc_slice_buffer_add(&t->qbuf, grpc_chttp2_rst_stream_create(
+                                          t->incoming_stream_id,
+                                          GRPC_HTTP2_REFUSED_STREAM, nullptr));
+      grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_RST_STREAM);
+      return init_header_skip_frame_parser(t, priority_type, is_eoh);
+    } else if (GPR_UNLIKELY(
+                   grpc_core::IsRedMaxConcurrentStreamsEnabled() &&
+                   t->stream_map.size() >=
+                       t->max_concurrent_streams_policy.AdvertiseValue() &&
+                   grpc_core::RandomEarlyDetection(
+                       t->max_concurrent_streams_policy.AdvertiseValue(),
+                       t->settings[GRPC_ACKED_SETTINGS]
+                                  [GRPC_CHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS])
+                       .Reject(t->stream_map.size(), t->bitgen))) {
+      // We are under the limit of max concurrent streams for the current
+      // setting, but are over the next value that will be advertised.
+      // Apply some backpressure by randomly not accepting new streams.
+      ++t->num_pending_induced_frames;
+      grpc_slice_buffer_add(&t->qbuf, grpc_chttp2_rst_stream_create(
+                                          t->incoming_stream_id,
+                                          GRPC_HTTP2_REFUSED_STREAM, nullptr));
+      grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_RST_STREAM);
+      return init_header_skip_frame_parser(t, priority_type, is_eoh);
     } else if (t->sent_goaway_state == GRPC_CHTTP2_FINAL_GOAWAY_SENT ||
                t->sent_goaway_state ==
                    GRPC_CHTTP2_FINAL_GOAWAY_SEND_SCHEDULED) {
@@ -639,10 +692,29 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
           t, std::string(t->peer_string.as_string_view()).c_str(),
           t->incoming_stream_id, t->last_new_stream_id));
       return init_header_skip_frame_parser(t, priority_type, is_eoh);
+    } else if (grpc_core::IsBlockExcessiveRequestsBeforeSettingsAckEnabled() &&
+               t->num_incoming_streams_before_settings_ack == 0) {
+      GRPC_CHTTP2_IF_TRACING(gpr_log(
+          GPR_ERROR,
+          "transport:%p SERVER peer:%s rejecting grpc_chttp2_stream id=%d, "
+          "last grpc_chttp2_stream id=%d before settings have been "
+          "acknowledged",
+          t, std::string(t->peer_string.as_string_view()).c_str(),
+          t->incoming_stream_id, t->last_new_stream_id));
+      ++t->num_pending_induced_frames;
+      grpc_slice_buffer_add(
+          &t->qbuf,
+          grpc_chttp2_rst_stream_create(t->incoming_stream_id,
+                                        GRPC_HTTP2_ENHANCE_YOUR_CALM, nullptr));
+      grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_RST_STREAM);
+      t->last_new_stream_id = t->incoming_stream_id;
+      return init_header_skip_frame_parser(t, priority_type, is_eoh);
     }
+    --t->num_incoming_streams_before_settings_ack;
     t->last_new_stream_id = t->incoming_stream_id;
     s = t->incoming_stream =
         grpc_chttp2_parsing_accept_stream(t, t->incoming_stream_id);
+    ++requests_started;
     if (GPR_UNLIKELY(s == nullptr)) {
       GRPC_CHTTP2_IF_TRACING(
           gpr_log(GPR_ERROR, "grpc_chttp2_stream not accepted"));
@@ -650,9 +722,12 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
     }
     if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace) ||
         GRPC_TRACE_FLAG_ENABLED(grpc_trace_chttp2_new_stream)) {
-      gpr_log(GPR_INFO, "[t:%p fd:%d peer:%s] Accepting new stream", t,
-              grpc_endpoint_get_fd(t->ep),
-              std::string(t->peer_string.as_string_view()).c_str());
+      gpr_log(GPR_INFO,
+              "[t:%p fd:%d peer:%s] Accepting new stream; "
+              "num_incoming_streams_before_settings_ack=%u",
+              t, grpc_endpoint_get_fd(t->ep),
+              std::string(t->peer_string.as_string_view()).c_str(),
+              t->num_incoming_streams_before_settings_ack);
     }
     if (t->channelz_socket != nullptr) {
       t->channelz_socket->RecordStreamStartedFromRemote();
@@ -763,6 +838,9 @@ static grpc_error_handle init_rst_stream_parser(grpc_chttp2_transport* t) {
   s->stats.incoming.framing_bytes += 9;
   t->parser = grpc_chttp2_transport::Parser{
       "rst_stream", grpc_chttp2_rst_stream_parser_parse, &t->simple.rst_stream};
+  if (!t->is_client && grpc_core::IsRstpitEnabled()) {
+    t->max_concurrent_streams_policy.AddDemerit();
+  }
   return absl::OkStatus();
 }
 
@@ -787,6 +865,7 @@ static grpc_error_handle init_settings_frame_parser(grpc_chttp2_transport* t) {
     return err;
   }
   if (t->incoming_frame_flags & GRPC_CHTTP2_FLAG_ACK) {
+    t->max_concurrent_streams_policy.AckLastSend();
     memcpy(t->settings[GRPC_ACKED_SETTINGS], t->settings[GRPC_SENT_SETTINGS],
            GRPC_CHTTP2_NUM_SETTINGS * sizeof(uint32_t));
     t->hpack_parser.hpack_table()->SetMaxBytes(
@@ -797,7 +876,17 @@ static grpc_error_handle init_settings_frame_parser(grpc_chttp2_transport* t) {
             t->settings[GRPC_ACKED_SETTINGS]
                        [GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE]),
         t, nullptr);
+    if (t->settings_ack_watchdog !=
+        grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid) {
+      t->event_engine->Cancel(std::exchange(
+          t->settings_ack_watchdog,
+          grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid));
+    }
     t->sent_local_settings = false;
+    // This is more streams than can be started in http2, so setting this
+    // effictively removes the limit for the rest of the connection.
+    t->num_incoming_streams_before_settings_ack =
+        std::numeric_limits<uint32_t>::max();
   }
   t->parser = grpc_chttp2_transport::Parser{
       "settings", grpc_chttp2_settings_parser_parse, &t->simple.settings};
@@ -828,7 +917,7 @@ static grpc_error_handle parse_frame_slice(grpc_chttp2_transport* t,
                          &unused)) {
     grpc_chttp2_parsing_become_skip_parser(t);
     if (s) {
-      grpc_chttp2_cancel_stream(t, s, err);
+      grpc_chttp2_cancel_stream(t, s, err, true);
     }
     return absl::OkStatus();
   }

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

@@ -0,0 +1,108 @@
+// Copyright 2023 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 <grpc/support/port_platform.h>
+
+#include "src/core/ext/transport/chttp2/transport/ping_callbacks.h"
+
+#include <utility>
+
+#include "absl/meta/type_traits.h"
+#include "absl/random/distributions.h"
+
+#include <grpc/support/log.h>
+
+grpc_core::TraceFlag grpc_ping_trace(false, "http2_ping");
+
+namespace grpc_core {
+
+void Chttp2PingCallbacks::OnPing(Callback on_start, Callback on_ack) {
+  on_start_.emplace_back(std::move(on_start));
+  on_ack_.emplace_back(std::move(on_ack));
+  ping_requested_ = true;
+}
+
+void Chttp2PingCallbacks::OnPingAck(Callback on_ack) {
+  auto it = inflight_.find(most_recent_inflight_);
+  if (it != inflight_.end()) {
+    it->second.on_ack.emplace_back(std::move(on_ack));
+    return;
+  }
+  ping_requested_ = true;
+  on_ack_.emplace_back(std::move(on_ack));
+}
+
+uint64_t Chttp2PingCallbacks::StartPing(absl::BitGenRef bitgen) {
+  uint64_t id;
+  do {
+    id = absl::Uniform<uint64_t>(bitgen);
+  } while (inflight_.contains(id));
+  CallbackVec cbs = std::move(on_start_);
+  CallbackVec().swap(on_start_);
+  InflightPing inflight;
+  inflight.on_ack.swap(on_ack_);
+  started_new_ping_without_setting_timeout_ = true;
+  inflight_.emplace(id, std::move(inflight));
+  most_recent_inflight_ = id;
+  ping_requested_ = false;
+  for (auto& cb : cbs) {
+    cb();
+  }
+  return id;
+}
+
+bool Chttp2PingCallbacks::AckPing(
+    uint64_t id, grpc_event_engine::experimental::EventEngine* event_engine) {
+  auto ping = inflight_.extract(id);
+  if (ping.empty()) return false;
+  if (ping.mapped().on_timeout !=
+      grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid) {
+    event_engine->Cancel(ping.mapped().on_timeout);
+  }
+  for (auto& cb : ping.mapped().on_ack) {
+    cb();
+  }
+  return true;
+}
+
+void Chttp2PingCallbacks::CancelAll(
+    grpc_event_engine::experimental::EventEngine* event_engine) {
+  CallbackVec().swap(on_start_);
+  CallbackVec().swap(on_ack_);
+  for (auto& cbs : inflight_) {
+    CallbackVec().swap(cbs.second.on_ack);
+    if (cbs.second.on_timeout !=
+        grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid) {
+      event_engine->Cancel(std::exchange(
+          cbs.second.on_timeout,
+          grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid));
+    }
+  }
+  ping_requested_ = false;
+}
+
+absl::optional<uint64_t> Chttp2PingCallbacks::OnPingTimeout(
+    Duration ping_timeout,
+    grpc_event_engine::experimental::EventEngine* event_engine,
+    Callback callback) {
+  GPR_ASSERT(started_new_ping_without_setting_timeout_);
+  started_new_ping_without_setting_timeout_ = false;
+  auto it = inflight_.find(most_recent_inflight_);
+  if (it == inflight_.end()) return absl::nullopt;
+  it->second.on_timeout =
+      event_engine->RunAfter(ping_timeout, std::move(callback));
+  return most_recent_inflight_;
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,115 @@
+// Copyright 2023 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_PING_CALLBACKS_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_PING_CALLBACKS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <algorithm>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/functional/any_invocable.h"
+#include "absl/hash/hash.h"
+#include "absl/random/bit_gen_ref.h"
+#include "absl/types/optional.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/time.h"
+
+extern grpc_core::TraceFlag grpc_ping_trace;
+
+namespace grpc_core {
+
+class Chttp2PingCallbacks {
+ public:
+  // One callback from OnPing/OnPingAck or the timeout.
+  using Callback = absl::AnyInvocable<void()>;
+
+  // Request a ping (but one we don't need any notification for when it begins
+  // or ends).
+  void RequestPing() { ping_requested_ = true; }
+
+  // Request a ping, and specify callbacks for when it begins and ends.
+  // on_start is invoked during the call to StartPing.
+  // on_ack is invoked during the call to AckPing.
+  void OnPing(Callback on_start, Callback on_ack);
+
+  // Request a notification when *some* ping is acked:
+  // If there is no ping in flight, one will be scheduled and the callback
+  // will be invoked when it is acked. (ie as per OnPing([]{}, on_ack)).
+  // If there is a ping in flight, the callback will be invoked when the most
+  // recently sent ping is acked.
+  // on_ack is invoked during the call to AckPing.
+  void OnPingAck(Callback on_ack);
+
+  // Write path: begin a ping.
+  // Uses bitgen to generate a randomized id for the ping.
+  // Sets started_new_ping_without_setting_timeout.
+  GRPC_MUST_USE_RESULT uint64_t StartPing(absl::BitGenRef bitgen);
+  bool AckPing(uint64_t id,
+               grpc_event_engine::experimental::EventEngine* event_engine);
+
+  // Cancel all the ping callbacks.
+  // Sufficient state is maintained such that AckPing will still return true
+  // if a ping is acked after this call.
+  // No timeouts or start or ack callbacks previously scheduled will be invoked.
+  void CancelAll(grpc_event_engine::experimental::EventEngine* event_engine);
+
+  // Return true if a ping needs to be started due to
+  // RequestPing/OnPing/OnPingAck.
+  bool ping_requested() const { return ping_requested_; }
+
+  // Returns the number of pings currently in flight.
+  size_t pings_inflight() const { return inflight_.size(); }
+
+  // Returns true if a ping was started without setting a timeout yet.
+  bool started_new_ping_without_setting_timeout() const {
+    return started_new_ping_without_setting_timeout_;
+  }
+
+  // Add a ping timeout for the most recently started ping.
+  // started_new_ping_without_setting_timeout must be set.
+  // Clears started_new_ping_without_setting_timeout.
+  // Returns the ping id of the ping the timeout was attached to if a timer was
+  // started, or nullopt otherwise.
+  absl::optional<uint64_t> OnPingTimeout(
+      Duration ping_timeout,
+      grpc_event_engine::experimental::EventEngine* event_engine,
+      Callback callback);
+
+ private:
+  using CallbackVec = std::vector<Callback>;
+  struct InflightPing {
+    grpc_event_engine::experimental::EventEngine::TaskHandle on_timeout =
+        grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid;
+    CallbackVec on_ack;
+  };
+  absl::flat_hash_map<uint64_t, InflightPing> inflight_;
+  uint64_t most_recent_inflight_ = 0;
+  bool ping_requested_ = false;
+  bool started_new_ping_without_setting_timeout_ = false;
+  CallbackVec on_start_;
+  CallbackVec on_ack_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_PING_CALLBACKS_H

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

@@ -25,12 +25,20 @@
 
 #include <grpc/impl/channel_arg_names.h>
 
+#include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/gprpp/match.h"
 
+// How many pings do we allow to be inflight at any given time?
+// In older versions of gRPC this was implicitly 1.
+// With the multiping experiment we allow this to rise to 100 by default.
+// TODO(ctiller): consider making this public API
+#define GRPC_ARG_HTTP2_MAX_INFLIGHT_PINGS "grpc.http2.max_inflight_pings"
+
 namespace grpc_core {
 
 namespace {
 int g_default_max_pings_without_data = 2;
+absl::optional<int> g_default_max_inflight_pings;
 }  // namespace
 
 Chttp2PingRatePolicy::Chttp2PingRatePolicy(const ChannelArgs& args,
@@ -39,19 +47,30 @@ Chttp2PingRatePolicy::Chttp2PingRatePolicy(const ChannelArgs& args,
           is_client
               ? std::max(0, args.GetInt(GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA)
                                 .value_or(g_default_max_pings_without_data))
-              : 0) {}
+              : 0),
+      // Configuration via channel arg dominates, otherwise if the multiping
+      // experiment is enabled we use 100, otherwise 1.
+      max_inflight_pings_(
+          std::max(0, args.GetInt(GRPC_ARG_HTTP2_MAX_INFLIGHT_PINGS)
+                          .value_or(g_default_max_inflight_pings.value_or(
+                              IsMultipingEnabled() ? 100 : 1)))) {}
 
 void Chttp2PingRatePolicy::SetDefaults(const ChannelArgs& args) {
   g_default_max_pings_without_data =
       std::max(0, args.GetInt(GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA)
                       .value_or(g_default_max_pings_without_data));
+  g_default_max_inflight_pings = args.GetInt(GRPC_ARG_HTTP2_MAX_INFLIGHT_PINGS);
 }
 
 Chttp2PingRatePolicy::RequestSendPingResult
-Chttp2PingRatePolicy::RequestSendPing(Duration next_allowed_ping_interval) {
+Chttp2PingRatePolicy::RequestSendPing(Duration next_allowed_ping_interval,
+                                      size_t inflight_pings) const {
   if (max_pings_without_data_ != 0 && pings_before_data_required_ == 0) {
     return TooManyRecentPings{};
   }
+  if (max_inflight_pings_ != 0 && inflight_pings > max_inflight_pings_) {
+    return TooManyRecentPings{};
+  }
   const Timestamp next_allowed_ping =
       last_ping_sent_time_ + next_allowed_ping_interval;
   const Timestamp now = Timestamp::Now();
@@ -59,11 +78,14 @@ Chttp2PingRatePolicy::RequestSendPing(Duration next_allowed_ping_interval) {
     return TooSoon{next_allowed_ping_interval, last_ping_sent_time_,
                    next_allowed_ping - now};
   }
-  last_ping_sent_time_ = now;
-  if (pings_before_data_required_) --pings_before_data_required_;
   return SendGranted{};
 }
 
+void Chttp2PingRatePolicy::SentPing() {
+  last_ping_sent_time_ = Timestamp::Now();
+  if (pings_before_data_required_) --pings_before_data_required_;
+}
+
 void Chttp2PingRatePolicy::ReceivedDataFrame() {
   last_ping_sent_time_ = Timestamp::InfPast();
 }

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

@@ -17,6 +17,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+
 #include <iosfwd>
 #include <string>
 
@@ -51,8 +53,20 @@ class Chttp2PingRatePolicy {
   using RequestSendPingResult =
       absl::variant<SendGranted, TooManyRecentPings, TooSoon>;
 
-  RequestSendPingResult RequestSendPing(Duration next_allowed_ping_interval);
+  // Request that one ping be sent.
+  // Returns:
+  //  - SendGranted if a ping can be sent.
+  //  - TooManyRecentPings if too many pings have been sent recently and we
+  //    should wait for some future write.
+  //  - TooSoon if we should wait for some time before sending the ping.
+  RequestSendPingResult RequestSendPing(Duration next_allowed_ping_interval,
+                                        size_t inflight_pings) const;
+  // Notify the policy that one ping has been sent.
+  void SentPing();
+  // Notify the policy that some data has been sent and so we should no longer
+  // block pings on that basis.
   void ResetPingsBeforeDataRequired();
+  // Notify the policy that we've received some data.
   void ReceivedDataFrame();
   std::string GetDebugString() const;
 
@@ -60,6 +74,7 @@ class Chttp2PingRatePolicy {
 
  private:
   const int max_pings_without_data_;
+  const int max_inflight_pings_;
   // No pings allowed before receiving a header or data frame.
   int pings_before_data_required_ = 0;
   Timestamp last_ping_sent_time_ = Timestamp::InfPast();

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

@@ -0,0 +1,60 @@
+// Copyright 2023 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 <grpc/support/port_platform.h>
+
+#include "src/core/ext/transport/chttp2/transport/write_size_policy.h"
+
+#include <algorithm>
+
+#include <grpc/support/log.h>
+
+namespace grpc_core {
+
+size_t Chttp2WriteSizePolicy::WriteTargetSize() { return current_target_; }
+
+void Chttp2WriteSizePolicy::BeginWrite(size_t size) {
+  GPR_ASSERT(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.
+    if (state_ < 0) state_ = 0;
+    return;
+  }
+  experiment_start_time_ = Timestamp::Now();
+}
+
+void Chttp2WriteSizePolicy::EndWrite(bool success) {
+  if (experiment_start_time_ == Timestamp::InfFuture()) return;
+  const auto elapsed = Timestamp::Now() - experiment_start_time_;
+  experiment_start_time_ = Timestamp::InfFuture();
+  if (!success) return;
+  if (elapsed < FastWrite()) {
+    --state_;
+    if (state_ == -2) {
+      state_ = 0;
+      current_target_ = std::min(current_target_ * 3 / 2, MaxTarget());
+    }
+  } else if (elapsed > SlowWrite()) {
+    ++state_;
+    if (state_ == 2) {
+      state_ = 0;
+      current_target_ = std::max(current_target_ / 3, MinTarget());
+    }
+  } else {
+    state_ = 0;
+  }
+}
+
+}  // namespace grpc_core