grpc 1.28.0 → 1.37.0

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

@@ -26,6 +26,8 @@
 #include <stdbool.h>
 #include <stddef.h>
 
+#include <string>
+
 /* String utility functions */
 
 /* Flags for gpr_dump function. */
@@ -43,8 +45,7 @@ char* gpr_dump_return_len(const char* buf, size_t len, uint32_t flags,
 
 /* Parses an array of bytes into an integer (base 10). Returns 1 on success,
    0 on failure. */
-int gpr_parse_bytes_to_uint32(const char* data, size_t length,
-                              uint32_t* result);
+int gpr_parse_bytes_to_uint32(const char* buf, size_t len, uint32_t* result);
 
 /* Minimum buffer size for calling ltoa */
 #define GPR_LTOA_MIN_BUFSIZE (3 * sizeof(long))
@@ -75,42 +76,26 @@ void gpr_reverse_bytes(char* str, int len);
 char* gpr_leftpad(const char* str, char flag, size_t length);
 
 /* Join a set of strings, returning the resulting string.
-   Total combined length (excluding null terminator) is returned in total_length
+   Total combined length (excluding null terminator) is returned in final_length
    if it is non-null. */
-char* gpr_strjoin(const char** strs, size_t nstrs, size_t* total_length);
+char* gpr_strjoin(const char** strs, size_t nstrs, size_t* final_length);
 
 /* Join a set of strings using a separator, returning the resulting string.
-   Total combined length (excluding null terminator) is returned in total_length
+   Total combined length (excluding null terminator) is returned in final_length
    if it is non-null. */
 char* gpr_strjoin_sep(const char** strs, size_t nstrs, const char* sep,
-                      size_t* total_length);
+                      size_t* final_length);
 
 void gpr_string_split(const char* input, const char* sep, char*** strs,
                       size_t* nstrs);
 
-/* Returns an allocated string that represents tm according to RFC-3339, and,
+/* Returns a string that represents tm according to RFC-3339, and,
    more specifically, follows:
    https://developers.google.com/protocol-buffers/docs/proto3#json
 
    Uses RFC 3339, where generated output will always be Z-normalized and uses
    0, 3, 6 or 9 fractional digits. */
-char* gpr_format_timespec(gpr_timespec);
-
-/* A vector of strings... for building up a final string one piece at a time */
-typedef struct {
-  char** strs;
-  size_t count;
-  size_t capacity;
-} gpr_strvec;
-
-/* Initialize/destroy */
-void gpr_strvec_init(gpr_strvec* strs);
-void gpr_strvec_destroy(gpr_strvec* strs);
-/* Add a string to a strvec, takes ownership of the string */
-void gpr_strvec_add(gpr_strvec* strs, char* add);
-/* Return a joined string with all added substrings, optionally setting
-   total_length as per gpr_strjoin */
-char* gpr_strvec_flatten(gpr_strvec* strs, size_t* total_length);
+std::string gpr_format_timespec(gpr_timespec);
 
 /** Case insensitive string comparison... return <0 if lower(a)<lower(b), ==0 if
     lower(a)==lower(b), >0 if lower(a)>lower(b) */

data/src/core/lib/gpr/sync.cc

@@ -48,7 +48,7 @@ static void event_initialize(void) {
 
 /* Hash ev into an element of sync_array[]. */
 static struct sync_array_s* hash(gpr_event* ev) {
-  return &sync_array[((uintptr_t)ev) % event_sync_partitions];
+  return &sync_array[reinterpret_cast<uintptr_t>(ev) % event_sync_partitions];
 }
 
 void gpr_event_init(gpr_event* ev) {
@@ -67,16 +67,16 @@ void gpr_event_set(gpr_event* ev, void* value) {
 }
 
 void* gpr_event_get(gpr_event* ev) {
-  return (void*)gpr_atm_acq_load(&ev->state);
+  return reinterpret_cast<void*>(gpr_atm_acq_load(&ev->state));
 }
 
 void* gpr_event_wait(gpr_event* ev, gpr_timespec abs_deadline) {
-  void* result = (void*)gpr_atm_acq_load(&ev->state);
+  void* result = reinterpret_cast<void*>(gpr_atm_acq_load(&ev->state));
   if (result == nullptr) {
     struct sync_array_s* s = hash(ev);
     gpr_mu_lock(&s->mu);
     do {
-      result = (void*)gpr_atm_acq_load(&ev->state);
+      result = reinterpret_cast<void*>(gpr_atm_acq_load(&ev->state));
     } while (result == nullptr && !gpr_cv_wait(&s->cv, &s->mu, abs_deadline));
     gpr_mu_unlock(&s->mu);
   }

data/src/core/lib/gpr/sync_abseil.cc

@@ -62,8 +62,7 @@ void gpr_mu_unlock(gpr_mu* mu) ABSL_NO_THREAD_SAFETY_ANALYSIS {
 
 int gpr_mu_trylock(gpr_mu* mu) {
   GPR_TIMER_SCOPE("gpr_mu_trylock", 0);
-  int ret = reinterpret_cast<absl::Mutex*>(mu)->TryLock() == true;
-  return ret;
+  return reinterpret_cast<absl::Mutex*>(mu)->TryLock();
 }
 
 /*----------------------------------------*/
@@ -89,10 +88,8 @@ int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) {
   abs_deadline = gpr_convert_clock_type(abs_deadline, GPR_CLOCK_REALTIME);
   timespec ts = {static_cast<decltype(ts.tv_sec)>(abs_deadline.tv_sec),
                  static_cast<decltype(ts.tv_nsec)>(abs_deadline.tv_nsec)};
-  int ret = reinterpret_cast<absl::CondVar*>(cv)->WaitWithDeadline(
-                reinterpret_cast<absl::Mutex*>(mu),
-                absl::TimeFromTimespec(ts)) == true;
-  return ret;
+  return reinterpret_cast<absl::CondVar*>(cv)->WaitWithDeadline(
+      reinterpret_cast<absl::Mutex*>(mu), absl::TimeFromTimespec(ts));
 }
 
 void gpr_cv_signal(gpr_cv* cv) {
@@ -108,6 +105,8 @@ void gpr_cv_broadcast(gpr_cv* cv) {
 /*----------------------------------------*/
 
 void gpr_once_init(gpr_once* once, void (*init_function)(void)) {
+  static_assert(sizeof(gpr_once) == sizeof(absl::once_flag),
+                "gpr_once and absl::once_flag must be the same size");
   absl::call_once(*reinterpret_cast<absl::once_flag*>(once), init_function);
 }
 

data/src/core/lib/gpr/sync_posix.cc

@@ -116,10 +116,6 @@ void gpr_cv_destroy(gpr_cv* cv) {
 #endif
 }
 
-#define gpr_convert_clock_type_debug(t, clock_type, now1, now2, add_result, \
-                                     sub_result)                            \
-  gpr_convert_clock_type((t), (clock_type))
-
 int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) {
   int err = 0;
   if (gpr_time_cmp(abs_deadline, gpr_inf_future(abs_deadline.clock_type)) ==
@@ -132,11 +128,9 @@ int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) {
   } else {
     struct timespec abs_deadline_ts;
 #if GPR_LINUX
-    abs_deadline = gpr_convert_clock_type_debug(
-        abs_deadline, GPR_CLOCK_MONOTONIC, now1, now2, add_result, sub_result);
+    abs_deadline = gpr_convert_clock_type(abs_deadline, GPR_CLOCK_MONOTONIC);
 #else
-    abs_deadline = gpr_convert_clock_type_debug(
-        abs_deadline, GPR_CLOCK_REALTIME, now1, now2, add_result, sub_result);
+    abs_deadline = gpr_convert_clock_type(abs_deadline, GPR_CLOCK_REALTIME);
 #endif  // GPR_LINUX
     abs_deadline_ts.tv_sec = static_cast<time_t>(abs_deadline.tv_sec);
     abs_deadline_ts.tv_nsec = abs_deadline.tv_nsec;

data/src/core/lib/gpr/sync_windows.cc

@@ -100,7 +100,7 @@ void gpr_cv_broadcast(gpr_cv* cv) { WakeAllConditionVariable(cv); }
 
 /*----------------------------------------*/
 
-static void* dummy;
+static void* phony;
 struct run_once_func_arg {
   void (*init_function)(void);
 };
@@ -113,7 +113,7 @@ static BOOL CALLBACK run_once_func(gpr_once* once, void* v, void** pv) {
 void gpr_once_init(gpr_once* once, void (*init_function)(void)) {
   struct run_once_func_arg arg;
   arg.init_function = init_function;
-  InitOnceExecuteOnce(once, run_once_func, &arg, &dummy);
+  InitOnceExecuteOnce(once, run_once_func, &arg, &phony);
 }
 
 #endif /* defined(GPR_WINDOWS) && !defined(GPR_ABSEIL_SYNC) && \

data/src/core/lib/gpr/time.cc

@@ -107,28 +107,28 @@ static gpr_timespec to_seconds_from_above_second_time(int64_t time_in_units,
   return out;
 }
 
-gpr_timespec gpr_time_from_nanos(int64_t ns, gpr_clock_type type) {
-  return to_seconds_from_sub_second_time(ns, GPR_NS_PER_SEC, type);
+gpr_timespec gpr_time_from_nanos(int64_t ns, gpr_clock_type clock_type) {
+  return to_seconds_from_sub_second_time(ns, GPR_NS_PER_SEC, clock_type);
 }
 
-gpr_timespec gpr_time_from_micros(int64_t us, gpr_clock_type type) {
-  return to_seconds_from_sub_second_time(us, GPR_US_PER_SEC, type);
+gpr_timespec gpr_time_from_micros(int64_t us, gpr_clock_type clock_type) {
+  return to_seconds_from_sub_second_time(us, GPR_US_PER_SEC, clock_type);
 }
 
-gpr_timespec gpr_time_from_millis(int64_t ms, gpr_clock_type type) {
-  return to_seconds_from_sub_second_time(ms, GPR_MS_PER_SEC, type);
+gpr_timespec gpr_time_from_millis(int64_t ms, gpr_clock_type clock_type) {
+  return to_seconds_from_sub_second_time(ms, GPR_MS_PER_SEC, clock_type);
 }
 
-gpr_timespec gpr_time_from_seconds(int64_t s, gpr_clock_type type) {
-  return to_seconds_from_sub_second_time(s, 1, type);
+gpr_timespec gpr_time_from_seconds(int64_t s, gpr_clock_type clock_type) {
+  return to_seconds_from_sub_second_time(s, 1, clock_type);
 }
 
-gpr_timespec gpr_time_from_minutes(int64_t m, gpr_clock_type type) {
-  return to_seconds_from_above_second_time(m, 60, type);
+gpr_timespec gpr_time_from_minutes(int64_t m, gpr_clock_type clock_type) {
+  return to_seconds_from_above_second_time(m, 60, clock_type);
 }
 
-gpr_timespec gpr_time_from_hours(int64_t h, gpr_clock_type type) {
-  return to_seconds_from_above_second_time(h, 3600, type);
+gpr_timespec gpr_time_from_hours(int64_t h, gpr_clock_type clock_type) {
+  return to_seconds_from_above_second_time(h, 3600, clock_type);
 }
 
 gpr_timespec gpr_time_add(gpr_timespec a, gpr_timespec b) {
@@ -254,6 +254,10 @@ gpr_timespec gpr_convert_clock_type(gpr_timespec t, gpr_clock_type clock_type) {
     return gpr_time_add(gpr_now(clock_type), t);
   }
 
+  // If the given input hits this code, the same result is not guaranteed for
+  // the same input because it relies on `gpr_now` to calculate the difference
+  // between two different clocks. Please be careful when you want to use this
+  // function in unit tests. (e.g. https://github.com/grpc/grpc/pull/22655)
   return gpr_time_add(gpr_now(clock_type),
                       gpr_time_sub(t, gpr_now(t.clock_type)));
 }

data/src/core/lib/gpr/time_posix.cc

@@ -82,7 +82,7 @@ static gpr_timespec now_impl(gpr_clock_type clock_type) {
   }
 }
 #else
-  /* For some reason Apple's OSes haven't implemented clock_gettime. */
+/* For some reason Apple's OSes haven't implemented clock_gettime. */
 
 #include <mach/mach.h>
 #include <mach/mach_time.h>

data/src/core/lib/gpr/time_precise.cc

@@ -31,6 +31,7 @@
 
 #include "src/core/lib/gpr/time_precise.h"
 
+#ifndef GPR_CYCLE_COUNTER_CUSTOM
 #if GPR_CYCLE_COUNTER_RDTSC_32 || GPR_CYCLE_COUNTER_RDTSC_64
 #if GPR_LINUX
 static bool read_freq_from_kernel(double* freq) {
@@ -147,8 +148,9 @@ gpr_cycle_counter gpr_get_cycle_counter() {
 
 gpr_timespec gpr_cycle_counter_to_time(gpr_cycle_counter cycles) {
   gpr_timespec ts;
-  ts.tv_sec = cycles / GPR_US_PER_SEC;
-  ts.tv_nsec = (cycles - ts.tv_sec * GPR_US_PER_SEC) * GPR_NS_PER_US;
+  ts.tv_sec = static_cast<int64_t>(cycles / GPR_US_PER_SEC);
+  ts.tv_nsec = static_cast<int64_t>((cycles - ts.tv_sec * GPR_US_PER_SEC) *
+                                    GPR_NS_PER_US);
   ts.clock_type = GPR_CLOCK_PRECISE;
   return ts;
 }
@@ -163,3 +165,4 @@ gpr_timespec gpr_cycle_counter_sub(gpr_cycle_counter a, gpr_cycle_counter b) {
                       gpr_cycle_counter_to_time(b));
 }
 #endif /* GPR_CYCLE_COUNTER_FALLBACK */
+#endif /* !GPR_CYCLE_COUNTER_CUSTOM */

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

@@ -31,7 +31,10 @@
 // Using gpr_get_cycle_counter() is preferred to using ExecCtx::Get()->Now()
 // whenever possible.
 
-#if GPR_CYCLE_COUNTER_RDTSC_32
+#if GPR_CYCLE_COUNTER_CUSTOM
+typedef int64_t gpr_cycle_counter;
+gpr_cycle_counter gpr_get_cycle_counter();
+#elif GPR_CYCLE_COUNTER_RDTSC_32
 typedef int64_t gpr_cycle_counter;
 inline gpr_cycle_counter gpr_get_cycle_counter() {
   int64_t ret;
@@ -54,7 +57,8 @@ gpr_cycle_counter gpr_get_cycle_counter();
 #else
 #error Must define exactly one of \
     GPR_CYCLE_COUNTER_RDTSC_32, \
-    GPR_CYCLE_COUNTER_RDTSC_64, or \
+    GPR_CYCLE_COUNTER_RDTSC_64, \
+    GPR_CYCLE_COUNTER_CUSTOM, or \
     GPR_CYCLE_COUNTER_FALLBACK
 #endif
 

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

@@ -53,6 +53,10 @@
 
    ALL functions here may be implemented as macros. */
 
+#ifdef GPR_STDCPP_TLS
+#include "src/core/lib/gpr/tls_stdcpp.h"
+#endif
+
 #ifdef GPR_GCC_TLS
 #include "src/core/lib/gpr/tls_gcc.h"
 #endif

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

@@ -24,6 +24,8 @@
 
    #include tls.h to use this - and see that file for documentation */
 
+#include <cstdint>
+
 struct gpr_msvc_thread_local {
   intptr_t value;
 };

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

@@ -0,0 +1,48 @@
+/*
+ *
+ * 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_GPR_TLS_STDCPP_H
+#define GRPC_CORE_LIB_GPR_TLS_STDCPP_H
+
+#include <grpc/support/port_platform.h>
+
+/** Thread local storage based on C++ thread_local.
+   #include tls.h to use this - and see that file for documentation */
+
+/** Use GPR_TLS_DECL to declare tls static variables outside a class */
+#define GPR_TLS_DECL(name) thread_local static intptr_t name = 0
+
+/** Use GPR_TLS_CLASS_DECL to declare tls static variable members of a class.
+ *  GPR_TLS_CLASS_DEF needs to be called to define this member. */
+#define GPR_TLS_CLASS_DECL(name) thread_local static intptr_t name
+
+#define GPR_TLS_CLASS_DEF(name) thread_local intptr_t name = 0
+
+#define gpr_tls_init(tls) \
+  do {                    \
+  } while (0)
+
+#define gpr_tls_destroy(tls) \
+  do {                       \
+  } while (0)
+
+#define gpr_tls_set(tls, new_value) (*(tls) = (new_value))
+
+#define gpr_tls_get(tls) (*(tls))
+
+#endif /* GRPC_CORE_LIB_GPR_TLS_STDCPP_H */

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

@@ -28,12 +28,12 @@
 namespace grpc_core {
 
 enum class MemoryOrder {
-  RELAXED = std::memory_order_relaxed,
-  CONSUME = std::memory_order_consume,
-  ACQUIRE = std::memory_order_acquire,
-  RELEASE = std::memory_order_release,
-  ACQ_REL = std::memory_order_acq_rel,
-  SEQ_CST = std::memory_order_seq_cst
+  RELAXED = static_cast<int>(std::memory_order_relaxed),
+  CONSUME = static_cast<int>(std::memory_order_consume),
+  ACQUIRE = static_cast<int>(std::memory_order_acquire),
+  RELEASE = static_cast<int>(std::memory_order_release),
+  ACQ_REL = static_cast<int>(std::memory_order_acq_rel),
+  SEQ_CST = static_cast<int>(std::memory_order_seq_cst)
 };
 
 template <typename T>
@@ -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

@@ -0,0 +1,331 @@
+//
+// 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_DUAL_REF_COUNTED_H
+#define GRPC_CORE_LIB_GPRPP_DUAL_REF_COUNTED_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/support/atm.h>
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+
+#include <atomic>
+#include <cassert>
+#include <cinttypes>
+
+#include "src/core/lib/gprpp/atomic.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+
+namespace grpc_core {
+
+// DualRefCounted is an interface for reference-counted objects with two
+// classes of refs: strong refs (usually just called "refs") and weak refs.
+// This supports cases where an object needs to start shutting down when
+// all external callers are done with it (represented by strong refs) but
+// cannot be destroyed until all internal callbacks are complete
+// (represented by weak refs).
+//
+// Each class of refs can be incremented and decremented independently.
+// Objects start with 1 strong ref and 0 weak refs at instantiation.
+// When the strong refcount reaches 0, the object's Orphan() method is called.
+// When the weak refcount reaches 0, the object is destroyed.
+//
+// This will be used by CRTP (curiously-recurring template pattern), e.g.:
+//   class MyClass : public RefCounted<MyClass> { ... };
+template <typename Child>
+class DualRefCounted : public Orphanable {
+ public:
+  ~DualRefCounted() override = default;
+
+  RefCountedPtr<Child> Ref() GRPC_MUST_USE_RESULT {
+    IncrementRefCount();
+    return RefCountedPtr<Child>(static_cast<Child*>(this));
+  }
+
+  RefCountedPtr<Child> Ref(const DebugLocation& location,
+                           const char* reason) GRPC_MUST_USE_RESULT {
+    IncrementRefCount(location, reason);
+    return RefCountedPtr<Child>(static_cast<Child*>(this));
+  }
+
+  void Unref() {
+    // Convert strong ref to weak ref.
+    const uint64_t prev_ref_pair =
+        refs_.FetchAdd(MakeRefPair(-1, 1), MemoryOrder::ACQ_REL);
+    const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
+#ifndef NDEBUG
+    const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
+    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
+    if (GPR_UNLIKELY(strong_refs == 1)) {
+      Orphan();
+    }
+    // Now drop the weak ref.
+    WeakUnref();
+  }
+  void Unref(const DebugLocation& location, const char* reason) {
+    const uint64_t prev_ref_pair =
+        refs_.FetchAdd(MakeRefPair(-1, 1), MemoryOrder::ACQ_REL);
+    const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
+#ifndef NDEBUG
+    const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
+    if (trace_ != nullptr) {
+      gpr_log(GPR_INFO, "%s:%p %s:%d unref %d -> %d, weak_ref %d -> %d) %s",
+              trace_, this, location.file(), location.line(), strong_refs,
+              strong_refs - 1, weak_refs, weak_refs + 1, reason);
+    }
+    GPR_ASSERT(strong_refs > 0);
+#else
+    // Avoid unused-parameter warnings for debug-only parameters
+    (void)location;
+    (void)reason;
+#endif
+    if (GPR_UNLIKELY(strong_refs == 1)) {
+      Orphan();
+    }
+    // Now drop the weak ref.
+    WeakUnref(location, reason);
+  }
+
+  RefCountedPtr<Child> RefIfNonZero() GRPC_MUST_USE_RESULT {
+    uint64_t prev_ref_pair = refs_.Load(MemoryOrder::ACQUIRE);
+    do {
+      const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
+#ifndef NDEBUG
+      const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
+      if (trace_ != nullptr) {
+        gpr_log(GPR_INFO, "%s:%p ref_if_non_zero %d -> %d (weak_refs=%d)",
+                trace_, this, strong_refs, strong_refs + 1, weak_refs);
+      }
+#endif
+      if (strong_refs == 0) return nullptr;
+    } while (!refs_.CompareExchangeWeak(
+        &prev_ref_pair, prev_ref_pair + MakeRefPair(1, 0), MemoryOrder::ACQ_REL,
+        MemoryOrder::ACQUIRE));
+    return RefCountedPtr<Child>(static_cast<Child*>(this));
+  }
+
+  RefCountedPtr<Child> RefIfNonZero(const DebugLocation& location,
+                                    const char* reason) GRPC_MUST_USE_RESULT {
+    uint64_t prev_ref_pair = refs_.Load(MemoryOrder::ACQUIRE);
+    do {
+      const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
+#ifndef NDEBUG
+      const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
+      if (trace_ != nullptr) {
+        gpr_log(GPR_INFO,
+                "%s:%p %s:%d ref_if_non_zero %d -> %d (weak_refs=%d) %s",
+                trace_, this, location.file(), location.line(), strong_refs,
+                strong_refs + 1, weak_refs, reason);
+      }
+#else
+      // Avoid unused-parameter warnings for debug-only parameters
+      (void)location;
+      (void)reason;
+#endif
+      if (strong_refs == 0) return nullptr;
+    } while (!refs_.CompareExchangeWeak(
+        &prev_ref_pair, prev_ref_pair + MakeRefPair(1, 0), MemoryOrder::ACQ_REL,
+        MemoryOrder::ACQUIRE));
+    return RefCountedPtr<Child>(static_cast<Child*>(this));
+  }
+
+  WeakRefCountedPtr<Child> WeakRef() GRPC_MUST_USE_RESULT {
+    IncrementWeakRefCount();
+    return WeakRefCountedPtr<Child>(static_cast<Child*>(this));
+  }
+
+  WeakRefCountedPtr<Child> WeakRef(const DebugLocation& location,
+                                   const char* reason) GRPC_MUST_USE_RESULT {
+    IncrementWeakRefCount(location, reason);
+    return WeakRefCountedPtr<Child>(static_cast<Child*>(this));
+  }
+
+  void WeakUnref() {
+#ifndef NDEBUG
+    // Grab a copy of the trace flag before the atomic change, since we
+    // 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);
+#ifndef NDEBUG
+    const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
+    const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
+    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
+    if (GPR_UNLIKELY(prev_ref_pair == MakeRefPair(0, 1))) {
+      delete static_cast<Child*>(this);
+    }
+  }
+  void WeakUnref(const DebugLocation& location, const char* reason) {
+#ifndef NDEBUG
+    // Grab a copy of the trace flag before the atomic change, since we
+    // 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);
+#ifndef NDEBUG
+    const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
+    const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
+    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
+    // Avoid unused-parameter warnings for debug-only parameters
+    (void)location;
+    (void)reason;
+#endif
+    if (GPR_UNLIKELY(prev_ref_pair == MakeRefPair(0, 1))) {
+      delete static_cast<Child*>(this);
+    }
+  }
+
+  // Not copyable nor movable.
+  DualRefCounted(const DualRefCounted&) = delete;
+  DualRefCounted& operator=(const DualRefCounted&) = delete;
+
+ protected:
+  // Note: Tracing is a no-op in non-debug builds.
+  explicit DualRefCounted(
+      const char*
+#ifndef NDEBUG
+          // Leave unnamed if NDEBUG to avoid unused parameter warning
+          trace
+#endif
+      = nullptr,
+      int32_t initial_refcount = 1)
+      :
+#ifndef NDEBUG
+        trace_(trace),
+#endif
+        refs_(MakeRefPair(initial_refcount, 0)) {
+  }
+
+ private:
+  // Allow RefCountedPtr<> to access IncrementRefCount().
+  template <typename T>
+  friend class RefCountedPtr;
+  // Allow WeakRefCountedPtr<> to access IncrementWeakRefCount().
+  template <typename T>
+  friend class WeakRefCountedPtr;
+
+  // First 32 bits are strong refs, next 32 bits are weak refs.
+  static uint64_t MakeRefPair(uint32_t strong, uint32_t weak) {
+    return (static_cast<uint64_t>(strong) << 32) + static_cast<int64_t>(weak);
+  }
+  static uint32_t GetStrongRefs(uint64_t ref_pair) {
+    return static_cast<uint32_t>(ref_pair >> 32);
+  }
+  static uint32_t GetWeakRefs(uint64_t ref_pair) {
+    return static_cast<uint32_t>(ref_pair & 0xffffffffu);
+  }
+
+  void IncrementRefCount() {
+#ifndef NDEBUG
+    const uint64_t prev_ref_pair =
+        refs_.FetchAdd(MakeRefPair(1, 0), MemoryOrder::RELAXED);
+    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_ != 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);
+#endif
+  }
+  void IncrementRefCount(const DebugLocation& location, const char* reason) {
+#ifndef NDEBUG
+    const uint64_t prev_ref_pair =
+        refs_.FetchAdd(MakeRefPair(1, 0), MemoryOrder::RELAXED);
+    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_ != 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
+    (void)location;
+    (void)reason;
+    refs_.FetchAdd(MakeRefPair(1, 0), MemoryOrder::RELAXED);
+#endif
+  }
+
+  void IncrementWeakRefCount() {
+#ifndef NDEBUG
+    const uint64_t prev_ref_pair =
+        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_ != 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);
+#endif
+  }
+  void IncrementWeakRefCount(const DebugLocation& location,
+                             const char* reason) {
+#ifndef NDEBUG
+    const uint64_t prev_ref_pair =
+        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_ != 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
+    (void)location;
+    (void)reason;
+    refs_.FetchAdd(MakeRefPair(0, 1), MemoryOrder::RELAXED);
+#endif
+  }
+
+#ifndef NDEBUG
+  const char* trace_;
+#endif
+  Atomic<uint64_t> refs_;
+};
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_LIB_GPRPP_DUAL_REF_COUNTED_H */