grpc 1.40.0.pre1 → 1.41.1

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

@@ -18,8 +18,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/transport/chttp2/transport/internal.h"
-
 #include <string.h>
 
 #include "absl/strings/str_cat.h"
@@ -28,6 +26,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/slice/slice_utils.h"
@@ -91,15 +90,13 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
     case GRPC_DTS_CLIENT_PREFIX_23:
       while (cur != end && t->deframe_state != GRPC_DTS_FH_0) {
         if (*cur != GRPC_CHTTP2_CLIENT_CONNECT_STRING[t->deframe_state]) {
-          return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-              absl::StrFormat(
-                  "Connect string mismatch: expected '%c' (%d) got '%c' (%d) "
-                  "at byte %d",
-                  GRPC_CHTTP2_CLIENT_CONNECT_STRING[t->deframe_state],
-                  static_cast<int>(static_cast<uint8_t>(
-                      GRPC_CHTTP2_CLIENT_CONNECT_STRING[t->deframe_state])),
-                  *cur, static_cast<int>(*cur), t->deframe_state)
-                  .c_str());
+          return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrFormat(
+              "Connect string mismatch: expected '%c' (%d) got '%c' (%d) "
+              "at byte %d",
+              GRPC_CHTTP2_CLIENT_CONNECT_STRING[t->deframe_state],
+              static_cast<int>(static_cast<uint8_t>(
+                  GRPC_CHTTP2_CLIENT_CONNECT_STRING[t->deframe_state])),
+              *cur, static_cast<int>(*cur), t->deframe_state));
         }
         ++cur;
         // NOLINTNEXTLINE(bugprone-misplaced-widening-cast)
@@ -198,12 +195,11 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
                  t->incoming_frame_size >
                      t->settings[GRPC_ACKED_SETTINGS]
                                 [GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE]) {
-        return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+        return GRPC_ERROR_CREATE_FROM_CPP_STRING(
             absl::StrFormat("Frame size %d is larger than max frame size %d",
                             t->incoming_frame_size,
                             t->settings[GRPC_ACKED_SETTINGS]
-                                       [GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE])
-                .c_str());
+                                       [GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE]));
       }
       if (++cur == end) {
         return GRPC_ERROR_NONE;
@@ -257,27 +253,22 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
 static grpc_error_handle init_frame_parser(grpc_chttp2_transport* t) {
   if (t->is_first_frame &&
       t->incoming_frame_type != GRPC_CHTTP2_FRAME_SETTINGS) {
-    return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-        absl::StrCat(
-            "Expected SETTINGS frame as the first frame, got frame type ",
-            t->incoming_frame_type)
-            .c_str());
+    return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+        "Expected SETTINGS frame as the first frame, got frame type ",
+        t->incoming_frame_type));
   }
   t->is_first_frame = false;
   if (t->expect_continuation_stream_id != 0) {
     if (t->incoming_frame_type != GRPC_CHTTP2_FRAME_CONTINUATION) {
-      return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+      return GRPC_ERROR_CREATE_FROM_CPP_STRING(
           absl::StrFormat("Expected CONTINUATION frame, got frame type %02x",
-                          t->incoming_frame_type)
-              .c_str());
+                          t->incoming_frame_type));
     }
     if (t->expect_continuation_stream_id != t->incoming_stream_id) {
-      return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-          absl::StrFormat(
-              "Expected CONTINUATION frame for grpc_chttp2_stream %08x, got "
-              "grpc_chttp2_stream %08x",
-              t->expect_continuation_stream_id, t->incoming_stream_id)
-              .c_str());
+      return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrFormat(
+          "Expected CONTINUATION frame for grpc_chttp2_stream %08x, got "
+          "grpc_chttp2_stream %08x",
+          t->expect_continuation_stream_id, t->incoming_stream_id));
     }
     return init_header_frame_parser(t, 1);
   }
@@ -767,8 +758,7 @@ static grpc_error_handle init_settings_frame_parser(grpc_chttp2_transport* t) {
   if (t->incoming_frame_flags & GRPC_CHTTP2_FLAG_ACK) {
     memcpy(t->settings[GRPC_ACKED_SETTINGS], t->settings[GRPC_SENT_SETTINGS],
            GRPC_CHTTP2_NUM_SETTINGS * sizeof(uint32_t));
-    grpc_chttp2_hptbl_set_max_bytes(
-        t->hpack_parser.hpack_table(),
+    t->hpack_parser.hpack_table()->SetMaxBytes(
         t->settings[GRPC_ACKED_SETTINGS]
                    [GRPC_CHTTP2_SETTINGS_HEADER_TABLE_SIZE]);
     t->sent_local_settings = false;

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

@@ -0,0 +1,60 @@
+// Copyright 2021 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_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_POPULARITY_COUNT_H
+#define GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_POPULARITY_COUNT_H
+
+#include <grpc/impl/codegen/port_platform.h>
+
+namespace grpc_core {
+
+// filter tables for elems: this tables provides an approximate
+// popularity count for particular hashes, and are used to determine whether
+// a new literal should be added to the compression table or not.
+// They track a single integer that counts how often a particular value has
+// been seen. When that count reaches max (255), all values are halved. */
+template <uint8_t kElems>
+class PopularityCount {
+ public:
+  PopularityCount() : sum_{0}, elems_{} {}
+
+  // increment a filter count, halve all counts if one element reaches max
+  // return true if this element seems to be popular, false otherwise
+  bool AddElement(uint8_t idx) {
+    elems_[idx]++;
+    if (GPR_LIKELY(elems_[idx] < 255)) {
+      sum_++;
+    } else {
+      HalveFilter();
+    }
+    return elems_[idx] >= 2 * sum_ / kElems;
+  }
+
+ private:
+  // halve all counts because an element reached max
+  void HalveFilter() {
+    sum_ = 0;
+    for (int i = 0; i < kElems; i++) {
+      elems_[i] /= 2;
+      sum_ += elems_[i];
+    }
+  }
+
+  uint32_t sum_;
+  uint8_t elems_[kElems];
+};
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_POPULARITY_COUNT_H */

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

@@ -18,11 +18,11 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <grpc/support/log.h>
+
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 
-#include <grpc/support/log.h>
-
 static const char* stream_list_id_string(grpc_chttp2_stream_list_id id) {
   switch (id) {
     case GRPC_CHTTP2_LIST_WRITABLE:

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

@@ -22,7 +22,9 @@
 
 #include "absl/base/attributes.h"
 
-uint32_t grpc_chttp2_hpack_varint_length(uint32_t tail_value) {
+namespace grpc_core {
+
+uint32_t VarintLength(uint32_t tail_value) {
   if (tail_value < (1 << 7)) {
     return 2;
   } else if (tail_value < (1 << 14)) {
@@ -36,8 +38,8 @@ uint32_t grpc_chttp2_hpack_varint_length(uint32_t tail_value) {
   }
 }
 
-void grpc_chttp2_hpack_write_varint_tail(uint32_t tail_value, uint8_t* target,
-                                         uint32_t tail_length) {
+void VarintWriteTail(uint32_t tail_value, uint8_t* target,
+                     uint32_t tail_length) {
   switch (tail_length) {
     case 5:
       target[4] = static_cast<uint8_t>((tail_value >> 28) | 0x80);
@@ -56,3 +58,5 @@ void grpc_chttp2_hpack_write_varint_tail(uint32_t tail_value, uint8_t* target,
   }
   target[tail_length - 1] &= 0x7f;
 }
+
+}  // namespace grpc_core

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

@@ -23,38 +23,49 @@
 
 /* Helpers for hpack varint encoding */
 
+namespace grpc_core {
+
+/* maximum value that can be bitpacked with the opcode if the opcode has a
+   prefix of length prefix_bits */
+constexpr uint32_t MaxInVarintPrefix(uint8_t prefix_bits) {
+  return (1 << (8 - prefix_bits)) - 1;
+}
+
 /* length of a value that needs varint tail encoding (it's bigger than can be
    bitpacked into the opcode byte) - returned value includes the length of the
    opcode byte */
-uint32_t grpc_chttp2_hpack_varint_length(uint32_t tail_value);
+uint32_t VarintLength(uint32_t tail_value);
+void VarintWriteTail(uint32_t tail_value, uint8_t* target,
+                     uint32_t tail_length);
 
-void grpc_chttp2_hpack_write_varint_tail(uint32_t tail_value, uint8_t* target,
-                                         uint32_t tail_length);
+template <uint8_t kPrefixBits>
+class VarintWriter {
+ public:
+  static constexpr uint32_t kMaxInPrefix = MaxInVarintPrefix(kPrefixBits);
 
-/* maximum value that can be bitpacked with the opcode if the opcode has a
-   prefix
-   of length prefix_bits */
-#define GRPC_CHTTP2_MAX_IN_PREFIX(prefix_bits) \
-  ((uint32_t)((1 << (8 - (prefix_bits))) - 1))
-
-/* length required to bitpack a value */
-#define GRPC_CHTTP2_VARINT_LENGTH(n, prefix_bits) \
-  ((n) < GRPC_CHTTP2_MAX_IN_PREFIX(prefix_bits)   \
-       ? 1u                                       \
-       : grpc_chttp2_hpack_varint_length(         \
-             (n)-GRPC_CHTTP2_MAX_IN_PREFIX(prefix_bits)))
-
-#define GRPC_CHTTP2_WRITE_VARINT(n, prefix_bits, prefix_or, target, length)   \
-  do {                                                                        \
-    uint8_t* tgt = target;                                                    \
-    if ((length) == 1u) {                                                     \
-      (tgt)[0] = (uint8_t)((prefix_or) | (n));                                \
-    } else {                                                                  \
-      (tgt)[0] =                                                              \
-          (prefix_or) | (uint8_t)GRPC_CHTTP2_MAX_IN_PREFIX(prefix_bits);      \
-      grpc_chttp2_hpack_write_varint_tail(                                    \
-          (n)-GRPC_CHTTP2_MAX_IN_PREFIX(prefix_bits), (tgt) + 1, (length)-1); \
-    }                                                                         \
-  } while (0)
+  explicit VarintWriter(uint32_t value)
+      : value_(value),
+        length_(value < kMaxInPrefix ? 1 : VarintLength(value - kMaxInPrefix)) {
+  }
+
+  uint32_t value() const { return value_; }
+  uint32_t length() const { return length_; }
+
+  void Write(uint8_t prefix, uint8_t* target) const {
+    if (length_ == 1) {
+      target[0] = prefix | value_;
+    } else {
+      target[0] = prefix | kMaxInPrefix;
+      VarintWriteTail(value_ - kMaxInPrefix, target + 1, length_ - 1);
+    }
+  }
+
+ private:
+  const uint32_t value_;
+  // length required to bitpack value_
+  const uint32_t length_;
+};
+
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_VARINT_H */

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

@@ -18,14 +18,13 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
-#include "src/core/ext/transport/chttp2/transport/context_list.h"
-#include "src/core/ext/transport/chttp2/transport/internal.h"
-
 #include <limits.h>
 
 #include <grpc/support/log.h>
 
+#include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
+#include "src/core/ext/transport/chttp2/transport/context_list.h"
+#include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/lib/compression/stream_compression.h"
 #include "src/core/lib/debug/stats.h"
 #include "src/core/lib/profiling/timers.h"
@@ -259,8 +258,7 @@ class WriteContext {
   }
 
   void EnactHpackSettings() {
-    grpc_chttp2_hpack_compressor_set_max_table_size(
-        &t_->hpack_compressor,
+    t_->hpack_compressor.SetMaxTableSize(
         t_->settings[GRPC_PEER_SETTINGS]
                     [GRPC_CHTTP2_SETTINGS_HEADER_TABLE_SIZE]);
   }
@@ -457,18 +455,20 @@ class StreamWriteContext {
         is_default_initial_metadata(s_->send_initial_metadata)) {
       ConvertInitialMetadataToTrailingMetadata();
     } else {
-      grpc_encode_header_options hopt = {
-          s_->id,  // stream_id
-          false,   // is_eof
-          t_->settings[GRPC_PEER_SETTINGS]
+      t_->hpack_compressor.EncodeHeaders(
+          grpc_core::HPackCompressor::EncodeHeaderOptions{
+              s_->id,  // stream_id
+              false,   // is_eof
+              t_->settings
+                      [GRPC_PEER_SETTINGS]
                       [GRPC_CHTTP2_SETTINGS_GRPC_ALLOW_TRUE_BINARY_METADATA] !=
-              0,  // use_true_binary_metadata
-          t_->settings[GRPC_PEER_SETTINGS]
-                      [GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE],  // max_frame_size
-          &s_->stats.outgoing                                 // stats
-      };
-      grpc_chttp2_encode_header(&t_->hpack_compressor, nullptr, 0,
-                                s_->send_initial_metadata, &hopt, &t_->outbuf);
+                  0,  // use_true_binary_metadata
+              t_->settings
+                  [GRPC_PEER_SETTINGS]
+                  [GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE],  // max_frame_size
+              &s_->stats.outgoing                         // stats
+          },
+          *s_->send_initial_metadata, &t_->outbuf);
       grpc_chttp2_reset_ping_clock(t_);
       write_context_->IncInitialMetadataWrites();
     }
@@ -565,18 +565,22 @@ class StreamWriteContext {
       grpc_chttp2_encode_data(s_->id, &s_->flow_controlled_buffer, 0, true,
                               &s_->stats.outgoing, &t_->outbuf);
     } else {
-      grpc_encode_header_options hopt = {
-          s_->id, true,
-          t_->settings[GRPC_PEER_SETTINGS]
+      t_->hpack_compressor.EncodeHeaders(
+          grpc_core::HPackCompressor::EncodeHeaderOptions{
+              s_->id, true,
+              t_->settings
+                      [GRPC_PEER_SETTINGS]
                       [GRPC_CHTTP2_SETTINGS_GRPC_ALLOW_TRUE_BINARY_METADATA] !=
-              0,
-
-          t_->settings[GRPC_PEER_SETTINGS][GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE],
-          &s_->stats.outgoing};
-      grpc_chttp2_encode_header(&t_->hpack_compressor,
-                                extra_headers_for_trailing_metadata_,
-                                num_extra_headers_for_trailing_metadata_,
-                                s_->send_trailing_metadata, &hopt, &t_->outbuf);
+                  0,
+              t_->settings[GRPC_PEER_SETTINGS]
+                          [GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE],
+              &s_->stats.outgoing},
+          grpc_core::ConcatMetadata(
+              grpc_core::MetadataArray(
+                  extra_headers_for_trailing_metadata_,
+                  num_extra_headers_for_trailing_metadata_),
+              *s_->send_trailing_metadata),
+          &t_->outbuf);
     }
     write_context_->IncTrailingMetadataWrites();
     grpc_chttp2_reset_ping_clock(t_);

data/src/core/ext/transport/inproc/inproc_transport.cc

@@ -18,12 +18,15 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/ext/transport/inproc/inproc_transport.h"
+
+#include <string.h>
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
-#include <string.h>
-#include "src/core/ext/transport/inproc/inproc_transport.h"
+
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/slice/slice_internal.h"
@@ -1290,7 +1293,6 @@ grpc_channel* grpc_inproc_channel_create(grpc_server* server,
   const grpc_channel_args* server_args = grpc_channel_args_copy_and_remove(
       server->core_server->channel_args(), args_to_remove,
       GPR_ARRAY_SIZE(args_to_remove));
-
   // Add a default authority channel argument for the client
   grpc_arg default_authority_arg;
   default_authority_arg.type = GRPC_ARG_STRING;
@@ -1311,7 +1313,7 @@ grpc_channel* grpc_inproc_channel_create(grpc_server* server,
   if (error == GRPC_ERROR_NONE) {
     channel =
         grpc_channel_create("inproc", client_args, GRPC_CLIENT_DIRECT_CHANNEL,
-                            client_transport, nullptr, &error);
+                            client_transport, nullptr, 0, &error);
     if (error != GRPC_ERROR_NONE) {
       GPR_ASSERT(!channel);
       gpr_log(GPR_ERROR, "Failed to create client channel: %s",