sanitizer_common: modernize SpinMutex

[dvyukov]

Summary

Some minor improvements:

1. Make StaticSpinMutex non-copyable.
2. Add LIKELY to Lock.
3. Move LockSlow into the .cpp file (now that we have it).
4. The only non-trivial change: use proc_yield(1) instread of proc_yield(10) with the proportional increase in the number of spin iterations. Latency of the PAUSE instruction has raised from ~1 cycle to ~100 cycles in the recent Intel CPUs. So proc_yield(10) is too aggressive backoff.

[dvyukov]

This broke some gcc bots, I've created https://reviews.llvm.org/D106424 to fix that.

compiler-rt/lib/sanitizer_common/sanitizer_mutex.h

 #include "sanitizer_internal_defs.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_thread_safety.h"
 
 namespace __sanitizer {
 
 class MUTEX StaticSpinMutex {
  public:
+  StaticSpinMutex() = default;
+
   void Init() {
     atomic_store(&state_, 0, memory_order_relaxed);
   }
 
   void Lock() ACQUIRE() {
-    if (TryLock())
+    if (LIKELY(TryLock()))
       return;
     LockSlow();
   }
 
   bool TryLock() TRY_ACQUIRE(true) {
     return atomic_exchange(&state_, 1, memory_order_acquire) == 0;
   }
 
   void Unlock() RELEASE() { atomic_store(&state_, 0, memory_order_release); }
 
   void CheckLocked() const CHECK_LOCKED() {
     CHECK_EQ(atomic_load(&state_, memory_order_relaxed), 1);
   }
 
  private:
   atomic_uint8_t state_;
 
-  void NOINLINE LockSlow() {
-    for (int i = 0;; i++) {
-      if (i < 10)
-        proc_yield(10);
-      else
-        internal_sched_yield();
-      if (atomic_load(&state_, memory_order_relaxed) == 0
-          && atomic_exchange(&state_, 1, memory_order_acquire) == 0)
-        return;
-    }
-  }
+  void LockSlow();
+
+  StaticSpinMutex(const StaticSpinMutex &) = delete;
+  void operator=(const StaticSpinMutex &) = delete;
 };
 
 class MUTEX SpinMutex : public StaticSpinMutex {
  public:
   SpinMutex() {
     Init();
   }
-
- private:
-  SpinMutex(const SpinMutex &) = delete;
-  void operator=(const SpinMutex &) = delete;
 };
 
 // Semaphore provides an OS-dependent way to park/unpark threads.
 // The last thread returned from Wait can destroy the object
 // (destruction-safety).
 class Semaphore {
  public:
   constexpr Semaphore() {}

compiler-rt/lib/sanitizer_common/sanitizer_mutex.cpp

 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_mutex.h"
 
 #include "sanitizer_common.h"
 
 namespace __sanitizer {
 
+void StaticSpinMutex::LockSlow() {
+  for (int i = 0;; i++) {
+    if (i < 100)
+      proc_yield(1);
+    else
+      internal_sched_yield();
+    if (atomic_load(&state_, memory_order_relaxed) == 0 &&
+        atomic_exchange(&state_, 1, memory_order_acquire) == 0)
+      return;
+  }
+}
+
 void Semaphore::Wait() {
   u32 count = atomic_load(&state_, memory_order_relaxed);
   for (;;) {
     if (count == 0) {
       FutexWait(&state_, 0);
       count = atomic_load(&state_, memory_order_relaxed);
       continue;
     }