grpc 1.33.0.pre1 → 1.37.0.pre1

data/src/core/lib/gpr/useful.h

@@ -33,8 +33,8 @@
 #define GPR_SWAP(type, a, b) \
   do {                       \
     type x = a;              \
-    a = b;                   \
-    b = x;                   \
+    (a) = b;                 \
+    (b) = x;                 \
   } while (0)
 
 /** Set the \a n-th bit of \a i (a mutable pointer). */
@@ -59,7 +59,8 @@
 
 #define GPR_ICMP(a, b) ((a) < (b) ? -1 : ((a) > (b) ? 1 : 0))
 
-#define GPR_HASH_POINTER(x, range) \
-  ((((size_t)x) >> 4) ^ (((size_t)x) >> 9) ^ (((size_t)x) >> 14)) % (range)
+#define GPR_HASH_POINTER(x, range)                                         \
+  (((((size_t)(x)) >> 4) ^ (((size_t)(x)) >> 9) ^ (((size_t)(x)) >> 14)) % \
+   (range))
 
 #endif /* GRPC_CORE_LIB_GPR_USEFUL_H */

data/src/core/lib/gprpp/arena.h

@@ -96,7 +96,8 @@ class Arena {
   //   where we wish to create an arena and then perform an immediate
   //   allocation.
   explicit Arena(size_t initial_size, size_t initial_alloc = 0)
-      : total_used_(initial_alloc), initial_zone_size_(initial_size) {}
+      : total_used_(GPR_ROUND_UP_TO_ALIGNMENT_SIZE(initial_alloc)),
+        initial_zone_size_(initial_size) {}
 
   ~Arena();
 
@@ -105,7 +106,7 @@ class Arena {
   // Keep track of the total used size. We use this in our call sizing
   // hysteresis.
   Atomic<size_t> total_used_;
-  size_t initial_zone_size_;
+  const size_t initial_zone_size_;
   gpr_spinlock arena_growth_spinlock_ = GPR_SPINLOCK_STATIC_INITIALIZER;
   // If the initial arena allocation wasn't enough, we allocate additional zones
   // in a reverse linked list. Each additional zone consists of (1) a pointer to

data/src/core/lib/gprpp/atomic.h

@@ -81,8 +81,8 @@ class Atomic {
 
   // Atomically increment a counter only if the counter value is not zero.
   // Returns true if increment took place; false if counter is zero.
-  bool IncrementIfNonzero(MemoryOrder load_order = MemoryOrder::ACQUIRE) {
-    T count = storage_.load(static_cast<std::memory_order>(load_order));
+  bool IncrementIfNonzero() {
+    T count = storage_.load(std::memory_order_acquire);
     do {
       // If zero, we are done (without an increment). If not, we must do a CAS
       // to maintain the contract: do not increment the counter if it is already
@@ -91,7 +91,7 @@ class Atomic {
         return false;
       }
     } while (!CompareExchangeWeak(&count, count + 1, MemoryOrder::ACQ_REL,
-                                  load_order));
+                                  MemoryOrder::ACQUIRE));
     return true;
   }
 

data/src/core/lib/gprpp/dual_ref_counted.h

@@ -27,7 +27,6 @@
 #include <cassert>
 #include <cinttypes>
 
-#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/atomic.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/orphanable.h"
@@ -52,7 +51,7 @@ namespace grpc_core {
 template <typename Child>
 class DualRefCounted : public Orphanable {
  public:
-  virtual ~DualRefCounted() = default;
+  ~DualRefCounted() override = default;
 
   RefCountedPtr<Child> Ref() GRPC_MUST_USE_RESULT {
     IncrementRefCount();
@@ -72,10 +71,9 @@ class DualRefCounted : public Orphanable {
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
 #ifndef NDEBUG
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
-      gpr_log(GPR_INFO, "%s:%p unref %d -> %d, weak_ref %d -> %d",
-              trace_flag_->name(), this, strong_refs, strong_refs - 1,
-              weak_refs, weak_refs + 1);
+    if (trace_ != nullptr) {
+      gpr_log(GPR_INFO, "%s:%p unref %d -> %d, weak_ref %d -> %d", trace_, this,
+              strong_refs, strong_refs - 1, weak_refs, weak_refs + 1);
     }
     GPR_ASSERT(strong_refs > 0);
 #endif
@@ -91,10 +89,10 @@ class DualRefCounted : public Orphanable {
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
 #ifndef NDEBUG
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
+    if (trace_ != nullptr) {
       gpr_log(GPR_INFO, "%s:%p %s:%d unref %d -> %d, weak_ref %d -> %d) %s",
-              trace_flag_->name(), this, location.file(), location.line(),
-              strong_refs, strong_refs - 1, weak_refs, weak_refs + 1, reason);
+              trace_, this, location.file(), location.line(), strong_refs,
+              strong_refs - 1, weak_refs, weak_refs + 1, reason);
     }
     GPR_ASSERT(strong_refs > 0);
 #else
@@ -115,10 +113,9 @@ class DualRefCounted : public Orphanable {
       const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
 #ifndef NDEBUG
       const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
-      if (trace_flag_ != nullptr && trace_flag_->enabled()) {
+      if (trace_ != nullptr) {
         gpr_log(GPR_INFO, "%s:%p ref_if_non_zero %d -> %d (weak_refs=%d)",
-                trace_flag_->name(), this, strong_refs, strong_refs + 1,
-                weak_refs);
+                trace_, this, strong_refs, strong_refs + 1, weak_refs);
       }
 #endif
       if (strong_refs == 0) return nullptr;
@@ -135,11 +132,11 @@ class DualRefCounted : public Orphanable {
       const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
 #ifndef NDEBUG
       const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
-      if (trace_flag_ != nullptr && trace_flag_->enabled()) {
+      if (trace_ != nullptr) {
         gpr_log(GPR_INFO,
                 "%s:%p %s:%d ref_if_non_zero %d -> %d (weak_refs=%d) %s",
-                trace_flag_->name(), this, location.file(), location.line(),
-                strong_refs, strong_refs + 1, weak_refs, reason);
+                trace_, this, location.file(), location.line(), strong_refs,
+                strong_refs + 1, weak_refs, reason);
       }
 #else
       // Avoid unused-parameter warnings for debug-only parameters
@@ -167,17 +164,18 @@ class DualRefCounted : public Orphanable {
   void WeakUnref() {
 #ifndef NDEBUG
     // Grab a copy of the trace flag before the atomic change, since we
-    // can't safely access it afterwards if we're going to be freed.
-    auto* trace_flag = trace_flag_;
+    // will no longer be holding a ref afterwards and therefore can't
+    // safely access it, since another thread might free us in the interim.
+    const char* trace = trace_;
 #endif
     const uint64_t prev_ref_pair =
         refs_.FetchSub(MakeRefPair(0, 1), MemoryOrder::ACQ_REL);
-    const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
 #ifndef NDEBUG
+    const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
-    if (trace_flag != nullptr && trace_flag->enabled()) {
-      gpr_log(GPR_INFO, "%s:%p weak_unref %d -> %d (refs=%d)",
-              trace_flag->name(), this, weak_refs, weak_refs - 1, strong_refs);
+    if (trace != nullptr) {
+      gpr_log(GPR_INFO, "%s:%p weak_unref %d -> %d (refs=%d)", trace, this,
+              weak_refs, weak_refs - 1, strong_refs);
     }
     GPR_ASSERT(weak_refs > 0);
 #endif
@@ -188,18 +186,19 @@ class DualRefCounted : public Orphanable {
   void WeakUnref(const DebugLocation& location, const char* reason) {
 #ifndef NDEBUG
     // Grab a copy of the trace flag before the atomic change, since we
-    // can't safely access it afterwards if we're going to be freed.
-    auto* trace_flag = trace_flag_;
+    // will no longer be holding a ref afterwards and therefore can't
+    // safely access it, since another thread might free us in the interim.
+    const char* trace = trace_;
 #endif
     const uint64_t prev_ref_pair =
         refs_.FetchSub(MakeRefPair(0, 1), MemoryOrder::ACQ_REL);
-    const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
 #ifndef NDEBUG
+    const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
-    if (trace_flag != nullptr && trace_flag->enabled()) {
-      gpr_log(GPR_INFO, "%s:%p %s:%d weak_unref %d -> %d (refs=%d) %s",
-              trace_flag->name(), this, location.file(), location.line(),
-              weak_refs, weak_refs - 1, strong_refs, reason);
+    if (trace != nullptr) {
+      gpr_log(GPR_INFO, "%s:%p %s:%d weak_unref %d -> %d (refs=%d) %s", trace,
+              this, location.file(), location.line(), weak_refs, weak_refs - 1,
+              strong_refs, reason);
     }
     GPR_ASSERT(weak_refs > 0);
 #else
@@ -217,21 +216,18 @@ class DualRefCounted : public Orphanable {
   DualRefCounted& operator=(const DualRefCounted&) = delete;
 
  protected:
-  // TraceFlagT is defined to accept both DebugOnlyTraceFlag and TraceFlag.
-  // Note: RefCount tracing is only enabled on debug builds, even when a
-  //       TraceFlag is used.
-  template <typename TraceFlagT = TraceFlag>
+  // Note: Tracing is a no-op in non-debug builds.
   explicit DualRefCounted(
-      TraceFlagT*
+      const char*
 #ifndef NDEBUG
           // Leave unnamed if NDEBUG to avoid unused parameter warning
-          trace_flag
+          trace
 #endif
       = nullptr,
       int32_t initial_refcount = 1)
       :
 #ifndef NDEBUG
-        trace_flag_(trace_flag),
+        trace_(trace),
 #endif
         refs_(MakeRefPair(initial_refcount, 0)) {
   }
@@ -262,10 +258,9 @@ class DualRefCounted : public Orphanable {
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
     GPR_ASSERT(strong_refs != 0);
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
-      gpr_log(GPR_INFO, "%s:%p ref %d -> %d; (weak_refs=%d)",
-              trace_flag_->name(), this, strong_refs, strong_refs + 1,
-              weak_refs);
+    if (trace_ != nullptr) {
+      gpr_log(GPR_INFO, "%s:%p ref %d -> %d; (weak_refs=%d)", trace_, this,
+              strong_refs, strong_refs + 1, weak_refs);
     }
 #else
     refs_.FetchAdd(MakeRefPair(1, 0), MemoryOrder::RELAXED);
@@ -278,10 +273,10 @@ class DualRefCounted : public Orphanable {
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
     GPR_ASSERT(strong_refs != 0);
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
-      gpr_log(GPR_INFO, "%s:%p %s:%d ref %d -> %d (weak_refs=%d) %s",
-              trace_flag_->name(), this, location.file(), location.line(),
-              strong_refs, strong_refs + 1, weak_refs, reason);
+    if (trace_ != nullptr) {
+      gpr_log(GPR_INFO, "%s:%p %s:%d ref %d -> %d (weak_refs=%d) %s", trace_,
+              this, location.file(), location.line(), strong_refs,
+              strong_refs + 1, weak_refs, reason);
     }
 #else
     // Use conditionally-important parameters
@@ -297,9 +292,9 @@ class DualRefCounted : public Orphanable {
         refs_.FetchAdd(MakeRefPair(0, 1), MemoryOrder::RELAXED);
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
-      gpr_log(GPR_INFO, "%s:%p weak_ref %d -> %d; (refs=%d)",
-              trace_flag_->name(), this, weak_refs, weak_refs + 1, strong_refs);
+    if (trace_ != nullptr) {
+      gpr_log(GPR_INFO, "%s:%p weak_ref %d -> %d; (refs=%d)", trace_, this,
+              weak_refs, weak_refs + 1, strong_refs);
     }
 #else
     refs_.FetchAdd(MakeRefPair(0, 1), MemoryOrder::RELAXED);
@@ -312,10 +307,10 @@ class DualRefCounted : public Orphanable {
         refs_.FetchAdd(MakeRefPair(0, 1), MemoryOrder::RELAXED);
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
-      gpr_log(GPR_INFO, "%s:%p %s:%d weak_ref %d -> %d (refs=%d) %s",
-              trace_flag_->name(), this, location.file(), location.line(),
-              weak_refs, weak_refs + 1, strong_refs, reason);
+    if (trace_ != nullptr) {
+      gpr_log(GPR_INFO, "%s:%p %s:%d weak_ref %d -> %d (refs=%d) %s", trace_,
+              this, location.file(), location.line(), weak_refs, weak_refs + 1,
+              strong_refs, reason);
     }
 #else
     // Use conditionally-important parameters
@@ -326,7 +321,7 @@ class DualRefCounted : public Orphanable {
   }
 
 #ifndef NDEBUG
-  TraceFlag* trace_flag_;
+  const char* trace_;
 #endif
   Atomic<uint64_t> refs_;
 };

data/src/core/lib/gprpp/examine_stack.cc

@@ -0,0 +1,43 @@
+/*
+ *
+ * Copyright 2020 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/gprpp/examine_stack.h"
+
+namespace grpc_core {
+
+gpr_current_stack_trace_func g_current_stack_trace_provider = nullptr;
+
+gpr_current_stack_trace_func GetCurrentStackTraceProvider() {
+  return g_current_stack_trace_provider;
+}
+
+void SetCurrentStackTraceProvider(
+    gpr_current_stack_trace_func current_stack_trace_provider) {
+  g_current_stack_trace_provider = current_stack_trace_provider;
+}
+
+absl::optional<std::string> GetCurrentStackTrace() {
+  if (g_current_stack_trace_provider != nullptr) {
+    return g_current_stack_trace_provider();
+  }
+  return absl::nullopt;
+}
+
+}  // namespace grpc_core

data/src/core/lib/gprpp/examine_stack.h

@@ -0,0 +1,46 @@
+/*
+ *
+ * Copyright 2020 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef GRPC_CORE_LIB_GPRPP_EXAMINE_STACK_H
+#define GRPC_CORE_LIB_GPRPP_EXAMINE_STACK_H
+
+#include <grpc/support/port_platform.h>
+
+#include <functional>
+#include <string>
+
+#include "absl/types/optional.h"
+
+namespace grpc_core {
+
+typedef std::string (*gpr_current_stack_trace_func)();
+
+// Returns a current_stack_trace_provider.
+gpr_current_stack_trace_func GetCurrentStackTraceProvider();
+
+// Sets current_stack_trace_provider which provides a current-stack trace.
+void SetCurrentStackTraceProvider(
+    gpr_current_stack_trace_func current_stack_trace_provider);
+
+// Returns the current stack trace as a string via current_stack_trace_provider
+// If current_stack_trace_provider is not set, it returns absl::nullopt.
+absl::optional<std::string> GetCurrentStackTrace();
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_LIB_GPRPP_EXAMINE_STACK_H */

data/src/core/lib/gprpp/fork.cc

@@ -43,7 +43,7 @@
 
 GPR_GLOBAL_CONFIG_DEFINE_BOOL(grpc_enable_fork_support,
                               GRPC_ENABLE_FORK_SUPPORT_DEFAULT,
-                              "Enable folk support");
+                              "Enable fork support");
 
 namespace grpc_core {
 namespace internal {
@@ -54,7 +54,7 @@ namespace internal {
 // When blocked, the exec_ctx_count is 0-indexed.  Note that ExecCtx
 // creation can only be blocked if there is exactly 1 outstanding ExecCtx,
 // meaning that BLOCKED and UNBLOCKED counts partition the integers
-#define UNBLOCKED(n) (n + 2)
+#define UNBLOCKED(n) ((n) + 2)
 #define BLOCKED(n) (n)
 
 class ExecCtxState {

data/src/core/lib/gprpp/manual_constructor.h

@@ -145,7 +145,7 @@ class PolymorphicManualConstructor {
   }
   template <class DerivedType>
   void Init(DerivedType&& x) {
-    FinishInit(new (&space_) DerivedType(std::move(x)));
+    FinishInit(new (&space_) DerivedType(std::forward<DerivedType>(x)));
   }
 
   void Destroy() { get()->~BaseType(); }

data/src/core/lib/gprpp/mpscq.cc

@@ -86,9 +86,9 @@ bool LockedMultiProducerSingleConsumerQueue::Push(Node* node) {
 
 LockedMultiProducerSingleConsumerQueue::Node*
 LockedMultiProducerSingleConsumerQueue::TryPop() {
-  if (gpr_mu_trylock(mu_.get())) {
+  if (mu_.TryLock()) {
     Node* node = queue_.Pop();
-    gpr_mu_unlock(mu_.get());
+    mu_.Unlock();
     return node;
   }
   return nullptr;

data/src/core/lib/gprpp/orphanable.h

@@ -27,7 +27,6 @@
 #include <cinttypes>
 #include <memory>
 
-#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted.h"
@@ -85,14 +84,11 @@ class InternallyRefCounted : public Orphanable {
   template <typename T>
   friend class RefCountedPtr;
 
-  // TraceFlagT is defined to accept both DebugOnlyTraceFlag and TraceFlag.
-  // Note: RefCount tracing is only enabled on debug builds, even when a
-  //       TraceFlag is used.
-  template <typename TraceFlagT = TraceFlag>
-  explicit InternallyRefCounted(TraceFlagT* trace_flag = nullptr,
+  // Note: Tracing is a no-op on non-debug builds.
+  explicit InternallyRefCounted(const char* trace = nullptr,
                                 intptr_t initial_refcount = 1)
-      : refs_(initial_refcount, trace_flag) {}
-  virtual ~InternallyRefCounted() = default;
+      : refs_(initial_refcount, trace) {}
+  ~InternallyRefCounted() override = default;
 
   RefCountedPtr<Child> Ref() GRPC_MUST_USE_RESULT {
     IncrementRefCount();

data/src/core/lib/gprpp/ref_counted.h

@@ -29,7 +29,6 @@
 #include <cassert>
 #include <cinttypes>
 
-#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/atomic.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/memory.h"
@@ -51,21 +50,19 @@ class RefCount {
 
   // `init` is the initial refcount stored in this object.
   //
-  // TraceFlagT is defined to accept both DebugOnlyTraceFlag and TraceFlag.
-  // Note: RefCount tracing is only enabled on debug builds, even when a
-  //       TraceFlag is used.
-  template <typename TraceFlagT = TraceFlag>
-  constexpr explicit RefCount(
+  // `trace` is a string to be logged with trace events; if null, no
+  // trace logging will be done.  Tracing is a no-op in non-debug builds.
+  explicit RefCount(
       Value init = 1,
-      TraceFlagT*
+      const char*
 #ifndef NDEBUG
           // Leave unnamed if NDEBUG to avoid unused parameter warning
-          trace_flag
+          trace
 #endif
       = nullptr)
       :
 #ifndef NDEBUG
-        trace_flag_(trace_flag),
+        trace_(trace),
 #endif
         value_(init) {
   }
@@ -74,9 +71,9 @@ class RefCount {
   void Ref(Value n = 1) {
 #ifndef NDEBUG
     const Value prior = value_.FetchAdd(n, MemoryOrder::RELAXED);
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
-      gpr_log(GPR_INFO, "%s:%p ref %" PRIdPTR " -> %" PRIdPTR,
-              trace_flag_->name(), this, prior, prior + n);
+    if (trace_ != nullptr) {
+      gpr_log(GPR_INFO, "%s:%p ref %" PRIdPTR " -> %" PRIdPTR, trace_, this,
+              prior, prior + n);
     }
 #else
     value_.FetchAdd(n, MemoryOrder::RELAXED);
@@ -85,16 +82,15 @@ class RefCount {
   void Ref(const DebugLocation& location, const char* reason, Value n = 1) {
 #ifndef NDEBUG
     const Value prior = value_.FetchAdd(n, MemoryOrder::RELAXED);
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
+    if (trace_ != nullptr) {
       gpr_log(GPR_INFO, "%s:%p %s:%d ref %" PRIdPTR " -> %" PRIdPTR " %s",
-              trace_flag_->name(), this, location.file(), location.line(),
-              prior, prior + n, reason);
+              trace_, this, location.file(), location.line(), prior, prior + n,
+              reason);
     }
 #else
     // Use conditionally-important parameters
     (void)location;
     (void)reason;
-
     value_.FetchAdd(n, MemoryOrder::RELAXED);
 #endif
   }
@@ -103,9 +99,9 @@ class RefCount {
   void RefNonZero() {
 #ifndef NDEBUG
     const Value prior = value_.FetchAdd(1, MemoryOrder::RELAXED);
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
-      gpr_log(GPR_INFO, "%s:%p ref %" PRIdPTR " -> %" PRIdPTR,
-              trace_flag_->name(), this, prior, prior + 1);
+    if (trace_ != nullptr) {
+      gpr_log(GPR_INFO, "%s:%p ref %" PRIdPTR " -> %" PRIdPTR, trace_, this,
+              prior, prior + 1);
     }
     assert(prior > 0);
 #else
@@ -115,10 +111,10 @@ class RefCount {
   void RefNonZero(const DebugLocation& location, const char* reason) {
 #ifndef NDEBUG
     const Value prior = value_.FetchAdd(1, MemoryOrder::RELAXED);
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
+    if (trace_ != nullptr) {
       gpr_log(GPR_INFO, "%s:%p %s:%d ref %" PRIdPTR " -> %" PRIdPTR " %s",
-              trace_flag_->name(), this, location.file(), location.line(),
-              prior, prior + 1, reason);
+              trace_, this, location.file(), location.line(), prior, prior + 1,
+              reason);
     }
     assert(prior > 0);
 #else
@@ -131,23 +127,22 @@ class RefCount {
 
   bool RefIfNonZero() {
 #ifndef NDEBUG
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
+    if (trace_ != nullptr) {
       const Value prior = get();
       gpr_log(GPR_INFO, "%s:%p ref_if_non_zero %" PRIdPTR " -> %" PRIdPTR,
-              trace_flag_->name(), this, prior, prior + 1);
+              trace_, this, prior, prior + 1);
     }
 #endif
     return value_.IncrementIfNonzero();
   }
   bool RefIfNonZero(const DebugLocation& location, const char* reason) {
 #ifndef NDEBUG
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
+    if (trace_ != nullptr) {
       const Value prior = get();
       gpr_log(GPR_INFO,
-              "%s:%p %s:%d ref_if_non_zero "
-              "%" PRIdPTR " -> %" PRIdPTR " %s",
-              trace_flag_->name(), this, location.file(), location.line(),
-              prior, prior + 1, reason);
+              "%s:%p %s:%d ref_if_non_zero %" PRIdPTR " -> %" PRIdPTR " %s",
+              trace_, this, location.file(), location.line(), prior, prior + 1,
+              reason);
     }
 #endif
     // Avoid unused-parameter warnings for debug-only parameters
@@ -160,14 +155,15 @@ class RefCount {
   bool Unref() {
 #ifndef NDEBUG
     // Grab a copy of the trace flag before the atomic change, since we
-    // can't safely access it afterwards if we're going to be freed.
-    auto* trace_flag = trace_flag_;
+    // will no longer be holding a ref afterwards and therefore can't
+    // safely access it, since another thread might free us in the interim.
+    auto* trace = trace_;
 #endif
     const Value prior = value_.FetchSub(1, MemoryOrder::ACQ_REL);
 #ifndef NDEBUG
-    if (trace_flag != nullptr && trace_flag->enabled()) {
-      gpr_log(GPR_INFO, "%s:%p unref %" PRIdPTR " -> %" PRIdPTR,
-              trace_flag->name(), this, prior, prior - 1);
+    if (trace != nullptr) {
+      gpr_log(GPR_INFO, "%s:%p unref %" PRIdPTR " -> %" PRIdPTR, trace, this,
+              prior, prior - 1);
     }
     GPR_DEBUG_ASSERT(prior > 0);
 #endif
@@ -176,15 +172,16 @@ class RefCount {
   bool Unref(const DebugLocation& location, const char* reason) {
 #ifndef NDEBUG
     // Grab a copy of the trace flag before the atomic change, since we
-    // can't safely access it afterwards if we're going to be freed.
-    auto* trace_flag = trace_flag_;
+    // will no longer be holding a ref afterwards and therefore can't
+    // safely access it, since another thread might free us in the interim.
+    auto* trace = trace_;
 #endif
     const Value prior = value_.FetchSub(1, MemoryOrder::ACQ_REL);
 #ifndef NDEBUG
-    if (trace_flag != nullptr && trace_flag->enabled()) {
+    if (trace != nullptr) {
       gpr_log(GPR_INFO, "%s:%p %s:%d unref %" PRIdPTR " -> %" PRIdPTR " %s",
-              trace_flag->name(), this, location.file(), location.line(), prior,
-              prior - 1, reason);
+              trace, this, location.file(), location.line(), prior, prior - 1,
+              reason);
     }
     GPR_DEBUG_ASSERT(prior > 0);
 #else
@@ -199,7 +196,7 @@ class RefCount {
   Value get() const { return value_.Load(MemoryOrder::RELAXED); }
 
 #ifndef NDEBUG
-  TraceFlag* trace_flag_;
+  const char* trace_;
 #endif
   Atomic<Value> value_;
 };
@@ -224,12 +221,12 @@ class Delete;
 template <typename T>
 class Delete<T, true> {
  public:
-  Delete(T* t) { delete t; }
+  explicit Delete(T* t) { delete t; }
 };
 template <typename T>
 class Delete<T, false> {
  public:
-  Delete(T* t) {}
+  explicit Delete(T* /*t*/) {}
 };
 }  // namespace internal
 
@@ -315,13 +312,10 @@ class RefCounted : public Impl {
   RefCounted& operator=(const RefCounted&) = delete;
 
  protected:
-  // TraceFlagT is defined to accept both DebugOnlyTraceFlag and TraceFlag.
-  // Note: RefCount tracing is only enabled on debug builds, even when a
-  //       TraceFlag is used.
-  template <typename TraceFlagT = TraceFlag>
-  explicit RefCounted(TraceFlagT* trace_flag = nullptr,
+  // Note: Tracing is a no-op on non-debug builds.
+  explicit RefCounted(const char* trace = nullptr,
                       intptr_t initial_refcount = 1)
-      : refs_(initial_refcount, trace_flag) {}
+      : refs_(initial_refcount, trace) {}
 
  private:
   // Allow RefCountedPtr<> to access IncrementRefCount().