Cleanup inline locking code

libc/intrin/pthread_pause_np.c

@@ -0,0 +1,30 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2023 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/thread/thread.h"
+
+/**
+ * Yields hyperthread.
+ */
+void pthread_pause_np(void) {
+#if defined(__GNUC__) && defined(__aarch64__)
+  __asm__ volatile("yield");
+#elif defined(__GNUC__) && (defined(__x86_64__) || defined(__i386__))
+  __asm__ volatile("pause");
+#endif
+}

libc/intrin/pthread_spin_destroy.c

@@ -24,7 +24,7 @@
  *
  * @return 0 on success, or errno on error
  */
-errno_t(pthread_spin_destroy)(pthread_spinlock_t *spin) {
+errno_t pthread_spin_destroy(pthread_spinlock_t *spin) {
   atomic_store_explicit(&spin->_lock, -1, memory_order_relaxed);
   return 0;
 }

libc/intrin/pthread_spin_init.c

@@ -28,7 +28,7 @@
  * @see pthread_spin_destroy
  * @see pthread_spin_lock
  */
-errno_t(pthread_spin_init)(pthread_spinlock_t *spin, int pshared) {
+errno_t pthread_spin_init(pthread_spinlock_t *spin, int pshared) {
   atomic_store_explicit(&spin->_lock, 0, memory_order_relaxed);
   return 0;
 }

libc/intrin/pthread_spin_lock.c

@@ -16,9 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/assert.h"
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/strace.internal.h"
 #include "libc/thread/thread.h"
 
 /**
@@ -39,24 +37,9 @@
  * @see pthread_spin_unlock
  * @see pthread_spin_init
  */
-errno_t(pthread_spin_lock)(pthread_spinlock_t *spin) {
-  int x;
-#if defined(SYSDEBUG) && _LOCKTRACE
-  for (;;) {
-    x = atomic_exchange_explicit(&spin->_lock, 1, memory_order_acquire);
-    if (!x) {
-      LOCKTRACE("pthread_spin_lock(%t)", spin);
-      break;
-    }
-    unassert(x == 1);
-    LOCKTRACE("pthread_spin_lock(%t) trying...", spin);
+errno_t pthread_spin_lock(pthread_spinlock_t *spin) {
+  while (atomic_exchange_explicit(&spin->_lock, 1, memory_order_acquire)) {
+    pthread_pause_np();
   }
-#else
-  for (;;) {
-    x = atomic_exchange_explicit(&spin->_lock, 1, memory_order_acquire);
-    if (!x) break;
-    unassert(x == 1);
-  }
-#endif
   return 0;
 }

libc/intrin/pthread_spin_trylock.c

@@ -16,7 +16,6 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/assert.h"
 #include "libc/errno.h"
 #include "libc/intrin/atomic.h"
 #include "libc/thread/thread.h"
@@ -30,10 +29,10 @@
  * @return 0 on success, or errno on error
  * @raise EBUSY if lock is already held
  */
-errno_t(pthread_spin_trylock)(pthread_spinlock_t *spin) {
-  int x;
-  x = atomic_exchange_explicit(&spin->_lock, 1, memory_order_acquire);
-  if (!x) return 0;
-  unassert(x == 1);
-  return EBUSY;
+errno_t pthread_spin_trylock(pthread_spinlock_t *spin) {
+  if (!atomic_exchange_explicit(&spin->_lock, 1, memory_order_acquire)) {
+    return 0;
+  } else {
+    return EBUSY;
+  }
 }

libc/intrin/pthread_spin_unlock.c

@@ -17,7 +17,6 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/strace.internal.h"
 #include "libc/thread/thread.h"
 
 /**
@@ -29,8 +28,7 @@
  * @return 0 on success, or errno on error
  * @see pthread_spin_lock
  */
-errno_t(pthread_spin_unlock)(pthread_spinlock_t *spin) {
-  LOCKTRACE("pthread_spin_unlock(%t)", spin);
+errno_t pthread_spin_unlock(pthread_spinlock_t *spin) {
   atomic_store_explicit(&spin->_lock, 0, memory_order_release);
   return 0;
 }