grpc 1.15.0 → 1.30.0

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

@@ -22,66 +22,110 @@
 #include <grpc/support/port_platform.h>
 
 #include <grpc/grpc.h>
+
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/atomic.h"
+#include "src/core/lib/gprpp/map.h"
+#include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/work_serializer.h"
+
+namespace grpc_core {
+
+extern TraceFlag grpc_connectivity_state_trace;
+
+// Enum to string conversion.
+const char* ConnectivityStateName(grpc_connectivity_state state);
+
+// Interface for watching connectivity state.
+// Subclasses must implement the Notify() method.
+//
+// Note: Most callers will want to use
+// AsyncConnectivityStateWatcherInterface instead.
+class ConnectivityStateWatcherInterface
+    : public InternallyRefCounted<ConnectivityStateWatcherInterface> {
+ public:
+  virtual ~ConnectivityStateWatcherInterface() = default;
+
+  // Notifies the watcher that the state has changed to new_state.
+  virtual void Notify(grpc_connectivity_state new_state) = 0;
+
+  void Orphan() override { Unref(); }
+};
+
+// An alternative watcher interface that performs notifications via an
+// asynchronous callback scheduled on the ExecCtx.
+// Subclasses must implement the OnConnectivityStateChange() method.
+class AsyncConnectivityStateWatcherInterface
+    : public ConnectivityStateWatcherInterface {
+ public:
+  virtual ~AsyncConnectivityStateWatcherInterface() = default;
+
+  // Schedules a closure on the ExecCtx to invoke
+  // OnConnectivityStateChange() asynchronously.
+  void Notify(grpc_connectivity_state new_state) override final;
+
+ protected:
+  class Notifier;
+
+  // If \a combiner is nullptr, then the notification will be scheduled on the
+  // ExecCtx.
+  explicit AsyncConnectivityStateWatcherInterface(
+      std::shared_ptr<WorkSerializer> work_serializer = nullptr)
+      : work_serializer_(std::move(work_serializer)) {}
+
+  // Invoked asynchronously when Notify() is called.
+  virtual void OnConnectivityStateChange(grpc_connectivity_state new_state) = 0;
+
+ private:
+  std::shared_ptr<WorkSerializer> work_serializer_;
+};
+
+// Tracks connectivity state.  Maintains a list of watchers that are
+// notified whenever the state changes.
+//
+// Note that once the state becomes SHUTDOWN, watchers will be notified
+// and then automatically orphaned (i.e., RemoveWatcher() does not need
+// to be called).
+class ConnectivityStateTracker {
+ public:
+  ConnectivityStateTracker(const char* name,
+                           grpc_connectivity_state state = GRPC_CHANNEL_IDLE)
+      : name_(name), state_(state) {}
+
+  ~ConnectivityStateTracker();
+
+  // Adds a watcher.
+  // If the current state is different than initial_state, the watcher
+  // will be notified immediately.  Otherwise, it will be notified
+  // whenever the state changes.
+  // Not thread safe; access must be serialized with an external lock.
+  void AddWatcher(grpc_connectivity_state initial_state,
+                  OrphanablePtr<ConnectivityStateWatcherInterface> watcher);
+
+  // Removes a watcher.  The watcher will be orphaned.
+  // Not thread safe; access must be serialized with an external lock.
+  void RemoveWatcher(ConnectivityStateWatcherInterface* watcher);
+
+  // Sets connectivity state.
+  // Not thread safe; access must be serialized with an external lock.
+  void SetState(grpc_connectivity_state state, const char* reason);
+
+  // Gets the current state.
+  // Thread safe; no need to use an external lock.
+  grpc_connectivity_state state() const;
+
+ private:
+  const char* name_;
+  Atomic<grpc_connectivity_state> state_;
+  // TODO(roth): Once we can use C++-14 heterogeneous lookups, this can
+  // be a set instead of a map.
+  std::map<ConnectivityStateWatcherInterface*,
+           OrphanablePtr<ConnectivityStateWatcherInterface>>
+      watchers_;
+};
 
-typedef struct grpc_connectivity_state_watcher {
-  /** we keep watchers in a linked list */
-  struct grpc_connectivity_state_watcher* next;
-  /** closure to notify on change */
-  grpc_closure* notify;
-  /** the current state as believed by the watcher */
-  grpc_connectivity_state* current;
-} grpc_connectivity_state_watcher;
-
-typedef struct {
-  /** current grpc_connectivity_state */
-  gpr_atm current_state_atm;
-  /** error associated with state */
-  grpc_error* current_error;
-  /** all our watchers */
-  grpc_connectivity_state_watcher* watchers;
-  /** a name to help debugging */
-  char* name;
-} grpc_connectivity_state_tracker;
-
-extern grpc_core::TraceFlag grpc_connectivity_state_trace;
-
-/** enum --> string conversion */
-const char* grpc_connectivity_state_name(grpc_connectivity_state state);
-
-void grpc_connectivity_state_init(grpc_connectivity_state_tracker* tracker,
-                                  grpc_connectivity_state init_state,
-                                  const char* name);
-void grpc_connectivity_state_destroy(grpc_connectivity_state_tracker* tracker);
-
-/** Set connectivity state; not thread safe; access must be serialized with an
- *  external lock */
-void grpc_connectivity_state_set(grpc_connectivity_state_tracker* tracker,
-                                 grpc_connectivity_state state,
-                                 grpc_error* associated_error,
-                                 const char* reason);
-
-/** Return true if this connectivity state has watchers.
-    Access must be serialized with an external lock. */
-bool grpc_connectivity_state_has_watchers(
-    grpc_connectivity_state_tracker* tracker);
-
-/** Return the last seen connectivity state. No need to synchronize access. */
-grpc_connectivity_state grpc_connectivity_state_check(
-    grpc_connectivity_state_tracker* tracker);
-
-/** Return the last seen connectivity state, and the associated error.
-    Access must be serialized with an external lock. */
-grpc_connectivity_state grpc_connectivity_state_get(
-    grpc_connectivity_state_tracker* tracker, grpc_error** error);
-
-/** Return 1 if the channel should start connecting, 0 otherwise.
-    If current==NULL cancel notify if it is already queued (success==0 in that
-    case).
-    Access must be serialized with an external lock. */
-bool grpc_connectivity_state_notify_on_state_change(
-    grpc_connectivity_state_tracker* tracker, grpc_connectivity_state* current,
-    grpc_closure* notify);
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_TRANSPORT_CONNECTIVITY_STATE_H */

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

@@ -22,12 +22,14 @@
 
 #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,
                                                      grpc_error_ints which) {
+  intptr_t unused;
   // If the error itself has a status code, return it.
-  if (grpc_error_get_int(error, which, nullptr)) {
+  if (grpc_error_get_int(error, which, &unused)) {
     return error;
   }
   if (grpc_error_is_special(error)) return nullptr;
@@ -47,6 +49,26 @@ void grpc_error_get_status(grpc_error* error, grpc_millis deadline,
                            grpc_status_code* code, grpc_slice* slice,
                            grpc_http2_error_code* http_error,
                            const char** error_string) {
+  // Fast path: We expect no error.
+  if (GPR_LIKELY(error == GRPC_ERROR_NONE)) {
+    if (code != nullptr) *code = GRPC_STATUS_OK;
+    if (slice != nullptr) {
+      // 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;
+    }
+    return;
+  }
+
   // Start with the parent error and recurse through the tree of children
   // until we find the first one that has a status code.
   grpc_error* found_error =
@@ -102,7 +124,8 @@ void grpc_error_get_status(grpc_error* error, grpc_millis deadline,
 }
 
 bool grpc_error_has_clear_grpc_status(grpc_error* error) {
-  if (grpc_error_get_int(error, GRPC_ERROR_INT_GRPC_STATUS, nullptr)) {
+  intptr_t unused;
+  if (grpc_error_get_int(error, GRPC_ERROR_INT_GRPC_STATUS, &unused)) {
     return true;
   }
   uint8_t slot = error->first_err;

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

@@ -41,6 +41,11 @@
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/transport/static_metadata.h"
 
+using grpc_core::AllocatedMetadata;
+using grpc_core::InternedMetadata;
+using grpc_core::StaticMetadata;
+using grpc_core::UserData;
+
 /* There are two kinds of mdelem and mdstr instances.
  * Static instances are declared in static_metadata.{h,c} and
  * are initialized by grpc_mdctx_global_init().
@@ -54,13 +59,40 @@ grpc_core::DebugOnlyTraceFlag grpc_trace_metadata(false, "metadata");
 
 #ifndef NDEBUG
 #define DEBUG_ARGS , const char *file, int line
-#define FWD_DEBUG_ARGS , file, line
-#define REF_MD_LOCKED(shard, s) ref_md_locked((shard), (s), __FILE__, __LINE__)
-#else
+#define FWD_DEBUG_ARGS file, line
+
+void grpc_mdelem_trace_ref(void* md, const grpc_slice& key,
+                           const grpc_slice& value, intptr_t refcnt,
+                           const char* file, int line) {
+  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(file, line, GPR_LOG_SEVERITY_DEBUG,
+            "mdelem   REF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'", md,
+            refcnt, refcnt + 1, key_str, value_str);
+    gpr_free(key_str);
+    gpr_free(value_str);
+  }
+}
+
+void grpc_mdelem_trace_unref(void* md, const grpc_slice& key,
+                             const grpc_slice& value, intptr_t refcnt,
+                             const char* file, int line) {
+  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(file, line, GPR_LOG_SEVERITY_DEBUG,
+            "mdelem   UNREF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'", md,
+            refcnt, refcnt - 1, key_str, value_str);
+    gpr_free(key_str);
+    gpr_free(value_str);
+  }
+}
+
+#else  // ifndef NDEBUG
 #define DEBUG_ARGS
 #define FWD_DEBUG_ARGS
-#define REF_MD_LOCKED(shard, s) ref_md_locked((shard), (s))
-#endif
+#endif  // ifndef NDEBUG
 
 #define INITIAL_SHARD_CAPACITY 8
 #define LOG2_SHARD_COUNT 4
@@ -69,37 +101,124 @@ grpc_core::DebugOnlyTraceFlag grpc_trace_metadata(false, "metadata");
 #define TABLE_IDX(hash, capacity) (((hash) >> (LOG2_SHARD_COUNT)) % (capacity))
 #define SHARD_IDX(hash) ((hash) & ((1 << (LOG2_SHARD_COUNT)) - 1))
 
-typedef void (*destroy_user_data_func)(void* user_data);
+void StaticMetadata::HashInit() {
+  uint32_t k_hash = grpc_slice_hash_internal(kv_.key);
+  uint32_t v_hash = grpc_slice_hash_internal(kv_.value);
+  hash_ = GRPC_MDSTR_KV_HASH(k_hash, v_hash);
+}
 
-/* Shadow structure for grpc_mdelem_data for interned elements */
-typedef struct interned_metadata {
-  /* must be byte compatible with grpc_mdelem_data */
-  grpc_slice key;
-  grpc_slice value;
+AllocatedMetadata::AllocatedMetadata(const grpc_slice& key,
+                                     const grpc_slice& value)
+    : RefcountedMdBase(grpc_slice_ref_internal(key),
+                       grpc_slice_ref_internal(value)) {
+#ifndef NDEBUG
+  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
+}
 
-  /* private only data */
-  gpr_atm refcnt;
+AllocatedMetadata::AllocatedMetadata(
+    const grpc_core::ManagedMemorySlice& key,
+    const grpc_core::UnmanagedMemorySlice& value)
+    : RefcountedMdBase(key, value) {
+#ifndef NDEBUG
+  TraceAtStart("ALLOC_MD_NOREF_KEY_VAL");
+#endif
+}
 
-  gpr_mu mu_user_data;
-  gpr_atm destroy_user_data;
-  gpr_atm user_data;
+AllocatedMetadata::AllocatedMetadata(
+    const grpc_core::ExternallyManagedSlice& key,
+    const grpc_core::UnmanagedMemorySlice& value)
+    : RefcountedMdBase(key, value) {
+#ifndef NDEBUG
+  TraceAtStart("ALLOC_MD_NOREF_KEY_VAL");
+#endif
+}
 
-  struct interned_metadata* bucket_next;
-} interned_metadata;
+AllocatedMetadata::~AllocatedMetadata() {
+  grpc_slice_unref_internal(key());
+  grpc_slice_unref_internal(value());
+  void* user_data = user_data_.data.Load(grpc_core::MemoryOrder::RELAXED);
+  if (user_data) {
+    destroy_user_data_func destroy_user_data =
+        user_data_.destroy_user_data.Load(grpc_core::MemoryOrder::RELAXED);
+    destroy_user_data(user_data);
+  }
+}
 
-/* Shadow structure for grpc_mdelem_data for allocated elements */
-typedef struct allocated_metadata {
-  /* must be byte compatible with grpc_mdelem_data */
-  grpc_slice key;
-  grpc_slice value;
+#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
 
-  /* private only data */
-  gpr_atm refcnt;
-} allocated_metadata;
+InternedMetadata::InternedMetadata(const grpc_slice& key,
+                                   const grpc_slice& value, uint32_t hash,
+                                   InternedMetadata* next)
+    : RefcountedMdBase(grpc_slice_ref_internal(key),
+                       grpc_slice_ref_internal(value), hash),
+      link_(next) {
+#ifndef NDEBUG
+  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
+}
+
+InternedMetadata::~InternedMetadata() {
+  grpc_slice_unref_internal(key());
+  grpc_slice_unref_internal(value());
+  void* user_data = user_data_.data.Load(grpc_core::MemoryOrder::RELAXED);
+  if (user_data) {
+    destroy_user_data_func destroy_user_data =
+        user_data_.destroy_user_data.Load(grpc_core::MemoryOrder::RELAXED);
+    destroy_user_data(user_data);
+  }
+}
+
+size_t InternedMetadata::CleanupLinkedMetadata(
+    InternedMetadata::BucketLink* head) {
+  size_t num_freed = 0;
+  InternedMetadata::BucketLink* prev_next = head;
+  InternedMetadata *md, *next;
+
+  for (md = head->next; md; md = next) {
+    next = md->link_.next;
+    if (md->AllRefsDropped()) {
+      prev_next->next = next;
+      delete md;
+      num_freed++;
+    } else {
+      prev_next = &md->link_;
+    }
+  }
+  return num_freed;
+}
 
 typedef struct mdtab_shard {
   gpr_mu mu;
-  interned_metadata** elems;
+  InternedMetadata::BucketLink* elems;
   size_t count;
   size_t capacity;
   /** Estimate of the number of unreferenced mdelems in the hash table.
@@ -120,7 +239,7 @@ void grpc_mdctx_global_init(void) {
     shard->count = 0;
     gpr_atm_no_barrier_store(&shard->free_estimate, 0);
     shard->capacity = INITIAL_SHARD_CAPACITY;
-    shard->elems = static_cast<interned_metadata**>(
+    shard->elems = static_cast<InternedMetadata::BucketLink*>(
         gpr_zalloc(sizeof(*shard->elems) * shard->capacity));
   }
 }
@@ -130,7 +249,6 @@ void grpc_mdctx_global_shutdown() {
     mdtab_shard* shard = &g_shards[i];
     gpr_mu_destroy(&shard->mu);
     gc_mdtab(shard);
-    /* TODO(ctiller): GPR_ASSERT(shard->count == 0); */
     if (shard->count != 0) {
       gpr_log(GPR_DEBUG, "WARNING: %" PRIuPTR " metadata elements were leaked",
               shard->count);
@@ -138,65 +256,53 @@ 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);
   }
 }
 
+#ifndef NDEBUG
 static int is_mdelem_static(grpc_mdelem e) {
-  return GRPC_MDELEM_DATA(e) >= &grpc_static_mdelem_table[0] &&
-         GRPC_MDELEM_DATA(e) <
-             &grpc_static_mdelem_table[GRPC_STATIC_MDELEM_COUNT];
+  return reinterpret_cast<grpc_core::StaticMetadata*>(GRPC_MDELEM_DATA(e)) >=
+             &grpc_static_mdelem_table()[0] &&
+         reinterpret_cast<grpc_core::StaticMetadata*>(GRPC_MDELEM_DATA(e)) <
+             &grpc_static_mdelem_table()[GRPC_STATIC_MDELEM_COUNT];
 }
+#endif
 
-static void ref_md_locked(mdtab_shard* shard,
-                          interned_metadata* md DEBUG_ARGS) {
+void InternedMetadata::RefWithShardLocked(mdtab_shard* shard) {
 #ifndef NDEBUG
   if (grpc_trace_metadata.enabled()) {
-    char* key_str = grpc_slice_to_c_string(md->key);
-    char* value_str = grpc_slice_to_c_string(md->value);
-    gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
-            "ELM   REF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'", (void*)md,
-            gpr_atm_no_barrier_load(&md->refcnt),
-            gpr_atm_no_barrier_load(&md->refcnt) + 1, key_str, value_str);
+    char* key_str = grpc_slice_to_c_string(key());
+    char* value_str = grpc_slice_to_c_string(value());
+    intptr_t value = RefValue();
+    gpr_log(__FILE__, __LINE__, GPR_LOG_SEVERITY_DEBUG,
+            "mdelem   REF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'", this,
+            value, value + 1, key_str, value_str);
     gpr_free(key_str);
     gpr_free(value_str);
   }
 #endif
-  if (0 == gpr_atm_no_barrier_fetch_add(&md->refcnt, 1)) {
+  if (FirstRef()) {
     gpr_atm_no_barrier_fetch_add(&shard->free_estimate, -1);
   }
 }
 
 static void gc_mdtab(mdtab_shard* shard) {
   GPR_TIMER_SCOPE("gc_mdtab", 0);
-
-  size_t i;
-  interned_metadata** prev_next;
-  interned_metadata *md, *next;
-  gpr_atm num_freed = 0;
-
-  for (i = 0; i < shard->capacity; i++) {
-    prev_next = &shard->elems[i];
-    for (md = shard->elems[i]; md; md = next) {
-      void* user_data = (void*)gpr_atm_no_barrier_load(&md->user_data);
-      next = md->bucket_next;
-      if (gpr_atm_acq_load(&md->refcnt) == 0) {
-        grpc_slice_unref_internal(md->key);
-        grpc_slice_unref_internal(md->value);
-        if (md->user_data) {
-          ((destroy_user_data_func)gpr_atm_no_barrier_load(
-              &md->destroy_user_data))(user_data);
-        }
-        gpr_free(md);
-        *prev_next = next;
-        num_freed++;
-        shard->count--;
-      } else {
-        prev_next = &md->bucket_next;
-      }
-    }
+  size_t num_freed = 0;
+  for (size_t i = 0; i < shard->capacity; ++i) {
+    intptr_t freed = InternedMetadata::CleanupLinkedMetadata(&shard->elems[i]);
+    num_freed += freed;
+    shard->count -= freed;
   }
-  gpr_atm_no_barrier_fetch_add(&shard->free_estimate, -num_freed);
+  gpr_atm_no_barrier_fetch_add(&shard->free_estimate,
+                               -static_cast<intptr_t>(num_freed));
 }
 
 static void grow_mdtab(mdtab_shard* shard) {
@@ -204,22 +310,21 @@ static void grow_mdtab(mdtab_shard* shard) {
 
   size_t capacity = shard->capacity * 2;
   size_t i;
-  interned_metadata** mdtab;
-  interned_metadata *md, *next;
+  InternedMetadata::BucketLink* mdtab;
+  InternedMetadata *md, *next;
   uint32_t hash;
 
-  mdtab = static_cast<interned_metadata**>(
-      gpr_zalloc(sizeof(interned_metadata*) * capacity));
+  mdtab = static_cast<InternedMetadata::BucketLink*>(
+      gpr_zalloc(sizeof(InternedMetadata::BucketLink) * capacity));
 
   for (i = 0; i < shard->capacity; i++) {
-    for (md = shard->elems[i]; md; md = next) {
+    for (md = shard->elems[i].next; md; md = next) {
       size_t idx;
-      hash = GRPC_MDSTR_KV_HASH(grpc_slice_hash(md->key),
-                                grpc_slice_hash(md->value));
-      next = md->bucket_next;
+      hash = md->hash();
+      next = md->bucket_next();
       idx = TABLE_IDX(hash, capacity);
-      md->bucket_next = mdtab[idx];
-      mdtab[idx] = md;
+      md->set_bucket_next(mdtab[idx].next);
+      mdtab[idx].next = md;
     }
   }
   gpr_free(shard->elems);
@@ -236,46 +341,100 @@ static void rehash_mdtab(mdtab_shard* shard) {
   }
 }
 
-grpc_mdelem grpc_mdelem_create(
-    grpc_slice key, grpc_slice value,
+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) {
-  if (!grpc_slice_is_interned(key) || !grpc_slice_is_interned(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));
+  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 (!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 key_definitely_static
+                 ? GRPC_MAKE_MDELEM(
+                       new AllocatedMetadata(
+                           key, value,
+                           static_cast<const AllocatedMetadata::NoRefKey*>(
+                               nullptr)),
+                       GRPC_MDELEM_STORAGE_ALLOCATED)
+                 : GRPC_MAKE_MDELEM(new AllocatedMetadata(key, value),
+                                    GRPC_MDELEM_STORAGE_ALLOCATED);
     }
-
-    allocated_metadata* allocated =
-        static_cast<allocated_metadata*>(gpr_malloc(sizeof(*allocated)));
-    allocated->key = grpc_slice_ref_internal(key);
-    allocated->value = grpc_slice_ref_internal(value);
-    gpr_atm_rel_store(&allocated->refcnt, 1);
-#ifndef NDEBUG
-    if (grpc_trace_metadata.enabled()) {
-      char* key_str = grpc_slice_to_c_string(allocated->key);
-      char* value_str = grpc_slice_to_c_string(allocated->value);
-      gpr_log(GPR_DEBUG, "ELM ALLOC:%p:%" PRIdPTR ": '%s' = '%s'",
-              (void*)allocated, gpr_atm_no_barrier_load(&allocated->refcnt),
-              key_str, value_str);
-      gpr_free(key_str);
-      gpr_free(value_str);
-    }
-#endif
-    return GRPC_MAKE_MDELEM(allocated, GRPC_MDELEM_STORAGE_ALLOCATED);
   }
+  return md_create_maybe_static<key_definitely_static, value_definitely_static>(
+      key, value);
+}
 
-  if (GRPC_IS_STATIC_METADATA_STRING(key) &&
-      GRPC_IS_STATIC_METADATA_STRING(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.
+  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(key), grpc_slice_hash(value));
-  interned_metadata* md;
+  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;
 
@@ -285,34 +444,22 @@ grpc_mdelem grpc_mdelem_create(
 
   idx = TABLE_IDX(hash, shard->capacity);
   /* search for an existing pair */
-  for (md = shard->elems[idx]; md; md = md->bucket_next) {
-    if (grpc_slice_eq(key, md->key) && grpc_slice_eq(value, md->value)) {
-      REF_MD_LOCKED(shard, md);
+  for (md = shard->elems[idx].next; md; md = md->bucket_next()) {
+    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);
     }
   }
 
   /* not found: create a new pair */
-  md = static_cast<interned_metadata*>(gpr_malloc(sizeof(interned_metadata)));
-  gpr_atm_rel_store(&md->refcnt, 1);
-  md->key = grpc_slice_ref_internal(key);
-  md->value = grpc_slice_ref_internal(value);
-  md->user_data = 0;
-  md->destroy_user_data = 0;
-  md->bucket_next = shard->elems[idx];
-  shard->elems[idx] = md;
-  gpr_mu_init(&md->mu_user_data);
-#ifndef NDEBUG
-  if (grpc_trace_metadata.enabled()) {
-    char* key_str = grpc_slice_to_c_string(md->key);
-    char* value_str = grpc_slice_to_c_string(md->value);
-    gpr_log(GPR_DEBUG, "ELM   NEW:%p:%" PRIdPTR ": '%s' = '%s'", (void*)md,
-            gpr_atm_no_barrier_load(&md->refcnt), key_str, value_str);
-    gpr_free(key_str);
-    gpr_free(value_str);
-  }
-#endif
+  md = key_definitely_static
+           ? new InternedMetadata(
+                 key, value, hash, shard->elems[idx].next,
+                 static_cast<const InternedMetadata::NoRefKey*>(nullptr))
+           : new InternedMetadata(key, value, hash, shard->elems[idx].next);
+  shard->elems[idx].next = md;
   shard->count++;
 
   if (shard->count > shard->capacity * 2) {
@@ -324,8 +471,68 @@ grpc_mdelem grpc_mdelem_create(
   return GRPC_MAKE_MDELEM(md, GRPC_MDELEM_STORAGE_INTERNED);
 }
 
-grpc_mdelem grpc_mdelem_from_slices(grpc_slice key, grpc_slice value) {
-  grpc_mdelem out = grpc_mdelem_create(key, value, nullptr);
+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) {
+  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;
@@ -342,198 +549,131 @@ grpc_mdelem grpc_mdelem_from_grpc_metadata(grpc_metadata* metadata) {
       changed ? nullptr : reinterpret_cast<grpc_mdelem_data*>(metadata));
 }
 
-static size_t get_base64_encoded_size(size_t raw_length) {
-  static const uint8_t tail_xtra[3] = {0, 2, 3};
-  return raw_length / 3 * 4 + tail_xtra[raw_length % 3];
-}
-
-size_t grpc_mdelem_get_size_in_hpack_table(grpc_mdelem elem,
-                                           bool use_true_binary_metadata) {
-  size_t overhead_and_key = 32 + GRPC_SLICE_LENGTH(GRPC_MDKEY(elem));
-  size_t value_len = GRPC_SLICE_LENGTH(GRPC_MDVALUE(elem));
-  if (grpc_is_binary_header(GRPC_MDKEY(elem))) {
-    return overhead_and_key + (use_true_binary_metadata
-                                   ? value_len + 1
-                                   : get_base64_encoded_size(value_len));
+static void* get_user_data(UserData* user_data, void (*destroy_func)(void*)) {
+  if (user_data->destroy_user_data.Load(grpc_core::MemoryOrder::ACQUIRE) ==
+      destroy_func) {
+    return user_data->data.Load(grpc_core::MemoryOrder::RELAXED);
   } else {
-    return overhead_and_key + value_len;
+    return nullptr;
   }
 }
 
-grpc_mdelem grpc_mdelem_ref(grpc_mdelem gmd DEBUG_ARGS) {
-  switch (GRPC_MDELEM_STORAGE(gmd)) {
+void* grpc_mdelem_get_user_data(grpc_mdelem md, void (*destroy_func)(void*)) {
+  switch (GRPC_MDELEM_STORAGE(md)) {
     case GRPC_MDELEM_STORAGE_EXTERNAL:
+      return nullptr;
     case GRPC_MDELEM_STORAGE_STATIC:
-      break;
+      return reinterpret_cast<void*>(
+          grpc_static_mdelem_user_data
+              [reinterpret_cast<grpc_core::StaticMetadata*>(
+                   GRPC_MDELEM_DATA(md)) -
+               grpc_static_mdelem_table()]);
+    case GRPC_MDELEM_STORAGE_ALLOCATED: {
+      auto* am = reinterpret_cast<AllocatedMetadata*>(GRPC_MDELEM_DATA(md));
+      return get_user_data(am->user_data(), destroy_func);
+    }
     case GRPC_MDELEM_STORAGE_INTERNED: {
-      interned_metadata* md =
-          reinterpret_cast<interned_metadata*> GRPC_MDELEM_DATA(gmd);
-#ifndef NDEBUG
-      if (grpc_trace_metadata.enabled()) {
-        char* key_str = grpc_slice_to_c_string(md->key);
-        char* value_str = grpc_slice_to_c_string(md->value);
-        gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
-                "ELM   REF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'",
-                (void*)md, gpr_atm_no_barrier_load(&md->refcnt),
-                gpr_atm_no_barrier_load(&md->refcnt) + 1, key_str, value_str);
-        gpr_free(key_str);
-        gpr_free(value_str);
-      }
-#endif
-      /* we can assume the ref count is >= 1 as the application is calling
-         this function - meaning that no adjustment to mdtab_free is necessary,
-         simplifying the logic here to be just an atomic increment */
-      /* use C assert to have this removed in opt builds */
-      GPR_ASSERT(gpr_atm_no_barrier_load(&md->refcnt) >= 1);
-      gpr_atm_no_barrier_fetch_add(&md->refcnt, 1);
-      break;
+      auto* im = reinterpret_cast<InternedMetadata*> GRPC_MDELEM_DATA(md);
+      return get_user_data(im->user_data(), destroy_func);
     }
+  }
+  GPR_UNREACHABLE_CODE(return nullptr);
+}
+
+static void* set_user_data(UserData* ud, void (*destroy_func)(void*),
+                           void* data) {
+  GPR_ASSERT((data == nullptr) == (destroy_func == nullptr));
+  grpc_core::ReleasableMutexLock lock(&ud->mu_user_data);
+  if (ud->destroy_user_data.Load(grpc_core::MemoryOrder::RELAXED)) {
+    /* user data can only be set once */
+    lock.Unlock();
+    if (destroy_func != nullptr) {
+      destroy_func(data);
+    }
+    return ud->data.Load(grpc_core::MemoryOrder::RELAXED);
+  }
+  ud->data.Store(data, grpc_core::MemoryOrder::RELAXED);
+  ud->destroy_user_data.Store(destroy_func, grpc_core::MemoryOrder::RELEASE);
+  return data;
+}
+
+void* grpc_mdelem_set_user_data(grpc_mdelem md, void (*destroy_func)(void*),
+                                void* data) {
+  switch (GRPC_MDELEM_STORAGE(md)) {
+    case GRPC_MDELEM_STORAGE_EXTERNAL:
+      destroy_func(data);
+      return nullptr;
+    case GRPC_MDELEM_STORAGE_STATIC:
+      destroy_func(data);
+      return reinterpret_cast<void*>(
+          grpc_static_mdelem_user_data
+              [reinterpret_cast<grpc_core::StaticMetadata*>(
+                   GRPC_MDELEM_DATA(md)) -
+               grpc_static_mdelem_table()]);
     case GRPC_MDELEM_STORAGE_ALLOCATED: {
-      allocated_metadata* md =
-          reinterpret_cast<allocated_metadata*> GRPC_MDELEM_DATA(gmd);
-#ifndef NDEBUG
-      if (grpc_trace_metadata.enabled()) {
-        char* key_str = grpc_slice_to_c_string(md->key);
-        char* value_str = grpc_slice_to_c_string(md->value);
-        gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
-                "ELM   REF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'",
-                (void*)md, gpr_atm_no_barrier_load(&md->refcnt),
-                gpr_atm_no_barrier_load(&md->refcnt) + 1, key_str, value_str);
-        gpr_free(key_str);
-        gpr_free(value_str);
-      }
-#endif
-      /* we can assume the ref count is >= 1 as the application is calling
-         this function - meaning that no adjustment to mdtab_free is necessary,
-         simplifying the logic here to be just an atomic increment */
-      /* use C assert to have this removed in opt builds */
-      gpr_atm_no_barrier_fetch_add(&md->refcnt, 1);
-      break;
+      auto* am = reinterpret_cast<AllocatedMetadata*>(GRPC_MDELEM_DATA(md));
+      return set_user_data(am->user_data(), destroy_func, data);
+    }
+    case GRPC_MDELEM_STORAGE_INTERNED: {
+      auto* im = reinterpret_cast<InternedMetadata*> GRPC_MDELEM_DATA(md);
+      GPR_DEBUG_ASSERT(!is_mdelem_static(md));
+      return set_user_data(im->user_data(), destroy_func, data);
     }
   }
-  return gmd;
+  GPR_UNREACHABLE_CODE(return nullptr);
 }
 
-void grpc_mdelem_unref(grpc_mdelem gmd DEBUG_ARGS) {
+bool grpc_mdelem_eq(grpc_mdelem a, grpc_mdelem b) {
+  if (a.payload == b.payload) return true;
+  if (GRPC_MDELEM_IS_INTERNED(a) && GRPC_MDELEM_IS_INTERNED(b)) return false;
+  if (GRPC_MDISNULL(a) || GRPC_MDISNULL(b)) return false;
+  return grpc_slice_eq(GRPC_MDKEY(a), GRPC_MDKEY(b)) &&
+         grpc_slice_eq(GRPC_MDVALUE(a), GRPC_MDVALUE(b));
+}
+
+static void note_disposed_interned_metadata(uint32_t hash) {
+  mdtab_shard* shard = &g_shards[SHARD_IDX(hash)];
+  gpr_atm_no_barrier_fetch_add(&shard->free_estimate, 1);
+}
+
+void grpc_mdelem_do_unref(grpc_mdelem gmd DEBUG_ARGS) {
   switch (GRPC_MDELEM_STORAGE(gmd)) {
     case GRPC_MDELEM_STORAGE_EXTERNAL:
     case GRPC_MDELEM_STORAGE_STATIC:
-      break;
+      return;
     case GRPC_MDELEM_STORAGE_INTERNED: {
-      interned_metadata* md =
-          reinterpret_cast<interned_metadata*> GRPC_MDELEM_DATA(gmd);
-#ifndef NDEBUG
-      if (grpc_trace_metadata.enabled()) {
-        char* key_str = grpc_slice_to_c_string(md->key);
-        char* value_str = grpc_slice_to_c_string(md->value);
-        gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
-                "ELM UNREF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'",
-                (void*)md, gpr_atm_no_barrier_load(&md->refcnt),
-                gpr_atm_no_barrier_load(&md->refcnt) - 1, key_str, value_str);
-        gpr_free(key_str);
-        gpr_free(value_str);
-      }
-#endif
-      uint32_t hash = GRPC_MDSTR_KV_HASH(grpc_slice_hash(md->key),
-                                         grpc_slice_hash(md->value));
-      const gpr_atm prev_refcount = gpr_atm_full_fetch_add(&md->refcnt, -1);
-      GPR_ASSERT(prev_refcount >= 1);
-      if (1 == prev_refcount) {
+      auto* md = reinterpret_cast<InternedMetadata*> GRPC_MDELEM_DATA(gmd);
+      uint32_t hash = md->hash();
+      if (GPR_UNLIKELY(md->Unref(FWD_DEBUG_ARGS))) {
         /* once the refcount hits zero, some other thread can come along and
            free md at any time: it's unsafe from this point on to access it */
-        mdtab_shard* shard = &g_shards[SHARD_IDX(hash)];
-        gpr_atm_no_barrier_fetch_add(&shard->free_estimate, 1);
+        note_disposed_interned_metadata(hash);
       }
       break;
     }
     case GRPC_MDELEM_STORAGE_ALLOCATED: {
-      allocated_metadata* md =
-          reinterpret_cast<allocated_metadata*> GRPC_MDELEM_DATA(gmd);
-#ifndef NDEBUG
-      if (grpc_trace_metadata.enabled()) {
-        char* key_str = grpc_slice_to_c_string(md->key);
-        char* value_str = grpc_slice_to_c_string(md->value);
-        gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
-                "ELM UNREF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'",
-                (void*)md, gpr_atm_no_barrier_load(&md->refcnt),
-                gpr_atm_no_barrier_load(&md->refcnt) - 1, key_str, value_str);
-        gpr_free(key_str);
-        gpr_free(value_str);
-      }
-#endif
-      const gpr_atm prev_refcount = gpr_atm_full_fetch_add(&md->refcnt, -1);
-      GPR_ASSERT(prev_refcount >= 1);
-      if (1 == prev_refcount) {
-        grpc_slice_unref_internal(md->key);
-        grpc_slice_unref_internal(md->value);
-        gpr_free(md);
+      auto* md = reinterpret_cast<AllocatedMetadata*> GRPC_MDELEM_DATA(gmd);
+      if (GPR_UNLIKELY(md->Unref(FWD_DEBUG_ARGS))) {
+        delete md;
       }
       break;
     }
   }
 }
 
-void* grpc_mdelem_get_user_data(grpc_mdelem md, void (*destroy_func)(void*)) {
-  switch (GRPC_MDELEM_STORAGE(md)) {
+void grpc_mdelem_on_final_unref(grpc_mdelem_data_storage storage, void* ptr,
+                                uint32_t hash DEBUG_ARGS) {
+  switch (storage) {
     case GRPC_MDELEM_STORAGE_EXTERNAL:
-    case GRPC_MDELEM_STORAGE_ALLOCATED:
-      return nullptr;
     case GRPC_MDELEM_STORAGE_STATIC:
-      return (void*)grpc_static_mdelem_user_data[GRPC_MDELEM_DATA(md) -
-                                                 grpc_static_mdelem_table];
+      return;
     case GRPC_MDELEM_STORAGE_INTERNED: {
-      interned_metadata* im =
-          reinterpret_cast<interned_metadata*> GRPC_MDELEM_DATA(md);
-      void* result;
-      if (gpr_atm_acq_load(&im->destroy_user_data) == (gpr_atm)destroy_func) {
-        return (void*)gpr_atm_no_barrier_load(&im->user_data);
-      } else {
-        return nullptr;
-      }
-      return result;
+      note_disposed_interned_metadata(hash);
+      break;
     }
-  }
-  GPR_UNREACHABLE_CODE(return nullptr);
-}
-
-void* grpc_mdelem_set_user_data(grpc_mdelem md, void (*destroy_func)(void*),
-                                void* user_data) {
-  switch (GRPC_MDELEM_STORAGE(md)) {
-    case GRPC_MDELEM_STORAGE_EXTERNAL:
-    case GRPC_MDELEM_STORAGE_ALLOCATED:
-      destroy_func(user_data);
-      return nullptr;
-    case GRPC_MDELEM_STORAGE_STATIC:
-      destroy_func(user_data);
-      return (void*)grpc_static_mdelem_user_data[GRPC_MDELEM_DATA(md) -
-                                                 grpc_static_mdelem_table];
-    case GRPC_MDELEM_STORAGE_INTERNED: {
-      interned_metadata* im =
-          reinterpret_cast<interned_metadata*> GRPC_MDELEM_DATA(md);
-      GPR_ASSERT(!is_mdelem_static(md));
-      GPR_ASSERT((user_data == nullptr) == (destroy_func == nullptr));
-      gpr_mu_lock(&im->mu_user_data);
-      if (gpr_atm_no_barrier_load(&im->destroy_user_data)) {
-        /* user data can only be set once */
-        gpr_mu_unlock(&im->mu_user_data);
-        if (destroy_func != nullptr) {
-          destroy_func(user_data);
-        }
-        return (void*)gpr_atm_no_barrier_load(&im->user_data);
-      }
-      gpr_atm_no_barrier_store(&im->user_data, (gpr_atm)user_data);
-      gpr_atm_rel_store(&im->destroy_user_data, (gpr_atm)destroy_func);
-      gpr_mu_unlock(&im->mu_user_data);
-      return user_data;
+    case GRPC_MDELEM_STORAGE_ALLOCATED: {
+      delete reinterpret_cast<AllocatedMetadata*>(ptr);
+      break;
     }
   }
-  GPR_UNREACHABLE_CODE(return nullptr);
-}
-
-bool grpc_mdelem_eq(grpc_mdelem a, grpc_mdelem b) {
-  if (a.payload == b.payload) return true;
-  if (GRPC_MDELEM_IS_INTERNED(a) && GRPC_MDELEM_IS_INTERNED(b)) return false;
-  if (GRPC_MDISNULL(a) || GRPC_MDISNULL(b)) return false;
-  return grpc_slice_eq(GRPC_MDKEY(a), GRPC_MDKEY(b)) &&
-         grpc_slice_eq(GRPC_MDVALUE(a), GRPC_MDVALUE(b));
 }