grpc 1.34.0 → 1.42.0

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

@@ -19,13 +19,16 @@
 #ifndef GRPC_CORE_LIB_GPRPP_SYNC_H
 #define GRPC_CORE_LIB_GPRPP_SYNC_H
 
-#include <grpc/impl/codegen/port_platform.h>
+#include <grpc/support/port_platform.h>
 
-#include <grpc/impl/codegen/log.h>
-#include <grpc/impl/codegen/sync.h>
+#include "absl/synchronization/mutex.h"
+
+#include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
 
+#include "src/core/lib/gprpp/time_util.h"
+
 // The core library is not accessible in C++ codegen headers, and vice versa.
 // Thus, we need to have duplicate headers with similar functionality.
 // Make sure any change to this file is also reflected in
@@ -37,7 +40,23 @@
 
 namespace grpc_core {
 
-class Mutex {
+#ifdef GPR_ABSEIL_SYNC
+
+using Mutex = absl::Mutex;
+using MutexLock = absl::MutexLock;
+using ReleasableMutexLock = absl::ReleasableMutexLock;
+using CondVar = absl::CondVar;
+
+// Returns the underlying gpr_mu from Mutex. This should be used only when
+// it has to like passing the C++ mutex to C-core API.
+// TODO(veblush): Remove this after C-core no longer uses gpr_mu.
+inline gpr_mu* GetUnderlyingGprMu(Mutex* mutex) {
+  return reinterpret_cast<gpr_mu*>(mutex);
+}
+
+#else
+
+class ABSL_LOCKABLE Mutex {
  public:
   Mutex() { gpr_mu_init(&mu_); }
   ~Mutex() { gpr_mu_destroy(&mu_); }
@@ -45,52 +64,60 @@ class Mutex {
   Mutex(const Mutex&) = delete;
   Mutex& operator=(const Mutex&) = delete;
 
-  gpr_mu* get() { return &mu_; }
-  const gpr_mu* get() const { return &mu_; }
+  void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() { gpr_mu_lock(&mu_); }
+  void Unlock() ABSL_UNLOCK_FUNCTION() { gpr_mu_unlock(&mu_); }
+  bool TryLock() ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(true) {
+    return gpr_mu_trylock(&mu_) != 0;
+  }
+  void AssertHeld() ABSL_ASSERT_EXCLUSIVE_LOCK() {}
 
  private:
   gpr_mu mu_;
+
+  friend class CondVar;
+  friend gpr_mu* GetUnderlyingGprMu(Mutex* mutex);
 };
 
-// MutexLock is a std::
-class MutexLock {
+// Returns the underlying gpr_mu from Mutex. This should be used only when
+// it has to like passing the C++ mutex to C-core API.
+// TODO(veblush): Remove this after C-core no longer uses gpr_mu.
+inline gpr_mu* GetUnderlyingGprMu(Mutex* mutex) { return &mutex->mu_; }
+
+class ABSL_SCOPED_LOCKABLE MutexLock {
  public:
-  explicit MutexLock(Mutex* mu) : mu_(mu->get()) { gpr_mu_lock(mu_); }
-  explicit MutexLock(gpr_mu* mu) : mu_(mu) { gpr_mu_lock(mu_); }
-  ~MutexLock() { gpr_mu_unlock(mu_); }
+  explicit MutexLock(Mutex* mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(mu) {
+    mu_->Lock();
+  }
+  ~MutexLock() ABSL_UNLOCK_FUNCTION() { mu_->Unlock(); }
 
   MutexLock(const MutexLock&) = delete;
   MutexLock& operator=(const MutexLock&) = delete;
 
  private:
-  gpr_mu* const mu_;
+  Mutex* const mu_;
 };
 
-class ReleasableMutexLock {
+class ABSL_SCOPED_LOCKABLE ReleasableMutexLock {
  public:
-  explicit ReleasableMutexLock(Mutex* mu) : mu_(mu->get()) { gpr_mu_lock(mu_); }
-  explicit ReleasableMutexLock(gpr_mu* mu) : mu_(mu) { gpr_mu_lock(mu_); }
-  ~ReleasableMutexLock() {
-    if (!released_) gpr_mu_unlock(mu_);
+  explicit ReleasableMutexLock(Mutex* mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
+      : mu_(mu) {
+    mu_->Lock();
+  }
+  ~ReleasableMutexLock() ABSL_UNLOCK_FUNCTION() {
+    if (!released_) mu_->Unlock();
   }
 
   ReleasableMutexLock(const ReleasableMutexLock&) = delete;
   ReleasableMutexLock& operator=(const ReleasableMutexLock&) = delete;
 
-  void Lock() {
-    GPR_DEBUG_ASSERT(released_);
-    gpr_mu_lock(mu_);
-    released_ = false;
-  }
-
-  void Unlock() {
+  void Release() ABSL_UNLOCK_FUNCTION() {
     GPR_DEBUG_ASSERT(!released_);
     released_ = true;
-    gpr_mu_unlock(mu_);
+    mu_->Unlock();
   }
 
  private:
-  gpr_mu* const mu_;
+  Mutex* const mu_;
   bool released_ = false;
 };
 
@@ -103,31 +130,67 @@ class CondVar {
   CondVar& operator=(const CondVar&) = delete;
 
   void Signal() { gpr_cv_signal(&cv_); }
-  void Broadcast() { gpr_cv_broadcast(&cv_); }
+  void SignalAll() { gpr_cv_broadcast(&cv_); }
 
-  int Wait(Mutex* mu) { return Wait(mu, gpr_inf_future(GPR_CLOCK_REALTIME)); }
-  int Wait(Mutex* mu, const gpr_timespec& deadline) {
-    return gpr_cv_wait(&cv_, mu->get(), deadline);
+  void Wait(Mutex* mu) { WaitWithDeadline(mu, absl::InfiniteFuture()); }
+  bool WaitWithTimeout(Mutex* mu, absl::Duration timeout) {
+    return gpr_cv_wait(&cv_, &mu->mu_, ToGprTimeSpec(timeout)) != 0;
+  }
+  bool WaitWithDeadline(Mutex* mu, absl::Time deadline) {
+    return gpr_cv_wait(&cv_, &mu->mu_, ToGprTimeSpec(deadline)) != 0;
   }
 
-  template <typename Predicate>
-  void WaitUntil(Mutex* mu, Predicate pred) {
-    while (!pred()) {
-      Wait(mu, gpr_inf_future(GPR_CLOCK_REALTIME));
-    }
+ private:
+  gpr_cv cv_;
+};
+
+#endif  // GPR_ABSEIL_SYNC
+
+// Deprecated. Prefer MutexLock
+class MutexLockForGprMu {
+ public:
+  explicit MutexLockForGprMu(gpr_mu* mu) : mu_(mu) { gpr_mu_lock(mu_); }
+  ~MutexLockForGprMu() { gpr_mu_unlock(mu_); }
+
+  MutexLockForGprMu(const MutexLock&) = delete;
+  MutexLockForGprMu& operator=(const MutexLock&) = delete;
+
+ private:
+  gpr_mu* const mu_;
+};
+
+// Deprecated. Prefer MutexLock or ReleasableMutexLock
+class ABSL_SCOPED_LOCKABLE LockableAndReleasableMutexLock {
+ public:
+  explicit LockableAndReleasableMutexLock(Mutex* mu)
+      ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
+      : mu_(mu) {
+    mu_->Lock();
+  }
+  ~LockableAndReleasableMutexLock() ABSL_UNLOCK_FUNCTION() {
+    if (!released_) mu_->Unlock();
+  }
+
+  LockableAndReleasableMutexLock(const LockableAndReleasableMutexLock&) =
+      delete;
+  LockableAndReleasableMutexLock& operator=(
+      const LockableAndReleasableMutexLock&) = delete;
+
+  void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() {
+    GPR_DEBUG_ASSERT(released_);
+    mu_->Lock();
+    released_ = false;
   }
 
-  // Returns true iff we timed-out
-  template <typename Predicate>
-  bool WaitUntil(Mutex* mu, Predicate pred, const gpr_timespec& deadline) {
-    while (!pred()) {
-      if (Wait(mu, deadline)) return true;
-    }
-    return false;
+  void Release() ABSL_UNLOCK_FUNCTION() {
+    GPR_DEBUG_ASSERT(!released_);
+    released_ = true;
+    mu_->Unlock();
   }
 
  private:
-  gpr_cv cv_;
+  Mutex* const mu_;
+  bool released_ = false;
 };
 
 }  // namespace grpc_core

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

@@ -0,0 +1,411 @@
+// 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_TABLE_H
+#define GRPC_CORE_LIB_GPRPP_TABLE_H
+
+#include <grpc/support/port_platform.h>
+
+#include <utility>
+
+#include "absl/utility/utility.h"
+
+#include "src/core/lib/gprpp/bitset.h"
+
+namespace grpc_core {
+
+// Meta-programming detail types to aid in building up a Table
+namespace table_detail {
+
+// A tuple-like type that contains manually constructed elements.
+template <typename... Ts>
+struct Elements;
+template <typename T, typename... Ts>
+struct Elements<T, Ts...> : Elements<Ts...> {
+  union U {
+    U() {}
+    ~U() {}
+    GPR_NO_UNIQUE_ADDRESS T x;
+  };
+  U u;
+};
+template <>
+struct Elements<> {};
+
+// Element accessor for Elements<>
+// Provides a static method f that returns a pointer to the value of element I
+// for Elements<Ts...>
+template <size_t I, typename... Ts>
+struct GetElem;
+
+template <typename T, typename... Ts>
+struct GetElem<0, T, Ts...> {
+  static T* f(Elements<T, Ts...>* e) { return &e->u.x; }
+  static const T* f(const Elements<T, Ts...>* e) { return &e->u.x; }
+};
+
+template <size_t I, typename T, typename... Ts>
+struct GetElem<I, T, Ts...> {
+  static auto f(Elements<T, Ts...>* e)
+      -> decltype(GetElem<I - 1, Ts...>::f(e)) {
+    return GetElem<I - 1, Ts...>::f(e);
+  }
+  static auto f(const Elements<T, Ts...>* e)
+      -> decltype(GetElem<I - 1, Ts...>::f(e)) {
+    return GetElem<I - 1, Ts...>::f(e);
+  }
+};
+
+// CountIncludedStruct is the backing for the CountIncluded function below.
+// Sets a member constant N to the number of times Needle is in Haystack.
+template <typename Needle, typename... Haystack>
+struct CountIncludedStruct;
+template <typename Needle, typename Straw, typename... RestOfHaystack>
+struct CountIncludedStruct<Needle, Straw, RestOfHaystack...> {
+  static constexpr size_t N =
+      static_cast<size_t>(std::is_same<Needle, Straw>::value) +
+      CountIncludedStruct<Needle, RestOfHaystack...>::N;
+};
+template <typename Needle>
+struct CountIncludedStruct<Needle> {
+  static constexpr size_t N = 0;
+};
+// Returns the number of times Needle is in Haystack.
+template <typename Needle, typename... Haystack>
+constexpr size_t CountIncluded() {
+  return CountIncludedStruct<Needle, Haystack...>::N;
+}
+
+// IndexOfStruct is the backing for IndexOf below.
+// Set a member constant N to the index of Needle in Haystack.
+// Ignored should be void always, and is used for enable_if_t.
+template <typename Ignored, typename Needle, typename... Haystack>
+struct IndexOfStruct;
+template <typename Needle, typename Straw, typename... RestOfHaystack>
+struct IndexOfStruct<absl::enable_if_t<std::is_same<Needle, Straw>::value>,
+                     Needle, Straw, RestOfHaystack...> {
+  // The first element is the one we're looking for. Done.
+  static constexpr size_t N = 0;
+};
+template <typename Needle, typename Straw, typename... RestOfHaystack>
+struct IndexOfStruct<absl::enable_if_t<!std::is_same<Needle, Straw>::value>,
+                     Needle, Straw, RestOfHaystack...> {
+  // The first element is not the one we're looking for, recurse looking at the
+  // tail, and sum the number of recursions.
+  static constexpr size_t N =
+      1 + IndexOfStruct<void, Needle, RestOfHaystack...>::N;
+};
+// Return the index of Needle in Haystack.
+// Guarded by CountIncluded to ensure that the return type is unambiguous.
+// If you got here from a compiler error using Table, it's likely that you've
+// used the type-based accessor/mutators, but the type you're using is repeated
+// more than once in the Table type arguments. Consider either using the indexed
+// accessor/mutator variants, or eliminating the ambiguity in type resolution.
+template <typename Needle, typename... Haystack>
+constexpr absl::enable_if_t<CountIncluded<Needle, Haystack...>() == 1, size_t>
+IndexOf() {
+  return IndexOfStruct<void, Needle, Haystack...>::N;
+}
+
+// TypeIndexStruct is the backing for TypeIndex below.
+// Sets member type Type to the type at index I in Ts.
+// Implemented as a simple type recursion.
+template <size_t I, typename... Ts>
+struct TypeIndexStruct;
+template <typename T, typename... Ts>
+struct TypeIndexStruct<0, T, Ts...> {
+  using Type = T;
+};
+template <size_t I, typename T, typename... Ts>
+struct TypeIndexStruct<I, T, Ts...> : TypeIndexStruct<I - 1, Ts...> {};
+// TypeIndex is the type at index I in Ts.
+template <size_t I, typename... Ts>
+using TypeIndex = typename TypeIndexStruct<I, Ts...>::Type;
+
+// Helper to call the destructor of p if p is non-null.
+template <typename T>
+void DestructIfNotNull(T* p) {
+  if (p) p->~T();
+}
+
+// Helper function... just ignore the initializer list passed into it.
+// Allows doing 'statements' via parameter pack expansion in C++11 - given
+// template <typename... Ts>:
+//  do_these_things({(foo<Ts>(), 1)});
+// will execute foo<T>() for each T in Ts.
+// In this example we also leverage the comma operator to make the resultant
+// type of each statement be a consistant int so that C++ type deduction works
+// as we'd like (note that in the expression (a, 1) in C++, the 'result' of the
+// expression is the value after the right-most ',' -- in this case 1, with a
+// executed as a side effect.
+template <typename T>
+void do_these_things(std::initializer_list<T>) {}
+
+}  // namespace table_detail
+
+// A Table<Ts> is much like a tuple<optional<Ts>...> - a set of values that are
+// optionally present. Table efficiently packs the presence bits for size, and
+// provides a slightly more convenient interface.
+template <typename... Ts>
+class Table {
+  // Helper - TypeIndex<I> is the type at index I in Ts
+  template <size_t I>
+  using TypeIndex = table_detail::TypeIndex<I, Ts...>;
+
+ public:
+  // Construct a table with no values set.
+  Table() = default;
+  // Destruct - forwards to the Destruct member with an integer sequence so we
+  // can destruct field-wise.
+  ~Table() { Destruct(absl::make_index_sequence<sizeof...(Ts)>()); }
+
+  // Copy another table
+  Table(const Table& rhs) {
+    // Since we know all fields are clear initially, pass false for or_clear.
+    Copy<false>(absl::make_index_sequence<sizeof...(Ts)>(), rhs);
+  }
+
+  // Copy another table
+  Table& operator=(const Table& rhs) {
+    // Since we may not be all clear, pass true for or_clear to have Copy()
+    // clear newly emptied fields.
+    Copy<true>(absl::make_index_sequence<sizeof...(Ts)>(), rhs);
+    return *this;
+  }
+
+  // Move from another table
+  Table(Table&& rhs) noexcept {
+    // Since we know all fields are clear initially, pass false for or_clear.
+    Move<false>(absl::make_index_sequence<sizeof...(Ts)>(),
+                std::forward<Table>(rhs));
+  }
+
+  // Move from another table
+  Table& operator=(Table&& rhs) noexcept {
+    // Since we may not be all clear, pass true for or_clear to have Move()
+    // clear newly emptied fields.
+    Move<true>(absl::make_index_sequence<sizeof...(Ts)>(),
+               std::forward<Table>(rhs));
+    return *this;
+  }
+
+  // Check if this table has a value for type T.
+  // Only available if there exists only one T in Ts.
+  template <typename T>
+  bool has() const {
+    return has<index_of<T>()>();
+  }
+
+  // Check if this table has index I.
+  template <size_t I>
+      absl::enable_if_t < I<sizeof...(Ts), bool> has() const {
+    return present_bits_.is_set(I);
+  }
+
+  // Return the value for type T, or nullptr if it is un-set.
+  // Only available if there exists only one T in Ts.
+  template <typename T>
+  T* get() {
+    return get<index_of<T>()>();
+  }
+
+  // Return the value for type T, or nullptr if it is un-set.
+  // Only available if there exists only one T in Ts.
+  template <typename T>
+  const T* get() const {
+    return get<index_of<T>()>();
+  }
+
+  // Return the value for index I, or nullptr if it is un-set.
+  template <size_t I>
+  TypeIndex<I>* get() {
+    if (has<I>()) return element_ptr<I>();
+    return nullptr;
+  }
+
+  // Return the value for index I, or nullptr if it is un-set.
+  template <size_t I>
+  const TypeIndex<I>* get() const {
+    if (has<I>()) return element_ptr<I>();
+    return nullptr;
+  }
+
+  // Return the value for type T, default constructing it if it is un-set.
+  template <typename T>
+  T* get_or_create() {
+    return get_or_create<index_of<T>()>();
+  }
+
+  // Return the value for index I, default constructing it if it is un-set.
+  template <size_t I>
+  TypeIndex<I>* get_or_create() {
+    auto* p = element_ptr<I>();
+    if (!set_present<I>(true)) {
+      new (p) TypeIndex<I>();
+    }
+    return element_ptr<I>();
+  }
+
+  // Set the value for type T - using Args as construction arguments.
+  template <typename T, typename... Args>
+  T* set(Args&&... args) {
+    return set<index_of<T>()>(std::forward<Args>(args)...);
+  }
+
+  // Set the value for index I - using Args as construction arguments.
+  template <size_t I, typename... Args>
+  TypeIndex<I>* set(Args&&... args) {
+    auto* p = element_ptr<I>();
+    if (set_present<I>(true)) {
+      *p = TypeIndex<I>(std::forward<Args>(args)...);
+    } else {
+      new (p) TypeIndex<I>(std::forward<Args>(args)...);
+    }
+    return p;
+  }
+
+  // Clear the value for type T, leaving it un-set.
+  template <typename T>
+  void clear() {
+    clear<index_of<T>()>();
+  }
+
+  // Clear the value for index I, leaving it un-set.
+  template <size_t I>
+  void clear() {
+    if (set_present<I>(false)) {
+      using T = TypeIndex<I>;
+      element_ptr<I>()->~T();
+    }
+  }
+
+  // Iterate through each set field in the table
+  template <typename F>
+  void ForEach(F f) const {
+    ForEachImpl(std::move(f), absl::make_index_sequence<sizeof...(Ts)>());
+  }
+
+  // Count the number of set fields in the table
+  size_t count() const { return present_bits_.count(); }
+
+ private:
+  // Bit field for which elements of the table are set (true) or un-set (false,
+  // the default) -- one bit for each type in Ts.
+  using PresentBits = BitSet<sizeof...(Ts)>;
+  // The tuple-like backing structure for Table.
+  using Elements = table_detail::Elements<Ts...>;
+  // Extractor from Elements
+  template <size_t I>
+  using GetElem = table_detail::GetElem<I, Ts...>;
+
+  // Given a T, return the unambiguous index of it within Ts.
+  template <typename T>
+  static constexpr size_t index_of() {
+    return table_detail::IndexOf<T, Ts...>();
+  }
+
+  // Given an index, return a point to the (maybe uninitialized!) data value at
+  // index I.
+  template <size_t I>
+  TypeIndex<I>* element_ptr() {
+    return GetElem<I>::f(&elements_);
+  }
+
+  // Given an index, return a point to the (maybe uninitialized!) data value at
+  // index I.
+  template <size_t I>
+  const TypeIndex<I>* element_ptr() const {
+    return GetElem<I>::f(&elements_);
+  }
+
+  // Set the present bit to value (if true - value is present/set, if false,
+  // value is un-set). Returns the old value so that calling code can note
+  // transition edges.
+  template <size_t I>
+  bool set_present(bool value) {
+    bool out = present_bits_.is_set(I);
+    present_bits_.set(I, value);
+    return out;
+  }
+
+  // Set the value of index I to the value held in rhs index I if it is set.
+  // If it is unset, if or_clear is true, then clear our value, otherwise do
+  // nothing.
+  template <bool or_clear, size_t I>
+  void CopyIf(const Table& rhs) {
+    if (auto* p = rhs.get<I>()) {
+      set<I>(*p);
+    } else if (or_clear) {
+      clear<I>();
+    }
+  }
+
+  // Set the value of index I to the value moved from rhs index I if it was set.
+  // If it is unset, if or_clear is true, then clear our value, otherwise do
+  // nothing.
+  template <bool or_clear, size_t I>
+  void MoveIf(Table&& rhs) {
+    if (auto* p = rhs.get<I>()) {
+      set<I>(std::move(*p));
+    } else if (or_clear) {
+      clear<I>();
+    }
+  }
+
+  // Call (*f)(value) if that value is in the table.
+  template <size_t I, typename F>
+  void CallIf(F* f) const {
+    if (auto* p = get<I>()) {
+      (*f)(*p);
+    }
+  }
+
+  // For each field (element I=0, 1, ...) if that field is present, call its
+  // destructor.
+  template <size_t... I>
+  void Destruct(absl::index_sequence<I...>) {
+    table_detail::do_these_things<int>(
+        {(table_detail::DestructIfNotNull(get<I>()), 1)...});
+  }
+
+  // For each field (element I=0, 1, ...) copy that field into this table -
+  // or_clear as per CopyIf().
+  template <bool or_clear, size_t... I>
+  void Copy(absl::index_sequence<I...>, const Table& rhs) {
+    table_detail::do_these_things<int>({(CopyIf<or_clear, I>(rhs), 1)...});
+  }
+
+  // For each field (element I=0, 1, ...) move that field into this table -
+  // or_clear as per MoveIf().
+  template <bool or_clear, size_t... I>
+  void Move(absl::index_sequence<I...>, Table&& rhs) {
+    table_detail::do_these_things<int>(
+        {(MoveIf<or_clear, I>(std::forward<Table>(rhs)), 1)...});
+  }
+
+  // For each field (element I=0, 1, ...) if that field is present, call f.
+  template <typename F, size_t... I>
+  void ForEachImpl(F f, absl::index_sequence<I...>) const {
+    table_detail::do_these_things<int>({(CallIf<I>(&f), 1)...});
+  }
+
+  // Bit field indicating which elements are set.
+  GPR_NO_UNIQUE_ADDRESS PresentBits present_bits_;
+  // The memory to store the elements themselves.
+  GPR_NO_UNIQUE_ADDRESS Elements elements_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_TABLE_H

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

@@ -157,7 +157,7 @@ class Thread {
   Thread& operator=(const Thread&) = delete;
 
   /// The thread states are as follows:
-  /// FAKE -- just a dummy placeholder Thread created by the default constructor
+  /// FAKE -- just a phony placeholder Thread created by the default constructor
   /// ALIVE -- an actual thread of control exists associated with this thread
   /// STARTED -- the thread of control has been started
   /// DONE -- the thread of control has completed and been joined

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

@@ -22,20 +22,20 @@
 
 #ifdef GPR_POSIX_SYNC
 
-#include "src/core/lib/gprpp/thd.h"
+#include <pthread.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/thd_id.h>
-#include <pthread.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
 
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/fork.h"
 #include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/gprpp/thd.h"
 
 namespace grpc_core {
 namespace {
@@ -199,6 +199,11 @@ Thread::Thread(const char* thd_name, void (*thd_body)(void* arg), void* arg,
 }  // namespace grpc_core
 
 // The following is in the external namespace as it is exposed as C89 API
-gpr_thd_id gpr_thd_currentid(void) { return (gpr_thd_id)pthread_self(); }
+gpr_thd_id gpr_thd_currentid(void) {
+  // Use C-style casting because Linux and OSX have different definitions
+  // of pthread_t so that a single C++ cast doesn't handle it.
+  // NOLINTNEXTLINE(google-readability-casting)
+  return (gpr_thd_id)pthread_self();
+}
 
 #endif /* GPR_POSIX_SYNC */