grpc 1.84.1 → 1.85.0.pre1

data/third_party/abseil-cpp/absl/strings/substitute.cc

@@ -26,7 +26,7 @@
 #include "absl/base/nullability.h"
 #include "absl/strings/ascii.h"
 #include "absl/strings/escaping.h"
-#include "absl/strings/internal/resize_uninitialized.h"
+#include "absl/strings/internal/append_and_overwrite.h"
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
@@ -85,29 +85,29 @@ void SubstituteAndAppendArray(std::string* absl_nonnull output,
   if (size == 0) return;
 
   // Build the string.
-  size_t original_size = output->size();
-  ABSL_INTERNAL_CHECK(
-      size <= std::numeric_limits<size_t>::max() - original_size,
-      "size_t overflow");
-  strings_internal::STLStringResizeUninitializedAmortized(output,
-                                                          original_size + size);
-  char* target = &(*output)[original_size];
-  for (size_t i = 0; i < format.size(); i++) {
-    if (format[i] == '$') {
-      if (absl::ascii_isdigit(static_cast<unsigned char>(format[i + 1]))) {
-        const absl::string_view src = args_array[format[i + 1] - '0'];
-        target = std::copy(src.begin(), src.end(), target);
-        ++i;  // Skip next char.
-      } else if (format[i + 1] == '$') {
-        *target++ = '$';
-        ++i;  // Skip next char.
-      }
-    } else {
-      *target++ = format[i];
-    }
-  }
-
-  assert(target == output->data() + output->size());
+  ABSL_INTERNAL_CHECK(size <= output->max_size() - output->size(),
+                      "Exceeds std::string::max_size()");
+  strings_internal::StringAppendAndOverwrite(
+      *output, size, [format, args_array](char* const buf, size_t buf_size) {
+        char* target = buf;
+        for (size_t i = 0; i < format.size(); i++) {
+          if (format[i] == '$') {
+            if (absl::ascii_isdigit(
+                    static_cast<unsigned char>(format[i + 1]))) {
+              const absl::string_view src = args_array[format[i + 1] - '0'];
+              target = std::copy(src.begin(), src.end(), target);
+              ++i;  // Skip next char.
+            } else if (format[i + 1] == '$') {
+              *target++ = '$';
+              ++i;  // Skip next char.
+            }
+          } else {
+            *target++ = format[i];
+          }
+        }
+        assert(target == buf + buf_size);
+        return buf_size;
+      });
 }
 
 Arg::Arg(const void* absl_nullable value) {

data/third_party/abseil-cpp/absl/strings/substitute.h

@@ -123,9 +123,9 @@ class Arg {
   // probably using them as 8-bit integers and would probably prefer an integer
   // representation. However, we can't really know, so we make the caller decide
   // what to do.
-  Arg(char value)  // NOLINT(google-explicit-constructor)
-      : piece_(scratch_, 1) {
+  Arg(char value) {  // NOLINT(google-explicit-constructor)
     scratch_[0] = value;
+    piece_ = absl::string_view(scratch_, 1);
   }
   Arg(short value)  // NOLINT(*)
       : piece_(scratch_,

data/third_party/abseil-cpp/absl/synchronization/barrier.cc

@@ -26,7 +26,7 @@ static bool IsZero(void *arg) {
 }
 
 bool Barrier::Block() {
-  MutexLock l(&this->lock_);
+  MutexLock l(this->lock_);
 
   this->num_to_block_--;
   if (this->num_to_block_ < 0) {

data/third_party/abseil-cpp/absl/synchronization/blocking_counter.cc

@@ -42,7 +42,7 @@ bool BlockingCounter::DecrementCount() {
                  "BlockingCounter::DecrementCount() called too many times");
   if (count == 0) {
     base_internal::TraceSignal(this, TraceObjectKind());
-    MutexLock l(&lock_);
+    MutexLock l(lock_);
     done_ = true;
     return true;
   }
@@ -52,7 +52,7 @@ bool BlockingCounter::DecrementCount() {
 void BlockingCounter::Wait() {
   base_internal::TraceWait(this, TraceObjectKind());
   {
-    MutexLock l(&this->lock_);
+    MutexLock l(this->lock_);
 
     // only one thread may call Wait(). To support more than one thread,
     // implement a counter num_to_exit, like in the Barrier class.

data/third_party/abseil-cpp/absl/synchronization/internal/create_thread_identity.cc

@@ -35,7 +35,7 @@ namespace synchronization_internal {
 // ThreadIdentity storage is persistent, we maintain a free-list of previously
 // released ThreadIdentity objects.
 ABSL_CONST_INIT static base_internal::SpinLock freelist_lock(
-    absl::kConstInit, base_internal::SCHEDULE_KERNEL_ONLY);
+    base_internal::SCHEDULE_KERNEL_ONLY);
 ABSL_CONST_INIT static base_internal::ThreadIdentity* thread_identity_freelist;
 
 // A per-thread destructor for reclaiming associated ThreadIdentity objects.
@@ -60,7 +60,7 @@ static void ReclaimThreadIdentity(void* v) {
   //     association state in this case.
   base_internal::ClearCurrentThreadIdentity();
   {
-    base_internal::SpinLockHolder l(&freelist_lock);
+    base_internal::SpinLockHolder l(freelist_lock);
     identity->next = thread_identity_freelist;
     thread_identity_freelist = identity;
   }
@@ -77,6 +77,16 @@ void OneTimeInitThreadIdentity(base_internal::ThreadIdentity* identity) {
   identity->ticker.store(0, std::memory_order_relaxed);
   identity->wait_start.store(0, std::memory_order_relaxed);
   identity->is_idle.store(false, std::memory_order_relaxed);
+  // To avoid a circular dependency we declare only the storage in the header
+  // and use placement new to construct the SpinLock.
+  static_assert(
+      sizeof(base_internal::ThreadIdentity::SchedulerState::
+                 association_lock_word) == sizeof(base_internal::SpinLock),
+      "Wrong size for SpinLock");
+  // Protects the association between this identity and its schedulable.  Should
+  // never be cooperative.
+  new (&identity->scheduler_state.association_lock_word)
+      base_internal::SpinLock(base_internal::SCHEDULE_KERNEL_ONLY);
 }
 
 static void ResetThreadIdentityBetweenReuse(
@@ -96,6 +106,17 @@ static void ResetThreadIdentityBetweenReuse(
   pts->wake = false;
   pts->cond_waiter = false;
   pts->all_locks = nullptr;
+  base_internal::ThreadIdentity::SchedulerState* ss =
+      &identity->scheduler_state;
+  ss->bound_schedulable.store(nullptr, std::memory_order_relaxed);
+  ss->association_lock_word = 0;
+  ss->scheduling_disabled_depth.store(0, std::memory_order_relaxed);
+  ss->potentially_blocking_depth = 0;
+  ss->schedule_next_state = 0;
+  ss->waking_designated_waker = false;
+  identity->static_initialization_depth = 0;
+  identity->wait_state.store(base_internal::ThreadIdentity::WaitState::kActive,
+                             std::memory_order_relaxed);
   identity->blocked_count_ptr = nullptr;
   identity->ticker.store(0, std::memory_order_relaxed);
   identity->wait_start.store(0, std::memory_order_relaxed);
@@ -108,7 +129,7 @@ static base_internal::ThreadIdentity* NewThreadIdentity() {
 
   {
     // Re-use a previously released object if possible.
-    base_internal::SpinLockHolder l(&freelist_lock);
+    base_internal::SpinLockHolder l(freelist_lock);
     if (thread_identity_freelist) {
       identity = thread_identity_freelist;  // Take list-head.
       thread_identity_freelist = thread_identity_freelist->next;

data/third_party/abseil-cpp/absl/synchronization/internal/graphcycles.cc

@@ -33,15 +33,15 @@
 #include "absl/base/internal/low_level_alloc.h"
 #ifndef ABSL_LOW_LEVEL_ALLOC_MISSING
 
-#include "absl/synchronization/internal/graphcycles.h"
-
 #include <algorithm>
 #include <array>
 #include <cinttypes>
 #include <limits>
+
 #include "absl/base/internal/hide_ptr.h"
 #include "absl/base/internal/raw_logging.h"
 #include "absl/base/internal/spinlock.h"
+#include "absl/synchronization/internal/graphcycles.h"
 
 // Do not use STL.   This module does not use standard memory allocation.
 
@@ -54,15 +54,14 @@ namespace {
 // Avoid LowLevelAlloc's default arena since it calls malloc hooks in
 // which people are doing things like acquiring Mutexes.
 ABSL_CONST_INIT static absl::base_internal::SpinLock arena_mu(
-    absl::kConstInit, base_internal::SCHEDULE_KERNEL_ONLY);
+    base_internal::SCHEDULE_KERNEL_ONLY);
 ABSL_CONST_INIT static base_internal::LowLevelAlloc::Arena* arena;
 
 static void InitArenaIfNecessary() {
-  arena_mu.Lock();
+  base_internal::SpinLockHolder l(arena_mu);
   if (arena == nullptr) {
     arena = base_internal::LowLevelAlloc::NewArena(0);
   }
-  arena_mu.Unlock();
 }
 
 // Number of inlined elements in Vec.  Hash table implementation
@@ -89,7 +88,7 @@ class Vec {
   T* end() { return ptr_ + size_; }
   const T& operator[](uint32_t i) const { return ptr_[i]; }
   T& operator[](uint32_t i) { return ptr_[i]; }
-  const T& back() const { return ptr_[size_-1]; }
+  const T& back() const { return ptr_[size_ - 1]; }
   void pop_back() { size_--; }
 
   void push_back(const T& v) {
@@ -178,7 +177,7 @@ class NodeSet {
     }
     table_[i] = v;
     // Double when 75% full.
-    if (occupied_ >= table_.size() - table_.size()/4) Grow();
+    if (occupied_ >= table_.size() - table_.size() / 4) Grow();
     return true;
   }
 
@@ -193,7 +192,7 @@ class NodeSet {
   // Example:
   //    HASH_FOR_EACH(elem, node->out) { ... }
 #define HASH_FOR_EACH(elem, eset) \
-  for (int32_t elem, _cursor = 0; (eset).Next(&_cursor, &elem); )
+  for (int32_t elem, _cursor = 0; (eset).Next(&_cursor, &elem);)
   bool Next(int32_t* cursor, int32_t* elem) {
     while (static_cast<uint32_t>(*cursor) < table_.size()) {
       int32_t v = table_[static_cast<uint32_t>(*cursor)];
@@ -209,7 +208,7 @@ class NodeSet {
  private:
   enum : int32_t { kEmpty = -1, kDel = -2 };
   Vec<int32_t> table_;
-  uint32_t occupied_;     // Count of non-empty slots (includes deleted slots)
+  uint32_t occupied_;  // Count of non-empty slots (includes deleted slots)
 
   static uint32_t Hash(int32_t a) { return static_cast<uint32_t>(a) * 41; }
 
@@ -270,25 +269,23 @@ inline GraphId MakeId(int32_t index, uint32_t version) {
   return g;
 }
 
-inline int32_t NodeIndex(GraphId id) {
-  return static_cast<int32_t>(id.handle);
-}
+inline int32_t NodeIndex(GraphId id) { return static_cast<int32_t>(id.handle); }
 
 inline uint32_t NodeVersion(GraphId id) {
   return static_cast<uint32_t>(id.handle >> 32);
 }
 
 struct Node {
-  int32_t rank;               // rank number assigned by Pearce-Kelly algorithm
-  uint32_t version;           // Current version number
-  int32_t next_hash;          // Next entry in hash table
-  bool visited;               // Temporary marker used by depth-first-search
-  uintptr_t masked_ptr;       // User-supplied pointer
-  NodeSet in;                 // List of immediate predecessor nodes in graph
-  NodeSet out;                // List of immediate successor nodes in graph
-  int priority;               // Priority of recorded stack trace.
-  int nstack;                 // Depth of recorded stack trace.
-  void* stack[40];            // stack[0,nstack-1] holds stack trace for node.
+  int32_t rank;          // rank number assigned by Pearce-Kelly algorithm
+  uint32_t version;      // Current version number
+  int32_t next_hash;     // Next entry in hash table
+  bool visited;          // Temporary marker used by depth-first-search
+  uintptr_t masked_ptr;  // User-supplied pointer
+  NodeSet in;            // List of immediate predecessor nodes in graph
+  NodeSet out;           // List of immediate successor nodes in graph
+  int priority;          // Priority of recorded stack trace.
+  int nstack;            // Depth of recorded stack trace.
+  void* stack[40];       // stack[0,nstack-1] holds stack trace for node.
 };
 
 // Hash table for pointer to node index lookups.
@@ -318,7 +315,7 @@ class PointerMap {
     // Advance through linked list while keeping track of the
     // predecessor slot that points to the current entry.
     auto masked = base_internal::HidePtr(ptr);
-    for (int32_t* slot = &table_[Hash(ptr)]; *slot != -1; ) {
+    for (int32_t* slot = &table_[Hash(ptr)]; *slot != -1;) {
       int32_t index = *slot;
       Node* n = (*nodes_)[static_cast<uint32_t>(index)];
       if (n->masked_ptr == masked) {
@@ -381,7 +378,9 @@ GraphCycles::GraphCycles() {
 
 GraphCycles::~GraphCycles() {
   for (auto* node : rep_->nodes_) {
-    if (node == nullptr) { continue; }
+    if (node == nullptr) {
+      continue;
+    }
     node->Node::~Node();
     base_internal::LowLevelAlloc::Free(node);
   }
@@ -474,8 +473,7 @@ void GraphCycles::RemoveNode(void* ptr) {
 
 void* GraphCycles::Ptr(GraphId id) {
   Node* n = FindNode(rep_, id);
-  return n == nullptr ? nullptr
-                      : base_internal::UnhidePtr<void>(n->masked_ptr);
+  return n == nullptr ? nullptr : base_internal::UnhidePtr<void>(n->masked_ptr);
 }
 
 bool GraphCycles::HasNode(GraphId node) {
@@ -502,8 +500,8 @@ static bool ForwardDFS(GraphCycles::Rep* r, int32_t n, int32_t upper_bound);
 static void BackwardDFS(GraphCycles::Rep* r, int32_t n, int32_t lower_bound);
 static void Reorder(GraphCycles::Rep* r);
 static void Sort(const Vec<Node*>&, Vec<int32_t>* delta);
-static void MoveToList(
-    GraphCycles::Rep* r, Vec<int32_t>* src, Vec<int32_t>* dst);
+static void MoveToList(GraphCycles::Rep* r, Vec<int32_t>* src,
+                       Vec<int32_t>* dst);
 
 bool GraphCycles::InsertEdge(GraphId idx, GraphId idy) {
   Rep* r = rep_;
@@ -605,9 +603,8 @@ static void Reorder(GraphCycles::Rep* r) {
 
   // Produce sorted list of all ranks that will be reassigned.
   r->merged_.resize(r->deltab_.size() + r->deltaf_.size());
-  std::merge(r->deltab_.begin(), r->deltab_.end(),
-             r->deltaf_.begin(), r->deltaf_.end(),
-             r->merged_.begin());
+  std::merge(r->deltab_.begin(), r->deltab_.end(), r->deltaf_.begin(),
+             r->deltaf_.end(), r->merged_.begin());
 
   // Assign the ranks in order to the collected list.
   for (uint32_t i = 0; i < r->list_.size(); i++) {
@@ -628,8 +625,8 @@ static void Sort(const Vec<Node*>& nodes, Vec<int32_t>* delta) {
   std::sort(delta->begin(), delta->end(), cmp);
 }
 
-static void MoveToList(
-    GraphCycles::Rep* r, Vec<int32_t>* src, Vec<int32_t>* dst) {
+static void MoveToList(GraphCycles::Rep* r, Vec<int32_t>* src,
+                       Vec<int32_t>* dst) {
   for (auto& v : *src) {
     int32_t w = v;
     // Replace v entry with its rank

data/third_party/abseil-cpp/absl/synchronization/internal/kernel_timeout.h

@@ -129,8 +129,8 @@ class KernelTimeout {
   std::chrono::nanoseconds ToChronoDuration() const;
 
   // Returns true if steady (aka monotonic) clocks are supported by the system.
-  // This method exists because go/btm requires synchronized clocks, and
-  // thus requires we use the system (aka walltime) clock.
+  // This currently returns true on all platforms, but we have encountered
+  // platforms that once lacked steady clock support.
   static constexpr bool SupportsSteadyClock() { return true; }
 
  private:

data/third_party/abseil-cpp/absl/synchronization/internal/per_thread_sem.h

@@ -31,6 +31,10 @@
 #include "absl/synchronization/internal/create_thread_identity.h"
 #include "absl/synchronization/internal/kernel_timeout.h"
 
+namespace gloop_do_not_use {
+struct SynchronizationBenchmarkPeer;
+}  // namespace gloop_do_not_use
+
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 
@@ -77,6 +81,7 @@ class PerThreadSem {
   // Permitted callers.
   friend class PerThreadSemTest;
   friend class absl::Mutex;
+  friend struct ::gloop_do_not_use::SynchronizationBenchmarkPeer;
   friend void OneTimeInitThreadIdentity(absl::base_internal::ThreadIdentity*);
 };
 

data/third_party/abseil-cpp/absl/synchronization/mutex.cc

@@ -226,7 +226,7 @@ static bool AtomicSetBits(std::atomic<intptr_t>* pv, intptr_t bits,
 
 // Data for doing deadlock detection.
 ABSL_CONST_INIT static absl::base_internal::SpinLock deadlock_graph_mu(
-    absl::kConstInit, base_internal::SCHEDULE_KERNEL_ONLY);
+    base_internal::SCHEDULE_KERNEL_ONLY);
 
 // Graph used to detect deadlocks.
 ABSL_CONST_INIT static GraphCycles* deadlock_graph
@@ -292,7 +292,7 @@ static const struct {
 };
 
 ABSL_CONST_INIT static absl::base_internal::SpinLock synch_event_mu(
-    absl::kConstInit, base_internal::SCHEDULE_KERNEL_ONLY);
+    base_internal::SCHEDULE_KERNEL_ONLY);
 
 // Hash table size; should be prime > 2.
 // Can't be too small, as it's used for deadlock detection information.
@@ -330,7 +330,7 @@ static SynchEvent* EnsureSynchEvent(std::atomic<intptr_t>* addr,
                                     const char* name, intptr_t bits,
                                     intptr_t lockbit) {
   uint32_t h = reinterpret_cast<uintptr_t>(addr) % kNSynchEvent;
-  synch_event_mu.Lock();
+  synch_event_mu.lock();
   // When a Mutex/CondVar is destroyed, we don't remove the associated
   // SynchEvent to keep destructors empty in release builds for performance
   // reasons. If the current call is the first to set bits (kMuEvent/kCVEvent),
@@ -392,16 +392,16 @@ static SynchEvent* EnsureSynchEvent(std::atomic<intptr_t>* addr,
   } else {
     e->refcount++;  // for return value
   }
-  synch_event_mu.Unlock();
+  synch_event_mu.unlock();
   return e;
 }
 
 // Decrement the reference count of *e, or do nothing if e==null.
 static void UnrefSynchEvent(SynchEvent* e) {
   if (e != nullptr) {
-    synch_event_mu.Lock();
+    synch_event_mu.lock();
     bool del = (--(e->refcount) == 0);
-    synch_event_mu.Unlock();
+    synch_event_mu.unlock();
     if (del) {
       base_internal::LowLevelAlloc::Free(e);
     }
@@ -414,7 +414,7 @@ static void UnrefSynchEvent(SynchEvent* e) {
 static SynchEvent* GetSynchEvent(const void* addr) {
   uint32_t h = reinterpret_cast<uintptr_t>(addr) % kNSynchEvent;
   SynchEvent* e;
-  synch_event_mu.Lock();
+  synch_event_mu.lock();
   for (e = synch_event[h];
        e != nullptr && e->masked_addr != base_internal::HidePtr(addr);
        e = e->next) {
@@ -422,7 +422,7 @@ static SynchEvent* GetSynchEvent(const void* addr) {
   if (e != nullptr) {
     e->refcount++;
   }
-  synch_event_mu.Unlock();
+  synch_event_mu.unlock();
   return e;
 }
 
@@ -509,10 +509,10 @@ struct SynchWaitParams {
   const Condition* cond;   // The condition that this thread is waiting for.
                            // In Mutex, this field is set to zero if a timeout
                            // expires.
-  KernelTimeout timeout;  // timeout expiry---absolute time
-                          // In Mutex, this field is set to zero if a timeout
-                          // expires.
-  Mutex* const cvmu;      // used for transfer from cond var to mutex
+  KernelTimeout timeout;   // timeout expiry---absolute time
+                           // In Mutex, this field is set to zero if a timeout
+                           // expires.
+  Mutex* const cvmu;       // used for transfer from cond var to mutex
   PerThreadSynch* const thread;  // thread that is waiting
 
   // If not null, thread should be enqueued on the CondVar whose state
@@ -745,7 +745,8 @@ static unsigned TsanFlags(Mutex::MuHow how) {
 Mutex::~Mutex() { Dtor(); }
 #endif
 
-#if !defined(NDEBUG) || defined(ABSL_HAVE_THREAD_SANITIZER)
+#if !defined(NDEBUG) || defined(ABSL_HAVE_THREAD_SANITIZER) || \
+    defined(ABSL_BUILD_DLL)
 void Mutex::Dtor() {
   if (kDebugMode) {
     this->ForgetDeadlockInfo();
@@ -1223,9 +1224,8 @@ static GraphId GetGraphIdLocked(Mutex* mu)
 }
 
 static GraphId GetGraphId(Mutex* mu) ABSL_LOCKS_EXCLUDED(deadlock_graph_mu) {
-  deadlock_graph_mu.Lock();
+  base_internal::SpinLockHolder l(deadlock_graph_mu);
   GraphId id = GetGraphIdLocked(mu);
-  deadlock_graph_mu.Unlock();
   return id;
 }
 
@@ -1327,8 +1327,7 @@ static char* StackString(void** pcs, int n, char* buf, int maxlen,
   char sym[kSymLen];
   int len = 0;
   for (int i = 0; i != n; i++) {
-    if (len >= maxlen)
-      return buf;
+    if (len >= maxlen) return buf;
     size_t count = static_cast<size_t>(maxlen - len);
     if (symbolize) {
       if (!absl::Symbolize(pcs[i], sym, kSymLen)) {
@@ -1387,7 +1386,7 @@ static GraphId DeadlockCheck(Mutex* mu) {
 
   SynchLocksHeld* all_locks = Synch_GetAllLocks();
 
-  absl::base_internal::SpinLockHolder lock(&deadlock_graph_mu);
+  absl::base_internal::SpinLockHolder lock(deadlock_graph_mu);
   const GraphId mu_id = GetGraphIdLocked(mu);
 
   if (all_locks->n == 0) {
@@ -1457,7 +1456,7 @@ static GraphId DeadlockCheck(Mutex* mu) {
       }
       if (synch_deadlock_detection.load(std::memory_order_acquire) ==
           OnDeadlockCycle::kAbort) {
-        deadlock_graph_mu.Unlock();  // avoid deadlock in fatal sighandler
+        deadlock_graph_mu.unlock();  // avoid deadlock in fatal sighandler
         ABSL_RAW_LOG(FATAL, "dying due to potential deadlock");
         return mu_id;
       }
@@ -1482,11 +1481,11 @@ static inline GraphId DebugOnlyDeadlockCheck(Mutex* mu) {
 void Mutex::ForgetDeadlockInfo() {
   if (kDebugMode && synch_deadlock_detection.load(std::memory_order_acquire) !=
                         OnDeadlockCycle::kIgnore) {
-    deadlock_graph_mu.Lock();
+    deadlock_graph_mu.lock();
     if (deadlock_graph != nullptr) {
       deadlock_graph->RemoveNode(this);
     }
-    deadlock_graph_mu.Unlock();
+    deadlock_graph_mu.unlock();
   }
 }
 
@@ -1528,7 +1527,7 @@ static bool TryAcquireWithSpinning(std::atomic<intptr_t>* mu) {
   return false;
 }
 
-void Mutex::Lock() {
+void Mutex::lock() {
   ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
   GraphId id = DebugOnlyDeadlockCheck(this);
   intptr_t v = mu_.load(std::memory_order_relaxed);
@@ -1546,7 +1545,7 @@ void Mutex::Lock() {
   ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
 }
 
-void Mutex::ReaderLock() {
+void Mutex::lock_shared() {
   ABSL_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_read_lock);
   GraphId id = DebugOnlyDeadlockCheck(this);
   intptr_t v = mu_.load(std::memory_order_relaxed);
@@ -1606,7 +1605,7 @@ bool Mutex::AwaitCommon(const Condition& cond, KernelTimeout t) {
   return res;
 }
 
-bool Mutex::TryLock() {
+bool Mutex::try_lock() {
   ABSL_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_try_lock);
   intptr_t v = mu_.load(std::memory_order_relaxed);
   // Try fast acquire.
@@ -1644,7 +1643,7 @@ ABSL_ATTRIBUTE_NOINLINE bool Mutex::TryLockSlow() {
   return false;
 }
 
-bool Mutex::ReaderTryLock() {
+bool Mutex::try_lock_shared() {
   ABSL_TSAN_MUTEX_PRE_LOCK(this,
                            __tsan_mutex_read_lock | __tsan_mutex_try_lock);
   intptr_t v = mu_.load(std::memory_order_relaxed);
@@ -1706,7 +1705,7 @@ ABSL_ATTRIBUTE_NOINLINE bool Mutex::ReaderTryLockSlow() {
   return false;
 }
 
-void Mutex::Unlock() {
+void Mutex::unlock() {
   ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0);
   DebugOnlyLockLeave(this);
   intptr_t v = mu_.load(std::memory_order_relaxed);
@@ -1776,7 +1775,7 @@ static bool ExactlyOneReader(intptr_t v) {
   return (v & kMuMultipleWaitersMask) == 0;
 }
 
-void Mutex::ReaderUnlock() {
+void Mutex::unlock_shared() {
   ABSL_TSAN_MUTEX_PRE_UNLOCK(this, __tsan_mutex_read_lock);
   DebugOnlyLockLeave(this);
   intptr_t v = mu_.load(std::memory_order_relaxed);
@@ -2140,6 +2139,8 @@ ABSL_ATTRIBUTE_NOINLINE void Mutex::UnlockSlow(SynchWaitParams* waitp) {
   intptr_t wr_wait = 0;  // set to kMuWrWait if we wake a reader and a
                          // later writer could have acquired the lock
                          // (starvation avoidance)
+  // When non-null, clear its "woken_has_waiters" field before returning.
+  absl::base_internal::ThreadIdentity* clear_waking_des_waker = nullptr;
   ABSL_RAW_CHECK(waitp == nullptr || waitp->thread->waitp == nullptr ||
                      waitp->thread->suppress_fatal_errors,
                  "detected illegal recursion into Mutex code");
@@ -2286,7 +2287,7 @@ ABSL_ATTRIBUTE_NOINLINE void Mutex::UnlockSlow(SynchWaitParams* waitp) {
         // set up to walk the list
         PerThreadSynch* w_walk;   // current waiter during list walk
         PerThreadSynch* pw_walk;  // previous waiter during list walk
-        if (old_h != nullptr) {  // we've searched up to old_h before
+        if (old_h != nullptr) {   // we've searched up to old_h before
           pw_walk = old_h;
           w_walk = old_h->next;
         } else {  // no prior search, start at beginning
@@ -2383,6 +2384,13 @@ ABSL_ATTRIBUTE_NOINLINE void Mutex::UnlockSlow(SynchWaitParams* waitp) {
         h->readers = 0;
         h->maybe_unlocking = false;  // finished unlocking
         nv |= wr_wait | kMuWait | reinterpret_cast<intptr_t>(h);
+
+        // Signal to any Scheduler that we are waking from Mutex Unlock
+        // and there are more waiters left, signaling possible contention.
+        ABSL_TSAN_MUTEX_PRE_DIVERT(this, 0);
+        clear_waking_des_waker = GetOrCreateCurrentThreadIdentity();
+        ABSL_TSAN_MUTEX_POST_DIVERT(this, 0);
+        clear_waking_des_waker->scheduler_state.waking_designated_waker = true;
       }
 
       // release both spinlock & lock
@@ -2418,6 +2426,10 @@ ABSL_ATTRIBUTE_NOINLINE void Mutex::UnlockSlow(SynchWaitParams* waitp) {
       ABSL_TSAN_MUTEX_POST_DIVERT(this, 0);
     }
   }
+
+  if (clear_waking_des_waker) {
+    clear_waking_des_waker->scheduler_state.waking_designated_waker = false;
+  }
 }
 
 // Used by CondVar implementation to reacquire mutex after waking from
@@ -2762,7 +2774,7 @@ void CondVar::SignalAll() {
 void ReleasableMutexLock::Release() {
   ABSL_RAW_CHECK(this->mu_ != nullptr,
                  "ReleasableMutexLock::Release may only be called once");
-  this->mu_->Unlock();
+  this->mu_->unlock();
   this->mu_ = nullptr;
 }