Mixed-size accesses

benchmarks/mixed/lockref-par1.c

@@ -0,0 +1,48 @@
+#include <stdatomic.h>
+#include <pthread.h>
+#include <assert.h>
+#include "lockref.h"
+
+#ifndef NTHREADS
+#define NTHREADS 2
+#endif
+
+struct lockref my_lockref;
+
+void *get(void *unused) {
+
+    lockref_get(&my_lockref);
+
+    return NULL;
+}
+
+void *ret(void *unused) {
+
+    lockref_put_return(&my_lockref);
+
+    return NULL;
+}
+
+int main() {
+
+    pthread_t g[NTHREADS];
+    pthread_t r[NTHREADS];
+
+    atomic_store(&my_lockref.lock_count, 0);
+
+    for (int i = 0; i < NTHREADS; i++)
+        pthread_create(&g[i], 0, get, (void *)(size_t)i);
+    for (int i = 0; i < NTHREADS; i++)
+        pthread_create(&r[i], 0, ret, (void *)(size_t)i);
+
+    for (int i = 0; i < NTHREADS; i++)
+        pthread_join(g[i], 0);
+    assert(my_lockref.count >= 0);
+    assert(my_lockref.count <= NTHREADS);
+
+    for (int i = 0; i < NTHREADS; i++)
+        pthread_join(r[i], 0);
+    assert(my_lockref.count == 0); // Wrong since some decrement might have no effect if there is no matching increment
+
+    return 0;
+}

benchmarks/mixed/lockref-par2.c

@@ -0,0 +1,47 @@
+#include <stdatomic.h>
+#include <pthread.h>
+#include <assert.h>
+#include "lockref.h"
+
+#ifndef NTHREADS
+#define NTHREADS 2
+#endif
+
+struct lockref my_lockref;
+
+void *get(void *unused) {
+
+    lockref_get(&my_lockref);
+
+    return NULL;
+}
+
+void *ret(void *unused) {
+
+    lockref_put_return(&my_lockref);
+
+    return NULL;
+}
+
+int main() {
+
+    pthread_t g[NTHREADS];
+    pthread_t r[NTHREADS];
+
+    atomic_store(&my_lockref.lock_count, 0);
+
+    for (int i = 0; i < NTHREADS; i++)
+        pthread_create(&g[i], 0, get, (void *)(size_t)i);
+    for (int i = 0; i < NTHREADS; i++)
+        pthread_create(&r[i], 0, ret, (void *)(size_t)i);
+
+    for (int i = 0; i < NTHREADS; i++)
+        pthread_join(g[i], 0);
+    assert(my_lockref.count >= 0); // Correct since decrements fail if counter is zero
+    assert(my_lockref.count <= NTHREADS); // Correct because if all increments come first we get == NTHREADS
+
+    for (int i = 0; i < NTHREADS; i++)
+        pthread_join(r[i], 0);
+
+    return 0;
+}

benchmarks/mixed/lockref-par3.c

@@ -0,0 +1,46 @@
+#include <stdatomic.h>
+#include <pthread.h>
+#include <assert.h>
+#include "lockref.h"
+
+#ifndef NTHREADS
+#define NTHREADS 2
+#endif
+
+struct lockref my_lockref;
+
+void *get(void *unused) {
+
+    lockref_get(&my_lockref);
+
+    return NULL;
+}
+
+void *ret(void *unused) {
+
+    lockref_put_return(&my_lockref);
+
+    return NULL;
+}
+
+int main() {
+
+    pthread_t g[NTHREADS];
+    pthread_t r[NTHREADS];
+
+    atomic_store(&my_lockref.lock_count, 0);
+
+    for (int i = 0; i < NTHREADS; i++)
+        pthread_create(&g[i], 0, get, (void *)(size_t)i);
+    for (int i = 0; i < NTHREADS; i++)
+        pthread_create(&r[i], 0, ret, (void *)(size_t)i);
+
+    for (int i = 0; i < NTHREADS; i++)
+        pthread_join(g[i], 0);
+    assert(my_lockref.count == NTHREADS); // Wrong, increment and decrement can be interleaved
+
+    for (int i = 0; i < NTHREADS; i++)
+        pthread_join(r[i], 0);
+
+    return 0;
+}

benchmarks/mixed/lockref-seq.c

@@ -0,0 +1,46 @@
+#include <stdatomic.h>
+#include <pthread.h>
+#include <assert.h>
+#include "lockref.h"
+
+#ifndef NTHREADS
+#define NTHREADS 2
+#endif
+
+struct lockref my_lockref;
+
+void *get(void *unused) {
+
+    lockref_get(&my_lockref);
+
+    return NULL;
+}
+
+void *ret(void *unused) {
+
+    lockref_put_return(&my_lockref);
+
+    return NULL;
+}
+
+int main() {
+
+    pthread_t g[NTHREADS];
+    pthread_t r[NTHREADS];
+
+    atomic_store(&my_lockref.lock_count, 0);
+
+    for (int i = 0; i < NTHREADS; i++)
+        pthread_create(&g[i], 0, get, (void *)(size_t)i);
+    for (int i = 0; i < NTHREADS; i++)
+        pthread_join(g[i], 0);
+    assert(my_lockref.count == NTHREADS); // Correct since all get first
+
+    for (int i = 0; i < NTHREADS; i++)
+        pthread_create(&r[i], 0, ret, (void *)(size_t)i);
+    for (int i = 0; i < NTHREADS; i++)
+        pthread_join(r[i], 0);
+    assert(my_lockref.count == 0); // Correct since every decrement has a matching increment
+
+    return 0;
+}

benchmarks/mixed/lockref.h

@@ -0,0 +1,67 @@
+#include <stdatomic.h>
+#include <pthread.h>
+#include <assert.h>
+#include "spinlock.c"
+
+#define CMPXCHG_LOOP(CODE, SUCCESS) do {                                    \
+        struct lockref old;                                                 \
+        old.lock_count = atomic_load(&lockref->lock_count);                 \
+        while (old.lock.lock == 0) {                                        \
+                struct lockref new = old;                                   \
+                CODE                                                        \
+                if (atomic_compare_exchange_strong(&lockref->lock_count,    \
+                                            (int64_t *) &old.lock_count,    \
+                                            new.lock_count)) {              \
+                        SUCCESS;                                            \
+                }                                                           \
+        }                                                                   \
+} while (0)
+
+struct lockref {
+    union {
+        _Atomic(int64_t) lock_count;
+        struct {
+            spinlock_t lock;
+            _Atomic(int32_t) count;
+        };
+    };
+};
+
+/**
+ * lockref_get - Increments reference count unconditionally
+ * @lockref: pointer to lockref structure
+ *
+ * This operation is only valid if you already hold a reference
+ * to the object, so you know the count cannot be zero.
+ */
+void lockref_get(struct lockref *lockref)
+{
+        CMPXCHG_LOOP(
+                new.count++;
+        ,
+                return;
+        );
+
+        spin_lock(&lockref->lock);
+        lockref->count++;
+        spin_unlock(&lockref->lock);
+}
+
+/**
+ * lockref_put_return - Decrement reference count if possible
+ * @lockref: pointer to lockref structure
+ *
+ * Decrement the reference count and return the new value.
+ * If the lockref was dead or locked, return an error.
+ */
+int lockref_put_return(struct lockref *lockref)
+{
+        CMPXCHG_LOOP(
+                new.count--;
+                if (old.count <= 0)
+                        return -1;
+        ,
+                return new.count;
+        );
+        return -1;
+}

benchmarks/mixed/lockref1.c

@@ -0,0 +1,103 @@
+#include <stdatomic.h>
+#include <pthread.h>
+#include <assert.h>
+
+
+#ifndef NTHREADS
+#define NTHREADS 3
+#endif
+
+// ==========================================
+//                   Spinlock
+// ==========================================
+
+struct spinlock_s {
+        _Atomic(int32_t) lock;
+};
+typedef struct spinlock_s spinlock_t;
+
+void await_for_lock(struct spinlock_s *l)
+{
+    while (atomic_load_explicit(&l->lock, memory_order_relaxed) != 0);
+    return;
+}
+
+int try_get_lock(struct spinlock_s *l)
+{
+    int val = 0;
+    return atomic_compare_exchange_strong_explicit(&l->lock, &val, 1, memory_order_acquire, memory_order_acquire);
+}
+
+void spin_lock(struct spinlock_s *l)
+{
+    do {
+        await_for_lock(l);
+    } while(!try_get_lock(l));
+    return;
+}
+
+void spin_unlock(struct spinlock_s *l)
+{
+    atomic_store_explicit(&l->lock, 0, memory_order_release);
+}
+
+// ==========================================
+//                   Lockref
+// ==========================================
+
+typedef struct {
+    union {
+        struct {
+            atomic_int lock;
+            int count;
+        };
+        atomic_long lock_count;
+    };
+} lockref_t;
+
+void lockref_get(lockref_t *lockref) {
+    long old_val = atomic_load_explicit(&lockref->lock_count, memory_order_relaxed);
+
+    while (((lockref_t *)&old_val)->lock == 0) {
+        long new_val = old_val;
+        ((lockref_t *)&new_val)->count++;
+        if (atomic_compare_exchange_strong_explicit(
+                &lockref->lock_count, &old_val, new_val,
+                memory_order_relaxed, memory_order_relaxed)) {
+            return;
+        }
+    }
+
+    spin_lock(&lockref->lock);
+    lockref->count++;
+    spin_unlock(&lockref->lock);
+}
+
+// ==========================================
+//                     Main
+// ==========================================
+
+lockref_t my_lockref;
+
+void *thread_n(void *unsued) {
+
+    lockref_get(&my_lockref);
+
+    return NULL;
+}
+
+int main() {
+
+    pthread_t t[NTHREADS];
+
+    atomic_store(&my_lockref.lock_count, 0);
+
+    for (int i = 0; i < NTHREADS; i++)
+        pthread_create(&t[i], 0, thread_n, (void *)(size_t)i);
+
+    for (int i = 0; i < NTHREADS; i++)
+        pthread_join(t[i], 0);
+
+    assert(my_lockref.count == NTHREADS);
+    return 0;
+}