Add MCS lock implementation

Author: jserv

README.md

@@ -29,7 +29,8 @@ purpose of these programs is to be illustrative and educational.
     - [hashmap](hashmap/): A concurrent hashmap implementation.
     - [lf-timer](lf-timer/): A lock-free timer.
 * [Synchronization](https://en.wikipedia.org/wiki/Synchronization_(computer_science))
-    - [hp\_list](hp_list): A concurrent linked list utilizing Hazard Pointers.
+    - [mcslock](mcslock/): MCS lock implementation.
+    - [hp\_list](hp_list)/: A concurrent linked list utilizing Hazard Pointers.
     - [rcu-list](rcu-list/): A concurrent linked list utilizing the simplified RCU algorithm.
     - [qsbr](qsbr/): An implementation of Quiescent state based reclamation (QSBR).
     - [list-move](list-move/): Evaluation of two concurrent linked lists: QSBR and lock-based.

mcslock/Makefile

@@ -0,0 +1,5 @@
+all:
+	gcc -o tests -std=gnu11 -Wall -O2 mcslock.c tests.c
+
+clean:
+	rm -f tests

mcslock/mcslock.c

@@ -0,0 +1,75 @@
+#include <stddef.h>
+
+#include "mcslock.h"
+
+#define LIKELY(x) __builtin_expect(!!(x), 1)
+
+enum { MCS_PROCEED = 0, MCS_WAIT = 1 };
+
+#if defined(__i386__) || defined(__x86_64__)
+#define spin_wait() __builtin_ia32_pause()
+#elif defined(__aarch64__)
+#define spin_wait() __asm__ __volatile__("isb\n")
+#else
+#define spin_wait() ((void) 0)
+#endif
+
+static inline void wait_until_equal_u8(uint8_t *loc, uint8_t val, int mm)
+{
+    while (__atomic_load_n(loc, mm) != val)
+        spin_wait();
+}
+
+void mcslock_init(mcslock_t *lock)
+{
+    *lock = NULL;
+}
+
+void mcslock_acquire(mcslock_t *lock, mcsnode_t *node)
+{
+    node->next = NULL;
+    /* A0: Read and write lock, synchronized with A0/A1 */
+    mcsnode_t *prev = __atomic_exchange_n(lock, node, __ATOMIC_ACQ_REL);
+    if (LIKELY(!prev)) /* Lock uncontended, the lock is acquired */
+        return;
+    /* Otherwise, the lock is owned by another thread, waiting for its turn */
+
+    node->wait = MCS_WAIT;
+    /* B0: Write next, synchronized with B1/B2 */
+    __atomic_store_n(&prev->next, node, __ATOMIC_RELEASE);
+
+    /* Waiting for the previous thread to signal using the assigned node
+     * C0: Read wait, synchronized with C1
+     */
+    wait_until_equal_u8(&node->wait, MCS_PROCEED, __ATOMIC_ACQUIRE);
+}
+
+void mcslock_release(mcslock_t *lock, mcsnode_t *node)
+{
+    mcsnode_t *next;
+
+    /* Check if any waiting thread exists */
+    /* B1: Read next, synchronized with B0 */
+    if ((next = __atomic_load_n(&node->next, __ATOMIC_ACQUIRE)) == NULL) {
+        /* No waiting threads detected, attempt lock release */
+        /* Use temporary variable as it might be overwritten */
+        mcsnode_t *tmp = node;
+
+        /* A1: write lock, synchronize with A0 */
+        if (__atomic_compare_exchange_n(lock, &tmp, NULL, 0, __ATOMIC_RELEASE,
+                                        __ATOMIC_RELAXED)) {
+            /* No waiting threads yet, lock released successfully */
+            return;
+        }
+        /* Otherwise, at least one waiting thread exists */
+
+        /* Wait for the first waiting thread to link its node with ours */
+        /* B2: Read next, synchronized with B0 */
+        while ((next = __atomic_load_n(&node->next, __ATOMIC_ACQUIRE)) == NULL)
+            spin_wait();
+    }
+
+    /* Signal the first waiting thread */
+    /* C1: Write wait, synchronized with C0 */
+    __atomic_store_n(&next->wait, MCS_PROCEED, __ATOMIC_RELEASE);
+}

mcslock/mcslock.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <stdint.h>
+
+typedef struct mcsnode {
+    struct mcsnode *next;
+    uint8_t wait;
+} mcsnode_t;
+
+typedef mcsnode_t *mcslock_t;
+
+/* Initialize an MCS lock */
+void mcslock_init(mcslock_t *lock);
+
+/* Acquire an MCS lock
+ * 'node' points to an uninitialized mcsnode
+ */
+void mcslock_acquire(mcslock_t *lock, mcsnode_t *node);
+
+/* Release an MCS lock
+ * node' must specify same node as used in matching acquire call
+ */
+void mcslock_release(mcslock_t *lock, mcsnode_t *node);

mcslock/tests.c

@@ -0,0 +1,16 @@
+#include <stdio.h>
+
+#include "mcslock.h"
+
+int main(void)
+{
+    mcslock_t lock;
+    mcsnode_t node;
+    mcslock_init(&lock);
+    mcslock_acquire(&lock, &node);
+    mcslock_release(&lock, &node);
+    mcslock_acquire(&lock, &node);
+    mcslock_release(&lock, &node);
+
+    return 0;
+}