grpc 1.49.0.pre1-x86_64-linux → 1.50.0.pre1-x86_64-linux

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

@@ -35,18 +35,13 @@
 
 #include <grpc/support/log.h>
 
+#include "src/core/ext/transport/chttp2/transport/http2_settings.h"
+#include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/gprpp/global_config_env.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
 
 grpc_core::TraceFlag grpc_flowctl_trace(false, "flowctl");
 
-GPR_GLOBAL_CONFIG_DEFINE_BOOL(
-    grpc_experimental_broad_flow_control_range, false,
-    "Use an enlarged memory pressure range for scaling flow control when using "
-    "a resource quota.");
-
 namespace grpc_core {
 namespace chttp2 {
 
@@ -118,7 +113,7 @@ TransportFlowControl::TransportFlowControl(const char* name,
                           .set_min_control_value(-1)
                           .set_max_control_value(25)
                           .set_integral_range(10)),
-      last_pid_update_(ExecCtx::Get()->Now()) {}
+      last_pid_update_(Timestamp::Now()) {}
 
 uint32_t TransportFlowControl::MaybeSendUpdate(bool writing_anyway) {
   const uint32_t target_announced_window =
@@ -211,7 +206,7 @@ double TransportFlowControl::TargetLogBdp() {
 }
 
 double TransportFlowControl::SmoothLogBdp(double value) {
-  Timestamp now = ExecCtx::Get()->Now();
+  Timestamp now = Timestamp::Now();
   double bdp_error = value - pid_controller_.last_control_value();
   const double dt = (now - last_pid_update_).seconds();
   last_pid_update_ = now;
@@ -274,56 +269,93 @@ TransportFlowControl::TargetInitialWindowSizeBasedOnMemoryPressureAndBdp()
 }
 
 void TransportFlowControl::UpdateSetting(
-    int64_t* desired_value, int64_t new_desired_value,
-    FlowControlAction* action,
+    grpc_chttp2_setting_id id, int64_t* desired_value,
+    uint32_t new_desired_value, FlowControlAction* action,
     FlowControlAction& (FlowControlAction::*set)(FlowControlAction::Urgency,
                                                  uint32_t)) {
-  int64_t delta = new_desired_value - *desired_value;
-  // TODO(ncteisen): tune this
-  if (delta != 0 &&
-      (delta <= -*desired_value / 5 || delta >= *desired_value / 5)) {
-    *desired_value = new_desired_value;
-    (action->*set)(FlowControlAction::Urgency::QUEUE_UPDATE, *desired_value);
+  if (IsFlowControlFixesEnabled()) {
+    new_desired_value =
+        Clamp(new_desired_value, grpc_chttp2_settings_parameters[id].min_value,
+              grpc_chttp2_settings_parameters[id].max_value);
+    if (new_desired_value != *desired_value) {
+      *desired_value = new_desired_value;
+      (action->*set)(FlowControlAction::Urgency::QUEUE_UPDATE, *desired_value);
+    }
+  } else {
+    int64_t delta = new_desired_value - *desired_value;
+    // TODO(ncteisen): tune this
+    if (delta != 0 &&
+        (delta <= -*desired_value / 5 || delta >= *desired_value / 5)) {
+      *desired_value = new_desired_value;
+      (action->*set)(FlowControlAction::Urgency::QUEUE_UPDATE, *desired_value);
+    }
   }
 }
 
 FlowControlAction TransportFlowControl::PeriodicUpdate() {
-  static const bool kSmoothMemoryPressure =
-      GPR_GLOBAL_CONFIG_GET(grpc_experimental_smooth_memory_presure);
   FlowControlAction action;
   if (enable_bdp_probe_) {
-    // get bdp estimate and update initial_window accordingly.
-    // target might change based on how much memory pressure we are under
-    // TODO(ncteisen): experiment with setting target to be huge under low
-    // memory pressure.
-    double target = kSmoothMemoryPressure
-                        ? TargetInitialWindowSizeBasedOnMemoryPressureAndBdp()
-                        : pow(2, SmoothLogBdp(TargetLogBdp()));
-    if (g_test_only_transport_target_window_estimates_mocker != nullptr) {
-      // Hook for simulating unusual flow control situations in tests.
-      target = g_test_only_transport_target_window_estimates_mocker
-                   ->ComputeNextTargetInitialWindowSizeFromPeriodicUpdate(
-                       target_initial_window_size_ /* current target */);
+    if (IsFlowControlFixesEnabled()) {
+      // get bdp estimate and update initial_window accordingly.
+      // target might change based on how much memory pressure we are under
+      // TODO(ncteisen): experiment with setting target to be huge under low
+      // memory pressure.
+      uint32_t target = static_cast<uint32_t>(RoundUpToPowerOf2(
+          Clamp(IsMemoryPressureControllerEnabled()
+                    ? TargetInitialWindowSizeBasedOnMemoryPressureAndBdp()
+                    : pow(2, SmoothLogBdp(TargetLogBdp())),
+                0.0, static_cast<double>(kMaxInitialWindowSize))));
+      if (target < kMinPositiveInitialWindowSize) target = 0;
+      if (g_test_only_transport_target_window_estimates_mocker != nullptr) {
+        // Hook for simulating unusual flow control situations in tests.
+        target = g_test_only_transport_target_window_estimates_mocker
+                     ->ComputeNextTargetInitialWindowSizeFromPeriodicUpdate(
+                         target_initial_window_size_ /* current target */);
+      }
+      // Though initial window 'could' drop to 0, we keep the floor at
+      // kMinInitialWindowSize
+      UpdateSetting(GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE,
+                    &target_initial_window_size_, target, &action,
+                    &FlowControlAction::set_send_initial_window_update);
+      // we target the max of BDP or bandwidth in microseconds.
+      UpdateSetting(GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE, &target_frame_size_,
+                    target, &action,
+                    &FlowControlAction::set_send_max_frame_size_update);
+    } else {
+      // get bdp estimate and update initial_window accordingly.
+      // target might change based on how much memory pressure we are under
+      // TODO(ncteisen): experiment with setting target to be huge under low
+      // memory pressure.
+      double target = IsMemoryPressureControllerEnabled()
+                          ? TargetInitialWindowSizeBasedOnMemoryPressureAndBdp()
+                          : pow(2, SmoothLogBdp(TargetLogBdp()));
+      if (g_test_only_transport_target_window_estimates_mocker != nullptr) {
+        // Hook for simulating unusual flow control situations in tests.
+        target = g_test_only_transport_target_window_estimates_mocker
+                     ->ComputeNextTargetInitialWindowSizeFromPeriodicUpdate(
+                         target_initial_window_size_ /* current target */);
+      }
+      // Though initial window 'could' drop to 0, we keep the floor at
+      // kMinInitialWindowSize
+      UpdateSetting(
+          GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE,
+          &target_initial_window_size_,
+          static_cast<int32_t>(Clamp(target, double(kMinInitialWindowSize),
+                                     double(kMaxInitialWindowSize))),
+          &action, &FlowControlAction::set_send_initial_window_update);
+      // get bandwidth estimate and update max_frame accordingly.
+      double bw_dbl = bdp_estimator_.EstimateBandwidth();
+      // we target the max of BDP or bandwidth in microseconds.
+      UpdateSetting(
+          GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE, &target_frame_size_,
+          static_cast<int32_t>(Clamp(
+              std::max(
+                  static_cast<int32_t>(Clamp(bw_dbl, 0.0, double(INT_MAX))) /
+                      1000,
+                  static_cast<int32_t>(target_initial_window_size_)),
+              16384, 16777215)),
+          &action, &FlowControlAction::set_send_max_frame_size_update);
     }
-    // Though initial window 'could' drop to 0, we keep the floor at
-    // kMinInitialWindowSize
-    UpdateSetting(
-        &target_initial_window_size_,
-        static_cast<int32_t>(Clamp(target, double(kMinInitialWindowSize),
-                                   double(kMaxInitialWindowSize))),
-        &action, &FlowControlAction::set_send_initial_window_update);
-
-    // get bandwidth estimate and update max_frame accordingly.
-    double bw_dbl = bdp_estimator_.EstimateBandwidth();
-    // we target the max of BDP or bandwidth in microseconds.
-    UpdateSetting(
-        &target_frame_size_,
-        static_cast<int32_t>(Clamp(
-            std::max(static_cast<int32_t>(Clamp(bw_dbl, 0.0, double(INT_MAX))) /
-                         1000,
-                     static_cast<int32_t>(target_initial_window_size_)),
-            16384, 16777215)),
-        &action, &FlowControlAction::set_send_max_frame_size_update);
   }
   return UpdateAction(action);
 }
@@ -358,7 +390,7 @@ uint32_t StreamFlowControl::DesiredAnnounceSize() const {
 FlowControlAction StreamFlowControl::UpdateAction(FlowControlAction action) {
   const int64_t desired_announce_size = DesiredAnnounceSize();
   if (desired_announce_size > 0) {
-    if ((min_progress_size_ > 0 && announced_window_delta_ < 0) ||
+    if ((min_progress_size_ > 0 && announced_window_delta_ <= 0) ||
         desired_announce_size >= 8192) {
       action.set_send_stream_update(
           FlowControlAction::Urgency::UPDATE_IMMEDIATELY);

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

@@ -25,14 +25,15 @@
 
 #include <iosfwd>
 #include <string>
+#include <utility>
 
 #include "absl/functional/function_ref.h"
 #include "absl/status/status.h"
 #include "absl/types/optional.h"
-#include "absl/utility/utility.h"
 
 #include <grpc/support/log.h>
 
+#include "src/core/ext/transport/chttp2/transport/http2_settings.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
@@ -53,13 +54,16 @@ namespace chttp2 {
 static constexpr uint32_t kDefaultWindow = 65535;
 static constexpr uint32_t kDefaultFrameSize = 16384;
 static constexpr int64_t kMaxWindow = static_cast<int64_t>((1u << 31) - 1);
-// TODO(ncteisen): Tune this
-static constexpr uint32_t kFrameSize = 1024 * 1024;
-static constexpr const uint32_t kMinInitialWindowSize = 128;
+// If smaller than this, advertise zero window.
+static constexpr uint32_t kMinPositiveInitialWindowSize = 1024;
 static constexpr const uint32_t kMaxInitialWindowSize = (1u << 30);
 // The maximum per-stream flow control window delta to advertise.
 static constexpr const int64_t kMaxWindowDelta = (1u << 20);
 
+// TODO(ctiller): clean up when flow_control_fixes is enabled by default
+static constexpr uint32_t kFrameSize = 1024 * 1024;
+static constexpr const uint32_t kMinInitialWindowSize = 128;
+
 class TransportFlowControl;
 class StreamFlowControl;
 
@@ -170,7 +174,7 @@ class TransportFlowControl final {
     // Reads the flow control data and returns an actionable struct that will
     // tell chttp2 exactly what it needs to do
     FlowControlAction MakeAction() {
-      return absl::exchange(tfc_, nullptr)->UpdateAction(FlowControlAction());
+      return std::exchange(tfc_, nullptr)->UpdateAction(FlowControlAction());
     }
 
     // Notify of data receipt. Returns OkStatus if the data was accepted,
@@ -253,7 +257,8 @@ class TransportFlowControl final {
   double TargetLogBdp();
   double SmoothLogBdp(double value);
   double TargetInitialWindowSizeBasedOnMemoryPressureAndBdp() const;
-  static void UpdateSetting(int64_t* desired_value, int64_t new_desired_value,
+  static void UpdateSetting(grpc_chttp2_setting_id id, int64_t* desired_value,
+                            uint32_t new_desired_value,
                             FlowControlAction* action,
                             FlowControlAction& (FlowControlAction::*set)(
                                 FlowControlAction::Urgency, uint32_t));

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

@@ -32,7 +32,6 @@
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/ext/transport/chttp2/transport/stream_map.h"
 #include "src/core/lib/gprpp/time.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
 
 static bool g_disable_ping_ack = false;
 
@@ -95,7 +94,7 @@ grpc_error_handle grpc_chttp2_ping_parser_parse(void* parser,
       grpc_chttp2_ack_ping(t, p->opaque_8bytes);
     } else {
       if (!t->is_client) {
-        grpc_core::Timestamp now = grpc_core::ExecCtx::Get()->Now();
+        grpc_core::Timestamp now = grpc_core::Timestamp::Now();
         grpc_core::Timestamp next_allowed_ping =
             t->ping_recv_state.last_ping_recv_time +
             t->ping_policy.min_recv_ping_interval_without_data;

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

@@ -24,8 +24,6 @@
 #include <cstdint>
 #include <memory>
 
-#include "absl/utility/utility.h"
-
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/log.h>
@@ -35,8 +33,6 @@
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder_table.h"
 #include "src/core/ext/transport/chttp2/transport/varint.h"
-#include "src/core/lib/debug/stats.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/surface/validate_metadata.h"
 #include "src/core/lib/transport/timeout_encoding.h"
 
@@ -158,7 +154,6 @@ uint8_t* HPackCompressor::Framer::AddTiny(size_t len) {
 }
 
 void HPackCompressor::Framer::EmitIndexed(uint32_t elem_index) {
-  GRPC_STATS_INC_HPACK_SEND_INDEXED();
   VarintWriter<1> w(elem_index);
   w.Write(0x80, AddTiny(w.length()));
 }
@@ -180,17 +175,14 @@ static WireValue GetWireValue(Slice value, bool true_binary_enabled,
                               bool is_bin_hdr) {
   if (is_bin_hdr) {
     if (true_binary_enabled) {
-      GRPC_STATS_INC_HPACK_SEND_BINARY();
       return WireValue(0x00, true, std::move(value));
     } else {
-      GRPC_STATS_INC_HPACK_SEND_BINARY_BASE64();
       return WireValue(0x80, false,
                        Slice(grpc_chttp2_base64_encode_and_huffman_compress(
                            value.c_slice())));
     }
   } else {
     /* TODO(ctiller): opportunistically compress non-binary headers */
-    GRPC_STATS_INC_HPACK_SEND_UNCOMPRESSED();
     return WireValue(0x00, false, std::move(value));
   }
 }
@@ -269,8 +261,6 @@ class StringKey {
 
 void HPackCompressor::Framer::EmitLitHdrWithNonBinaryStringKeyIncIdx(
     Slice key_slice, Slice value_slice) {
-  GRPC_STATS_INC_HPACK_SEND_LITHDR_INCIDX_V();
-  GRPC_STATS_INC_HPACK_SEND_UNCOMPRESSED();
   StringKey key(std::move(key_slice));
   key.WritePrefix(0x40, AddTiny(key.prefix_length()));
   Add(key.key());
@@ -281,8 +271,6 @@ void HPackCompressor::Framer::EmitLitHdrWithNonBinaryStringKeyIncIdx(
 
 void HPackCompressor::Framer::EmitLitHdrWithBinaryStringKeyNotIdx(
     Slice key_slice, Slice value_slice) {
-  GRPC_STATS_INC_HPACK_SEND_LITHDR_NOTIDX_V();
-  GRPC_STATS_INC_HPACK_SEND_UNCOMPRESSED();
   StringKey key(std::move(key_slice));
   key.WritePrefix(0x00, AddTiny(key.prefix_length()));
   Add(key.key());
@@ -293,8 +281,6 @@ void HPackCompressor::Framer::EmitLitHdrWithBinaryStringKeyNotIdx(
 
 void HPackCompressor::Framer::EmitLitHdrWithBinaryStringKeyIncIdx(
     Slice key_slice, Slice value_slice) {
-  GRPC_STATS_INC_HPACK_SEND_LITHDR_INCIDX_V();
-  GRPC_STATS_INC_HPACK_SEND_UNCOMPRESSED();
   StringKey key(std::move(key_slice));
   key.WritePrefix(0x40, AddTiny(key.prefix_length()));
   Add(key.key());
@@ -305,8 +291,6 @@ void HPackCompressor::Framer::EmitLitHdrWithBinaryStringKeyIncIdx(
 
 void HPackCompressor::Framer::EmitLitHdrWithBinaryStringKeyNotIdx(
     uint32_t key_index, Slice value_slice) {
-  GRPC_STATS_INC_HPACK_SEND_LITHDR_NOTIDX();
-  GRPC_STATS_INC_HPACK_SEND_UNCOMPRESSED();
   BinaryStringValue emit(std::move(value_slice), use_true_binary_metadata_);
   VarintWriter<4> key(key_index);
   uint8_t* data = AddTiny(key.length() + emit.prefix_length());
@@ -317,8 +301,6 @@ void HPackCompressor::Framer::EmitLitHdrWithBinaryStringKeyNotIdx(
 
 void HPackCompressor::Framer::EmitLitHdrWithNonBinaryStringKeyNotIdx(
     Slice key_slice, Slice value_slice) {
-  GRPC_STATS_INC_HPACK_SEND_LITHDR_NOTIDX_V();
-  GRPC_STATS_INC_HPACK_SEND_UNCOMPRESSED();
   StringKey key(std::move(key_slice));
   key.WritePrefix(0x00, AddTiny(key.prefix_length()));
   Add(key.key());
@@ -536,7 +518,7 @@ void HPackCompressor::Framer::EncodeRepeatingSliceValue(
 }
 
 void HPackCompressor::Framer::Encode(GrpcTimeoutMetadata, Timestamp deadline) {
-  Timeout timeout = Timeout::FromDuration(deadline - ExecCtx::Get()->Now());
+  Timeout timeout = Timeout::FromDuration(deadline - Timestamp::Now());
   for (auto it = compressor_->previous_timeouts_.begin();
        it != compressor_->previous_timeouts_.end(); ++it) {
     double ratio = timeout.RatioVersus(it->timeout);
@@ -678,7 +660,7 @@ HPackCompressor::Framer::Framer(const EncodeHeaderOptions& options,
       stats_(options.stats),
       compressor_(compressor),
       prefix_(BeginFrame()) {
-  if (absl::exchange(compressor_->advertise_table_size_change_, false)) {
+  if (std::exchange(compressor_->advertise_table_size_change_, false)) {
     AdvertiseTableSizeChange();
   }
 }

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

@@ -43,14 +43,14 @@
 #include <grpc/status.h>
 #include <grpc/support/log.h>
 
+#include "src/core/ext/transport/chttp2/transport/decode_huff.h"
 #include "src/core/ext/transport/chttp2/transport/frame_rst_stream.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
-#include "src/core/lib/debug/stats.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/combiner.h"
-#include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_refcount_base.h"
 #include "src/core/lib/transport/http2_errors.h"
@@ -66,8 +66,9 @@ TraceFlag grpc_trace_chttp2_hpack_parser(false, "chttp2_hpack_parser");
 /* state table for huffman decoding: given a state, gives an index/16 into
    next_sub_tbl. Taking that index and adding the value of the nibble being
    considered returns the next state.
-
-   generated by gen_hpack_tables.c */
+   generated by gen_hpack_tables.c
+   TODO(ctiller): remove once the new_hpack_huffman_decoder experiment is
+                  complete. */
 static const uint8_t next_tbl[256] = {
     0,  1,  2,  3,  4,  1,  2, 5,  6,  1, 7,  8,  1,  3,  3,  9,  10, 11, 1,  1,
     1,  12, 1,  2,  13, 1,  1, 1,  1,  1, 1,  1,  1,  1,  1,  1,  1,  1,  1,  2,
@@ -143,7 +144,6 @@ static const int16_t next_sub_tbl[48 * 16] = {
 
 /* emission table: indexed like next_tbl, ultimately gives the byte to be
    emitted, or -1 for no byte, or 256 for end of stream
-
    generated by gen_hpack_tables.c */
 static const uint16_t emit_tbl[256] = {
     0,   1,   2,   3,   4,   5,   6,   7,   0,   8,   9,   10,  11,  12,  13,
@@ -766,22 +766,6 @@ class HPackParser::String {
   // decoded byte.
   template <typename Out>
   static bool ParseHuff(Input* input, uint32_t length, Out output) {
-    GRPC_STATS_INC_HPACK_RECV_HUFFMAN();
-    int16_t state = 0;
-    // Parse one half byte... we leverage some lookup tables to keep the logic
-    // here really simple.
-    auto nibble = [&output, &state](uint8_t nibble) {
-      int16_t emit = emit_sub_tbl[16 * emit_tbl[state] + nibble];
-      int16_t next = next_sub_tbl[16 * next_tbl[state] + nibble];
-      if (emit != -1) {
-        if (emit >= 0 && emit < 256) {
-          output(static_cast<uint8_t>(emit));
-        } else {
-          assert(emit == 256);
-        }
-      }
-      state = next;
-    };
     // If there's insufficient bytes remaining, return now.
     if (input->remaining() < length) {
       return input->UnexpectedEOF(false);
@@ -789,17 +773,35 @@ class HPackParser::String {
     // Grab the byte range, and iterate through it.
     const uint8_t* p = input->cur_ptr();
     input->Advance(length);
-    for (uint32_t i = 0; i < length; i++) {
-      nibble(p[i] >> 4);
-      nibble(p[i] & 0xf);
+    if (IsNewHpackHuffmanDecoderEnabled()) {
+      return HuffDecoder<Out>(output, p, p + length).Run();
+    } else {
+      int16_t state = 0;
+      // Parse one half byte... we leverage some lookup tables to keep the logic
+      // here really simple.
+      auto nibble = [&output, &state](uint8_t nibble) {
+        int16_t emit = emit_sub_tbl[16 * emit_tbl[state] + nibble];
+        int16_t next = next_sub_tbl[16 * next_tbl[state] + nibble];
+        if (emit != -1) {
+          if (emit >= 0 && emit < 256) {
+            output(static_cast<uint8_t>(emit));
+          } else {
+            assert(emit == 256);
+          }
+        }
+        state = next;
+      };
+      for (uint32_t i = 0; i < length; i++) {
+        nibble(p[i] >> 4);
+        nibble(p[i] & 0xf);
+      }
+      return true;
     }
-    return true;
   }
 
   // Parse some uncompressed string bytes.
   static absl::optional<String> ParseUncompressed(Input* input,
                                                   uint32_t length) {
-    GRPC_STATS_INC_HPACK_RECV_UNCOMPRESSED();
     // Check there's enough bytes
     if (input->remaining() < length) {
       return input->UnexpectedEOF(absl::optional<String>());
@@ -1161,7 +1163,6 @@ class HPackParser::Parser {
     if (GPR_UNLIKELY(elem == nullptr)) {
       return InvalidHPackIndexError(*index, false);
     }
-    GRPC_STATS_INC_HPACK_RECV_INDEXED();
     return FinishHeaderOmitFromTable(*elem);
   }
 
@@ -1347,7 +1348,6 @@ grpc_error_handle grpc_chttp2_header_parser_parse(void* hpack_parser,
                                                   grpc_chttp2_stream* s,
                                                   const grpc_slice& slice,
                                                   int is_last) {
-  GPR_TIMER_SCOPE("grpc_chttp2_header_parser_parse", 0);
   auto* parser = static_cast<grpc_core::HPackParser*>(hpack_parser);
   if (s != nullptr) {
     s->stats.incoming.header_bytes += GRPC_SLICE_LENGTH(slice);

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

@@ -78,10 +78,6 @@ void HPackTable::MementoRingBuffer::Rebuild(uint32_t max_entries) {
   entries_.swap(entries);
 }
 
-HPackTable::HPackTable() : static_metadata_(GetStaticMementos()) {}
-
-HPackTable::~HPackTable() = default;
-
 /* Evict one element from the table */
 void HPackTable::EvictOne() {
   auto first_entry = entries_.PopOne();
@@ -229,7 +225,7 @@ const StaticTableEntry kStaticTable[hpack_constants::kLastStaticEntry] = {
     {"www-authenticate", ""},
 };
 
-GPR_ATTRIBUTE_NOINLINE HPackTable::Memento MakeMemento(size_t i) {
+HPackTable::Memento MakeMemento(size_t i) {
   auto sm = kStaticTable[i];
   return grpc_metadata_batch::Parse(
       sm.key, Slice::FromStaticString(sm.value),
@@ -241,11 +237,6 @@ GPR_ATTRIBUTE_NOINLINE HPackTable::Memento MakeMemento(size_t i) {
 
 }  // namespace
 
-auto HPackTable::GetStaticMementos() -> const StaticMementos& {
-  static const StaticMementos* const static_mementos = new StaticMementos();
-  return *static_mementos;
-}
-
 HPackTable::StaticMementos::StaticMementos() {
   for (uint32_t i = 0; i < hpack_constants::kLastStaticEntry; i++) {
     memento[i] = MakeMemento(i);

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

@@ -26,6 +26,7 @@
 #include <vector>
 
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
+#include "src/core/lib/gprpp/no_destruct.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/parsed_metadata.h"
@@ -35,8 +36,8 @@ namespace grpc_core {
 // HPACK header table
 class HPackTable {
  public:
-  HPackTable();
-  ~HPackTable();
+  HPackTable() = default;
+  ~HPackTable() = default;
 
   HPackTable(const HPackTable&) = delete;
   HPackTable& operator=(const HPackTable&) = delete;
@@ -55,7 +56,7 @@ class HPackTable {
     // reading the core static metadata table here; at that point we'd need our
     // own singleton static metadata in the correct order.
     if (index <= hpack_constants::kLastStaticEntry) {
-      return &static_metadata_.memento[index - 1];
+      return &static_mementos_->memento[index - 1];
     } else {
       return LookupDynamic(index);
     }
@@ -72,7 +73,6 @@ class HPackTable {
     StaticMementos();
     Memento memento[hpack_constants::kLastStaticEntry];
   };
-  static const StaticMementos& GetStaticMementos() GPR_ATTRIBUTE_NOINLINE;
 
   class MementoRingBuffer {
    public:
@@ -114,6 +114,11 @@ class HPackTable {
 
   void EvictOne();
 
+  static const StaticMementos* GetStaticMementos() {
+    static const NoDestruct<StaticMementos> static_mementos;
+    return static_mementos.get();
+  }
+
   // The amount of memory used by the table, according to the hpack algorithm
   uint32_t mem_used_ = 0;
   // The max memory allowed to be used by the table, according to the hpack
@@ -123,8 +128,8 @@ class HPackTable {
   uint32_t current_table_bytes_ = hpack_constants::kInitialTableSize;
   // HPack table entries
   MementoRingBuffer entries_;
-  // Mementos for static data
-  const StaticMementos& static_metadata_;
+  // Static mementos
+  const StaticMementos* const static_mementos_ = GetStaticMementos();
 };
 
 }  // namespace grpc_core

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

@@ -782,4 +782,6 @@ void grpc_chttp2_retry_initiate_ping(void* tp, grpc_error_handle error);
 
 void schedule_bdp_ping_locked(grpc_chttp2_transport* t);
 
+uint32_t grpc_chttp2_min_read_progress_size(grpc_chttp2_transport* t);
+
 #endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_INTERNAL_H */

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

@@ -79,6 +79,50 @@ static char get_utf8_safe_char(char c) {
   return static_cast<unsigned char>(c) < 128 ? c : 32;
 }
 
+uint32_t grpc_chttp2_min_read_progress_size(grpc_chttp2_transport* t) {
+  switch (t->deframe_state) {
+    case GRPC_DTS_CLIENT_PREFIX_0:
+    case GRPC_DTS_CLIENT_PREFIX_1:
+    case GRPC_DTS_CLIENT_PREFIX_2:
+    case GRPC_DTS_CLIENT_PREFIX_3:
+    case GRPC_DTS_CLIENT_PREFIX_4:
+    case GRPC_DTS_CLIENT_PREFIX_5:
+    case GRPC_DTS_CLIENT_PREFIX_6:
+    case GRPC_DTS_CLIENT_PREFIX_7:
+    case GRPC_DTS_CLIENT_PREFIX_8:
+    case GRPC_DTS_CLIENT_PREFIX_9:
+    case GRPC_DTS_CLIENT_PREFIX_10:
+    case GRPC_DTS_CLIENT_PREFIX_11:
+    case GRPC_DTS_CLIENT_PREFIX_12:
+    case GRPC_DTS_CLIENT_PREFIX_13:
+    case GRPC_DTS_CLIENT_PREFIX_14:
+    case GRPC_DTS_CLIENT_PREFIX_15:
+    case GRPC_DTS_CLIENT_PREFIX_16:
+    case GRPC_DTS_CLIENT_PREFIX_17:
+    case GRPC_DTS_CLIENT_PREFIX_18:
+    case GRPC_DTS_CLIENT_PREFIX_19:
+    case GRPC_DTS_CLIENT_PREFIX_20:
+    case GRPC_DTS_CLIENT_PREFIX_21:
+    case GRPC_DTS_CLIENT_PREFIX_22:
+    case GRPC_DTS_CLIENT_PREFIX_23:
+      // Need the client prefix *and* the first fixed header to make progress.
+      return 9 + 24 - (t->deframe_state - GRPC_DTS_CLIENT_PREFIX_0);
+    case GRPC_DTS_FH_0:
+    case GRPC_DTS_FH_1:
+    case GRPC_DTS_FH_2:
+    case GRPC_DTS_FH_3:
+    case GRPC_DTS_FH_4:
+    case GRPC_DTS_FH_5:
+    case GRPC_DTS_FH_6:
+    case GRPC_DTS_FH_7:
+    case GRPC_DTS_FH_8:
+      return 9 - (t->deframe_state - GRPC_DTS_FH_0);
+    case GRPC_DTS_FRAME:
+      return t->incoming_frame_size;
+  }
+  GPR_UNREACHABLE_CODE(return 1);
+}
+
 grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
                                            const grpc_slice& slice) {
   const uint8_t* beg = GRPC_SLICE_START_PTR(slice);