grpc 1.22.0 → 1.23.0

data/src/core/lib/surface/server.h

@@ -34,31 +34,22 @@ extern grpc_core::TraceFlag grpc_server_channel_trace;
 
 /* Add a listener to the server: when the server starts, it will call start,
    and when it shuts down, it will call destroy */
-void grpc_server_add_listener(grpc_server* server, void* listener,
-                              void (*start)(grpc_server* server, void* arg,
-                                            grpc_pollset** pollsets,
-                                            size_t npollsets),
-                              void (*destroy)(grpc_server* server, void* arg,
-                                              grpc_closure* on_done),
-                              intptr_t socket_uuid);
+void grpc_server_add_listener(
+    grpc_server* server, void* listener_arg,
+    void (*start)(grpc_server* server, void* arg, grpc_pollset** pollsets,
+                  size_t npollsets),
+    void (*destroy)(grpc_server* server, void* arg, grpc_closure* on_done),
+    grpc_core::RefCountedPtr<grpc_core::channelz::ListenSocketNode> node);
 
 /* Setup a transport - creates a channel stack, binds the transport to the
    server */
 void grpc_server_setup_transport(
     grpc_server* server, grpc_transport* transport,
     grpc_pollset* accepting_pollset, const grpc_channel_args* args,
-    grpc_core::RefCountedPtr<grpc_core::channelz::SocketNode> socket_node,
+    const grpc_core::RefCountedPtr<grpc_core::channelz::SocketNode>&
+        socket_node,
     grpc_resource_user* resource_user = nullptr);
 
-/* fills in the uuids of all sockets used for connections on this server */
-void grpc_server_populate_server_sockets(
-    grpc_server* server, grpc_core::channelz::ChildSocketsList* server_sockets,
-    intptr_t start_idx);
-
-/* fills in the uuids of all listen sockets on this server */
-void grpc_server_populate_listen_sockets(
-    grpc_server* server, grpc_core::channelz::ChildRefsList* listen_sockets);
-
 grpc_core::channelz::ServerNode* grpc_server_get_channelz_node(
     grpc_server* server);
 

data/src/core/lib/surface/version.cc

@@ -25,4 +25,4 @@
 
 const char* grpc_version_string(void) { return "7.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "gale"; }
+const char* grpc_g_stands_for(void) { return "gangnam"; }

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

@@ -55,17 +55,15 @@ void SliceBufferByteStream::Orphan() {
 
 bool SliceBufferByteStream::Next(size_t max_size_hint,
                                  grpc_closure* on_complete) {
-  GPR_ASSERT(cursor_ < backing_buffer_.count);
+  GPR_DEBUG_ASSERT(backing_buffer_.count > 0);
   return true;
 }
 
 grpc_error* SliceBufferByteStream::Pull(grpc_slice* slice) {
-  if (shutdown_error_ != GRPC_ERROR_NONE) {
+  if (GPR_UNLIKELY(shutdown_error_ != GRPC_ERROR_NONE)) {
     return GRPC_ERROR_REF(shutdown_error_);
   }
-  GPR_ASSERT(cursor_ < backing_buffer_.count);
-  *slice = grpc_slice_ref_internal(backing_buffer_.slices[cursor_]);
-  ++cursor_;
+  *slice = grpc_slice_buffer_take_first(&backing_buffer_);
   return GRPC_ERROR_NONE;
 }
 

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

@@ -99,9 +99,8 @@ class SliceBufferByteStream : public ByteStream {
   void Shutdown(grpc_error* error) override;
 
  private:
-  grpc_slice_buffer backing_buffer_;
-  size_t cursor_ = 0;
   grpc_error* shutdown_error_ = GRPC_ERROR_NONE;
+  grpc_slice_buffer backing_buffer_;
 };
 
 //

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

@@ -22,6 +22,7 @@
 
 #include <grpc/support/string_util.h>
 #include "src/core/lib/iomgr/error_internal.h"
+#include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/transport/status_conversion.h"
 
 static grpc_error* recursively_find_error_with_field(grpc_error* error,
@@ -52,7 +53,15 @@ void grpc_error_get_status(grpc_error* error, grpc_millis deadline,
   if (GPR_LIKELY(error == GRPC_ERROR_NONE)) {
     if (code != nullptr) *code = GRPC_STATUS_OK;
     if (slice != nullptr) {
-      grpc_error_get_str(error, GRPC_ERROR_STR_GRPC_MESSAGE, slice);
+      // Normally, we call grpc_error_get_str(
+      //   error, GRPC_ERROR_STR_GRPC_MESSAGE, slice).
+      // We can fastpath since we know that:
+      // 1) Error is null
+      // 2) which == GRPC_ERROR_STR_GRPC_MESSAGE
+      // 3) The resulting slice is statically known.
+      // 4) Said resulting slice is of length 0 ("").
+      // This means 3 movs, instead of 10s of instructions and a strlen.
+      *slice = grpc_core::ExternallyManagedSlice("");
     }
     if (http_error != nullptr) {
       *http_error = GRPC_HTTP2_NO_ERROR;

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

@@ -68,8 +68,8 @@ void grpc_mdelem_trace_ref(void* md, const grpc_slice& key,
     char* key_str = grpc_slice_to_c_string(key);
     char* value_str = grpc_slice_to_c_string(value);
     gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
-            "ELM   REF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'", md, refcnt,
-            refcnt + 1, key_str, value_str);
+            "mdelem   REF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'", md,
+            refcnt, refcnt + 1, key_str, value_str);
     gpr_free(key_str);
     gpr_free(value_str);
   }
@@ -82,7 +82,7 @@ void grpc_mdelem_trace_unref(void* md, const grpc_slice& key,
     char* key_str = grpc_slice_to_c_string(key);
     char* value_str = grpc_slice_to_c_string(value);
     gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
-            "ELM   UNREF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'", md,
+            "mdelem   UNREF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'", md,
             refcnt, refcnt - 1, key_str, value_str);
     gpr_free(key_str);
     gpr_free(value_str);
@@ -112,14 +112,33 @@ AllocatedMetadata::AllocatedMetadata(const grpc_slice& key,
     : RefcountedMdBase(grpc_slice_ref_internal(key),
                        grpc_slice_ref_internal(value)) {
 #ifndef NDEBUG
-  if (grpc_trace_metadata.enabled()) {
-    char* key_str = grpc_slice_to_c_string(key);
-    char* value_str = grpc_slice_to_c_string(value);
-    gpr_log(GPR_DEBUG, "ELM ALLOC:%p:%" PRIdPTR ": '%s' = '%s'", this,
-            RefValue(), key_str, value_str);
-    gpr_free(key_str);
-    gpr_free(value_str);
-  }
+  TraceAtStart("ALLOC_MD");
+#endif
+}
+
+AllocatedMetadata::AllocatedMetadata(const grpc_slice& key,
+                                     const grpc_slice& value, const NoRefKey*)
+    : RefcountedMdBase(key, grpc_slice_ref_internal(value)) {
+#ifndef NDEBUG
+  TraceAtStart("ALLOC_MD_NOREF_KEY");
+#endif
+}
+
+AllocatedMetadata::AllocatedMetadata(
+    const grpc_core::ManagedMemorySlice& key,
+    const grpc_core::UnmanagedMemorySlice& value)
+    : RefcountedMdBase(key, value) {
+#ifndef NDEBUG
+  TraceAtStart("ALLOC_MD_NOREF_KEY_VAL");
+#endif
+}
+
+AllocatedMetadata::AllocatedMetadata(
+    const grpc_core::ExternallyManagedSlice& key,
+    const grpc_core::UnmanagedMemorySlice& value)
+    : RefcountedMdBase(key, value) {
+#ifndef NDEBUG
+  TraceAtStart("ALLOC_MD_NOREF_KEY_VAL");
 #endif
 }
 
@@ -134,6 +153,19 @@ AllocatedMetadata::~AllocatedMetadata() {
   }
 }
 
+#ifndef NDEBUG
+void grpc_core::RefcountedMdBase::TraceAtStart(const char* tag) {
+  if (grpc_trace_metadata.enabled()) {
+    char* key_str = grpc_slice_to_c_string(key());
+    char* value_str = grpc_slice_to_c_string(value());
+    gpr_log(GPR_DEBUG, "mdelem   %s:%p:%" PRIdPTR ": '%s' = '%s'", tag, this,
+            RefValue(), key_str, value_str);
+    gpr_free(key_str);
+    gpr_free(value_str);
+  }
+}
+#endif
+
 InternedMetadata::InternedMetadata(const grpc_slice& key,
                                    const grpc_slice& value, uint32_t hash,
                                    InternedMetadata* next)
@@ -141,14 +173,16 @@ InternedMetadata::InternedMetadata(const grpc_slice& key,
                        grpc_slice_ref_internal(value), hash),
       link_(next) {
 #ifndef NDEBUG
-  if (grpc_trace_metadata.enabled()) {
-    char* key_str = grpc_slice_to_c_string(key);
-    char* value_str = grpc_slice_to_c_string(value);
-    gpr_log(GPR_DEBUG, "ELM   NEW:%p:%" PRIdPTR ": '%s' = '%s'", this,
-            RefValue(), key_str, value_str);
-    gpr_free(key_str);
-    gpr_free(value_str);
-  }
+  TraceAtStart("INTERNED_MD");
+#endif
+}
+
+InternedMetadata::InternedMetadata(const grpc_slice& key,
+                                   const grpc_slice& value, uint32_t hash,
+                                   InternedMetadata* next, const NoRefKey*)
+    : RefcountedMdBase(key, grpc_slice_ref_internal(value), hash), link_(next) {
+#ifndef NDEBUG
+  TraceAtStart("INTERNED_MD_NOREF_KEY");
 #endif
 }
 
@@ -222,7 +256,12 @@ void grpc_mdctx_global_shutdown() {
         abort();
       }
     }
+      // For ASAN builds, we don't want to crash here, because that will
+      // prevent ASAN from providing leak detection information, which is
+      // far more useful than this simple assertion.
+#ifndef GRPC_ASAN_ENABLED
     GPR_DEBUG_ASSERT(shard->count == 0);
+#endif
     gpr_free(shard->elems);
   }
 }
@@ -243,8 +282,8 @@ void InternedMetadata::RefWithShardLocked(mdtab_shard* shard) {
     char* value_str = grpc_slice_to_c_string(value());
     intptr_t value = RefValue();
     gpr_log(__FILE__, __LINE__, GPR_LOG_SEVERITY_DEBUG,
-            "ELM   REF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'", this, value,
-            value + 1, key_str, value_str);
+            "mdelem   REF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'", this,
+            value, value + 1, key_str, value_str);
     gpr_free(key_str);
     gpr_free(value_str);
   }
@@ -302,36 +341,100 @@ static void rehash_mdtab(mdtab_shard* shard) {
   }
 }
 
-grpc_mdelem grpc_mdelem_create(
+template <bool key_definitely_static, bool value_definitely_static = false>
+static grpc_mdelem md_create_maybe_static(const grpc_slice& key,
+                                          const grpc_slice& value);
+template <bool key_definitely_static>
+static grpc_mdelem md_create_must_intern(const grpc_slice& key,
+                                         const grpc_slice& value,
+                                         uint32_t hash);
+
+template <bool key_definitely_static, bool value_definitely_static = false>
+static grpc_mdelem md_create(
     const grpc_slice& key, const grpc_slice& value,
     grpc_mdelem_data* compatible_external_backing_store) {
+  // Ensure slices are, in fact, static if we claimed they were.
+  GPR_DEBUG_ASSERT(!key_definitely_static ||
+                   GRPC_IS_STATIC_METADATA_STRING(key));
+  GPR_DEBUG_ASSERT(!value_definitely_static ||
+                   GRPC_IS_STATIC_METADATA_STRING(value));
+  const bool key_is_interned =
+      key_definitely_static || grpc_slice_is_interned(key);
+  const bool value_is_interned =
+      value_definitely_static || grpc_slice_is_interned(value);
   // External storage if either slice is not interned and the caller already
   // created a backing store. If no backing store, we allocate one.
-  if (!grpc_slice_is_interned(key) || !grpc_slice_is_interned(value)) {
+  if (!key_is_interned || !value_is_interned) {
     if (compatible_external_backing_store != nullptr) {
       // Caller provided backing store.
       return GRPC_MAKE_MDELEM(compatible_external_backing_store,
                               GRPC_MDELEM_STORAGE_EXTERNAL);
     } else {
       // We allocate backing store.
-      return GRPC_MAKE_MDELEM(grpc_core::New<AllocatedMetadata>(key, value),
-                              GRPC_MDELEM_STORAGE_ALLOCATED);
+      return key_definitely_static
+                 ? GRPC_MAKE_MDELEM(
+                       grpc_core::New<AllocatedMetadata>(
+                           key, value,
+                           static_cast<const AllocatedMetadata::NoRefKey*>(
+                               nullptr)),
+                       GRPC_MDELEM_STORAGE_ALLOCATED)
+                 : GRPC_MAKE_MDELEM(
+                       grpc_core::New<AllocatedMetadata>(key, value),
+                       GRPC_MDELEM_STORAGE_ALLOCATED);
     }
   }
+  return md_create_maybe_static<key_definitely_static, value_definitely_static>(
+      key, value);
+}
+
+template <bool key_definitely_static, bool value_definitely_static>
+static grpc_mdelem md_create_maybe_static(const grpc_slice& key,
+                                          const grpc_slice& value) {
+  // Ensure slices are, in fact, static if we claimed they were.
+  GPR_DEBUG_ASSERT(!key_definitely_static ||
+                   GRPC_IS_STATIC_METADATA_STRING(key));
+  GPR_DEBUG_ASSERT(!value_definitely_static ||
+                   GRPC_IS_STATIC_METADATA_STRING(value));
+  GPR_DEBUG_ASSERT(key.refcount != nullptr);
+  GPR_DEBUG_ASSERT(value.refcount != nullptr);
+
+  const bool key_is_static_mdstr =
+      key_definitely_static ||
+      key.refcount->GetType() == grpc_slice_refcount::Type::STATIC;
+  const bool value_is_static_mdstr =
+      value_definitely_static ||
+      value.refcount->GetType() == grpc_slice_refcount::Type::STATIC;
+
+  const intptr_t kidx = GRPC_STATIC_METADATA_INDEX(key);
 
   // Not all static slice input yields a statically stored metadata element.
-  // It may be worth documenting why.
-  if (GRPC_IS_STATIC_METADATA_STRING(key) &&
-      GRPC_IS_STATIC_METADATA_STRING(value)) {
+  if (key_is_static_mdstr && value_is_static_mdstr) {
     grpc_mdelem static_elem = grpc_static_mdelem_for_static_strings(
-        GRPC_STATIC_METADATA_INDEX(key), GRPC_STATIC_METADATA_INDEX(value));
+        kidx, GRPC_STATIC_METADATA_INDEX(value));
     if (!GRPC_MDISNULL(static_elem)) {
       return static_elem;
     }
   }
 
-  uint32_t hash = GRPC_MDSTR_KV_HASH(grpc_slice_hash_refcounted(key),
-                                     grpc_slice_hash_refcounted(value));
+  uint32_t khash = key_definitely_static
+                       ? grpc_static_metadata_hash_values[kidx]
+                       : grpc_slice_hash_refcounted(key);
+
+  uint32_t hash = GRPC_MDSTR_KV_HASH(khash, grpc_slice_hash_refcounted(value));
+  return md_create_must_intern<key_definitely_static>(key, value, hash);
+}
+
+template <bool key_definitely_static>
+static grpc_mdelem md_create_must_intern(const grpc_slice& key,
+                                         const grpc_slice& value,
+                                         uint32_t hash) {
+  // Here, we know both key and value are both at least interned, and both
+  // possibly static. We know that anything inside the shared interned table is
+  // also at least interned (and maybe static). Note that equality for a static
+  // and interned slice implies that they are both the same exact slice.
+  // The same applies to a pair of interned slices, or a pair of static slices.
+  // Rather than run the full equality check, we can therefore just do a pointer
+  // comparison of the refcounts.
   InternedMetadata* md;
   mdtab_shard* shard = &g_shards[SHARD_IDX(hash)];
   size_t idx;
@@ -343,7 +446,8 @@ grpc_mdelem grpc_mdelem_create(
   idx = TABLE_IDX(hash, shard->capacity);
   /* search for an existing pair */
   for (md = shard->elems[idx].next; md; md = md->bucket_next()) {
-    if (grpc_slice_eq(key, md->key()) && grpc_slice_eq(value, md->value())) {
+    if (grpc_slice_static_interned_equal(key, md->key()) &&
+        grpc_slice_static_interned_equal(value, md->value())) {
       md->RefWithShardLocked(shard);
       gpr_mu_unlock(&shard->mu);
       return GRPC_MAKE_MDELEM(md, GRPC_MDELEM_STORAGE_INTERNED);
@@ -351,8 +455,12 @@ grpc_mdelem grpc_mdelem_create(
   }
 
   /* not found: create a new pair */
-  md = grpc_core::New<InternedMetadata>(key, value, hash,
-                                        shard->elems[idx].next);
+  md = key_definitely_static
+           ? grpc_core::New<InternedMetadata>(
+                 key, value, hash, shard->elems[idx].next,
+                 static_cast<const InternedMetadata::NoRefKey*>(nullptr))
+           : grpc_core::New<InternedMetadata>(key, value, hash,
+                                              shard->elems[idx].next);
   shard->elems[idx].next = md;
   shard->count++;
 
@@ -365,9 +473,68 @@ grpc_mdelem grpc_mdelem_create(
   return GRPC_MAKE_MDELEM(md, GRPC_MDELEM_STORAGE_INTERNED);
 }
 
+grpc_mdelem grpc_mdelem_create(
+    const grpc_slice& key, const grpc_slice& value,
+    grpc_mdelem_data* compatible_external_backing_store) {
+  return md_create<false>(key, value, compatible_external_backing_store);
+}
+
+grpc_mdelem grpc_mdelem_create(
+    const grpc_core::StaticMetadataSlice& key, const grpc_slice& value,
+    grpc_mdelem_data* compatible_external_backing_store) {
+  return md_create<true>(key, value, compatible_external_backing_store);
+}
+
+/* Create grpc_mdelem from provided slices. We specify via template parameter
+   whether we know that the input key is static or not. If it is, we short
+   circuit various comparisons and a no-op unref. */
+template <bool key_definitely_static>
+static grpc_mdelem md_from_slices(const grpc_slice& key,
+                                  const grpc_slice& value) {
+  // Ensure key is, in fact, static if we claimed it was.
+  GPR_DEBUG_ASSERT(!key_definitely_static ||
+                   GRPC_IS_STATIC_METADATA_STRING(key));
+  grpc_mdelem out = md_create<key_definitely_static>(key, value, nullptr);
+  if (!key_definitely_static) {
+    grpc_slice_unref_internal(key);
+  }
+  grpc_slice_unref_internal(value);
+  return out;
+}
+
 grpc_mdelem grpc_mdelem_from_slices(const grpc_slice& key,
                                     const grpc_slice& value) {
-  grpc_mdelem out = grpc_mdelem_create(key, value, nullptr);
+  return md_from_slices</*key_definitely_static=*/false>(key, value);
+}
+
+grpc_mdelem grpc_mdelem_from_slices(const grpc_core::StaticMetadataSlice& key,
+                                    const grpc_slice& value) {
+  return md_from_slices</*key_definitely_static=*/true>(key, value);
+}
+
+grpc_mdelem grpc_mdelem_from_slices(
+    const grpc_core::StaticMetadataSlice& key,
+    const grpc_core::StaticMetadataSlice& value) {
+  grpc_mdelem out = md_create_maybe_static<true, true>(key, value);
+  return out;
+}
+
+grpc_mdelem grpc_mdelem_from_slices(
+    const grpc_core::StaticMetadataSlice& key,
+    const grpc_core::ManagedMemorySlice& value) {
+  // TODO(arjunroy): We can save the unref if md_create_maybe_static ended up
+  // creating a new interned metadata. But otherwise - we need this here.
+  grpc_mdelem out = md_create_maybe_static<true>(key, value);
+  grpc_slice_unref_internal(value);
+  return out;
+}
+
+grpc_mdelem grpc_mdelem_from_slices(
+    const grpc_core::ManagedMemorySlice& key,
+    const grpc_core::ManagedMemorySlice& value) {
+  grpc_mdelem out = md_create_maybe_static<false>(key, value);
+  // TODO(arjunroy): We can save the unref if md_create_maybe_static ended up
+  // creating a new interned metadata. But otherwise - we need this here.
   grpc_slice_unref_internal(key);
   grpc_slice_unref_internal(value);
   return out;

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

@@ -118,10 +118,31 @@ struct grpc_mdelem {
   ((grpc_mdelem_data_storage)((md).payload & \
                               (uintptr_t)GRPC_MDELEM_STORAGE_INTERNED_BIT))
 
-/* Unrefs the slices. */
+/* Given arbitrary input slices, create a grpc_mdelem object. The caller refs
+ * the input slices; we unref them. This method is always safe to call; however,
+ * if we know data about the slices in question (e.g. if we knew our key was
+ * static) we can call specializations that save on cycle count. */
 grpc_mdelem grpc_mdelem_from_slices(const grpc_slice& key,
                                     const grpc_slice& value);
 
+/* Like grpc_mdelem_from_slices, but we know that key is a static slice. This
+   saves us a few branches and a no-op call to md_unref() for the key. */
+grpc_mdelem grpc_mdelem_from_slices(const grpc_core::StaticMetadataSlice& key,
+                                    const grpc_slice& value);
+
+/* Like grpc_mdelem_from_slices, but key is static and val is static. */
+grpc_mdelem grpc_mdelem_from_slices(
+    const grpc_core::StaticMetadataSlice& key,
+    const grpc_core::StaticMetadataSlice& value);
+
+/* Like grpc_mdelem_from_slices, but key is static and val is interned. */
+grpc_mdelem grpc_mdelem_from_slices(const grpc_core::StaticMetadataSlice& key,
+                                    const grpc_core::ManagedMemorySlice& value);
+
+/* Like grpc_mdelem_from_slices, but key and val are interned. */
+grpc_mdelem grpc_mdelem_from_slices(const grpc_core::ManagedMemorySlice& key,
+                                    const grpc_core::ManagedMemorySlice& value);
+
 /* Cheaply convert a grpc_metadata to a grpc_mdelem; may use the grpc_metadata
    object as backing storage (so lifetimes should align) */
 grpc_mdelem grpc_mdelem_from_grpc_metadata(grpc_metadata* metadata);
@@ -134,6 +155,11 @@ grpc_mdelem grpc_mdelem_create(
     const grpc_slice& key, const grpc_slice& value,
     grpc_mdelem_data* compatible_external_backing_store);
 
+/* Like grpc_mdelem_create, but we know that key is static. */
+grpc_mdelem grpc_mdelem_create(
+    const grpc_core::StaticMetadataSlice& key, const grpc_slice& value,
+    grpc_mdelem_data* compatible_external_backing_store);
+
 #define GRPC_MDKEY(md) (GRPC_MDELEM_DATA(md)->key)
 #define GRPC_MDVALUE(md) (GRPC_MDELEM_DATA(md)->value)
 
@@ -186,19 +212,21 @@ struct UserData {
 
 class StaticMetadata {
  public:
-  StaticMetadata(const grpc_slice& key, const grpc_slice& value)
-      : kv_({key, value}), hash_(0) {}
+  StaticMetadata(const grpc_slice& key, const grpc_slice& value, uintptr_t idx)
+      : kv_({key, value}), hash_(0), static_idx_(idx) {}
 
   const grpc_mdelem_data& data() const { return kv_; }
 
   void HashInit();
   uint32_t hash() { return hash_; }
+  uintptr_t StaticIndex() { return static_idx_; }
 
  private:
   grpc_mdelem_data kv_;
 
   /* private only data */
   uint32_t hash_;
+  uintptr_t static_idx_;
 };
 
 class RefcountedMdBase {
@@ -237,6 +265,10 @@ class RefcountedMdBase {
   }
 
  protected:
+#ifndef NDEBUG
+  void TraceAtStart(const char* tag);
+#endif
+
   intptr_t RefValue() { return refcnt_.Load(MemoryOrder::RELAXED); }
   bool AllRefsDropped() { return refcnt_.Load(MemoryOrder::ACQUIRE) == 0; }
   bool FirstRef() { return refcnt_.FetchAdd(1, MemoryOrder::RELAXED) == 0; }
@@ -251,16 +283,19 @@ class RefcountedMdBase {
 
 class InternedMetadata : public RefcountedMdBase {
  public:
+  // TODO(arjunroy): Change to use strongly typed slices instead.
+  struct NoRefKey {};
   struct BucketLink {
     explicit BucketLink(InternedMetadata* md) : next(md) {}
 
     InternedMetadata* next = nullptr;
   };
-
   InternedMetadata(const grpc_slice& key, const grpc_slice& value,
                    uint32_t hash, InternedMetadata* next);
-  ~InternedMetadata();
+  InternedMetadata(const grpc_slice& key, const grpc_slice& value,
+                   uint32_t hash, InternedMetadata* next, const NoRefKey*);
 
+  ~InternedMetadata();
   void RefWithShardLocked(mdtab_shard* shard);
   UserData* user_data() { return &user_data_; }
   InternedMetadata* bucket_next() { return link_.next; }
@@ -276,7 +311,15 @@ class InternedMetadata : public RefcountedMdBase {
 /* Shadow structure for grpc_mdelem_data for allocated elements */
 class AllocatedMetadata : public RefcountedMdBase {
  public:
+  // TODO(arjunroy): Change to use strongly typed slices instead.
+  struct NoRefKey {};
   AllocatedMetadata(const grpc_slice& key, const grpc_slice& value);
+  AllocatedMetadata(const grpc_core::ManagedMemorySlice& key,
+                    const grpc_core::UnmanagedMemorySlice& value);
+  AllocatedMetadata(const grpc_core::ExternallyManagedSlice& key,
+                    const grpc_core::UnmanagedMemorySlice& value);
+  AllocatedMetadata(const grpc_slice& key, const grpc_slice& value,
+                    const NoRefKey*);
   ~AllocatedMetadata();
 
   UserData* user_data() { return &user_data_; }
@@ -348,10 +391,11 @@ inline void grpc_mdelem_unref(grpc_mdelem gmd) {
          free an interned md at any time: it's unsafe from this point on to
          access it so we read the hash now. */
       uint32_t hash = md->hash();
-      if (GPR_UNLIKELY(md->Unref())) {
 #ifndef NDEBUG
+      if (GPR_UNLIKELY(md->Unref(file, line))) {
         grpc_mdelem_on_final_unref(storage, md, hash, file, line);
 #else
+      if (GPR_UNLIKELY(md->Unref())) {
         grpc_mdelem_on_final_unref(storage, md, hash);
 #endif
       }
@@ -371,4 +415,35 @@ inline void grpc_mdelem_unref(grpc_mdelem gmd) {
 void grpc_mdctx_global_init(void);
 void grpc_mdctx_global_shutdown();
 
+/* Like grpc_mdelem_from_slices, but we know that key is a static or interned
+   slice and value is not static or interned. This gives us an inlinable
+   fastpath - we know we must allocate metadata now, and that we do not need to
+   unref the value (rather, we just transfer the ref). We can avoid a ref since:
+   1) the key slice is passed in already ref'd
+   2) We're guaranteed to create a new Allocated slice, thus meaning the
+      ref can be considered 'transferred'.*/
+inline grpc_mdelem grpc_mdelem_from_slices(
+    const grpc_core::ManagedMemorySlice& key,
+    const grpc_core::UnmanagedMemorySlice& value) {
+  using grpc_core::AllocatedMetadata;
+  return GRPC_MAKE_MDELEM(grpc_core::New<AllocatedMetadata>(key, value),
+                          GRPC_MDELEM_STORAGE_ALLOCATED);
+}
+
+inline grpc_mdelem grpc_mdelem_from_slices(
+    const grpc_core::ExternallyManagedSlice& key,
+    const grpc_core::UnmanagedMemorySlice& value) {
+  using grpc_core::AllocatedMetadata;
+  return GRPC_MAKE_MDELEM(grpc_core::New<AllocatedMetadata>(key, value),
+                          GRPC_MDELEM_STORAGE_ALLOCATED);
+}
+
+inline grpc_mdelem grpc_mdelem_from_slices(
+    const grpc_core::StaticMetadataSlice& key,
+    const grpc_core::UnmanagedMemorySlice& value) {
+  using grpc_core::AllocatedMetadata;
+  return GRPC_MAKE_MDELEM(grpc_core::New<AllocatedMetadata>(key, value),
+                          GRPC_MDELEM_STORAGE_ALLOCATED);
+}
+
 #endif /* GRPC_CORE_LIB_TRANSPORT_METADATA_H */