Inline SpinLock Lock->lock, Unlock->unlock internal to Abseil.

PiperOrigin-RevId: 788531193
Change-Id: Icca9ff096c2ec2fc0662f1f94ecfb232a8492974

Author: ckennelly

absl/base/internal/low_level_alloc.cc

@@ -318,11 +318,11 @@ class ABSL_SCOPED_LOCKABLE ArenaLock {
       mask_valid_ = pthread_sigmask(SIG_BLOCK, &all, &mask_) == 0;
     }
 #endif
-    arena_->mu.Lock();
+    arena_->mu.lock();
   }
   ~ArenaLock() { ABSL_RAW_CHECK(left_, "haven't left Arena region"); }
   void Leave() ABSL_UNLOCK_FUNCTION() {
-    arena_->mu.Unlock();
+    arena_->mu.unlock();
 #ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
     if (mask_valid_) {
       const int err = pthread_sigmask(SIG_SETMASK, &mask_, nullptr);
@@ -573,7 +573,7 @@ static void *DoAllocWithArena(size_t request, LowLevelAlloc::Arena *arena) {
       }
       // we unlock before mmap() both because mmap() may call a callback hook,
       // and because it may be slow.
-      arena->mu.Unlock();
+      arena->mu.unlock();
       // mmap generous 64K chunks to decrease
       // the chances/impact of fragmentation:
       size_t new_pages_size = RoundUp(req_rnd, arena->pagesize * 16);
@@ -612,7 +612,7 @@ static void *DoAllocWithArena(size_t request, LowLevelAlloc::Arena *arena) {
 #endif
 #endif  // __linux__
 #endif  // _WIN32
-      arena->mu.Lock();
+      arena->mu.lock();
       s = reinterpret_cast<AllocList *>(new_pages);
       s->header.size = new_pages_size;
       // Pretend the block is allocated; call AddToFreelist() to free it.

absl/base/internal/spinlock_benchmark.cc

@@ -35,7 +35,7 @@ static void BM_TryLock(benchmark::State& state) {
   static absl::NoDestructor<absl::base_internal::SpinLock> spinlock(
       scheduling_mode);
   for (auto _ : state) {
-    if (spinlock->TryLock()) spinlock->Unlock();
+    if (spinlock->try_lock()) spinlock->unlock();
   }
 }
 

absl/base/spinlock_test_common.cc

@@ -132,15 +132,13 @@ static_assert(std::is_trivially_destructible<SpinLock>(), "");
 
 TEST(SpinLock, StackNonCooperativeDisablesScheduling) {
   SpinLock spinlock(base_internal::SCHEDULE_KERNEL_ONLY);
-  spinlock.Lock();
+  SpinLockHolder l(&spinlock);
   EXPECT_FALSE(base_internal::SchedulingGuard::ReschedulingIsAllowed());
-  spinlock.Unlock();
 }
 
 TEST(SpinLock, StaticNonCooperativeDisablesScheduling) {
-  static_noncooperative_spinlock.Lock();
+  SpinLockHolder l(&static_noncooperative_spinlock);
   EXPECT_FALSE(base_internal::SchedulingGuard::ReschedulingIsAllowed());
-  static_noncooperative_spinlock.Unlock();
 }
 
 TEST(SpinLock, WaitCyclesEncoding) {

absl/debugging/symbolize_elf.inc

@@ -167,7 +167,7 @@ struct FileMappingHint {
 // We are using SpinLock and not a Mutex here, because we may be called
 // from inside Mutex::Lock itself, and it prohibits recursive calls.
 // This happens in e.g. base/stacktrace_syscall_unittest.
-// Moreover, we are using only TryLock(), if the decorator list
+// Moreover, we are using only try_lock(), if the decorator list
 // is being modified (is busy), we skip all decorators, and possibly
 // loose some info. Sorry, that's the best we could do.
 ABSL_CONST_INIT absl::base_internal::SpinLock g_decorators_mu(
@@ -1549,7 +1549,7 @@ const char *Symbolizer::GetUncachedSymbol(const void *pc) {
 #endif
   }
 
-  if (g_decorators_mu.TryLock()) {
+  if (g_decorators_mu.try_lock()) {
     if (g_num_decorators > 0) {
       SymbolDecoratorArgs decorator_args = {
           pc,       relocation,       fd,     symbol_buf_, sizeof(symbol_buf_),
@@ -1559,7 +1559,7 @@ const char *Symbolizer::GetUncachedSymbol(const void *pc) {
         g_decorators[i].fn(&decorator_args);
       }
     }
-    g_decorators_mu.Unlock();
+    g_decorators_mu.unlock();
   }
   if (symbol_buf_[0] == '\0') {
     return nullptr;
@@ -1605,17 +1605,17 @@ const char *Symbolizer::GetSymbol(const void *pc) {
 }
 
 bool RemoveAllSymbolDecorators(void) {
-  if (!g_decorators_mu.TryLock()) {
+  if (!g_decorators_mu.try_lock()) {
     // Someone else is using decorators. Get out.
     return false;
   }
   g_num_decorators = 0;
-  g_decorators_mu.Unlock();
+  g_decorators_mu.unlock();
   return true;
 }
 
 bool RemoveSymbolDecorator(int ticket) {
-  if (!g_decorators_mu.TryLock()) {
+  if (!g_decorators_mu.try_lock()) {
     // Someone else is using decorators. Get out.
     return false;
   }
@@ -1629,14 +1629,14 @@ bool RemoveSymbolDecorator(int ticket) {
       break;
     }
   }
-  g_decorators_mu.Unlock();
+  g_decorators_mu.unlock();
   return true;  // Decorator is known to be removed.
 }
 
 int InstallSymbolDecorator(SymbolDecorator decorator, void *arg) {
   static int ticket = 0;
 
-  if (!g_decorators_mu.TryLock()) {
+  if (!g_decorators_mu.try_lock()) {
     // Someone else is using decorators. Get out.
     return -2;
   }
@@ -1647,7 +1647,7 @@ int InstallSymbolDecorator(SymbolDecorator decorator, void *arg) {
     g_decorators[g_num_decorators] = {decorator, arg, ticket++};
     ++g_num_decorators;
   }
-  g_decorators_mu.Unlock();
+  g_decorators_mu.unlock();
   return ret;
 }
 
@@ -1658,7 +1658,7 @@ bool RegisterFileMappingHint(const void *start, const void *end,
 
   base_internal::InitSigSafeArena();
 
-  if (!g_file_mapping_mu.TryLock()) {
+  if (!g_file_mapping_mu.try_lock()) {
     return false;
   }
 
@@ -1681,13 +1681,13 @@ bool RegisterFileMappingHint(const void *start, const void *end,
     hint.filename = dst;
   }
 
-  g_file_mapping_mu.Unlock();
+  g_file_mapping_mu.unlock();
   return ret;
 }
 
 bool GetFileMappingHint(const void **start, const void **end, uint64_t *offset,
                         const char **filename) {
-  if (!g_file_mapping_mu.TryLock()) {
+  if (!g_file_mapping_mu.try_lock()) {
     return false;
   }
   bool found = false;
@@ -1710,7 +1710,7 @@ bool GetFileMappingHint(const void **start, const void **end, uint64_t *offset,
       break;
     }
   }
-  g_file_mapping_mu.Unlock();
+  g_file_mapping_mu.unlock();
   return found;
 }
 

absl/log/internal/vlog_config.cc

@@ -267,7 +267,7 @@ void UpdateVLogSites() ABSL_UNLOCK_FUNCTION(mutex)
   // have to wait on all updates in order to acquire `mutex` and initialize
   // themselves.
   absl::MutexLock ul(GetUpdateSitesMutex());
-  mutex.Unlock();
+  mutex.unlock();
   VLogSite* n = site_list_head.load(std::memory_order_seq_cst);
   // Because sites are added to the list in the order they are executed, there
   // tend to be clusters of entries with the same file.
@@ -299,7 +299,7 @@ void UpdateVModule(absl::string_view vmodule)
     if (!absl::SimpleAtoi(glob_level.substr(eq + 1), &level)) continue;
     glob_levels.emplace_back(glob, level);
   }
-  mutex.Lock();  // Unlocked by UpdateVLogSites().
+  mutex.lock();  // unlocked by UpdateVLogSites().
   get_vmodule_info().clear();
   for (const auto& it : glob_levels) {
     const absl::string_view glob = it.first;
@@ -311,10 +311,10 @@ void UpdateVModule(absl::string_view vmodule)
 
 int UpdateGlobalVLogLevel(int v)
     ABSL_LOCKS_EXCLUDED(mutex, GetUpdateSitesMutex()) {
-  mutex.Lock();  // Unlocked by UpdateVLogSites().
+  mutex.lock();  // unlocked by UpdateVLogSites().
   const int old_global_v = global_v;
   if (v == global_v) {
-    mutex.Unlock();
+    mutex.unlock();
     return old_global_v;
   }
   global_v = v;
@@ -324,7 +324,7 @@ int UpdateGlobalVLogLevel(int v)
 
 int PrependVModule(absl::string_view module_pattern, int log_level)
     ABSL_LOCKS_EXCLUDED(mutex, GetUpdateSitesMutex()) {
-  mutex.Lock();  // Unlocked by UpdateVLogSites().
+  mutex.lock();  // unlocked by UpdateVLogSites().
   int old_v = PrependVModuleLocked(module_pattern, log_level);
   UpdateVLogSites();
   return old_v;

absl/synchronization/internal/graphcycles.cc

@@ -58,11 +58,10 @@ ABSL_CONST_INIT static absl::base_internal::SpinLock arena_mu(
 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

absl/synchronization/mutex.cc

@@ -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,15 +414,15 @@ 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) {
   }
   if (e != nullptr) {
     e->refcount++;
   }
-  synch_event_mu.Unlock();
+  synch_event_mu.unlock();
   return e;
 }
 
@@ -1223,9 +1223,9 @@ static GraphId GetGraphIdLocked(Mutex* mu)
 }
 
 static GraphId GetGraphId(Mutex* mu) ABSL_LOCKS_EXCLUDED(deadlock_graph_mu) {
-  deadlock_graph_mu.Lock();
+  deadlock_graph_mu.lock();
   GraphId id = GetGraphIdLocked(mu);
-  deadlock_graph_mu.Unlock();
+  deadlock_graph_mu.unlock();
   return id;
 }
 
@@ -1456,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;
       }
@@ -1481,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();
   }
 }
 

absl/synchronization/mutex_benchmark.cc

@@ -72,24 +72,6 @@ static void DelayNs(int64_t ns, int* data) {
   }
 }
 
-template <typename MutexType>
-class RaiiLocker {
- public:
-  explicit RaiiLocker(MutexType* mu) : mu_(mu) { mu_->Lock(); }
-  ~RaiiLocker() { mu_->Unlock(); }
- private:
-  MutexType* mu_;
-};
-
-template <>
-class RaiiLocker<std::mutex> {
- public:
-  explicit RaiiLocker(std::mutex* mu) : mu_(mu) { mu_->lock(); }
-  ~RaiiLocker() { mu_->unlock(); }
- private:
-  std::mutex* mu_;
-};
-
 // RAII object to change the Mutex priority of the running thread.
 class ScopedThreadMutexPriority {
  public:
@@ -226,7 +208,7 @@ void BM_Contended(benchmark::State& state) {
     // to keep ratio between local work and critical section approximately
     // equal regardless of number of threads.
     DelayNs(100 * state.threads(), &local);
-    RaiiLocker<MutexType> locker(&shared->mu);
+    std::scoped_lock locker(shared->mu);
     DelayNs(state.range(0), &shared->data);
   }
 }

absl/time/clock.cc

@@ -415,7 +415,7 @@ static int64_t GetCurrentTimeNanosSlowPath()
     ABSL_LOCKS_EXCLUDED(time_state.lock) {
   // Serialize access to slow-path.  Fast-path readers are not blocked yet, and
   // code below must not modify last_sample until the seqlock is acquired.
-  time_state.lock.Lock();
+  base_internal::SpinLockHolder l(&time_state.lock);
 
   // Sample the kernel time base.  This is the definition of
   // "now" if we take the slow path.
@@ -446,8 +446,6 @@ static int64_t GetCurrentTimeNanosSlowPath()
         UpdateLastSample(now_cycles, now_ns, delta_cycles, &sample);
   }
 
-  time_state.lock.Unlock();
-
   return static_cast<int64_t>(estimated_base_ns);
 }