grpc 1.43.1 → 1.44.0.pre2

data/src/core/lib/slice/slice.h

@@ -17,10 +17,13 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <cstdint>
+
 #include "absl/strings/string_view.h"
 
 #include <grpc/slice.h>
 
+#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/slice/slice_internal.h"
 
 // Herein lies grpc_core::Slice and its team of thin wrappers around grpc_slice.
@@ -110,6 +113,8 @@ class BaseSlice {
 
   uint8_t* mutable_data() { return GRPC_SLICE_START_PTR(slice_); }
 
+  grpc_slice* c_slice_ptr() { return &slice_; }
+
  private:
   grpc_slice slice_;
 };
@@ -159,6 +164,9 @@ struct CopyConstructors {
   static Out FromCopiedString(const char* s) {
     return Out(grpc_slice_from_copied_string(s));
   }
+  static Out FromCopiedString(absl::string_view s) {
+    return FromCopiedBuffer(s.data(), s.size());
+  }
   static Out FromCopiedString(std::string s) {
     return Out(grpc_slice_from_cpp_string(std::move(s)));
   }
@@ -171,30 +179,39 @@ struct CopyConstructors {
     return FromCopiedBuffer(reinterpret_cast<const char*>(buffer.data()),
                             buffer.size());
   }
+
+  static Out FromInt64(int64_t i) {
+    char buffer[GPR_LTOA_MIN_BUFSIZE];
+    gpr_ltoa(i, buffer);
+    return FromCopiedString(buffer);
+  }
+};
+
+template <typename Out>
+struct StaticConstructors {
+  static Out FromStaticString(const char* s) {
+    return Out(grpc_slice_from_static_string(s));
+  }
+
+  static Out FromStaticString(absl::string_view s) {
+    return Out(ExternallyManagedSlice(s.data(), s.size()));
+  }
 };
 
 }  // namespace slice_detail
 
-class StaticSlice : public slice_detail::BaseSlice {
+class StaticSlice : public slice_detail::BaseSlice,
+                    public slice_detail::StaticConstructors<StaticSlice> {
  public:
   StaticSlice() = default;
   explicit StaticSlice(const grpc_slice& slice)
       : slice_detail::BaseSlice(slice) {
-    GPR_DEBUG_ASSERT(
-        slice.refcount->GetType() == grpc_slice_refcount::Type::STATIC ||
-        slice.refcount->GetType() == grpc_slice_refcount::Type::NOP);
+    GPR_DEBUG_ASSERT(slice.refcount->GetType() ==
+                     grpc_slice_refcount::Type::NOP);
   }
   explicit StaticSlice(const StaticMetadataSlice& slice)
       : slice_detail::BaseSlice(slice) {}
 
-  static StaticSlice FromStaticString(const char* s) {
-    return StaticSlice(grpc_slice_from_static_string(s));
-  }
-
-  static StaticSlice FromStaticString(absl::string_view s) {
-    return StaticSlice(ExternallyManagedSlice(s.data(), s.size()));
-  }
-
   StaticSlice(const StaticSlice& other)
       : slice_detail::BaseSlice(other.c_slice()) {}
   StaticSlice& operator=(const StaticSlice& other) {
@@ -242,13 +259,15 @@ class MutableSlice : public slice_detail::BaseSlice,
   // Iterator access to the underlying bytes
   uint8_t* begin() { return mutable_data(); }
   uint8_t* end() { return mutable_data() + size(); }
+  uint8_t* data() { return mutable_data(); }
 
   // Array access
   uint8_t& operator[](size_t i) { return mutable_data()[i]; }
 };
 
 class Slice : public slice_detail::BaseSlice,
-              public slice_detail::CopyConstructors<Slice> {
+              public slice_detail::CopyConstructors<Slice>,
+              public slice_detail::StaticConstructors<Slice> {
  public:
   Slice() = default;
   ~Slice() { grpc_slice_unref_internal(c_slice()); }
@@ -321,6 +340,17 @@ class Slice : public slice_detail::BaseSlice,
     return Slice(grpc_slice_sub_no_ref(TakeCSlice(), pos, pos + n));
   }
 
+  // Return a sub slice of this one. Adds a reference to the underlying slice.
+  Slice RefSubSlice(size_t pos, size_t n) const {
+    return Slice(grpc_slice_sub(c_slice(), pos, pos + n));
+  }
+
+  // Split this slice, returning a new slice containing (split:end] and
+  // leaving this slice with [begin:split).
+  Slice Split(size_t split) {
+    return Slice(grpc_slice_split_tail(c_slice_ptr(), split));
+  }
+
   Slice Ref() const { return Slice(grpc_slice_ref_internal(c_slice())); }
 
   Slice Copy() const { return Slice(grpc_slice_copy(c_slice())); }

data/src/core/lib/slice/slice_intern.cc

@@ -31,7 +31,6 @@
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/slice/slice_utils.h"
-#include "src/core/lib/transport/static_metadata.h"
 
 #define LOG2_SHARD_COUNT 5
 #define SHARD_COUNT (1 << LOG2_SHARD_COUNT)
@@ -51,15 +50,6 @@ typedef struct slice_shard {
 
 static slice_shard* g_shards;
 
-struct static_metadata_hash_ent {
-  uint32_t hash;
-  uint32_t idx;
-};
-static static_metadata_hash_ent
-    static_metadata_hash[4 * GRPC_STATIC_MDSTR_COUNT];
-static uint32_t max_static_metadata_hash_probe;
-uint32_t grpc_static_metadata_hash_values[GRPC_STATIC_MDSTR_COUNT];
-
 namespace grpc_core {
 
 /* hash seed: decided at initialization time */
@@ -116,37 +106,8 @@ uint32_t grpc_slice_default_hash_impl(grpc_slice s) {
                           grpc_core::g_hash_seed);
 }
 
-uint32_t grpc_static_slice_hash(grpc_slice s) {
-  return grpc_static_metadata_hash_values[GRPC_STATIC_METADATA_INDEX(s)];
-}
-
-int grpc_static_slice_eq(grpc_slice a, grpc_slice b) {
-  return GRPC_STATIC_METADATA_INDEX(a) == GRPC_STATIC_METADATA_INDEX(b);
-}
-
 uint32_t grpc_slice_hash(grpc_slice s) { return grpc_slice_hash_internal(s); }
 
-grpc_slice grpc_slice_maybe_static_intern(grpc_slice slice,
-                                          bool* returned_slice_is_different) {
-  if (GRPC_IS_STATIC_METADATA_STRING(slice)) {
-    return slice;
-  }
-
-  uint32_t hash = grpc_slice_hash_internal(slice);
-  for (uint32_t i = 0; i <= max_static_metadata_hash_probe; i++) {
-    static_metadata_hash_ent ent =
-        static_metadata_hash[(hash + i) % GPR_ARRAY_SIZE(static_metadata_hash)];
-    if (ent.hash == hash && ent.idx < GRPC_STATIC_MDSTR_COUNT &&
-        grpc_slice_eq_static_interned(
-            slice, grpc_core::g_static_metadata_slice_table[ent.idx])) {
-      *returned_slice_is_different = true;
-      return grpc_core::g_static_metadata_slice_table[ent.idx];
-    }
-  }
-
-  return slice;
-}
-
 grpc_slice grpc_slice_intern(grpc_slice slice) {
   /* TODO(arjunroy): At present, this is capable of returning either a static or
      an interned slice. This yields weirdness like the constructor for
@@ -155,25 +116,6 @@ grpc_slice grpc_slice_intern(grpc_slice slice) {
   return grpc_core::ManagedMemorySlice(&slice);
 }
 
-// Attempt to see if the provided slice or string matches a static slice.
-// SliceArgs is either a const grpc_slice& or const pair<const char*, size_t>&.
-// In either case, hash is the pre-computed hash value.
-//
-// Returns: a matching static slice, or null.
-template <typename SliceArgs>
-static const grpc_core::StaticMetadataSlice* MatchStaticSlice(
-    uint32_t hash, const SliceArgs& args) {
-  for (uint32_t i = 0; i <= max_static_metadata_hash_probe; i++) {
-    static_metadata_hash_ent ent =
-        static_metadata_hash[(hash + i) % GPR_ARRAY_SIZE(static_metadata_hash)];
-    if (ent.hash == hash && ent.idx < GRPC_STATIC_MDSTR_COUNT &&
-        grpc_core::g_static_metadata_slice_table[ent.idx] == args) {
-      return &grpc_core::g_static_metadata_slice_table[ent.idx];
-    }
-  }
-  return nullptr;
-}
-
 // Helper methods to enable us to select appropriately overloaded slice methods
 // whether we're dealing with a slice, or a buffer with length, when interning
 // strings. Helpers for FindOrCreateInternedSlice().
@@ -271,30 +213,15 @@ grpc_core::ManagedMemorySlice::ManagedMemorySlice(const char* string)
 grpc_core::ManagedMemorySlice::ManagedMemorySlice(const char* buf, size_t len) {
   GPR_TIMER_SCOPE("grpc_slice_intern", 0);
   const uint32_t hash = gpr_murmur_hash3(buf, len, g_hash_seed);
-  const StaticMetadataSlice* static_slice =
-      MatchStaticSlice(hash, std::pair<const char*, size_t>(buf, len));
-  if (static_slice) {
-    *this = *static_slice;
-  } else {
-    *this = grpc_core::InternedSlice(FindOrCreateInternedSlice(
-        hash, std::pair<const char*, size_t>(buf, len)));
-  }
+  *this = grpc_core::InternedSlice(FindOrCreateInternedSlice(
+      hash, std::pair<const char*, size_t>(buf, len)));
 }
 
 grpc_core::ManagedMemorySlice::ManagedMemorySlice(const grpc_slice* slice_ptr) {
   GPR_TIMER_SCOPE("grpc_slice_intern", 0);
   const grpc_slice& slice = *slice_ptr;
-  if (GRPC_IS_STATIC_METADATA_STRING(slice)) {
-    *this = static_cast<const grpc_core::StaticMetadataSlice&>(slice);
-    return;
-  }
   const uint32_t hash = grpc_slice_hash_internal(slice);
-  const StaticMetadataSlice* static_slice = MatchStaticSlice(hash, slice);
-  if (static_slice) {
-    *this = *static_slice;
-  } else {
-    *this = grpc_core::InternedSlice(FindOrCreateInternedSlice(hash, slice));
-  }
+  *this = grpc_core::InternedSlice(FindOrCreateInternedSlice(hash, slice));
 }
 
 void grpc_test_only_set_slice_hash_seed(uint32_t seed) {
@@ -315,31 +242,6 @@ void grpc_slice_intern_init(void) {
     shard->strs = static_cast<InternedSliceRefcount**>(
         gpr_zalloc(sizeof(*shard->strs) * shard->capacity));
   }
-  for (size_t i = 0; i < GPR_ARRAY_SIZE(static_metadata_hash); i++) {
-    static_metadata_hash[i].hash = 0;
-    static_metadata_hash[i].idx = GRPC_STATIC_MDSTR_COUNT;
-  }
-  max_static_metadata_hash_probe = 0;
-  for (size_t i = 0; i < GRPC_STATIC_MDSTR_COUNT; i++) {
-    grpc_static_metadata_hash_values[i] = grpc_slice_default_hash_internal(
-        grpc_core::g_static_metadata_slice_table[i]);
-    for (size_t j = 0; j < GPR_ARRAY_SIZE(static_metadata_hash); j++) {
-      size_t slot = (grpc_static_metadata_hash_values[i] + j) %
-                    GPR_ARRAY_SIZE(static_metadata_hash);
-      if (static_metadata_hash[slot].idx == GRPC_STATIC_MDSTR_COUNT) {
-        static_metadata_hash[slot].hash = grpc_static_metadata_hash_values[i];
-        static_metadata_hash[slot].idx = static_cast<uint32_t>(i);
-        if (j > max_static_metadata_hash_probe) {
-          max_static_metadata_hash_probe = static_cast<uint32_t>(j);
-        }
-        break;
-      }
-    }
-  }
-  // Handle KV hash for all static mdelems.
-  for (size_t i = 0; i < GRPC_STATIC_MDELEM_COUNT; ++i) {
-    grpc_core::g_static_mdelem_table[i].HashInit();
-  }
 }
 
 void grpc_slice_intern_shutdown(void) {

data/src/core/lib/slice/slice_internal.h

@@ -56,8 +56,7 @@ void grpc_slice_buffer_sub_first(grpc_slice_buffer* sb, size_t begin,
 bool grpc_slice_is_interned(const grpc_slice& slice);
 inline bool grpc_slice_is_interned(const grpc_slice& slice) {
   return (slice.refcount &&
-          (slice.refcount->GetType() == grpc_slice_refcount::Type::INTERNED ||
-           slice.refcount->GetType() == grpc_slice_refcount::Type::STATIC));
+          (slice.refcount->GetType() == grpc_slice_refcount::Type::INTERNED));
 }
 
 inline bool grpc_slice_static_interned_equal(const grpc_slice& a,

data/src/core/lib/slice/slice_refcount.h

@@ -17,17 +17,16 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <string.h>
+
 #include <grpc/support/alloc.h>
 
+#include "src/core/lib/gpr/murmur_hash.h"
 #include "src/core/lib/slice/slice_refcount_base.h"
-#include "src/core/lib/slice/static_slice.h"
-
-// Interned slices have specific fast-path operations for hashing. To inline
-// these operations, we need to forward declare them here.
-extern uint32_t grpc_static_metadata_hash_values[GRPC_STATIC_MDSTR_COUNT];
 
 namespace grpc_core {
 
+extern uint32_t g_hash_seed;
 extern grpc_slice_refcount kNoopRefcount;
 
 // TODO(ctiller): when this is removed, remove the std::atomic* in
@@ -73,11 +72,6 @@ inline int grpc_slice_refcount::Eq(const grpc_slice& a, const grpc_slice& b) {
   GPR_DEBUG_ASSERT(a.refcount != nullptr);
   GPR_DEBUG_ASSERT(a.refcount == this);
   switch (ref_type_) {
-    case Type::STATIC:
-      GPR_DEBUG_ASSERT(
-          (GRPC_STATIC_METADATA_INDEX(a) == GRPC_STATIC_METADATA_INDEX(b)) ==
-          (a.refcount == b.refcount));
-      ABSL_FALLTHROUGH_INTENDED;
     case Type::INTERNED:
       return a.refcount == b.refcount;
     case Type::NOP:
@@ -94,9 +88,6 @@ inline uint32_t grpc_slice_refcount::Hash(const grpc_slice& slice) {
   GPR_DEBUG_ASSERT(slice.refcount != nullptr);
   GPR_DEBUG_ASSERT(slice.refcount == this);
   switch (ref_type_) {
-    case Type::STATIC:
-      return ::grpc_static_metadata_hash_values[GRPC_STATIC_METADATA_INDEX(
-          slice)];
     case Type::INTERNED:
       return reinterpret_cast<grpc_core::InternedSliceRefcount*>(slice.refcount)
           ->hash;

data/src/core/lib/slice/slice_refcount_base.h

@@ -85,7 +85,6 @@
 struct grpc_slice_refcount {
  public:
   enum class Type {
-    STATIC,    // Refcount for a static metadata slice.
     INTERNED,  // Refcount for an interned slice.
     NOP,       // No-Op
     REGULAR    // Refcount for non-static-metadata, non-interned slices.
@@ -163,19 +162,4 @@ struct grpc_slice_refcount {
   void* destroy_fn_arg_ = nullptr;
 };
 
-namespace grpc_core {
-
-struct StaticSliceRefcount {
-  static grpc_slice_refcount kStaticSubRefcount;
-
-  explicit StaticSliceRefcount(uint32_t index)
-      : base(&kStaticSubRefcount, grpc_slice_refcount::Type::STATIC),
-        index(index) {}
-
-  grpc_slice_refcount base;
-  const uint32_t index;
-};
-
-}  // namespace grpc_core
-
 #endif  // GRPC_CORE_LIB_SLICE_SLICE_REFCOUNT_BASE_H