[scudo] Make the mutex be aware of number of contenders on Linux [wip]

compiler-rt/lib/scudo/standalone/linux.cpp

 // Calling getenv should be fine (c)(tm) at any time.
 const char *getEnv(const char *Name) { return getenv(Name); }
 
 namespace {
 enum State : u32 { Unlocked = 0, Locked = 1, Sleeping = 2 };
 }
 
 bool HybridMutex::tryLock() {
-  return atomic_compare_exchange(&M, Unlocked, Locked) == Unlocked;
+  constexpr u32 kHeldMask = 1UL;
+  const u32 V = atomic_load(&M, memory_order_acquire);
+  return (V & kHeldMask) == Unlocked &&
+         atomic_compare_exchange(&M, V, (V | Locked)) == V;
 }
 
 // The following is based on https://akkadia.org/drepper/futex.pdf.
 void HybridMutex::lockSlow() {
-  u32 V = atomic_compare_exchange(&M, Unlocked, Locked);
-  if (V == Unlocked)
+  constexpr u32 kIncWaiter = 1UL << 1;
+  constexpr u32 kHeldMask = 1UL;
+
+  do {
+    u32 V = atomic_load(&M, memory_order_acquire);
+    if ((V & kHeldMask) == Unlocked) {
+      if (atomic_compare_exchange(&M, V, (V | Locked)) == V)
         return;
-  if (V != Sleeping)
-    V = atomic_exchange(&M, Sleeping, memory_order_acquire);
-  while (V != Unlocked) {
-    syscall(SYS_futex, reinterpret_cast<uptr>(&M), FUTEX_WAIT_PRIVATE, Sleeping,
-            nullptr, nullptr, 0);
-    V = atomic_exchange(&M, Sleeping, memory_order_acquire);
+    } else {
+      atomic_fetch_add(&M, kIncWaiter, memory_order_release);
+      V += kIncWaiter;
+      do {
+        if (syscall(SYS_futex, reinterpret_cast<uptr>(&M), FUTEX_WAIT_PRIVATE,
+                    V, nullptr, nullptr, 0) != 0) {
+          V = atomic_load(&M, memory_order_acquire);
+        } else {
+          break;
         }
+      } while ((V & kHeldMask) != Unlocked);
+      atomic_fetch_sub(&M, kIncWaiter, memory_order_release);
+    }
+  } while (true);
 }
 
 void HybridMutex::unlock() {
-  if (atomic_fetch_sub(&M, 1U, memory_order_release) != Locked) {
-    atomic_store(&M, Unlocked, memory_order_release);
+  constexpr u32 kHeldMask = 1UL;
+
+  do {
+    const u32 V = atomic_load(&M, memory_order_acquire);
+    if (atomic_compare_exchange(&M, V, (V & ~kHeldMask)) == V) {
+      if ((V & ~kHeldMask) != 0) {
         syscall(SYS_futex, reinterpret_cast<uptr>(&M), FUTEX_WAKE_PRIVATE, 1,
                 nullptr, nullptr, 0);
       }
+      return;
+    }
+  } while (true);
 }
 
 void HybridMutex::assertHeldImpl() {
-  CHECK(atomic_load(&M, memory_order_acquire) != Unlocked);
+  constexpr u32 kHeldMask = 1UL;
+  CHECK((atomic_load(&M, memory_order_acquire) & kHeldMask) != Unlocked);
 }
 
 u64 getMonotonicTime() {
   timespec TS;
   clock_gettime(CLOCK_MONOTONIC, &TS);
   return static_cast<u64>(TS.tv_sec) * (1000ULL * 1000 * 1000) +
          static_cast<u64>(TS.tv_nsec);
 }

compiler-rt/lib/scudo/standalone/mutex.h

#endif
   ALWAYS_INLINE void assertHeld() ASSERT_CAPABILITY(this) {
     if (SCUDO_DEBUG)
       assertHeldImpl();
   }
 
 private:
   void assertHeldImpl();
 
-  static constexpr u8 NumberOfTries = 8U;
-  static constexpr u8 NumberOfYields = 8U;
+  static constexpr u8 NumberOfTries = 0U;
+  static constexpr u8 NumberOfYields = 0U;
 
 #if SCUDO_LINUX
   atomic_u32 M = {};
 #elif SCUDO_FUCHSIA
   sync_mutex_t M = {};
 #endif
 
   void lockSlow() ACQUIRE();