grpc 1.42.0 → 1.43.1

data/src/core/lib/transport/parsed_metadata.h

@@ -24,6 +24,7 @@
 #include "absl/strings/match.h"
 
 #include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/surface/validate_metadata.h"
 #include "src/core/lib/transport/metadata.h"
 
@@ -37,9 +38,54 @@ template <typename Which>
 struct HasSimpleMemento {
   static constexpr bool value =
       std::is_trivial<typename Which::MementoType>::value &&
-      sizeof(typename Which::MementoType) <= sizeof(intptr_t);
+      sizeof(typename Which::MementoType) <= sizeof(uint64_t);
 };
 
+// Storage type for a single metadata entry.
+union Buffer {
+  uint64_t trivial;
+  void* pointer;
+  grpc_slice slice;
+  grpc_mdelem mdelem;
+};
+
+// Given a key and a value, concatenate together to make a debug string.
+// Split out to avoid template bloat.
+std::string MakeDebugString(absl::string_view key, absl::string_view value);
+
+// Wrapper around MakeDebugString.
+// For the value part, use two functions - one to extract a typed field from
+// Buffer, and a second (sourced from the trait) to generate a displayable debug
+// string from the field value. We try to maximize indirection/code sharing here
+// as this is not critical path code and we'd like to avoid some code bloat -
+// better to scale by number of types than then number of metadata traits!
+template <typename Field, typename CompatibleWithField, typename Display>
+GPR_ATTRIBUTE_NOINLINE std::string MakeDebugStringPipeline(
+    absl::string_view key, const Buffer& value,
+    Field (*field_from_buffer)(const Buffer&),
+    Display (*display_from_field)(CompatibleWithField)) {
+  return MakeDebugString(
+      key, absl::StrCat(display_from_field(field_from_buffer(value))));
+}
+
+// Extract a trivial field value from a Buffer - for MakeDebugStringPipeline.
+template <typename Field>
+Field FieldFromTrivial(const Buffer& value) {
+  return static_cast<Field>(value.trivial);
+}
+
+// Extract a pointer field value from a Buffer - for MakeDebugStringPipeline.
+template <typename Field>
+Field FieldFromPointer(const Buffer& value) {
+  return *static_cast<const Field*>(value.pointer);
+}
+
+// Extract a Slice from a Buffer.
+Slice SliceFromBuffer(const Buffer& buffer);
+
+// Unref the grpc_slice part of a Buffer (assumes it is in fact a grpc_slice).
+void DestroySliceValue(const Buffer& value);
+
 }  // namespace metadata_detail
 
 // A parsed metadata value.
@@ -60,27 +106,38 @@ class ParsedMetadata {
           value,
       uint32_t transport_size)
       : vtable_(ParsedMetadata::template TrivialTraitVTable<Which>()),
-        value_(static_cast<intptr_t>(value)),
-        transport_size_(transport_size) {}
+        transport_size_(transport_size) {
+    value_.trivial = static_cast<uint64_t>(value);
+  }
   template <typename Which>
   ParsedMetadata(
       Which,
-      absl::enable_if_t<!metadata_detail::HasSimpleMemento<Which>::value,
-                        typename Which::MementoType>
+      absl::enable_if_t<
+          !metadata_detail::HasSimpleMemento<Which>::value &&
+              !std::is_convertible<typename Which::MementoType, Slice>::value,
+          typename Which::MementoType>
           value,
       uint32_t transport_size)
       : vtable_(ParsedMetadata::template NonTrivialTraitVTable<Which>()),
-        value_(
-            reinterpret_cast<intptr_t>(new typename Which::MementoType(value))),
-        transport_size_(transport_size) {}
+        transport_size_(transport_size) {
+    value_.pointer = new typename Which::MementoType(std::move(value));
+  }
+  // Construct metadata from a Slice typed value.
+  template <typename Which>
+  ParsedMetadata(Which, Slice value, uint32_t transport_size)
+      : vtable_(ParsedMetadata::template SliceTraitVTable<Which>()),
+        transport_size_(transport_size) {
+    value_.slice = value.TakeCSlice();
+  }
   // Takes ownership of elem
   explicit ParsedMetadata(grpc_mdelem elem)
       : vtable_(grpc_is_binary_header_internal(GRPC_MDKEY(elem))
                     ? MdelemVtable<true>()
                     : MdelemVtable<false>()),
-        value_(static_cast<intptr_t>(elem.payload)),
-        transport_size_(GRPC_MDELEM_LENGTH(elem)) {}
-  ParsedMetadata() : vtable_(EmptyVTable()), value_(0), transport_size_(0) {}
+        transport_size_(GRPC_MDELEM_LENGTH(elem)) {
+    value_.mdelem = elem;
+  }
+  ParsedMetadata() : vtable_(EmptyVTable()), transport_size_(0) {}
   ~ParsedMetadata() { vtable_->destroy(value_); }
 
   // Non copyable, but movable.
@@ -111,8 +168,14 @@ class ParsedMetadata {
   // HTTP2 defined storage size of this metadatum.
   uint32_t transport_size() const { return transport_size_; }
   // Create a new parsed metadata with the same key but a different value.
-  ParsedMetadata WithNewValue(const grpc_slice& value) const {
-    return vtable_->with_new_value(value_, value);
+  ParsedMetadata WithNewValue(Slice value) const {
+    ParsedMetadata result;
+    result.vtable_ = vtable_;
+    result.value_ = value_;
+    result.transport_size_ =
+        TransportSize(vtable_->key_length(value_), value.length());
+    vtable_->with_new_value(&value, &result);
+    return result;
   }
   std::string DebugString() const { return vtable_->debug_string(value_); }
 
@@ -123,14 +186,19 @@ class ParsedMetadata {
   }
 
  private:
+  using Buffer = metadata_detail::Buffer;
+
   struct VTable {
     const bool is_binary_header;
-    void (*const destroy)(intptr_t value);
-    grpc_error_handle (*const set)(intptr_t value,
+    void (*const destroy)(const Buffer& value);
+    grpc_error_handle (*const set)(const Buffer& value,
                                    MetadataContainer* container);
-    ParsedMetadata (*const with_new_value)(intptr_t value,
-                                           const grpc_slice& new_value);
-    std::string (*debug_string)(intptr_t value);
+    // result is a bitwise copy of the originating ParsedMetadata.
+    void (*const with_new_value)(Slice* new_value, ParsedMetadata* result);
+    std::string (*const debug_string)(const Buffer& value);
+    // TODO(ctiller): when we delete mdelem, make this a simple integer constant
+    // on the vtable
+    size_t (*const key_length)(const Buffer& value);
   };
 
   static const VTable* EmptyVTable();
@@ -138,27 +206,39 @@ class ParsedMetadata {
   static const VTable* TrivialTraitVTable();
   template <typename Which>
   static const VTable* NonTrivialTraitVTable();
+  template <typename Which>
+  static const VTable* SliceTraitVTable();
   template <bool kIsBinaryHeader>
   static const VTable* MdelemVtable();
 
+  template <Slice (*ParseMemento)(Slice)>
+  GPR_ATTRIBUTE_NOINLINE void WithNewValueSetSlice(Slice* slice) {
+    value_.slice = ParseMemento(std::move(*slice)).TakeCSlice();
+  }
+
   const VTable* vtable_;
-  intptr_t value_;
+  Buffer value_;
   uint32_t transport_size_;
 };
 
+namespace metadata_detail {}  // namespace metadata_detail
+
 template <typename MetadataContainer>
 const typename ParsedMetadata<MetadataContainer>::VTable*
 ParsedMetadata<MetadataContainer>::EmptyVTable() {
   static const VTable vtable = {
       false,
       // destroy
-      [](intptr_t) {},
+      [](const Buffer&) {},
       // set
-      [](intptr_t, MetadataContainer*) { return GRPC_ERROR_NONE; },
+      [](const Buffer&, MetadataContainer*) { return GRPC_ERROR_NONE; },
       // with_new_value
-      [](intptr_t, const grpc_slice&) { return ParsedMetadata(); },
+      [](Slice*, ParsedMetadata*) {},
       // debug_string
-      [](intptr_t) -> std::string { return "empty"; }};
+      [](const Buffer&) -> std::string { return "empty"; },
+      // key_length
+      [](const Buffer&) -> size_t { return 0; },
+  };
   return &vtable;
 }
 
@@ -169,26 +249,28 @@ ParsedMetadata<MetadataContainer>::TrivialTraitVTable() {
   static const VTable vtable = {
       absl::EndsWith(Which::key(), "-bin"),
       // destroy
-      [](intptr_t) {},
+      [](const Buffer&) {},
       // set
-      [](intptr_t value, MetadataContainer* map) {
-        map->Set(Which(), Which::MementoToValue(
-                              static_cast<typename Which::MementoType>(value)));
+      [](const Buffer& value, MetadataContainer* map) {
+        map->Set(Which(),
+                 Which::MementoToValue(
+                     static_cast<typename Which::MementoType>(value.trivial)));
         return GRPC_ERROR_NONE;
       },
       // with_new_value
-      [](intptr_t, const grpc_slice& value) {
-        return ParsedMetadata(
-            Which(), Which::ParseMemento(value),
-            TransportSize(strlen(Which::key()), GRPC_SLICE_LENGTH(value)));
+      [](Slice* value, ParsedMetadata* result) {
+        result->value_.trivial = Which::ParseMemento(std::move(*value));
       },
       // debug_string
-      [](intptr_t value) {
-        return absl::StrCat(
-            Which::key(), ": ",
-            Which::DisplayValue(
-                static_cast<typename Which::MementoType>(value)));
-      }};
+      [](const Buffer& value) {
+        return metadata_detail::MakeDebugStringPipeline(
+            Which::key(), value,
+            metadata_detail::FieldFromTrivial<typename Which::MementoType>,
+            Which::DisplayValue);
+      },
+      // key_length
+      [](const Buffer&) { return Which::key().size(); },
+  };
   return &vtable;
 }
 
@@ -199,26 +281,60 @@ ParsedMetadata<MetadataContainer>::NonTrivialTraitVTable() {
   static const VTable vtable = {
       absl::EndsWith(Which::key(), "-bin"),
       // destroy
-      [](intptr_t value) {
-        delete reinterpret_cast<typename Which::MementoType*>(value);
+      [](const Buffer& value) {
+        delete static_cast<typename Which::MementoType*>(value.pointer);
       },
       // set
-      [](intptr_t value, MetadataContainer* map) {
-        auto* p = reinterpret_cast<typename Which::MementoType*>(value);
+      [](const Buffer& value, MetadataContainer* map) {
+        auto* p = static_cast<typename Which::MementoType*>(value.pointer);
         map->Set(Which(), Which::MementoToValue(*p));
         return GRPC_ERROR_NONE;
       },
       // with_new_value
-      [](intptr_t, const grpc_slice& value) {
-        return ParsedMetadata(
-            Which(), Which::ParseMemento(value),
-            TransportSize(strlen(Which::key()), GRPC_SLICE_LENGTH(value)));
+      [](Slice* value, ParsedMetadata* result) {
+        result->value_.pointer = new
+            typename Which::MementoType(Which::ParseMemento(std::move(*value)));
       },
       // debug_string
-      [](intptr_t value) {
-        auto* p = reinterpret_cast<typename Which::MementoType*>(value);
-        return absl::StrCat(Which::key(), ": ", Which::DisplayValue(*p));
-      }};
+      [](const Buffer& value) {
+        return metadata_detail::MakeDebugStringPipeline(
+            Which::key(), value,
+            metadata_detail::FieldFromPointer<typename Which::MementoType>,
+            Which::DisplayValue);
+      },
+      // key_length
+      [](const Buffer&) { return Which::key().size(); },
+  };
+  return &vtable;
+}
+
+template <typename MetadataContainer>
+template <typename Which>
+const typename ParsedMetadata<MetadataContainer>::VTable*
+ParsedMetadata<MetadataContainer>::SliceTraitVTable() {
+  static const VTable vtable = {
+      absl::EndsWith(Which::key(), "-bin"),
+      // destroy
+      metadata_detail::DestroySliceValue,
+      // set
+      [](const Buffer& value, MetadataContainer* map) {
+        map->Set(Which(), Which::MementoToValue(
+                              metadata_detail::SliceFromBuffer(value)));
+        return GRPC_ERROR_NONE;
+      },
+      // with_new_value
+      [](Slice* value, ParsedMetadata* result) {
+        result->WithNewValueSetSlice<Which::ParseMemento>(value);
+      },
+      // debug_string
+      [](const Buffer& value) {
+        return metadata_detail::MakeDebugStringPipeline(
+            Which::key(), value, metadata_detail::SliceFromBuffer,
+            Which::DisplayValue);
+      },
+      // key_length
+      [](const Buffer&) { return Which::key().size(); },
+  };
   return &vtable;
 }
 
@@ -229,10 +345,10 @@ ParsedMetadata<MetadataContainer>::MdelemVtable() {
   static const VTable vtable = {
       kIsBinaryHeader,
       // destroy
-      [](intptr_t value) { GRPC_MDELEM_UNREF(grpc_mdelem{uintptr_t(value)}); },
+      [](const Buffer& value) { GRPC_MDELEM_UNREF(value.mdelem); },
       // set
-      [](intptr_t value, MetadataContainer* map) {
-        auto md = GRPC_MDELEM_REF(grpc_mdelem{uintptr_t(value)});
+      [](const Buffer& value, MetadataContainer* map) {
+        auto md = GRPC_MDELEM_REF(value.mdelem);
         auto err = map->Append(md);
         // If an error occurs, md is not consumed and we need to.
         // This is an awful API, but that's why we're replacing it.
@@ -242,18 +358,21 @@ ParsedMetadata<MetadataContainer>::MdelemVtable() {
         return err;
       },
       // with_new_value
-      [](intptr_t value, const grpc_slice& value_slice) {
-        grpc_mdelem elem{uintptr_t(value)};
-        return ParsedMetadata(grpc_mdelem_from_slices(
+      [](Slice* value_slice, ParsedMetadata* result) {
+        result->value_.mdelem = grpc_mdelem_from_slices(
             static_cast<const ManagedMemorySlice&>(
-                grpc_slice_ref_internal(GRPC_MDKEY(elem))),
-            value_slice));
+                grpc_slice_ref_internal(GRPC_MDKEY(result->value_.mdelem))),
+            value_slice->TakeCSlice());
       },
       // debug_string
-      [](intptr_t value) {
-        grpc_mdelem elem{uintptr_t(value)};
-        return absl::StrCat(StringViewFromSlice(GRPC_MDKEY(elem)), ": ",
-                            StringViewFromSlice(GRPC_MDVALUE(elem)));
+      [](const Buffer& value) {
+        return metadata_detail::MakeDebugString(
+            StringViewFromSlice(GRPC_MDKEY(value.mdelem)),
+            StringViewFromSlice(GRPC_MDVALUE(value.mdelem)));
+      },
+      // key_length
+      [](const Buffer& value) {
+        return GRPC_SLICE_LENGTH(GRPC_MDKEY(value.mdelem));
       }};
   return &vtable;
 }

data/src/core/lib/transport/pid_controller.cc

@@ -31,8 +31,8 @@ double PidController::Update(double error, double dt) {
   if (dt <= 0) return last_control_value_;
   /* integrate error using the trapezoid rule */
   error_integral_ += dt * (last_error_ + error) * 0.5;
-  error_integral_ = grpc_core::Clamp(error_integral_, -args_.integral_range(),
-                                     args_.integral_range());
+  error_integral_ =
+      Clamp(error_integral_, -args_.integral_range(), args_.integral_range());
   double diff_error = (error - last_error_) / dt;
   /* calculate derivative of control value vs time */
   double dc_dt = args_.gain_p() * error + args_.gain_i() * error_integral_ +
@@ -40,8 +40,8 @@ double PidController::Update(double error, double dt) {
   /* and perform trapezoidal integration */
   double new_control_value =
       last_control_value_ + dt * (last_dc_dt_ + dc_dt) * 0.5;
-  new_control_value = grpc_core::Clamp(
-      new_control_value, args_.min_control_value(), args_.max_control_value());
+  new_control_value = Clamp(new_control_value, args_.min_control_value(),
+                            args_.max_control_value());
   last_error_ = error;
   last_dc_dt_ = dc_dt;
   last_control_value_ = new_control_value;