Test rwlock more

test/libc/thread/footek_test.c

@@ -1,11 +1,14 @@
-#define USE        POSIX_RECURSIVE
+#define USE        POSIX
 #define ITERATIONS 100000
 #define THREADS    30
 
 #define SPIN            1
 #define FUTEX           2
-#define POSIX           3
-#define POSIX_RECURSIVE 4
+#define FUTEX_SHARED    3
+#define POSIX           4
+#define POSIX_RECURSIVE 5
+#define RWLOCK          6
+#define RWLOCK_SHARED   7
 
 #ifdef __COSMOPOLITAN__
 #include <cosmo.h>
@@ -274,8 +277,11 @@ void lock(atomic_int *futex) {
     word = atomic_exchange_explicit(futex, 2, memory_order_acquire);
   while (word > 0) {
     pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);
-#if USE == FUTEX
-    nsync_futex_wait_(futex, 2, 0, 0, 0);
+#if USE == FUTEX || USE == FUTEX_SHARED
+    cosmo_futex_wait(
+        futex, 2,
+        USE == FUTEX_SHARED ? PTHREAD_PROCESS_SHARED : PTHREAD_PROCESS_PRIVATE,
+        0, 0);
 #else
     pthread_yield_np();
 #endif
@@ -288,8 +294,10 @@ void unlock(atomic_int *futex) {
   int word = atomic_fetch_sub_explicit(futex, 1, memory_order_release);
   if (word == 2) {
     atomic_store_explicit(futex, 0, memory_order_release);
-#if USE == FUTEX
-    nsync_futex_wake_(futex, 1, 0);
+#if USE == FUTEX || USE == FUTEX_SHARED
+    cosmo_futex_wake(
+        futex, 1,
+        USE == FUTEX_SHARED ? PTHREAD_PROCESS_SHARED : PTHREAD_PROCESS_PRIVATE);
 #endif
   }
 }
@@ -297,6 +305,7 @@ void unlock(atomic_int *futex) {
 int g_chores;
 atomic_int g_lock;
 pthread_mutex_t g_locker;
+pthread_rwlock_t g_rwlocker;
 
 void *worker(void *arg) {
   for (int i = 0; i < ITERATIONS; ++i) {
@@ -304,6 +313,10 @@ void *worker(void *arg) {
     pthread_mutex_lock(&g_locker);
     ++g_chores;
     pthread_mutex_unlock(&g_locker);
+#elif USE == RWLOCK || USE == RWLOCK_SHARED
+    pthread_rwlock_wrlock(&g_rwlocker);
+    ++g_chores;
+    pthread_rwlock_unlock(&g_rwlocker);
 #else
     lock(&g_lock);
     ++g_chores;
@@ -331,7 +344,6 @@ int main() {
   struct timeval start;
   gettimeofday(&start, 0);
 
-  pthread_mutex_t lock;
   pthread_mutexattr_t attr;
   pthread_mutexattr_init(&attr);
 #if USE == POSIX_RECURSIVE
@@ -342,6 +354,14 @@ int main() {
   pthread_mutex_init(&g_locker, &attr);
   pthread_mutexattr_destroy(&attr);
 
+  pthread_rwlockattr_t rwattr;
+  pthread_rwlockattr_init(&rwattr);
+#if USE == RWLOCK_SHARED
+  pthread_rwlockattr_setpshared(&rwattr, PTHREAD_PROCESS_SHARED);
+#endif
+  pthread_rwlock_init(&g_rwlocker, &rwattr);
+  pthread_rwlockattr_destroy(&rwattr);
+
   pthread_t th[THREADS];
   for (int i = 0; i < THREADS; ++i)
     pthread_create(&th[i], 0, worker, 0);
@@ -360,7 +380,8 @@ int main() {
          tomicros(ru.ru_utime),      //
          tomicros(ru.ru_stime));
 
-  pthread_mutex_destroy(&lock);
+  pthread_rwlock_destroy(&g_rwlocker);
+  pthread_mutex_destroy(&g_locker);
 
 #ifdef __COSMOPOLITAN__
   CheckForMemoryLeaks();

test/libc/thread/pthread_rwlock_rdlock_test.c

@@ -18,34 +18,32 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/atomic.h"
 #include "libc/calls/calls.h"
+#include "libc/intrin/atomic.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
+#include "libc/stdalign.h"
+#include "libc/stdio/rand.h"
 #include "libc/testlib/testlib.h"
 #include "libc/thread/thread.h"
 
-#define READERS           8
-#define WRITERS           2
-#define READER_ITERATIONS 10000
-#define WRITER_ITERATIONS 1000
+#define READERS    8
+#define WRITERS    2
+#define ITERATIONS 1000
 
-int writes;
-atomic_int reads;
+atomic_bool done;
+alignas(128) int foo;
+alignas(128) int bar;
 pthread_rwlock_t lock;
 pthread_rwlockattr_t attr;
 pthread_barrier_t barrier;
 
-FIXTURE(pthread_rwlock, private) {
-  reads = 0;
-  writes = 0;
-  ASSERT_EQ(0, pthread_rwlockattr_init(&attr));
-  ASSERT_EQ(0, pthread_rwlockattr_setpshared(&attr, PTHREAD_PROCESS_PRIVATE));
-  ASSERT_EQ(0, pthread_rwlock_init(&lock, &attr));
-  ASSERT_EQ(0, pthread_rwlockattr_destroy(&attr));
+void delay(int k) {
+  int n = rand() % k;
+  for (volatile int i = 0; i < n; ++i) {
+  }
 }
 
-FIXTURE(pthread_rwlock, pshared) {
-  reads = 0;
-  writes = 0;
+void SetUp(void) {
   ASSERT_EQ(0, pthread_rwlockattr_init(&attr));
   ASSERT_EQ(0, pthread_rwlockattr_setpshared(&attr, PTHREAD_PROCESS_SHARED));
   ASSERT_EQ(0, pthread_rwlock_init(&lock, &attr));
@@ -58,23 +56,33 @@ void TearDown(void) {
 
 void *Reader(void *arg) {
   pthread_barrier_wait(&barrier);
-  for (int i = 0; i < READER_ITERATIONS; ++i) {
+  while (!atomic_load_explicit(&done, memory_order_relaxed)) {
     ASSERT_EQ(0, pthread_rwlock_rdlock(&lock));
-    ++reads;
+    // cosmo_trace_begin("reader");
+    int x = foo;
+    usleep(1);  // delay(100000);
+    int y = bar;
+    ASSERT_EQ(x, y);
+    // cosmo_trace_end("reader");
     ASSERT_EQ(0, pthread_rwlock_unlock(&lock));
+    usleep(1);  // delay(100000);
   }
   return 0;
 }
 
 void *Writer(void *arg) {
   pthread_barrier_wait(&barrier);
-  for (int i = 0; i < WRITER_ITERATIONS; ++i) {
+  for (int i = 0; i < ITERATIONS; ++i) {
     ASSERT_EQ(0, pthread_rwlock_wrlock(&lock));
-    ++writes;
+    // cosmo_trace_begin("writer");
+    ++foo;
+    delay(100);
+    ++bar;
+    // cosmo_trace_end("writer");
     ASSERT_EQ(0, pthread_rwlock_unlock(&lock));
-    for (volatile int i = 0; i < 100; ++i)
-      pthread_pause_np();
+    delay(100);
   }
+  done = true;
   return 0;
 }
 
@@ -82,14 +90,12 @@ TEST(pthread_rwlock_rdlock, test) {
   int i;
   pthread_t *t = gc(malloc(sizeof(pthread_t) * (READERS + WRITERS)));
   ASSERT_EQ(0, pthread_barrier_init(&barrier, 0, READERS + WRITERS));
-  for (i = 0; i < READERS + WRITERS; ++i) {
+  for (i = 0; i < READERS + WRITERS; ++i)
     ASSERT_SYS(0, 0,
                pthread_create(t + i, 0, i < READERS ? Reader : Writer, 0));
-  }
-  for (i = 0; i < READERS + WRITERS; ++i) {
+  for (i = 0; i < READERS + WRITERS; ++i)
     EXPECT_SYS(0, 0, pthread_join(t[i], 0));
-  }
-  EXPECT_EQ(READERS * READER_ITERATIONS, reads);
-  EXPECT_EQ(WRITERS * WRITER_ITERATIONS, writes);
+  EXPECT_EQ(WRITERS * ITERATIONS, foo);
+  EXPECT_EQ(WRITERS * ITERATIONS, bar);
   ASSERT_EQ(0, pthread_barrier_destroy(&barrier));
 }