grpc 1.84.1 → 1.85.0.pre1

data/src/core/util/latent_see.cc

@@ -14,11 +14,16 @@
 
 #include "src/core/util/latent_see.h"
 
+#include <algorithm>
 #include <atomic>
+#include <cmath>
 #include <cstdint>
 #include <cstdlib>
+#include <deque>
+#include <limits>
 #include <memory>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "src/core/channelz/property_list.h"
@@ -27,8 +32,13 @@
 #include "src/core/util/json/json_writer.h"
 #include "src/core/util/notification.h"
 #include "src/core/util/sync.h"
+#include "absl/container/flat_hash_map.h"
 #include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
+#include "absl/time/clock.h"
+#include "absl/time/time.h"
 
 namespace grpc_core::latent_see {
 
@@ -86,10 +96,6 @@ void JsonOutput::Finish() { out_ << "\n]"; }
 namespace grpc_core {
 namespace latent_see {
 
-namespace {
-const Duration kMaxBackoff = Duration::Milliseconds(300);
-}
-
 void Appender::Enable(Sink* sink) {
   active_sink_.store(sink, std::memory_order_release);
 }
@@ -102,45 +108,129 @@ Sink::Sink() : gatherer_("grpc_latent_see_gatherer", [this]() { Gather(); }) {
   gatherer_.Start();
 }
 
-void Sink::Append(std::unique_ptr<Bin> bin) { appending_.Push(bin.release()); }
+void Sink::Append(std::unique_ptr<Bin> bin) {
+  // Push the bin to the lock-free MPSC queue. If this was the first item
+  // in an empty queue, signal the gatherer thread to wake up immediately.
+  if (appending_.Push(bin.release())) {
+    cv_gather_.Signal();
+  }
+}
 
 void Sink::Gather() {
-  BackOff backoff(BackOff::Options()
-                      .set_initial_backoff(Duration::Milliseconds(1))
-                      .set_multiplier(1.1)
-                      .set_jitter(0.05)
-                      .set_max_backoff(kMaxBackoff));
+  // Pre-allocated batch buffer to avoid heap allocations in the gatherer loop.
+  std::vector<std::unique_ptr<Bin>> batch;
+  batch.reserve(64u);
   while (true) {
-    std::unique_ptr<Bin> bin(static_cast<Bin*>(appending_.Pop()));
-    if (bin == nullptr) {
-      absl::SleepFor(absl::Milliseconds(backoff.NextAttemptDelay().millis()));
-      continue;
+    // 1. Wait until collection is actively started via Start().
+    {
+      MutexLock lock(mu_);
+      while (state_ == State::kInactive) {
+        cv_gather_.Wait(&mu_);
+      }
+    }
+
+    // 2. Active recording and draining loop.
+    while (true) {
+      batch.clear();
+      bool empty = false;
+      // Pop up to 64 ready bins from the lock-free queue without holding mu_.
+      while (batch.size() < 64u) {
+        Bin* bin_raw;
+        // In-flight push handling: MPSCQueue::Push performs a 2-step atomic
+        // update (head exchange then next store). If PopAndCheckEnd returns
+        // nullptr with !empty, a push is actively in progress; spin until the
+        // producer finishes linking the node.
+        do {
+          bin_raw = static_cast<Bin*>(appending_.PopAndCheckEnd(&empty));
+        } while (bin_raw == nullptr && !empty);
+        if (bin_raw == nullptr) break;
+        batch.emplace_back(bin_raw);
+      }
+
+      // If we gathered any bins, record them under the mutex and immediately
+      // loop back to pop more without sleeping.
+      if (!batch.empty()) {
+        MutexLock lock(mu_);
+        if (GPR_LIKELY(events_ != nullptr)) {
+          for (std::unique_ptr<Bin>& bin : batch) {
+            RecordLocked(std::move(bin));
+          }
+        }
+        continue;
+      }
+
+      // Maximum time the gatherer thread sleeps waiting for new bins.
+      // Bounding the wait ensures that if a wakeup signal from Sink::Append
+      // is lost when racing with entering wait, the gatherer will still
+      // wake up to drain the queue.
+      constexpr absl::Duration kGatherWaitTimeout = absl::Milliseconds(100);
+
+      // Queue is fully empty (empty == true). Inspect state under lock.
+      MutexLock lock(mu_);
+      bool done_draining = false;  // to break to the outer while loop.
+      switch (state_) {
+        case State::kRecording:
+          // Queue is currently empty during active recording. Wait for a new
+          // bin to be pushed (Append signal) or Stop() to be called. It's
+          // possible that a wakeup signal from Sink::Append() is lost, so we'll
+          // break after kGatherWaitTimeout to re-evaluate the state.
+          cv_gather_.WaitWithTimeout(&mu_, kGatherWaitTimeout);
+          break;
+        case State::kDraining:
+          // Stop() was requested and all queued bins (including any in-flight
+          // pushes) have been fully drained into events_. Transition to
+          // kInactive, notify the stopping thread, and return to outer loop.
+          state_ = State::kInactive;
+          cv_drained_.Signal();
+          done_draining = true;
+          break;
+        case State::kInactive:
+          // State is kInactive; break to outer wait loop.
+          done_draining = true;
+          break;
+      }
+      if (done_draining) break;
     }
-    backoff.Reset();
-    Record(std::move(bin));
   }
 }
 
 void Sink::Start(size_t max_bins) {
-  auto events = std::make_unique<EventDump>();
-  MutexLock lock(&mu_);
+  std::unique_ptr<EventDump> events = std::make_unique<EventDump>();
+  MutexLock lock(mu_);
+  // Ensure previous collection session has fully drained before resetting.
+  while (state_ != State::kInactive) {
+    cv_drained_.Wait(&mu_);
+  }
   max_bins_ = max_bins;
   events_ = std::move(events);
+  state_ = State::kRecording;
+  cv_gather_.Signal();
 }
 
 std::unique_ptr<Sink::EventDump> Sink::Stop() {
-  MutexLock lock(&mu_);
-  auto events = std::move(events_);
+  MutexLock lock(mu_);
+  CHECK(state_ == State::kRecording || state_ == State::kDraining);
+  if (state_ == State::kRecording) {
+    state_ = State::kDraining;
+    cv_gather_.Signal();
+  }
+  // Wait until the gatherer thread has drained all queued bins.
+  while (state_ == State::kDraining) {
+    cv_drained_.Wait(&mu_);
+  }
+  std::unique_ptr<EventDump> events = std::move(events_);
   events_ = nullptr;
   return events;
 }
 
-void Sink::Record(std::unique_ptr<Bin> bin) {
-  MutexLock lock(&mu_);
-  if (events_ == nullptr) return;
-  CHECK_LE(bin->used_space, Bin::kMaxBinSize);
+void Sink::RecordLocked(std::unique_ptr<Bin> bin) {
+  if (GPR_UNLIKELY(events_ == nullptr)) return;
   events_->emplace_back(std::move(bin));
-  if (events_->size() > max_bins_) events_->pop_front();
+  if (GPR_UNLIKELY(events_->size() > max_bins_)) {
+    LOG_FIRST_N(INFO, 10) << "Latent-see collection dropping oldest bin due to "
+                             "memory limit";
+    events_->pop_front();
+  }
 }
 
 void Collect(Notification* n, absl::Duration timeout, size_t memory_limit,
@@ -150,14 +240,11 @@ void Collect(Notification* n, absl::Duration timeout, size_t memory_limit,
 
   // Collection phase - under a mutex to prevent multiple collections at once.
   mu->Lock();
-  // First we enable the appender and then wait for a short time to clear out
-  // any backoff
-  LOG(INFO) << "Latent-see collection enabling";
+  LOG(INFO) << "Latent-see collection starting";
+  // Start the sink before enabling appender to ensure events are not dropped.
+  sink->Start(memory_limit / sizeof(Bin) + 1u);
   Appender::Enable(sink);
-  absl::SleepFor(2 * absl::Milliseconds(kMaxBackoff.millis()));
-  // Now we start the collection
   LOG(INFO) << "Latent-see collection recording";
-  sink->Start(memory_limit / sizeof(Bin) + 1);
   // If we got a Notification object, use that to sleep until we're notified;
   // if not just sleep.
   if (n == nullptr) {
@@ -167,9 +254,9 @@ void Collect(Notification* n, absl::Duration timeout, size_t memory_limit,
   }
   // Grab all events
   LOG(INFO) << "Latent-see collection stopping";
-  auto events = sink->Stop();
-  // Disable the sink
+  // Disable appender first to prevent new incoming events while draining.
   Appender::Disable();
+  std::unique_ptr<Sink::EventDump> events = sink->Stop();
   mu->Unlock();
   CHECK(events != nullptr);
   LOG(INFO) << "Latent-see collection stopped: processing " << events->size()
@@ -180,13 +267,13 @@ void Collect(Notification* n, absl::Duration timeout, size_t memory_limit,
   int64_t earliest_timestamp = std::numeric_limits<int64_t>::max();
   for (const auto& bin : *events) {
     for (const auto& event : *bin) {
-      // Exclude negative timestamps as they're used for event type markers
+      // Exclude negative timestamps as they're used for event type markers.
       if (event.timestamp_begin > 0) {
         earliest_timestamp = std::min(
             {earliest_timestamp, event.timestamp_begin, event.timestamp_end});
       } else {
         earliest_timestamp =
-            std::min(earliest_timestamp, abs(event.timestamp_end));
+            std::min(earliest_timestamp, std::abs(event.timestamp_end));
       }
     }
   }
@@ -201,7 +288,7 @@ void Collect(Notification* n, absl::Duration timeout, size_t memory_limit,
     size_t displayed_thread_id;
     auto it = thread_id_map.find(bin->thd_id);
     if (it == thread_id_map.end()) {
-      displayed_thread_id = thread_id_map.size() + 1;
+      displayed_thread_id = thread_id_map.size() + 1u;
       thread_id_map[bin->thd_id] = displayed_thread_id;
     } else {
       displayed_thread_id = it->second;

data/src/core/util/latent_see.h

@@ -23,6 +23,7 @@
 #include <cstdint>
 #include <cstdio>
 #include <cstdlib>
+#include <deque>
 #include <iterator>
 #include <memory>
 #include <string>
@@ -33,6 +34,7 @@
 #include "src/core/util/function_signature.h"
 #include "src/core/util/mpscq.h"
 #include "src/core/util/notification.h"
+#include "src/core/util/sync.h"
 #include "src/core/util/thd.h"
 #include "absl/container/flat_hash_map.h"
 #include "absl/strings/string_view.h"
@@ -234,8 +236,16 @@ class Sink {
  private:
   friend void Collect(Notification*, absl::Duration, size_t, Output*);
 
+  enum class State {
+    kInactive,
+    kRecording,
+    kDraining,
+  };
+
   void Gather();
-  void Record(std::unique_ptr<Bin> bin);
+  // Records a bin into the event dump. Caller must hold mu_.
+  void RecordLocked(std::unique_ptr<Bin> bin)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
   void Start(size_t max_bins);
   std::unique_ptr<EventDump> Stop();
@@ -243,6 +253,9 @@ class Sink {
   MultiProducerSingleConsumerQueue appending_;
   Thread gatherer_;
   Mutex mu_;
+  CondVar cv_gather_;
+  CondVar cv_drained_;
+  State state_ ABSL_GUARDED_BY(mu_) = State::kInactive;
   std::unique_ptr<EventDump> events_ ABSL_GUARDED_BY(mu_);
   size_t max_bins_ ABSL_GUARDED_BY(mu_);
 };

data/src/core/util/mpscq.cc

@@ -96,7 +96,7 @@ LockedMultiProducerSingleConsumerQueue::TryPop() {
 
 LockedMultiProducerSingleConsumerQueue::Node*
 LockedMultiProducerSingleConsumerQueue::Pop() {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   bool empty = false;
   Node* node;
   do {

data/src/core/util/notification.h

@@ -27,13 +27,13 @@ namespace grpc_core {
 class Notification {
  public:
   void Notify() {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     notified_ = true;
     cv_.SignalAll();
   }
 
   void WaitForNotification() {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     while (!notified_) {
       cv_.Wait(&mu_);
     }
@@ -42,7 +42,7 @@ class Notification {
   bool WaitForNotificationWithTimeout(absl::Duration timeout) {
     auto now = absl::Now();
     auto deadline = now + timeout;
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     while (!notified_ && now < deadline) {
       cv_.WaitWithTimeout(&mu_, deadline - now);
       now = absl::Now();
@@ -51,7 +51,7 @@ class Notification {
   }
 
   bool HasBeenNotified() {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     return notified_;
   }
 

data/src/core/util/sync.h

@@ -65,8 +65,13 @@ class ABSL_LOCKABLE Mutex {
   Mutex(const Mutex&) = delete;
   Mutex& operator=(const Mutex&) = delete;
 
-  void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() { gpr_mu_lock(&mu_); }
-  void Unlock() ABSL_UNLOCK_FUNCTION() { gpr_mu_unlock(&mu_); }
+  void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() { lock(); }
+  void Unlock() ABSL_UNLOCK_FUNCTION() { unlock(); }
+
+  // lower-case interface to be consistent with absl::Mutex.
+  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;
   }
@@ -86,6 +91,9 @@ inline gpr_mu* GetUnderlyingGprMu(Mutex* mutex) { return &mutex->mu_; }
 
 class ABSL_SCOPED_LOCKABLE MutexLock {
  public:
+  explicit MutexLock(Mutex& mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(&mu) {
+    mu_->Lock();
+  }
   explicit MutexLock(Mutex* mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(mu) {
     mu_->Lock();
   }
@@ -100,10 +108,16 @@ class ABSL_SCOPED_LOCKABLE MutexLock {
 
 class ABSL_SCOPED_LOCKABLE ReleasableMutexLock {
  public:
+  explicit ReleasableMutexLock(Mutex& mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
+      : mu_(&mu) {
+    mu_->Lock();
+  }
+
   explicit ReleasableMutexLock(Mutex* mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
       : mu_(mu) {
     mu_->Lock();
   }
+
   ~ReleasableMutexLock() ABSL_UNLOCK_FUNCTION() {
     if (!released_) mu_->Unlock();
   }
@@ -166,10 +180,10 @@ class ABSL_SCOPED_LOCKABLE LockableAndReleasableMutexLock {
   explicit LockableAndReleasableMutexLock(Mutex* mu)
       ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
       : mu_(mu) {
-    mu_->Lock();
+    mu_->lock();
   }
   ~LockableAndReleasableMutexLock() ABSL_UNLOCK_FUNCTION() {
-    if (!released_) mu_->Unlock();
+    if (!released_) mu_->unlock();
   }
 
   LockableAndReleasableMutexLock(const LockableAndReleasableMutexLock&) =
@@ -179,14 +193,14 @@ class ABSL_SCOPED_LOCKABLE LockableAndReleasableMutexLock {
 
   void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() {
     DCHECK(released_);
-    mu_->Lock();
+    mu_->lock();
     released_ = false;
   }
 
   void Release() ABSL_UNLOCK_FUNCTION() {
     DCHECK(!released_);
     released_ = true;
-    mu_->Unlock();
+    mu_->unlock();
   }
 
  private:

data/src/core/util/table.h

@@ -25,8 +25,6 @@
 #include <utility>
 
 #include "src/core/util/bitset.h"
-#include "absl/meta/type_traits.h"
-#include "absl/utility/utility.h"
 
 namespace grpc_core {
 
@@ -55,11 +53,11 @@ template <typename IndexSequence, typename... Ts>
 struct ElementsImpl;
 
 template <size_t... Is, typename... Ts>
-struct ElementsImpl<absl::index_sequence<Is...>, Ts...> : TableLeaf<Is, Ts>... {
+struct ElementsImpl<std::index_sequence<Is...>, Ts...> : TableLeaf<Is, Ts>... {
 };
 
 template <typename... Ts>
-using Elements = ElementsImpl<absl::make_index_sequence<sizeof...(Ts)>, Ts...>;
+using Elements = ElementsImpl<std::make_index_sequence<sizeof...(Ts)>, Ts...>;
 
 template <typename T, size_t I>
 struct IndexedType {};
@@ -68,11 +66,11 @@ template <typename IndexSequence, typename... Ts>
 struct IndexMapImpl;
 
 template <size_t... Is, typename... Ts>
-struct IndexMapImpl<absl::index_sequence<Is...>, Ts...>
+struct IndexMapImpl<std::index_sequence<Is...>, Ts...>
     : IndexedType<Ts, Is>... {};
 
 template <typename... Ts>
-using IndexMap = IndexMapImpl<absl::make_index_sequence<sizeof...(Ts)>, Ts...>;
+using IndexMap = IndexMapImpl<std::make_index_sequence<sizeof...(Ts)>, Ts...>;
 
 template <typename T, size_t I>
 constexpr size_t ResolveIndex(IndexedType<T, I>*) {
@@ -108,26 +106,26 @@ class Table {
   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)>()); }
+  ~Table() { Destruct(std::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<false>(std::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);
+    Copy<true>(std::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)>(),
+    Move<false>(std::make_index_sequence<sizeof...(Ts)>(),
                 std::forward<Table>(rhs));
   }
 
@@ -135,7 +133,7 @@ class 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)>(),
+    Move<true>(std::make_index_sequence<sizeof...(Ts)>(),
                std::forward<Table>(rhs));
     return *this;
   }
@@ -149,7 +147,7 @@ class Table {
 
   // Check if this table has index I.
   template <size_t I>
-  absl::enable_if_t<(I < sizeof...(Ts)), bool> has() const {
+  std::enable_if_t<(I < sizeof...(Ts)), bool> has() const {
     return present_bits_.is_set(I);
   }
 
@@ -245,7 +243,7 @@ class Table {
   // 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)>());
+    ForEachImpl(std::move(f), std::make_index_sequence<sizeof...(Ts)>());
   }
 
   // Iterate through each set field in the table if it exists in Vs, in the
@@ -253,7 +251,7 @@ class Table {
   template <typename F, typename... Vs>
   void ForEachIn(F f) const {
     ForEachImpl(std::move(f),
-                absl::index_sequence<table_detail::IndexOf<Vs, Ts...>()...>());
+                std::index_sequence<table_detail::IndexOf<Vs, Ts...>()...>());
   }
 
   // Iterate through each set field in the table if it exists in Vs, in the
@@ -262,7 +260,7 @@ class Table {
   template <typename F, typename... Vs>
   void FilterIn(F f) {
     FilterInImpl(std::move(f),
-                 absl::index_sequence<table_detail::IndexOf<Vs, Ts...>()...>());
+                 std::index_sequence<table_detail::IndexOf<Vs, Ts...>()...>());
   }
 
   // Count the number of set fields in the table
@@ -272,7 +270,7 @@ class Table {
   bool empty() const { return present_bits_.none(); }
 
   // Clear all elements in the table.
-  void ClearAll() { ClearAllImpl(absl::make_index_sequence<sizeof...(Ts)>()); }
+  void ClearAll() { ClearAllImpl(std::make_index_sequence<sizeof...(Ts)>()); }
 
  private:
   // Bit field for which elements of the table are set (true) or un-set (false,
@@ -360,39 +358,39 @@ class Table {
   // 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...>) {
+  void Destruct(std::index_sequence<I...>) {
     (table_detail::DestructIfNotNull(get<I>()), ...);
   }
 
   // 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) {
+  void Copy(std::index_sequence<I...>, const Table& rhs) {
     (CopyIf<or_clear, I>(rhs), ...);
   }
 
   // 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) {
+  void Move(std::index_sequence<I...>, Table&& rhs) {
     (MoveIf<or_clear, I>(std::forward<Table>(rhs)), ...);
   }
 
   // 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 {
+  void ForEachImpl(F f, std::index_sequence<I...>) const {
     (CallIf<I>(&f), ...);
   }
 
   // For each field (element I=0, 1, ...) if that field is present, call f. If
   // f returns false, remove the field from the table.
   template <typename F, size_t... I>
-  void FilterInImpl(F f, absl::index_sequence<I...>) {
+  void FilterInImpl(F f, std::index_sequence<I...>) {
     (FilterIf<I>(&f), ...);
   }
 
   template <size_t... I>
-  void ClearAllImpl(absl::index_sequence<I...>) {
+  void ClearAllImpl(std::index_sequence<I...>) {
     (clear<I>(), ...);
   }
 

data/src/core/util/work_serializer.cc

@@ -167,7 +167,7 @@ void WorkSerializer::WorkSerializerImpl::Run(
       << "WorkSerializer[" << this << "] Scheduling callback ["
       << location.file() << ":" << location.line() << "]";
   global_stats().IncrementWorkSerializerItemsEnqueued();
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (!running_) {
     // If we were previously idle, insert this callback directly into the
     // empty processing_ list and start running.
@@ -225,7 +225,7 @@ WorkSerializer::WorkSerializerImpl::RefillInner() {
   // Recover any memory held by processing_, so that we don't grow forever.
   // Do so before acquiring a lock so we don't cause inadvertent contention.
   processing_.shrink_to_fit();
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   // Swap incoming_ into processing_ - effectively lets us release memory
   // (outside the lock) once per iteration for the storage vectors.
   processing_.swap(incoming_);

data/src/core/xds/grpc/blackboard.cc

@@ -24,7 +24,7 @@ void Blackboard::Entry::Orphaned() {
 
 RefCountedPtr<Blackboard::Entry> Blackboard::Get(UniqueTypeName type,
                                                  const std::string& key) const {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   auto it = map_.find(std::pair(type, key));
   if (it == map_.end()) return nullptr;
   return it->second->RefIfNonZero();
@@ -33,13 +33,14 @@ RefCountedPtr<Blackboard::Entry> Blackboard::Get(UniqueTypeName type,
 RefCountedPtr<Blackboard::Entry> Blackboard::GetOrSet(
     UniqueTypeName type, const std::string& key,
     absl::FunctionRef<RefCountedPtr<Entry>()> construct) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   auto& entry = map_[std::pair(type, key)];
   if (entry != nullptr) {
     auto reffed_entry = entry->RefIfNonZero();
     if (reffed_entry != nullptr) return reffed_entry;
   }
   auto constructed = construct();
+  if (constructed == nullptr) return nullptr;
   entry = constructed->WeakRef();
   constructed->blackboard_ = Ref();
   constructed->type_ = type;
@@ -49,7 +50,7 @@ RefCountedPtr<Blackboard::Entry> Blackboard::GetOrSet(
 
 void Blackboard::Remove(UniqueTypeName type, const std::string& key,
                         Entry* entry) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   auto it = map_.find(std::pair(type, key));
   if (it == map_.end()) return;
   if (it->second == entry) map_.erase(it);

data/src/core/xds/grpc/certificate_provider_store.cc

@@ -96,7 +96,7 @@ RefCountedPtr<grpc_tls_certificate_provider>
 CertificateProviderStore::CreateOrGetCertificateProvider(
     absl::string_view key) {
   RefCountedPtr<CertificateProviderWrapper> result;
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   auto it = certificate_providers_map_.find(key);
   if (it == certificate_providers_map_.end()) {
     result = CreateCertificateProviderLocked(key);
@@ -137,7 +137,7 @@ CertificateProviderStore::CreateCertificateProviderLocked(
 
 void CertificateProviderStore::ReleaseCertificateProvider(
     absl::string_view key, CertificateProviderWrapper* wrapper) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   auto it = certificate_providers_map_.find(key);
   if (it != certificate_providers_map_.end()) {
     if (it->second == wrapper) {