grpc 1.54.0 → 1.54.2

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

@@ -28,15 +28,14 @@
 #include <vector>
 
 #include "absl/strings/match.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 
-#include <grpc/impl/compression_types.h>
 #include <grpc/slice.h>
-#include <grpc/status.h>
+#include <grpc/support/log.h>
 
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder_table.h"
-#include "src/core/lib/compression/compression_internal.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
@@ -46,6 +45,280 @@
 
 namespace grpc_core {
 
+// Forward decl for encoder
+class HPackCompressor;
+
+namespace hpack_encoder_detail {
+
+class Encoder {
+ public:
+  Encoder(HPackCompressor* compressor, bool use_true_binary_metadata,
+          SliceBuffer& output);
+
+  void Encode(const Slice& key, const Slice& value);
+  template <typename MetadataTrait>
+  void Encode(MetadataTrait, const typename MetadataTrait::ValueType& value);
+
+  void AdvertiseTableSizeChange();
+  void EmitIndexed(uint32_t index);
+  GRPC_MUST_USE_RESULT
+  uint32_t EmitLitHdrWithNonBinaryStringKeyIncIdx(Slice key_slice,
+                                                  Slice value_slice);
+  GRPC_MUST_USE_RESULT
+  uint32_t EmitLitHdrWithBinaryStringKeyIncIdx(Slice key_slice,
+                                               Slice value_slice);
+  void EmitLitHdrWithBinaryStringKeyNotIdx(Slice key_slice, Slice value_slice);
+  void EmitLitHdrWithBinaryStringKeyNotIdx(uint32_t key_index,
+                                           Slice value_slice);
+  void EmitLitHdrWithNonBinaryStringKeyNotIdx(Slice key_slice,
+                                              Slice value_slice);
+
+  void EncodeAlwaysIndexed(uint32_t* index, absl::string_view key, Slice value,
+                           size_t transport_length);
+  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);
+
+  HPackEncoderTable& hpack_table();
+
+ private:
+  const bool use_true_binary_metadata_;
+  HPackCompressor* const compressor_;
+  SliceBuffer& output_;
+};
+
+// Compressor is partially specialized on CompressionTraits, but leaves
+// MetadataTrait as variable.
+// Via MetadataMap::StatefulCompressor it builds compression state for
+// HPackCompressor.
+// Each trait compressor gets to have some persistent state across the channel
+// (declared as Compressor member variables).
+// The compressors expose a single method:
+// void EncodeWith(MetadataTrait, const MetadataTrait::ValueType, Encoder*);
+// This method figures out how to encode the value, and then delegates to
+// Encoder to perform the encoding.
+template <typename MetadataTrait, typename CompressonTraits>
+class Compressor;
+
+// No compression encoder: just emit the key and value as literals.
+template <typename MetadataTrait>
+class Compressor<MetadataTrait, NoCompressionCompressor> {
+ public:
+  void EncodeWith(MetadataTrait, const typename MetadataTrait::ValueType& value,
+                  Encoder* encoder) {
+    const Slice& slice = MetadataValueAsSlice<MetadataTrait>(value);
+    if (absl::EndsWith(MetadataTrait::key(), "-bin")) {
+      encoder->EmitLitHdrWithBinaryStringKeyNotIdx(
+          Slice::FromStaticString(MetadataTrait::key()), slice.Ref());
+    } else {
+      encoder->EmitLitHdrWithNonBinaryStringKeyNotIdx(
+          Slice::FromStaticString(MetadataTrait::key()), slice.Ref());
+    }
+  }
+};
+
+// Frequent key with no value compression encoder
+template <typename MetadataTrait>
+class Compressor<MetadataTrait, FrequentKeyWithNoValueCompressionCompressor> {
+ public:
+  void EncodeWith(MetadataTrait, const typename MetadataTrait::ValueType& value,
+                  Encoder* encoder) {
+    const Slice& slice = MetadataValueAsSlice<MetadataTrait>(value);
+    encoder->EncodeRepeatingSliceValue(MetadataTrait::key(), slice,
+                                       &some_sent_value_,
+                                       HPackEncoderTable::MaxEntrySize());
+  }
+
+ private:
+  // Some previously sent value with this tag.
+  uint32_t some_sent_value_ = 0;
+};
+
+// Helper to determine if two objects have the same identity.
+// Equivalent here => equality, but equality does not imply equivalency.
+// For example, two slices with the same contents are equal, but not
+// equivalent.
+// Used as a much faster check for equality than the full equality check,
+// since many metadatum that are stable have the same root object in metadata
+// maps.
+template <typename T>
+static bool IsEquivalent(T a, T b) {
+  return a == b;
+}
+
+template <typename T>
+static bool IsEquivalent(const Slice& a, const Slice& b) {
+  return a.is_equivalent(b);
+}
+
+template <typename T>
+static void SaveCopyTo(const T& value, T& copy) {
+  copy = value;
+}
+
+static inline void SaveCopyTo(const Slice& value, Slice& copy) {
+  copy = value.Ref();
+}
+
+template <typename MetadataTrait>
+class Compressor<MetadataTrait, StableValueCompressor> {
+ public:
+  void EncodeWith(MetadataTrait, const typename MetadataTrait::ValueType& value,
+                  Encoder* encoder) {
+    auto& table = encoder->hpack_table();
+    if (previously_sent_value_ == value &&
+        table.ConvertableToDynamicIndex(previously_sent_index_)) {
+      encoder->EmitIndexed(table.DynamicIndex(previously_sent_index_));
+      return;
+    }
+    previously_sent_index_ = 0;
+    auto key = MetadataTrait::key();
+    const Slice& value_slice = MetadataValueAsSlice<MetadataTrait>(value);
+    if (hpack_constants::SizeForEntry(key.size(), value_slice.size()) >
+        HPackEncoderTable::MaxEntrySize()) {
+      encoder->EmitLitHdrWithNonBinaryStringKeyNotIdx(
+          Slice::FromStaticString(key), value_slice.Ref());
+      return;
+    }
+    encoder->EncodeAlwaysIndexed(
+        &previously_sent_index_, key, value_slice.Ref(),
+        hpack_constants::SizeForEntry(key.size(), value_slice.size()));
+    SaveCopyTo(value, previously_sent_value_);
+  }
+
+ private:
+  // Previously sent value
+  typename MetadataTrait::ValueType previously_sent_value_{};
+  // And its index in the table
+  uint32_t previously_sent_index_ = 0;
+};
+
+template <typename MetadataTrait, typename MetadataTrait::ValueType known_value>
+class Compressor<
+    MetadataTrait,
+    KnownValueCompressor<typename MetadataTrait::ValueType, known_value>> {
+ public:
+  void EncodeWith(MetadataTrait, const typename MetadataTrait::ValueType& value,
+                  Encoder* encoder) {
+    if (value != known_value) {
+      gpr_log(GPR_ERROR, "%s",
+              absl::StrCat("Not encoding bad ", MetadataTrait::key(), " header")
+                  .c_str());
+      return;
+    }
+    Slice encoded(MetadataTrait::Encode(known_value));
+    const auto encoded_length = encoded.length();
+    encoder->EncodeAlwaysIndexed(&previously_sent_index_, MetadataTrait::key(),
+                                 std::move(encoded),
+                                 MetadataTrait::key().size() + encoded_length +
+                                     hpack_constants::kEntryOverhead);
+  }
+
+ private:
+  uint32_t previously_sent_index_ = 0;
+};
+template <typename MetadataTrait, size_t N>
+class Compressor<MetadataTrait, SmallIntegralValuesCompressor<N>> {
+ public:
+  void EncodeWith(MetadataTrait, const typename MetadataTrait::ValueType& value,
+                  Encoder* encoder) {
+    uint32_t* index = nullptr;
+    auto& table = encoder->hpack_table();
+    if (static_cast<size_t>(value) < N) {
+      index = &previously_sent_[static_cast<uint32_t>(value)];
+      if (table.ConvertableToDynamicIndex(*index)) {
+        encoder->EmitIndexed(table.DynamicIndex(*index));
+        return;
+      }
+    }
+    auto key = Slice::FromStaticString(MetadataTrait::key());
+    auto encoded_value = MetadataTrait::Encode(value);
+    if (index != nullptr) {
+      *index = encoder->EmitLitHdrWithNonBinaryStringKeyIncIdx(
+          std::move(key), std::move(encoded_value));
+    } else {
+      encoder->EmitLitHdrWithNonBinaryStringKeyNotIdx(std::move(key),
+                                                      std::move(encoded_value));
+    }
+  }
+
+ private:
+  uint32_t previously_sent_[N] = {};
+};
+
+class SliceIndex {
+ public:
+  void EmitTo(absl::string_view key, const Slice& value, Encoder* encoder);
+
+ private:
+  struct ValueIndex {
+    ValueIndex(Slice value, uint32_t index)
+        : value(std::move(value)), index(index) {}
+    Slice value;
+    uint32_t index;
+  };
+  std::vector<ValueIndex> values_;
+};
+
+template <typename MetadataTrait>
+class Compressor<MetadataTrait, SmallSetOfValuesCompressor> {
+ public:
+  void EncodeWith(MetadataTrait, const Slice& value, Encoder* encoder) {
+    index_.EmitTo(MetadataTrait::key(), value, encoder);
+  }
+
+ private:
+  SliceIndex index_;
+};
+
+struct PreviousTimeout {
+  Timeout timeout;
+  uint32_t index;
+};
+
+class TimeoutCompressorImpl {
+ public:
+  void EncodeWith(absl::string_view key, Timestamp deadline, Encoder* encoder);
+
+ private:
+  std::vector<PreviousTimeout> previous_timeouts_;
+};
+
+template <typename MetadataTrait>
+class Compressor<MetadataTrait, TimeoutCompressor>
+    : public TimeoutCompressorImpl {
+ public:
+  void EncodeWith(MetadataTrait, const typename MetadataTrait::ValueType& value,
+                  Encoder* encoder) {
+    TimeoutCompressorImpl::EncodeWith(MetadataTrait::key(), value, encoder);
+  }
+};
+
+template <>
+class Compressor<HttpStatusMetadata, HttpStatusCompressor> {
+ public:
+  void EncodeWith(HttpStatusMetadata, uint32_t status, Encoder* encoder);
+};
+
+template <>
+class Compressor<HttpMethodMetadata, HttpMethodCompressor> {
+ public:
+  void EncodeWith(HttpMethodMetadata, HttpMethodMetadata::ValueType method,
+                  Encoder* encoder);
+};
+
+template <>
+class Compressor<HttpSchemeMetadata, HttpSchemeCompressor> {
+ public:
+  void EncodeWith(HttpSchemeMetadata, HttpSchemeMetadata::ValueType value,
+                  Encoder* encoder);
+};
+
+}  // namespace hpack_encoder_detail
+
 class HPackCompressor {
   class SliceIndex;
 
@@ -75,87 +348,22 @@ class HPackCompressor {
   void EncodeHeaders(const EncodeHeaderOptions& options,
                      const HeaderSet& headers, grpc_slice_buffer* output) {
     SliceBuffer raw;
-    Encoder encoder(this, options.use_true_binary_metadata, raw);
+    hpack_encoder_detail::Encoder encoder(
+        this, options.use_true_binary_metadata, raw);
     headers.Encode(&encoder);
     Frame(options, raw, output);
   }
 
   template <typename HeaderSet>
   void EncodeRawHeaders(const HeaderSet& headers, SliceBuffer& output) {
-    Encoder encoder(this, true, output);
+    hpack_encoder_detail::Encoder encoder(this, true, output);
     headers.Encode(&encoder);
   }
 
  private:
-  class Encoder {
-   public:
-    Encoder(HPackCompressor* compressor, bool use_true_binary_metadata,
-            SliceBuffer& output);
-
-    void Encode(const Slice& key, const Slice& value);
-    void Encode(HttpPathMetadata, const Slice& value);
-    void Encode(HttpAuthorityMetadata, const Slice& value);
-    void Encode(HttpStatusMetadata, uint32_t status);
-    void Encode(GrpcTimeoutMetadata, Timestamp deadline);
-    void Encode(TeMetadata, TeMetadata::ValueType value);
-    void Encode(ContentTypeMetadata, ContentTypeMetadata::ValueType value);
-    void Encode(HttpSchemeMetadata, HttpSchemeMetadata::ValueType value);
-    void Encode(HttpMethodMetadata, HttpMethodMetadata::ValueType method);
-    void Encode(UserAgentMetadata, const Slice& slice);
-    void Encode(GrpcStatusMetadata, grpc_status_code status);
-    void Encode(GrpcEncodingMetadata, grpc_compression_algorithm value);
-    void Encode(GrpcAcceptEncodingMetadata, CompressionAlgorithmSet value);
-    void Encode(GrpcTagsBinMetadata, const Slice& slice);
-    void Encode(GrpcTraceBinMetadata, const Slice& slice);
-    void Encode(GrpcMessageMetadata, const Slice& slice) {
-      if (slice.empty()) return;
-      EmitLitHdrWithNonBinaryStringKeyNotIdx(
-          Slice::FromStaticString("grpc-message"), slice.Ref());
-    }
-    template <typename Which>
-    void Encode(Which, const typename Which::ValueType& value) {
-      const Slice& slice = MetadataValueAsSlice<Which>(value);
-      if (absl::EndsWith(Which::key(), "-bin")) {
-        EmitLitHdrWithBinaryStringKeyNotIdx(
-            Slice::FromStaticString(Which::key()), slice.Ref());
-      } else {
-        EmitLitHdrWithNonBinaryStringKeyNotIdx(
-            Slice::FromStaticString(Which::key()), slice.Ref());
-      }
-    }
-
-   private:
-    friend class SliceIndex;
-
-    void AdvertiseTableSizeChange();
-    void EmitIndexed(uint32_t index);
-    void EmitLitHdrWithNonBinaryStringKeyIncIdx(Slice key_slice,
-                                                Slice value_slice);
-    void EmitLitHdrWithBinaryStringKeyIncIdx(Slice key_slice,
-                                             Slice value_slice);
-    void EmitLitHdrWithBinaryStringKeyNotIdx(Slice key_slice,
-                                             Slice value_slice);
-    void EmitLitHdrWithBinaryStringKeyNotIdx(uint32_t key_index,
-                                             Slice value_slice);
-    void EmitLitHdrWithNonBinaryStringKeyNotIdx(Slice key_slice,
-                                                Slice value_slice);
-
-    void EncodeAlwaysIndexed(uint32_t* index, absl::string_view key,
-                             Slice value, size_t transport_length);
-    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);
-
-    const bool use_true_binary_metadata_;
-    HPackCompressor* const compressor_;
-    SliceBuffer& output_;
-  };
-
   static constexpr size_t kNumFilterValues = 64;
   static constexpr uint32_t kNumCachedGrpcStatusValues = 16;
+  friend class hpack_encoder_detail::Encoder;
 
   void Frame(const EncodeHeaderOptions& options, SliceBuffer& raw,
              grpc_slice_buffer* output);
@@ -168,49 +376,23 @@ class HPackCompressor {
   bool advertise_table_size_change_ = false;
   HPackEncoderTable table_;
 
-  class SliceIndex {
-   public:
-    void EmitTo(absl::string_view key, const Slice& value, Encoder* encoder);
-
-   private:
-    struct ValueIndex {
-      ValueIndex(Slice value, uint32_t index)
-          : value(std::move(value)), index(index) {}
-      Slice value;
-      uint32_t index;
-    };
-    std::vector<ValueIndex> values_;
-  };
+  grpc_metadata_batch::StatefulCompressor<hpack_encoder_detail::Compressor>
+      compression_state_;
+};
 
-  struct PreviousTimeout {
-    Timeout timeout;
-    uint32_t index;
-  };
+namespace hpack_encoder_detail {
 
-  // Index into table_ for the te:trailers metadata element
-  uint32_t te_index_ = 0;
-  // Index into table_ for the content-type metadata element
-  uint32_t content_type_index_ = 0;
-  // Index into table_ for the user-agent metadata element
-  uint32_t user_agent_index_ = 0;
-  // Cached grpc-status values
-  uint32_t cached_grpc_status_[kNumCachedGrpcStatusValues] = {};
-  // Cached grpc-encoding values
-  uint32_t cached_grpc_encoding_[GRPC_COMPRESS_ALGORITHMS_COUNT] = {};
-  // Cached grpc-accept-encoding value
-  uint32_t grpc_accept_encoding_index_ = 0;
-  // The grpc-accept-encoding string referred to by grpc_accept_encoding_index_
-  CompressionAlgorithmSet grpc_accept_encoding_;
-  // Index of something that was sent with grpc-tags-bin
-  uint32_t grpc_tags_bin_index_ = 0;
-  // Index of something that was sent with grpc-trace-bin
-  uint32_t grpc_trace_bin_index_ = 0;
-  // The user-agent string referred to by user_agent_index_
-  Slice user_agent_;
-  SliceIndex path_index_;
-  SliceIndex authority_index_;
-  std::vector<PreviousTimeout> previous_timeouts_;
-};
+template <typename MetadataTrait>
+void Encoder::Encode(MetadataTrait,
+                     const typename MetadataTrait::ValueType& value) {
+  compressor_->compression_state_
+      .Compressor<MetadataTrait, typename MetadataTrait::CompressionTraits>::
+          EncodeWith(MetadataTrait(), value, this);
+}
+
+inline HPackEncoderTable& Encoder::hpack_table() { return compressor_->table_; }
+
+}  // namespace hpack_encoder_detail
 
 }  // namespace grpc_core
 

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

@@ -23,6 +23,8 @@
 namespace grpc_core {
 
 uint32_t HPackEncoderTable::AllocateIndex(size_t element_size) {
+  GPR_DEBUG_ASSERT(element_size >= 32);
+
   uint32_t new_index = tail_remote_index_ + table_elems_ + 1;
   GPR_DEBUG_ASSERT(element_size <= MaxEntrySize());
 

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

@@ -50,6 +50,8 @@ class HPackEncoderTable {
   uint32_t max_size() const { return max_table_size_; }
   // Get the current table size
   uint32_t test_only_table_size() const { return table_size_; }
+  // Get the number of entries in the table
+  uint32_t test_only_table_elems() const { return table_elems_; }
 
   // Convert an element index into a dynamic index
   uint32_t DynamicIndex(uint32_t index) const {