grpc 1.39.0.pre1 → 1.41.0.pre2

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

@@ -19,54 +19,133 @@
 #ifndef GRPC_CORE_LIB_GPR_TLS_H
 #define GRPC_CORE_LIB_GPR_TLS_H
 
-#include <grpc/support/port_platform.h>
+#include <grpc/impl/codegen/port_platform.h>
 
-/** Thread local storage.
-
-   A minimal wrapper that should be implementable across many compilers,
-   and implementable efficiently across most modern compilers.
-
-   Thread locals have type intptr_t.
-
-   Declaring a thread local variable 'foo':
-     GPR_TLS_DECL(foo);
-   Thread locals always have static scope.
-
-   Declaring a thread local class variable 'foo':
-     GPR_TLS_CLASS_DECL(foo);
-
-   Defining the thread local class variable:
-     GPR_TLS_CLASS_DEF(foo);
-
-   Initializing a thread local (must be done at library initialization
-   time):
-     gpr_tls_init(&foo);
+#include <type_traits>
 
-   Destroying a thread local:
-     gpr_tls_destroy(&foo);
-
-   Setting a thread local (returns new_value):
-     gpr_tls_set(&foo, new_value);
+/** Thread local storage.
 
-   Accessing a thread local:
-     current_value = gpr_tls_get(&foo);
+   Usage is the same as C++ thread_local. Declaring a thread local:
+     static GPR_THREAD_LOCAL(uint32_t) foo;
 
    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
-
-#ifdef GPR_MSVC_TLS
-#include "src/core/lib/gpr/tls_msvc.h"
-#endif
+namespace grpc_core {
+
+// This class is never instantiated. It exists to statically ensure that all
+// TLS usage is compatible with the most restrictive implementation, allowing
+// developers to write correct code regardless of the platform they develop on.
+template <typename T>
+class TlsTypeConstrainer {
+  static_assert(std::is_trivial<T>::value,
+                "TLS support is limited to trivial types");
+
+ public:
+  using Type = T;
+};
+
+}  // namespace grpc_core
+
+#if defined(GPR_PTHREAD_TLS)
+
+#include <pthread.h>
+
+#include <array>
+#include <cstring>
+
+#include <grpc/support/log.h> /* for GPR_ASSERT */
+
+namespace grpc_core {
+
+template <typename T>
+class PthreadTlsImpl : TlsTypeConstrainer<T> {
+ public:
+  PthreadTlsImpl(const PthreadTlsImpl&) = delete;
+  PthreadTlsImpl& operator=(const PthreadTlsImpl&) = delete;
+
+  // Achtung! This class emulates C++ `thread_local` using pthread keys. Each
+  // instance of this class is a stand in for a C++ `thread_local`. Think of
+  // each `thread_local` as a *global* pthread_key_t and a type tag. An
+  // important consequence of this is that the lifetime of a `pthread_key_t`
+  // is precisely the lifetime of an instance of this class. To understand why
+  // this is, consider the following scenario given a fictional implementation
+  // of this class which creates and destroys its `pthread_key_t` each time
+  // a given block of code runs (all actions take place on a single thread):
+  //
+  // - instance 1 (type tag = T*) is initialized, is assigned `pthread_key_t` 1
+  // - instance 2 (type tag = int) is initialized, is assigned `pthread_key_t` 2
+  // - instances 1 and 2 store and retrieve values; all is well
+  // - instances 1 and 2 are de-initialized; their keys are released to the pool
+  //
+  // - another run commences
+  // - instance 1 receives key 2
+  // - a value is read from instance 1, it observes a value of type int, but
+  //   interprets it as T*; undefined behavior, kaboom
+  //
+  // To properly ensure these invariants are upheld the `pthread_key_t` must be
+  // `const`, which means it can only be released in the destructor. This is a
+  // a violation of the style guide, since these objects are always static (see
+  // footnote) but this code is used in sufficiently narrow circumstances to
+  // justify the deviation.
+  //
+  // https://google.github.io/styleguide/cppguide.html#Static_and_Global_Variables
+  PthreadTlsImpl()
+      : keys_([]() {
+          typename std::remove_const<decltype(PthreadTlsImpl::keys_)>::type
+              keys;
+          for (pthread_key_t& key : keys) {
+            GPR_ASSERT(0 == pthread_key_create(&key, nullptr));
+          }
+          return keys;
+        }()) {}
+  PthreadTlsImpl(T t) : PthreadTlsImpl() { *this = t; }
+  ~PthreadTlsImpl() {
+    for (pthread_key_t key : keys_) {
+      GPR_ASSERT(0 == pthread_key_delete(key));
+    }
+  }
+
+  operator T() const {
+    T t;
+    char* dst = reinterpret_cast<char*>(&t);
+    for (pthread_key_t key : keys_) {
+      uintptr_t src = uintptr_t(pthread_getspecific(key));
+      size_t remaining = reinterpret_cast<char*>(&t + 1) - dst;
+      size_t step = std::min(sizeof(src), remaining);
+      memcpy(dst, &src, step);
+      dst += step;
+    }
+    return t;
+  }
+
+  T operator=(T t) {
+    char* src = reinterpret_cast<char*>(&t);
+    for (pthread_key_t key : keys_) {
+      uintptr_t dst;
+      size_t remaining = reinterpret_cast<char*>(&t + 1) - src;
+      size_t step = std::min(sizeof(dst), remaining);
+      memcpy(&dst, src, step);
+      GPR_ASSERT(0 == pthread_setspecific(key, reinterpret_cast<void*>(dst)));
+      src += step;
+    }
+    return t;
+  }
+
+ private:
+  const std::array<pthread_key_t,
+                   (sizeof(T) + sizeof(void*) - 1) / sizeof(void*)>
+      keys_;
+};
+
+}  // namespace grpc_core
+
+#define GPR_THREAD_LOCAL(type) grpc_core::PthreadTlsImpl<type>
+
+#else
+
+#define GPR_THREAD_LOCAL(type) \
+  thread_local typename grpc_core::TlsTypeConstrainer<type>::Type
 
-#ifdef GPR_PTHREAD_TLS
-#include "src/core/lib/gpr/tls_pthread.h"
 #endif
 
 #endif /* GRPC_CORE_LIB_GPR_TLS_H */

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

@@ -20,8 +20,6 @@
 
 #ifdef GPR_POSIX_TMPFILE
 
-#include "src/core/lib/gpr/tmpfile.h"
-
 #include <errno.h>
 #include <stdlib.h>
 #include <string.h>
@@ -32,6 +30,7 @@
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gpr/tmpfile.h"
 
 FILE* gpr_tmpfile(const char* prefix, char** tmp_filename) {
   FILE* result = nullptr;

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

@@ -21,6 +21,7 @@
 #include "src/core/lib/gprpp/arena.h"
 
 #include <string.h>
+
 #include <new>
 
 #include <grpc/support/alloc.h>
@@ -75,7 +76,7 @@ std::pair<Arena*, void*> Arena::CreateWithAlloc(size_t initial_size,
 }
 
 size_t Arena::Destroy() {
-  size_t size = total_used_.Load(MemoryOrder::RELAXED);
+  size_t size = total_used_.load(std::memory_order_relaxed);
   this->~Arena();
   gpr_free_aligned(this);
   return size;

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

@@ -27,6 +27,9 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+
+#include <atomic>
 #include <new>
 #include <utility>
 
@@ -35,9 +38,6 @@
 
 #include "src/core/lib/gpr/alloc.h"
 #include "src/core/lib/gpr/spinlock.h"
-#include "src/core/lib/gprpp/atomic.h"
-
-#include <stddef.h>
 
 namespace grpc_core {
 
@@ -59,7 +59,7 @@ class Arena {
     static constexpr size_t base_size =
         GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(Arena));
     size = GPR_ROUND_UP_TO_ALIGNMENT_SIZE(size);
-    size_t begin = total_used_.FetchAdd(size, MemoryOrder::RELAXED);
+    size_t begin = total_used_.fetch_add(size, std::memory_order_relaxed);
     if (begin + size <= initial_zone_size_) {
       return reinterpret_cast<char*>(this) + base_size + begin;
     } else {
@@ -105,7 +105,7 @@ class Arena {
 
   // Keep track of the total used size. We use this in our call sizing
   // hysteresis.
-  Atomic<size_t> total_used_;
+  std::atomic<size_t> total_used_{0};
   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

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

@@ -0,0 +1,47 @@
+/*
+ *
+ * Copyright 2017 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_ATOMIC_UTILS_H
+#define GRPC_CORE_LIB_GPRPP_ATOMIC_UTILS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <atomic>
+
+namespace grpc_core {
+
+// Atomically increment a counter only if the counter value is not zero.
+// Returns true if increment took place; false if counter is zero.
+template <typename T>
+inline bool IncrementIfNonzero(std::atomic<T>* p) {
+  T count = p->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
+    // zero
+    if (count == 0) {
+      return false;
+    }
+  } while (!p->compare_exchange_weak(
+      count, count + 1, std::memory_order_acq_rel, std::memory_order_acquire));
+  return true;
+}
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_LIB_GPRPP_ATOMIC_UTILS_H */

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

@@ -0,0 +1,166 @@
+// Copyright 2021 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_BITSET_H
+#define GRPC_CORE_LIB_GPRPP_BITSET_H
+
+#include <grpc/impl/codegen/port_platform.h>
+
+#include <utility>
+
+#if __cplusplus > 201103l
+#define GRPC_BITSET_CONSTEXPR_MUTATOR constexpr
+#else
+#define GRPC_BITSET_CONSTEXPR_MUTATOR
+#endif
+
+namespace grpc_core {
+
+// Given a bit count as an integer, vend as member type `Type` a type with
+// exactly that number of bits. Undefined if that bit count is not available.
+template <std::size_t kBits>
+struct UintSelector;
+template <>
+struct UintSelector<8> {
+  typedef uint8_t Type;
+};
+template <>
+struct UintSelector<16> {
+  typedef uint16_t Type;
+};
+template <>
+struct UintSelector<32> {
+  typedef uint32_t Type;
+};
+template <>
+struct UintSelector<64> {
+  typedef uint64_t Type;
+};
+
+// An unsigned integer of some number of bits.
+template <std::size_t kBits>
+using Uint = typename UintSelector<kBits>::Type;
+
+// Given the total number of bits that need to be stored, choose the size of
+// 'unit' for a BitSet... We'll use an array of units to store the total set.
+// For small bit counts we are selective in the type to try and balance byte
+// size and performance
+// - the details will likely be tweaked into the future.
+// Once we get over 96 bits, we just use uint64_t for everything.
+constexpr std::size_t ChooseUnitBitsForBitSet(std::size_t total_bits) {
+  return total_bits <= 8    ? 8
+         : total_bits <= 16 ? 16
+         : total_bits <= 24 ? 8
+         : total_bits <= 32 ? 32
+         : total_bits <= 48 ? 16
+         : total_bits <= 64 ? 64
+         : total_bits <= 96 ? 32
+                            : 64;
+}
+
+// A BitSet that's configurable.
+// Contains storage for kTotalBits, stored as an array of integers of size
+// kUnitBits. e.g. to store 72 bits in 8 bit chunks, we'd say BitSet<72, 8>.
+// Since most users shouldn't care about the size of unit used, we default
+// kUnitBits to whatever is selected by ChooseUnitBitsForBitSet
+template <std::size_t kTotalBits,
+          std::size_t kUnitBits = ChooseUnitBitsForBitSet(kTotalBits)>
+class BitSet {
+  static constexpr std::size_t kUnits =
+      (kTotalBits + kUnitBits - 1) / kUnitBits;
+
+ public:
+  // Initialize to all bits false
+  constexpr BitSet() : units_{} {}
+
+  // Set bit i to true
+  GRPC_BITSET_CONSTEXPR_MUTATOR void set(int i) {
+    units_[unit_for(i)] |= mask_for(i);
+  }
+
+  // Set bit i to is_set
+  GRPC_BITSET_CONSTEXPR_MUTATOR void set(int i, bool is_set) {
+    if (is_set) {
+      set(i);
+    } else {
+      clear(i);
+    }
+  }
+
+  // Set bit i to false
+  GRPC_BITSET_CONSTEXPR_MUTATOR void clear(int i) {
+    units_[unit_for(i)] &= ~mask_for(i);
+  }
+
+  // Return true if bit i is set
+  constexpr bool is_set(int i) const {
+    return (units_[unit_for(i)] & mask_for(i)) != 0;
+  }
+
+  // Return true if all bits are set
+  bool all() const {
+    if (kTotalBits % kUnitBits == 0) {
+      // kTotalBits is a multiple of kUnitBits ==> we can just check for all
+      // ones in each unit.
+      for (std::size_t i = 0; i < kUnits; i++) {
+        if (units_[i] != all_ones()) return false;
+      }
+      return true;
+    } else {
+      // kTotalBits is not a multiple of kUnitBits ==> we need special handling
+      // for checking partial filling of the last unit (since not all of its
+      // bits are used!)
+      for (std::size_t i = 0; i < kUnits - 1; i++) {
+        if (units_[i] != all_ones()) return false;
+      }
+      return units_[kUnits - 1] == n_ones(kTotalBits % kUnitBits);
+    }
+  }
+
+  // Return true if *no* bits are set.
+  bool none() const {
+    for (std::size_t i = 0; i < kUnits; i++) {
+      if (units_[i] != 0) return false;
+    }
+    return true;
+  }
+
+ private:
+  // Given a bit index, return which unit it's stored in.
+  static constexpr std::size_t unit_for(std::size_t bit) {
+    return bit / kUnitBits;
+  }
+
+  // Given a bit index, return a mask to access that bit within it's unit.
+  static constexpr Uint<kUnitBits> mask_for(std::size_t bit) {
+    return Uint<kUnitBits>{1} << (bit % kUnitBits);
+  }
+
+  // Return a value that is all ones
+  static constexpr Uint<kUnitBits> all_ones() {
+    return Uint<kUnitBits>(~Uint<kUnitBits>(0));
+  }
+
+  // Return a value with n bottom bits ones
+  static constexpr Uint<kUnitBits> n_ones(std::size_t n) {
+    return n == kUnitBits ? all_ones() : (Uint<kUnitBits>(1) << n) - 1;
+  }
+
+  // The set of units - kUnitBits sized integers that store kUnitBits bits!
+  Uint<kUnitBits> units_[kUnits];
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_BITSET_H

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

@@ -0,0 +1,39 @@
+// Copyright 2021 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_CONSTRUCT_DESTRUCT_H
+#define GRPC_CORE_LIB_GPRPP_CONSTRUCT_DESTRUCT_H
+
+#include <grpc/impl/codegen/port_platform.h>
+
+#include <utility>
+
+namespace grpc_core {
+
+// Call the destructor of p without having to name the type of p.
+template <typename T>
+void Destruct(T* p) {
+  p->~T();
+}
+
+// Call the constructor of p without having to name the type of p and forward
+// any arguments
+template <typename T, typename... Args>
+void Construct(T* p, Args&&... args) {
+  new (p) T(std::forward<Args>(args)...);
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_CONSTRUCT_DESTRUCT_H

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

@@ -19,15 +19,14 @@
 
 #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 <grpc/support/atm.h>
+#include <grpc/support/log.h>
+#include <grpc/support/sync.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"
@@ -67,7 +66,7 @@ class DualRefCounted : public Orphanable {
   void Unref() {
     // Convert strong ref to weak ref.
     const uint64_t prev_ref_pair =
-        refs_.FetchAdd(MakeRefPair(-1, 1), MemoryOrder::ACQ_REL);
+        refs_.fetch_add(MakeRefPair(-1, 1), std::memory_order_acq_rel);
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
 #ifndef NDEBUG
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
@@ -85,7 +84,7 @@ class DualRefCounted : public Orphanable {
   }
   void Unref(const DebugLocation& location, const char* reason) {
     const uint64_t prev_ref_pair =
-        refs_.FetchAdd(MakeRefPair(-1, 1), MemoryOrder::ACQ_REL);
+        refs_.fetch_add(MakeRefPair(-1, 1), std::memory_order_acq_rel);
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
 #ifndef NDEBUG
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
@@ -108,7 +107,7 @@ class DualRefCounted : public Orphanable {
   }
 
   RefCountedPtr<Child> RefIfNonZero() GRPC_MUST_USE_RESULT {
-    uint64_t prev_ref_pair = refs_.Load(MemoryOrder::ACQUIRE);
+    uint64_t prev_ref_pair = refs_.load(std::memory_order_acquire);
     do {
       const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
 #ifndef NDEBUG
@@ -119,15 +118,15 @@ class DualRefCounted : public Orphanable {
       }
 #endif
       if (strong_refs == 0) return nullptr;
-    } while (!refs_.CompareExchangeWeak(
-        &prev_ref_pair, prev_ref_pair + MakeRefPair(1, 0), MemoryOrder::ACQ_REL,
-        MemoryOrder::ACQUIRE));
+    } while (!refs_.compare_exchange_weak(
+        prev_ref_pair, prev_ref_pair + MakeRefPair(1, 0),
+        std::memory_order_acq_rel, std::memory_order_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);
+    uint64_t prev_ref_pair = refs_.load(std::memory_order_acquire);
     do {
       const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
 #ifndef NDEBUG
@@ -144,9 +143,9 @@ class DualRefCounted : public Orphanable {
       (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));
+    } while (!refs_.compare_exchange_weak(
+        prev_ref_pair, prev_ref_pair + MakeRefPair(1, 0),
+        std::memory_order_acq_rel, std::memory_order_acquire));
     return RefCountedPtr<Child>(static_cast<Child*>(this));
   }
 
@@ -169,7 +168,7 @@ class DualRefCounted : public Orphanable {
     const char* trace = trace_;
 #endif
     const uint64_t prev_ref_pair =
-        refs_.FetchSub(MakeRefPair(0, 1), MemoryOrder::ACQ_REL);
+        refs_.fetch_sub(MakeRefPair(0, 1), std::memory_order_acq_rel);
 #ifndef NDEBUG
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
@@ -191,7 +190,7 @@ class DualRefCounted : public Orphanable {
     const char* trace = trace_;
 #endif
     const uint64_t prev_ref_pair =
-        refs_.FetchSub(MakeRefPair(0, 1), MemoryOrder::ACQ_REL);
+        refs_.fetch_sub(MakeRefPair(0, 1), std::memory_order_acq_rel);
 #ifndef NDEBUG
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
@@ -254,7 +253,7 @@ class DualRefCounted : public Orphanable {
   void IncrementRefCount() {
 #ifndef NDEBUG
     const uint64_t prev_ref_pair =
-        refs_.FetchAdd(MakeRefPair(1, 0), MemoryOrder::RELAXED);
+        refs_.fetch_add(MakeRefPair(1, 0), std::memory_order_relaxed);
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
     GPR_ASSERT(strong_refs != 0);
@@ -263,13 +262,13 @@ class DualRefCounted : public Orphanable {
               strong_refs, strong_refs + 1, weak_refs);
     }
 #else
-    refs_.FetchAdd(MakeRefPair(1, 0), MemoryOrder::RELAXED);
+    refs_.fetch_add(MakeRefPair(1, 0), std::memory_order_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);
+        refs_.fetch_add(MakeRefPair(1, 0), std::memory_order_relaxed);
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
     GPR_ASSERT(strong_refs != 0);
@@ -282,14 +281,14 @@ class DualRefCounted : public Orphanable {
     // Use conditionally-important parameters
     (void)location;
     (void)reason;
-    refs_.FetchAdd(MakeRefPair(1, 0), MemoryOrder::RELAXED);
+    refs_.fetch_add(MakeRefPair(1, 0), std::memory_order_relaxed);
 #endif
   }
 
   void IncrementWeakRefCount() {
 #ifndef NDEBUG
     const uint64_t prev_ref_pair =
-        refs_.FetchAdd(MakeRefPair(0, 1), MemoryOrder::RELAXED);
+        refs_.fetch_add(MakeRefPair(0, 1), std::memory_order_relaxed);
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
     if (trace_ != nullptr) {
@@ -297,14 +296,14 @@ class DualRefCounted : public Orphanable {
               weak_refs, weak_refs + 1, strong_refs);
     }
 #else
-    refs_.FetchAdd(MakeRefPair(0, 1), MemoryOrder::RELAXED);
+    refs_.fetch_add(MakeRefPair(0, 1), std::memory_order_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);
+        refs_.fetch_add(MakeRefPair(0, 1), std::memory_order_relaxed);
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
     if (trace_ != nullptr) {
@@ -316,14 +315,14 @@ class DualRefCounted : public Orphanable {
     // Use conditionally-important parameters
     (void)location;
     (void)reason;
-    refs_.FetchAdd(MakeRefPair(0, 1), MemoryOrder::RELAXED);
+    refs_.fetch_add(MakeRefPair(0, 1), std::memory_order_relaxed);
 #endif
   }
 
 #ifndef NDEBUG
   const char* trace_;
 #endif
-  Atomic<uint64_t> refs_;
+  std::atomic<uint64_t> refs_{0};
 };
 
 }  // namespace grpc_core