[libc] reword contented to in contenion

Author: SchrodingerZhu

libc/config/config.json

@@ -48,7 +48,7 @@
     },
     "LIBC_CONF_RAW_MUTEX_DEFAULT_SPIN_COUNT": {
       "value": 100,
-      "doc": "Default number of spins before blocking if a mutex is contented."
+      "doc": "Default number of spins before blocking if a mutex is in contention."
     }
   }
 }

libc/docs/configure.rst

@@ -35,7 +35,7 @@ to learn about the defaults for your platform and target.
     - ``LIBC_CONF_PRINTF_DISABLE_WRITE_INT``: Disable handling of %n in printf format string.
     - ``LIBC_CONF_PRINTF_FLOAT_TO_STR_USE_MEGA_LONG_DOUBLE_TABLE``: Use large table for better printf long double performance.
 * **"pthread" options**
-    - ``LIBC_CONF_RAW_MUTEX_DEFAULT_SPIN_COUNT``: Default number of spins before blocking if a mutex is contented.
+    - ``LIBC_CONF_RAW_MUTEX_DEFAULT_SPIN_COUNT``: Default number of spins before blocking if a mutex is in contention.
     - ``LIBC_CONF_TIMEOUT_ENSURE_MONOTONICITY``: Automatically adjust timeout to CLOCK_MONOTONIC.
 * **"string" options**
     - ``LIBC_CONF_MEMSET_X86_USE_SOFTWARE_PREFETCHING``: Inserts prefetch for write instructions (PREFETCHW) for memset on x86 to recover performance when hardware prefetcher is disabled.

libc/src/__support/threads/linux/raw_mutex.h

@@ -34,15 +34,15 @@ class RawMutex {
   Futex futex;
   LIBC_INLINE_VAR static constexpr FutexWordType UNLOCKED = 0b00;
   LIBC_INLINE_VAR static constexpr FutexWordType LOCKED = 0b01;
-  LIBC_INLINE_VAR static constexpr FutexWordType CONTENTED = 0b10;
+  LIBC_INLINE_VAR static constexpr FutexWordType IN_CONTENTION = 0b10;
 
   LIBC_INLINE FutexWordType spin(uint_fast32_t spin_count) {
     FutexWordType result;
     for (;;) {
       result = futex.load(cpp::MemoryOrder::RELAXED);
       // spin until one of the following conditions is met:
       // - the mutex is unlocked
-      // - the mutex is contented
+      // - the mutex is in contention
       // - the spin count reaches 0
       if (result != LOCKED || spin_count == 0)
         return result;
@@ -56,8 +56,8 @@ class RawMutex {
   // Return true if the lock is acquired. Return false if timeout happens before
   // the lock is acquired.
   [[gnu::cold]] LIBC_INLINE bool
-  lock_contented(cpp::optional<Futex::Timeout> timeout, bool is_pshared,
-                 uint_fast32_t spin_count) {
+  lock_slow(cpp::optional<Futex::Timeout> timeout, bool is_pshared,
+            uint_fast32_t spin_count) {
     FutexWordType state = spin(spin_count);
     // Before go into contention state, try to grab the lock.
     if (state == UNLOCKED &&
@@ -69,12 +69,13 @@ class RawMutex {
       ensure_monotonicity(*timeout);
 #endif
     for (;;) {
-      // Try to grab the lock if it is unlocked. Mark contented if it is locked.
-      if (state != CONTENTED &&
-          futex.exchange(CONTENTED, cpp::MemoryOrder::ACQUIRE) == UNLOCKED)
+      // Try to grab the lock if it is unlocked. Mark the contention flag if it
+      // is locked.
+      if (state != IN_CONTENTION &&
+          futex.exchange(IN_CONTENTION, cpp::MemoryOrder::ACQUIRE) == UNLOCKED)
         return true;
       // Contention persists. Park the thread and wait for further notification.
-      if (-ETIMEDOUT == futex.wait(CONTENTED, timeout, is_pshared))
+      if (-ETIMEDOUT == futex.wait(IN_CONTENTION, timeout, is_pshared))
         return false;
       // Continue to spin after waking up.
       state = spin(spin_count);
@@ -99,12 +100,12 @@ class RawMutex {
        bool is_shared = false,
        uint_fast32_t spin_count = LIBC_COPT_RAW_MUTEX_DEFAULT_SPIN_COUNT) {
     // Timeout will not be checked if immediate lock is possible.
-    return try_lock() || lock_contented(timeout, is_shared, spin_count);
+    return try_lock() || lock_slow(timeout, is_shared, spin_count);
   }
   LIBC_INLINE bool unlock(bool is_pshared = false) {
     FutexWordType prev = futex.exchange(UNLOCKED, cpp::MemoryOrder::RELEASE);
     // if there is someone waiting, wake them up
-    if (prev == CONTENTED)
+    if (prev == IN_CONTENTION)
       wake(is_pshared);
     // Detect invalid unlock operation.
     return prev != UNLOCKED;