grpc 1.48.0 → 1.50.0

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

@@ -35,8 +35,9 @@
 
 #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/iomgr/exec_ctx.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
 
 grpc_core::TraceFlag grpc_flowctl_trace(false, "flowctl");
@@ -112,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 =
@@ -198,12 +199,14 @@ static double AdjustForMemoryPressure(double memory_pressure, double target) {
 
 double TransportFlowControl::TargetLogBdp() {
   return AdjustForMemoryPressure(
-      memory_owner_->is_valid() ? memory_owner_->InstantaneousPressure() : 0.0,
+      memory_owner_->is_valid()
+          ? memory_owner_->GetPressureInfo().pressure_control_value
+          : 0.0,
       1 + log2(bdp_estimator_.EstimateBdp()));
 }
 
 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;
@@ -212,53 +215,147 @@ double TransportFlowControl::SmoothLogBdp(double value) {
   return pid_controller_.Update(bdp_error, dt > kMaxDt ? kMaxDt : dt);
 }
 
+double
+TransportFlowControl::TargetInitialWindowSizeBasedOnMemoryPressureAndBdp()
+    const {
+  const double bdp = bdp_estimator_.EstimateBdp() * 2.0;
+  const double memory_pressure =
+      memory_owner_->GetPressureInfo().pressure_control_value;
+  // Linear interpolation between two values.
+  // Given a line segment between the two points (t_min, a), and (t_max, b),
+  // and a value t such that t_min <= t <= t_max, return the value on the line
+  // segment at t.
+  auto lerp = [](double t, double t_min, double t_max, double a, double b) {
+    return a + (b - a) * (t - t_min) / (t_max - t_min);
+  };
+  // We split memory pressure into three broad regions:
+  // 1. Low memory pressure, the "anything goes" case - we assume no memory
+  //    pressure concerns and advertise a huge window to keep things flowing.
+  // 2. Moderate memory pressure, the "adjust to BDP" case - we linearly ramp
+  //    down window size to 2*BDP - which should still allow bytes to flow, but
+  //    is arguably more considered.
+  // 3. High memory pressure - past 50% we linearly ramp down window size from
+  //    BDP to 0 - at which point senders effectively must request to send bytes
+  //    to us.
+  //
+  //          ▲
+  //          │
+  // 16mb ────┤---------x----
+  //          │              -----
+  //  BDP ────┤                   ----x---
+  //          │                           ----
+  //          │                               -----
+  //          │                                    ----
+  //          │                                        -----
+  //          │                                             ---x
+  //          ├─────────┬─────────────┬────────────────────────┬─────►
+  //          │Anything │Adjust to    │Drop to zero            │
+  //          │Goes     │BDP          │                        │
+  //          0%        20%           50%                      100% memory
+  //                                                                pressure
+  const double kAnythingGoesPressure = 0.2;
+  const double kAdjustedToBdpPressure = 0.5;
+  const double kAnythingGoesWindow = std::max(double(1 << 24), bdp);
+  if (memory_pressure < kAnythingGoesPressure) {
+    return kAnythingGoesWindow;
+  } else if (memory_pressure < kAdjustedToBdpPressure) {
+    return lerp(memory_pressure, kAnythingGoesPressure, kAdjustedToBdpPressure,
+                kAnythingGoesWindow, bdp);
+  } else if (memory_pressure < 1.0) {
+    return lerp(memory_pressure, kAdjustedToBdpPressure, 1.0, bdp, 0);
+  } else {
+    return 0;
+  }
+}
+
 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() {
   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 = 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);
 }
@@ -293,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,
@@ -252,7 +256,9 @@ class TransportFlowControl final {
  private:
   double TargetLogBdp();
   double SmoothLogBdp(double value);
-  static void UpdateSetting(int64_t* desired_value, int64_t new_desired_value,
+  double TargetInitialWindowSizeBasedOnMemoryPressureAndBdp() const;
+  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_constants.h

@@ -17,7 +17,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdint.h>
+#include <cstddef>
+#include <cstdint>
 
 namespace grpc_core {
 namespace hpack_constants {
@@ -33,6 +34,11 @@ static constexpr uint32_t EntriesForBytes(uint32_t bytes) noexcept {
   return (bytes + kEntryOverhead - 1) / kEntryOverhead;
 }
 
+static constexpr size_t SizeForEntry(size_t key_length,
+                                     size_t value_length) noexcept {
+  return key_length + value_length + kEntryOverhead;
+}
+
 static constexpr uint32_t kInitialTableEntries =
     EntriesForBytes(kInitialTableSize);
 }  // namespace hpack_constants

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());
@@ -431,13 +413,15 @@ void HPackCompressor::Framer::Encode(HttpSchemeMetadata,
 }
 
 void HPackCompressor::Framer::Encode(GrpcTraceBinMetadata, const Slice& slice) {
-  EncodeIndexedKeyWithBinaryValue(&compressor_->grpc_trace_bin_index_,
-                                  "grpc-trace-bin", slice.Ref());
+  EncodeRepeatingSliceValue(GrpcTraceBinMetadata::key(), slice,
+                            &compressor_->grpc_trace_bin_index_,
+                            HPackEncoderTable::MaxEntrySize());
 }
 
 void HPackCompressor::Framer::Encode(GrpcTagsBinMetadata, const Slice& slice) {
-  EncodeIndexedKeyWithBinaryValue(&compressor_->grpc_tags_bin_index_,
-                                  "grpc-tags-bin", slice.Ref());
+  EncodeRepeatingSliceValue(GrpcTagsBinMetadata::key(), slice,
+                            &compressor_->grpc_tags_bin_index_,
+                            HPackEncoderTable::MaxEntrySize());
 }
 
 void HPackCompressor::Framer::Encode(HttpStatusMetadata, uint32_t status) {
@@ -521,8 +505,20 @@ void HPackCompressor::Framer::EncodeIndexedKeyWithBinaryValue(
   }
 }
 
+void HPackCompressor::Framer::EncodeRepeatingSliceValue(
+    const absl::string_view& key, const Slice& slice, uint32_t* index,
+    size_t max_compression_size) {
+  if (hpack_constants::SizeForEntry(key.size(), slice.size()) >
+      max_compression_size) {
+    EmitLitHdrWithBinaryStringKeyNotIdx(Slice::FromStaticString(key),
+                                        slice.Ref());
+  } else {
+    EncodeIndexedKeyWithBinaryValue(index, key, slice.Ref());
+  }
+}
+
 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);
@@ -553,7 +549,9 @@ void HPackCompressor::Framer::Encode(GrpcTimeoutMetadata, Timestamp deadline) {
 }
 
 void HPackCompressor::Framer::Encode(UserAgentMetadata, const Slice& slice) {
-  if (slice.length() > HPackEncoderTable::MaxEntrySize()) {
+  if (hpack_constants::SizeForEntry(UserAgentMetadata::key().size(),
+                                    slice.size()) >
+      HPackEncoderTable::MaxEntrySize()) {
     EmitLitHdrWithNonBinaryStringKeyNotIdx(
         Slice::FromStaticString(UserAgentMetadata::key()), slice.Ref());
     return;
@@ -562,9 +560,10 @@ void HPackCompressor::Framer::Encode(UserAgentMetadata, const Slice& slice) {
     compressor_->user_agent_ = slice.Ref();
     compressor_->user_agent_index_ = 0;
   }
-  EncodeAlwaysIndexed(
-      &compressor_->user_agent_index_, "user-agent", slice.Ref(),
-      10 /* user-agent */ + slice.size() + hpack_constants::kEntryOverhead);
+  EncodeAlwaysIndexed(&compressor_->user_agent_index_, UserAgentMetadata::key(),
+                      slice.Ref(),
+                      hpack_constants::SizeForEntry(
+                          UserAgentMetadata::key().size(), slice.size()));
 }
 
 void HPackCompressor::Framer::Encode(GrpcStatusMetadata,
@@ -661,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_encoder.h

@@ -154,6 +154,10 @@ class HPackCompressor {
     void EncodeIndexedKeyWithBinaryValue(uint32_t* index, absl::string_view key,
                                          Slice value);
 
+    void EncodeRepeatingSliceValue(const absl::string_view& key,
+                                   const Slice& slice, uint32_t* index,
+                                   size_t max_compression_size);
+
     size_t CurrentFrameSize() const;
     void Add(Slice slice);
     uint8_t* AddTiny(size_t len);

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

@@ -17,7 +17,6 @@
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder_table.h"
 
 #include <algorithm>
-#include <cstdint>
 
 #include <grpc/support/log.h>
 

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

@@ -20,6 +20,8 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <limits>
+
 #include "absl/container/inlined_vector.h"
 
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
@@ -30,9 +32,13 @@ namespace grpc_core {
 // sizes.
 class HPackEncoderTable {
  public:
+  using EntrySize = uint16_t;
+
   HPackEncoderTable() : elem_size_(hpack_constants::kInitialTableEntries) {}
 
-  static constexpr size_t MaxEntrySize() { return 65535; }
+  static constexpr size_t MaxEntrySize() {
+    return std::numeric_limits<EntrySize>::max();
+  }
 
   // Reserve space in table for the new element, evict entries if needed.
   // Return the new index of the element. Return 0 to indicate not adding to
@@ -65,7 +71,7 @@ class HPackEncoderTable {
   uint32_t table_elems_ = 0;
   uint32_t table_size_ = 0;
   // The size of each element in the HPACK table.
-  absl::InlinedVector<uint16_t, hpack_constants::kInitialTableEntries>
+  absl::InlinedVector<EntrySize, hpack_constants::kInitialTableEntries>
       elem_size_;
 };