From 1491fc3840762ae57661f247ae363be83e0132a2 Mon Sep 17 00:00:00 2001
From: weiyu <weiyuluo1232@gmail.com>
Date: Tue, 4 Aug 2020 12:37:20 -0700
Subject: [PATCH] Add data structure benchmarks

---
 cdschecker_modified_benchmarks/Makefile       |   7 +
 .../barrier/Makefile                          |  11 +
 .../barrier/barrier.cc                        |  43 +++
 .../barrier/barrier.h                         |  36 +++
 cdschecker_modified_benchmarks/benchmarks.mk  |  10 +
 .../chase-lev-deque/Makefile                  |  17 ++
 .../chase-lev-deque/deque.cc                  |  85 ++++++
 .../chase-lev-deque/deque.h                   |  25 ++
 .../chase-lev-deque/main.cc                   |  52 ++++
 .../dekker-fences/Makefile                    |  11 +
 .../dekker-fences/dekker-fences.cc            |  95 +++++++
 .../include/cds_atomic.h                      |  52 ++++
 .../include/cds_threads.h                     |  38 +++
 .../include/librace.h                         |  29 ++
 .../include/model-assert.h                    |  21 ++
 .../include/unrelacy.h                        |  96 +++++++
 .../linuxrwlocks/Makefile                     |  11 +
 .../linuxrwlocks/linuxrwlocks.cc              | 118 ++++++++
 .../mcs-lock/Makefile                         |  11 +
 .../mcs-lock/mcs-lock.cc                      |  43 +++
 .../mcs-lock/mcs-lock.h                       |  93 +++++++
 .../mpmc-queue/Makefile                       |  24 ++
 .../mpmc-queue/mpmc-queue.cc                  | 143 ++++++++++
 .../mpmc-queue/mpmc-queue.h                   |  97 +++++++
 .../ms-queue-tsan11/Makefile                  |  17 ++
 .../ms-queue-tsan11/main.cc                   |  87 ++++++
 .../ms-queue-tsan11/main.o                    | Bin 0 -> 289240 bytes
 .../ms-queue-tsan11/my_queue.cc               | 161 +++++++++++
 .../ms-queue-tsan11/my_queue.h                |  31 +++
 .../ms-queue-tsan11/my_queue.o                | Bin 0 -> 285376 bytes
 .../ms-queue/Makefile                         |  19 ++
 .../ms-queue/main.cc                          |  88 ++++++
 .../ms-queue/my_queue.c.correct               | 260 ++++++++++++++++++
 .../ms-queue/my_queue.cc                      | 167 +++++++++++
 .../ms-queue/my_queue.h                       |  32 +++
 .../spsc-queue/Makefile                       |  23 ++
 .../spsc-queue/eventcount-relacy.h            |  64 +++++
 .../spsc-queue/eventcount.h                   |  72 +++++
 .../spsc-queue/queue-relacy.h                 |  74 +++++
 .../spsc-queue/queue.h                        |  77 ++++++
 .../spsc-queue/spsc-queue.cc                  |  34 +++
 .../spsc-queue/spsc-relacy.cc                 |  27 ++
 cdschecker_modified_benchmarks/test.sh        |  46 ++++
 cdschecker_modified_benchmarks/test_all.sh    |  13 +
 44 files changed, 2460 insertions(+)
 create mode 100644 cdschecker_modified_benchmarks/Makefile
 create mode 100644 cdschecker_modified_benchmarks/barrier/Makefile
 create mode 100644 cdschecker_modified_benchmarks/barrier/barrier.cc
 create mode 100644 cdschecker_modified_benchmarks/barrier/barrier.h
 create mode 100644 cdschecker_modified_benchmarks/benchmarks.mk
 create mode 100644 cdschecker_modified_benchmarks/chase-lev-deque/Makefile
 create mode 100644 cdschecker_modified_benchmarks/chase-lev-deque/deque.cc
 create mode 100644 cdschecker_modified_benchmarks/chase-lev-deque/deque.h
 create mode 100644 cdschecker_modified_benchmarks/chase-lev-deque/main.cc
 create mode 100644 cdschecker_modified_benchmarks/dekker-fences/Makefile
 create mode 100644 cdschecker_modified_benchmarks/dekker-fences/dekker-fences.cc
 create mode 100755 cdschecker_modified_benchmarks/include/cds_atomic.h
 create mode 100755 cdschecker_modified_benchmarks/include/cds_threads.h
 create mode 100755 cdschecker_modified_benchmarks/include/librace.h
 create mode 100755 cdschecker_modified_benchmarks/include/model-assert.h
 create mode 100755 cdschecker_modified_benchmarks/include/unrelacy.h
 create mode 100644 cdschecker_modified_benchmarks/linuxrwlocks/Makefile
 create mode 100644 cdschecker_modified_benchmarks/linuxrwlocks/linuxrwlocks.cc
 create mode 100644 cdschecker_modified_benchmarks/mcs-lock/Makefile
 create mode 100644 cdschecker_modified_benchmarks/mcs-lock/mcs-lock.cc
 create mode 100644 cdschecker_modified_benchmarks/mcs-lock/mcs-lock.h
 create mode 100644 cdschecker_modified_benchmarks/mpmc-queue/Makefile
 create mode 100644 cdschecker_modified_benchmarks/mpmc-queue/mpmc-queue.cc
 create mode 100644 cdschecker_modified_benchmarks/mpmc-queue/mpmc-queue.h
 create mode 100755 cdschecker_modified_benchmarks/ms-queue-tsan11/Makefile
 create mode 100755 cdschecker_modified_benchmarks/ms-queue-tsan11/main.cc
 create mode 100644 cdschecker_modified_benchmarks/ms-queue-tsan11/main.o
 create mode 100755 cdschecker_modified_benchmarks/ms-queue-tsan11/my_queue.cc
 create mode 100755 cdschecker_modified_benchmarks/ms-queue-tsan11/my_queue.h
 create mode 100644 cdschecker_modified_benchmarks/ms-queue-tsan11/my_queue.o
 create mode 100644 cdschecker_modified_benchmarks/ms-queue/Makefile
 create mode 100644 cdschecker_modified_benchmarks/ms-queue/main.cc
 create mode 100644 cdschecker_modified_benchmarks/ms-queue/my_queue.c.correct
 create mode 100644 cdschecker_modified_benchmarks/ms-queue/my_queue.cc
 create mode 100644 cdschecker_modified_benchmarks/ms-queue/my_queue.h
 create mode 100644 cdschecker_modified_benchmarks/spsc-queue/Makefile
 create mode 100644 cdschecker_modified_benchmarks/spsc-queue/eventcount-relacy.h
 create mode 100644 cdschecker_modified_benchmarks/spsc-queue/eventcount.h
 create mode 100644 cdschecker_modified_benchmarks/spsc-queue/queue-relacy.h
 create mode 100644 cdschecker_modified_benchmarks/spsc-queue/queue.h
 create mode 100644 cdschecker_modified_benchmarks/spsc-queue/spsc-queue.cc
 create mode 100644 cdschecker_modified_benchmarks/spsc-queue/spsc-relacy.cc
 create mode 100755 cdschecker_modified_benchmarks/test.sh
 create mode 100755 cdschecker_modified_benchmarks/test_all.sh

diff --git a/cdschecker_modified_benchmarks/Makefile b/cdschecker_modified_benchmarks/Makefile
new file mode 100644
index 0000000..01dae3f
--- /dev/null
+++ b/cdschecker_modified_benchmarks/Makefile
@@ -0,0 +1,7 @@
+DIRS = barrier chase-lev-deque dekker-fences linuxrwlocks mcs-lock mpmc-queue ms-queue spsc-queue
+
+all :
+	set -e; set -u; for d in $(DIRS); do (cd $$d; $(MAKE) ); done
+
+clean :
+	set -e; set -u; for d in $(DIRS); do (cd $$d; $(MAKE) clean ); done
diff --git a/cdschecker_modified_benchmarks/barrier/Makefile b/cdschecker_modified_benchmarks/barrier/Makefile
new file mode 100644
index 0000000..22df223
--- /dev/null
+++ b/cdschecker_modified_benchmarks/barrier/Makefile
@@ -0,0 +1,11 @@
+include ../benchmarks.mk
+
+TESTNAME = barrier
+
+all: $(TESTNAME)
+
+$(TESTNAME): $(TESTNAME).cc $(TESTNAME).h
+	$(CXX) -o $@ $< $(CXXFLAGS) $(LDFLAGS)
+
+clean:
+	rm -f $(TESTNAME) *.o
diff --git a/cdschecker_modified_benchmarks/barrier/barrier.cc b/cdschecker_modified_benchmarks/barrier/barrier.cc
new file mode 100644
index 0000000..4d3c8ba
--- /dev/null
+++ b/cdschecker_modified_benchmarks/barrier/barrier.cc
@@ -0,0 +1,43 @@
+#include <stdio.h>
+
+#include "cds_threads.h"
+
+#include "barrier.h"
+
+#include "librace.h"
+
+spinning_barrier *barr;
+int var = 0;
+
+void threadA(void *arg)
+{
+//	std::this_thread::sleep_for(std::chrono::milliseconds(10));
+	store_32(&var, 1);
+	barr->wait();
+}
+
+void threadB(void *arg)
+{
+//	std::this_thread::sleep_for(std::chrono::milliseconds(10));
+	barr->wait();
+	printf("var = %d\n", load_32(&var));
+}
+
+#define NUMREADERS 3
+int user_main(int argc, char **argv)
+{
+	std::thread A, B[NUMREADERS];
+	int i;
+
+	barr = new spinning_barrier(NUMREADERS + 1);
+
+	A = std::thread(threadA, (void *)NULL);
+	for (i = 0; i < NUMREADERS; i++)
+		B[i] = std::thread(threadB, (void *)NULL);
+
+	for (i = 0; i < NUMREADERS; i++)
+		B[i].join();
+	A.join();
+
+	return 0;
+}
diff --git a/cdschecker_modified_benchmarks/barrier/barrier.h b/cdschecker_modified_benchmarks/barrier/barrier.h
new file mode 100644
index 0000000..b52b849
--- /dev/null
+++ b/cdschecker_modified_benchmarks/barrier/barrier.h
@@ -0,0 +1,36 @@
+#include "cds_atomic.h"
+
+class spinning_barrier {
+ public:
+	spinning_barrier (unsigned int n) : n_ (n) {
+		nwait_ = 0;
+		step_ = 0;
+	}
+
+	bool wait() {
+		unsigned int step = step_.load ();
+
+		if (nwait_.fetch_add (1) == n_ - 1) {
+			/* OK, last thread to come.  */
+			nwait_.store (0); // XXX: maybe can use relaxed ordering here ??
+			step_.fetch_add (1, std::memory_order_relaxed);
+			return true;
+		} else {
+			/* Run in circles and scream like a little girl.  */
+			while (step_.load () == step)
+				thrd_yield();
+			return false;
+		}
+	}
+
+ protected:
+	/* Number of synchronized threads. */
+	const unsigned int n_;
+
+	/* Number of threads currently spinning.  */
+	std::atomic<unsigned int> nwait_;
+
+	/* Number of barrier syncronizations completed so far, 
+	 *      * it's OK to wrap.  */
+	std::atomic<unsigned int> step_;
+};
diff --git a/cdschecker_modified_benchmarks/benchmarks.mk b/cdschecker_modified_benchmarks/benchmarks.mk
new file mode 100644
index 0000000..b103419
--- /dev/null
+++ b/cdschecker_modified_benchmarks/benchmarks.mk
@@ -0,0 +1,10 @@
+# A few common Makefile items
+
+CC=../../clang
+CXX=../../clang++
+
+CXXFLAGS=-std=c++0x -pthread -Wall $(SANITIZE) -g -I../include
+
+UNAME = $(shell uname)
+
+
diff --git a/cdschecker_modified_benchmarks/chase-lev-deque/Makefile b/cdschecker_modified_benchmarks/chase-lev-deque/Makefile
new file mode 100644
index 0000000..73266a3
--- /dev/null
+++ b/cdschecker_modified_benchmarks/chase-lev-deque/Makefile
@@ -0,0 +1,17 @@
+include ../benchmarks.mk
+
+TESTNAME = chase-lev-deque
+
+HEADERS = deque.h
+OBJECTS = main.o deque.o
+
+all: $(TESTNAME)
+
+$(TESTNAME): $(HEADERS) $(OBJECTS)
+	$(CXX) -o $@ $(OBJECTS) $(CXXFLAGS) $(LDFLAGS)
+
+%.o: %.c
+	$(CXX) -c -o $@ $< $(CXXFLAGS)
+
+clean:
+	rm -f $(TESTNAME) *.o
diff --git a/cdschecker_modified_benchmarks/chase-lev-deque/deque.cc b/cdschecker_modified_benchmarks/chase-lev-deque/deque.cc
new file mode 100644
index 0000000..feb3fc9
--- /dev/null
+++ b/cdschecker_modified_benchmarks/chase-lev-deque/deque.cc
@@ -0,0 +1,85 @@
+#include "cds_atomic.h"
+#include <inttypes.h>
+#include "deque.h"
+#include <stdlib.h>
+#include <stdio.h>
+
+Deque * create() {
+	Deque * q = (Deque *) calloc(1, sizeof(Deque));
+	Array * a = (Array *) calloc(1, sizeof(Array)+2*sizeof(atomic_int));
+	atomic_store_explicit(&q->array, (uintptr_t)a, memory_order_relaxed);
+	atomic_store_explicit(&q->top, 0, memory_order_relaxed);
+	atomic_store_explicit(&q->bottom, 0, memory_order_relaxed);
+	atomic_store_explicit(&a->size, 2, memory_order_relaxed);
+	return q;
+}
+
+int take(Deque *q) {
+	size_t b = atomic_load_explicit(&q->bottom, memory_order_relaxed) - 1;
+	Array *a = (Array *) atomic_load_explicit(&q->array, memory_order_relaxed);
+	atomic_store_explicit(&q->bottom, b, memory_order_relaxed);
+	atomic_thread_fence(memory_order_seq_cst);
+	size_t t = atomic_load_explicit(&q->top, memory_order_relaxed);
+	int x;
+	if (t <= b) {
+		/* Non-empty queue. */
+		x = atomic_load_explicit(&a->buffer[b % atomic_load_explicit(&a->size,memory_order_relaxed)], memory_order_relaxed);
+		if (t == b) {
+			/* Single last element in queue. */
+			if (!atomic_compare_exchange_strong_explicit(&q->top, &t, t + 1, memory_order_seq_cst, memory_order_relaxed))
+				/* Failed race. */
+				x = EMPTY;
+			atomic_store_explicit(&q->bottom, b + 1, memory_order_relaxed);
+		}
+	} else { /* Empty queue. */
+		x = EMPTY;
+		atomic_store_explicit(&q->bottom, b + 1, memory_order_relaxed);
+	}
+	return x;
+}
+
+void resize(Deque *q) {
+	Array *a = (Array *) atomic_load_explicit(&q->array, memory_order_relaxed);
+	size_t size=atomic_load_explicit(&a->size, memory_order_relaxed);
+	size_t new_size=size << 1;
+	Array *new_a = (Array *) calloc(1, new_size * sizeof(atomic_int) + sizeof(Array));
+	size_t top=atomic_load_explicit(&q->top, memory_order_relaxed);
+	size_t bottom=atomic_load_explicit(&q->bottom, memory_order_relaxed);
+	atomic_store_explicit(&new_a->size, new_size, memory_order_relaxed);
+	size_t i;
+	for(i=top; i < bottom; i++) {
+		atomic_store_explicit(&new_a->buffer[i % new_size], atomic_load_explicit(&a->buffer[i % size], memory_order_relaxed), memory_order_relaxed);
+	}
+	atomic_store_explicit(&q->array, (uintptr_t)new_a, memory_order_relaxed);
+	printf("resize\n");
+}
+
+void push(Deque *q, int x) {
+	size_t b = atomic_load_explicit(&q->bottom, memory_order_relaxed);
+	size_t t = atomic_load_explicit(&q->top, memory_order_acquire);
+	Array *a = (Array *) atomic_load_explicit(&q->array, memory_order_relaxed);
+	if (b - t > atomic_load_explicit(&a->size, memory_order_relaxed) - 1) /* Full queue. */ {
+		resize(q);
+		//Bug in paper...should have next line...
+		a = (Array *) atomic_load_explicit(&q->array, memory_order_relaxed);
+	}
+	atomic_store_explicit(&a->buffer[b % atomic_load_explicit(&a->size, memory_order_relaxed)], x, memory_order_relaxed);
+	atomic_thread_fence(memory_order_release);
+	atomic_store_explicit(&q->bottom, b + 1, memory_order_relaxed);
+}
+
+int steal(Deque *q) {
+	size_t t = atomic_load_explicit(&q->top, memory_order_acquire);
+	atomic_thread_fence(memory_order_seq_cst);
+	size_t b = atomic_load_explicit(&q->bottom, memory_order_acquire);
+	int x = EMPTY;
+	if (t < b) {
+		/* Non-empty queue. */
+		Array *a = (Array *) atomic_load_explicit(&q->array, memory_order_relaxed);
+		x = atomic_load_explicit(&a->buffer[t % atomic_load_explicit(&a->size, memory_order_relaxed)], memory_order_relaxed);
+		if (!atomic_compare_exchange_strong_explicit(&q->top, &t, t + 1, memory_order_seq_cst, memory_order_relaxed))
+			/* Failed race. */
+			return ABORT;
+	}
+	return x;
+}
diff --git a/cdschecker_modified_benchmarks/chase-lev-deque/deque.h b/cdschecker_modified_benchmarks/chase-lev-deque/deque.h
new file mode 100644
index 0000000..c65da6f
--- /dev/null
+++ b/cdschecker_modified_benchmarks/chase-lev-deque/deque.h
@@ -0,0 +1,25 @@
+#ifndef DEQUE_H
+#define DEQUE_H
+
+#include "cds_atomic.h"
+
+typedef struct {
+	atomic_size_t size;
+	atomic_int buffer[];
+} Array;
+
+typedef struct {
+	atomic_size_t top, bottom;
+	atomic_uintptr_t array; /* Atomic(Array *) */
+} Deque;
+
+Deque * create();
+int take(Deque *q);
+int steal(Deque *q);
+void resize(Deque *q);
+void push(Deque *q, int x);
+
+#define EMPTY 0xffffffff
+#define ABORT 0xfffffffe
+
+#endif
diff --git a/cdschecker_modified_benchmarks/chase-lev-deque/main.cc b/cdschecker_modified_benchmarks/chase-lev-deque/main.cc
new file mode 100644
index 0000000..706d812
--- /dev/null
+++ b/cdschecker_modified_benchmarks/chase-lev-deque/main.cc
@@ -0,0 +1,52 @@
+#include <stdlib.h>
+#include <assert.h>
+#include <stdio.h>
+#include "cds_threads.h"
+//#include <atomic>
+
+#include "model-assert.h"
+
+#include "deque.h"
+
+#define ITERATION 1
+
+Deque *q;
+int a;
+int b;
+int c;
+
+static void task(void * param) {
+	for (int i = 0; i < ITERATION; i++)
+		a=steal(q);
+}
+
+int user_main(int argc, char **argv)
+{
+	q=create();
+	std::thread t(task, (void *)0);
+
+	for (int i = 0; i < ITERATION; i++) {
+		push(q, 1);
+		push(q, 2);
+		push(q, 4);
+		b=take(q);
+		c=take(q);
+	}
+
+	t.join();
+
+	bool correct=true;
+	if (a!=1 && a!=2 && a!=4 && a!= EMPTY)
+		correct=false;
+	if (b!=1 && b!=2 && b!=4 && b!= EMPTY)
+		correct=false;
+	if (c!=1 && c!=2 && c!=4 && a!= EMPTY)
+		correct=false;
+	if (a!=EMPTY && b!=EMPTY && c!=EMPTY && (a+b+c)!=7)
+		correct=false;
+	if (!correct)
+		printf("a=%d b=%d c=%d\n",a,b,c);
+	MODEL_ASSERT(correct);
+
+	return 0;
+}
diff --git a/cdschecker_modified_benchmarks/dekker-fences/Makefile b/cdschecker_modified_benchmarks/dekker-fences/Makefile
new file mode 100644
index 0000000..ffbb77a
--- /dev/null
+++ b/cdschecker_modified_benchmarks/dekker-fences/Makefile
@@ -0,0 +1,11 @@
+include ../benchmarks.mk
+
+TESTNAME = dekker-fences
+
+all: $(TESTNAME)
+
+$(TESTNAME): $(TESTNAME).cc
+	$(CXX) -o $@ $< $(CXXFLAGS) $(LDFLAGS)
+
+clean:
+	rm -f $(TESTNAME) *.o
diff --git a/cdschecker_modified_benchmarks/dekker-fences/dekker-fences.cc b/cdschecker_modified_benchmarks/dekker-fences/dekker-fences.cc
new file mode 100644
index 0000000..30a3633
--- /dev/null
+++ b/cdschecker_modified_benchmarks/dekker-fences/dekker-fences.cc
@@ -0,0 +1,95 @@
+/*
+ * Dekker's critical section algorithm, implemented with fences.
+ *
+ * URL:
+ *   http://www.justsoftwaresolutions.co.uk/threading/
+ */
+
+
+#include "cds_threads.h"
+//#include "cds_atomic.h"
+#include <atomic>
+
+#include "librace.h"
+
+std::atomic<bool> flag0, flag1;
+std::atomic<int> turn;
+
+uint32_t var = 0;
+
+void p0()
+{
+//	std::this_thread::sleep_for(std::chrono::milliseconds(10));
+
+	flag0.store(true,std::memory_order_relaxed);
+	//std::atomic_thread_fence(std::memory_order_seq_cst);
+
+	while (flag1.load(std::memory_order_relaxed))
+	{
+		if (turn.load(std::memory_order_relaxed) != 0)
+		{
+			flag0.store(false,std::memory_order_relaxed);
+			while (turn.load(std::memory_order_relaxed) != 0)
+			{
+				thrd_yield();
+			}
+			flag0.store(true,std::memory_order_relaxed);
+			std::atomic_thread_fence(std::memory_order_seq_cst);
+		} else
+			thrd_yield();
+	}
+	std::atomic_thread_fence(std::memory_order_acquire);
+
+	// critical section
+	store_32(&var, 1);
+
+	turn.store(1,std::memory_order_relaxed);
+	std::atomic_thread_fence(std::memory_order_release);
+	flag0.store(false,std::memory_order_relaxed);
+}
+
+void p1()
+{
+//	std::this_thread::sleep_for(std::chrono::milliseconds(10));
+
+	flag1.store(true,std::memory_order_relaxed);
+	std::atomic_thread_fence(std::memory_order_seq_cst);
+
+	while (flag0.load(std::memory_order_relaxed))
+	{
+		if (turn.load(std::memory_order_relaxed) != 1)
+		{
+			flag1.store(false,std::memory_order_relaxed);
+			while (turn.load(std::memory_order_relaxed) != 1)
+			{
+				thrd_yield();
+			}
+			flag1.store(true,std::memory_order_relaxed);
+			std::atomic_thread_fence(std::memory_order_seq_cst);
+		} else
+			thrd_yield();
+	}
+	std::atomic_thread_fence(std::memory_order_acquire);
+
+	// critical section
+	store_32(&var, 2);
+
+	turn.store(0,std::memory_order_relaxed);
+	std::atomic_thread_fence(std::memory_order_release);
+	flag1.store(false,std::memory_order_relaxed);
+}
+
+int user_main(int argc, char **argv)
+{
+	flag0 = false;
+	flag1 = false;
+	turn = 0;
+
+	std::thread a(p0);
+	std::thread b(p1);
+
+	a.join();
+	b.join();
+
+	return 0;
+}
diff --git a/cdschecker_modified_benchmarks/include/cds_atomic.h b/cdschecker_modified_benchmarks/include/cds_atomic.h
new file mode 100755
index 0000000..aa71b59
--- /dev/null
+++ b/cdschecker_modified_benchmarks/include/cds_atomic.h
@@ -0,0 +1,52 @@
+#ifndef __STDATOMIC_H__
+#define __STDATOMIC_H__
+
+#ifdef __cplusplus
+
+#include <atomic>
+
+using std::atomic_flag;
+using std::atomic_bool;
+//using std::atomic_address;
+using std::atomic_char;
+using std::atomic_schar;
+using std::atomic_uchar;
+using std::atomic_short;
+using std::atomic_ushort;
+using std::atomic_int;
+using std::atomic_uint;
+using std::atomic_long;
+using std::atomic_ulong;
+using std::atomic_llong;
+using std::atomic_ullong;
+using std::atomic_wchar_t;
+
+using std::atomic_size_t;
+using std::atomic_uintptr_t;
+
+using std::atomic;
+using std::memory_order;
+using std::memory_order_relaxed;
+using std::memory_order_acquire;
+using std::memory_order_release;
+using std::memory_order_acq_rel;
+using std::memory_order_seq_cst;
+
+using std::atomic_thread_fence;
+using std::atomic_signal_fence;
+
+using std::atomic_init;
+
+#define atomic_init(A, V) *A=V
+
+#define atomic_load_explicit(A, MO) (*A).load(MO)
+#define atomic_store_explicit(A, V, MO) (*A).store(V, MO)
+
+#define atomic_fetch_add_explicit(A, V, MO) (*A).fetch_add(V, MO);
+#define atomic_fetch_sub_explicit(A, V, MO) (*A).fetch_sub(V, MO);
+#define atomic_compare_exchange_strong_explicit(A, E, V, MO, FMO) \
+    (*A).compare_exchange_strong(*E, V, MO, FMO)
+
+#endif
+
+#endif  // __STDATOMIC_H__
diff --git a/cdschecker_modified_benchmarks/include/cds_threads.h b/cdschecker_modified_benchmarks/include/cds_threads.h
new file mode 100755
index 0000000..5b13720
--- /dev/null
+++ b/cdschecker_modified_benchmarks/include/cds_threads.h
@@ -0,0 +1,38 @@
+// Header to handle CDSChecker bullshit.
+// Handles most things, not just threads:
+//  - Catches C11 threads and forwards to C++11 threads.
+//  - Catches store_n and load_n and turns them into normal stores/loads.
+//  - Replaces user_main with just main.
+
+#ifndef __THREADS_H__
+#define __THREADS_H__
+
+#ifdef __cplusplus
+#include <thread>
+
+#include <map>
+#include <string>
+#include <cassert>
+
+#define thrd_t std::thread
+typedef int (*thrd_start_t)(void *); 
+
+static std::map<std::string, std::thread> thrs;
+
+#define thrd_create(T, F, A) new_thread(#T, F, A)
+static void new_thread(const char *t, thrd_start_t f, void *args) {
+  assert(thrs.emplace(std::string(++t), std::thread(*f, args)).second);
+}
+
+#define thrd_join(T) end_thread(#T)
+static void end_thread(const char *t) {
+  thrs[std::string(t)].join();
+}
+
+#define thrd_yield() std::this_thread::yield()
+
+#define user_main main
+
+#endif
+
+#endif  // __THREADS_H__
diff --git a/cdschecker_modified_benchmarks/include/librace.h b/cdschecker_modified_benchmarks/include/librace.h
new file mode 100755
index 0000000..2445139
--- /dev/null
+++ b/cdschecker_modified_benchmarks/include/librace.h
@@ -0,0 +1,29 @@
+#ifndef __LIBRACE_H__
+#define __LIBRACE_H__
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+	void store_8(void *addr, uint8_t val) { *((uint8_t *)addr) = val; }
+	void store_16(void *addr, uint16_t val) { *((uint16_t *)addr) = val; }
+	void store_32(void *addr, uint32_t val) { *((uint32_t *)addr) = val; }
+	void store_64(void *addr, uint64_t val) { *((uint64_t *)addr) = val; }
+
+	void store_8_(void *addr);
+	void store_16_(void *addr);
+	void store_32_(void *addr);
+	void store_64_(void *addr);
+
+	uint8_t load_8(const void *addr) { return *((uint8_t *)addr); }
+	uint16_t load_16(const void *addr) { return *((uint16_t *)addr); }
+	uint32_t load_32(const void *addr) { return *((uint32_t *)addr); }
+	uint64_t load_64(const void *addr) { return *((uint64_t *)addr); }
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // __LIBRACE_H__
diff --git a/cdschecker_modified_benchmarks/include/model-assert.h b/cdschecker_modified_benchmarks/include/model-assert.h
new file mode 100755
index 0000000..5cba524
--- /dev/null
+++ b/cdschecker_modified_benchmarks/include/model-assert.h
@@ -0,0 +1,21 @@
+#ifndef __MODEL_ASSERT_H__
+#define __MODEL_ASSERT_H__
+
+#if __cplusplus
+extern "C" {
+#else
+#include <stdbool.h>
+#endif
+
+#include <cassert>
+
+static void model_assert(bool expr, const char *file, int line) {
+  assert(expr && file && line);
+}
+#define MODEL_ASSERT(expr) model_assert((expr), __FILE__, __LINE__)
+
+#if __cplusplus
+}
+#endif
+
+#endif /* __MODEL_ASSERT_H__ */
diff --git a/cdschecker_modified_benchmarks/include/unrelacy.h b/cdschecker_modified_benchmarks/include/unrelacy.h
new file mode 100755
index 0000000..555ec9b
--- /dev/null
+++ b/cdschecker_modified_benchmarks/include/unrelacy.h
@@ -0,0 +1,96 @@
+#ifndef __UNRELACY_H__
+#define __UNRELACY_H__
+
+#include <atomic>
+#include <stdlib.h>
+#include <stdio.h>
+#include <mutex>
+#include <condition_variable>
+
+#include <model-assert.h>
+#include <librace.h>
+
+#define $
+
+#define ASSERT(expr) MODEL_ASSERT(expr)
+#define RL_ASSERT(expr) MODEL_ASSERT(expr)
+
+#define RL_NEW new
+#define RL_DELETE(expr) delete expr
+
+#define mo_seqcst memory_order_relaxed
+#define mo_release memory_order_release
+#define mo_acquire memory_order_acquire
+#define mo_acq_rel memory_order_acq_rel
+#define mo_relaxed memory_order_relaxed
+
+namespace rl {
+
+	/* This 'useless' struct is declared just so we can use partial template
+	 * specialization in our store and load functions. */
+	template <typename T, size_t n>
+	struct useless {
+		static void store(void *addr, T val);
+		static T load(const void *addr);
+	};
+
+	template <typename T>
+	struct useless<T, 1> {
+		static void store(void *addr, T val) { store_8(addr, (uint8_t)val); }
+		static T load(const void *addr) { return (T)load_8(addr); }
+	};
+
+	template <typename T>
+	struct useless<T, 2> {
+		static void store(void *addr, T val) { store_16(addr, (uint16_t)val); }
+		static T load(const void *addr) { return (T)load_16(addr); }
+	};
+
+	template <typename T>
+	struct useless<T, 4> {
+		static void store(void *addr, T val) { store_32(addr, (uint32_t)val); }
+		static T load(const void *addr) { return (T)load_32(addr); }
+	};
+
+	template <typename T>
+	struct useless<T, 8> {
+		static void store(void *addr, T val) { store_64(addr, (uint64_t)val); }
+		static T load(const void *addr) { return (T)load_64(addr); }
+	};
+
+	template <typename T>
+	struct var {
+		var() { useless<T, sizeof(T)>::store(&value, 0); }
+		var(T v) { useless<T, sizeof(T)>::store(&value, v); }
+		var(var const& r) {
+			value = r.value;
+		}
+		~var() { }
+
+		void operator = (T v) { useless<T, sizeof(T)>::store(&value, v); }
+		T operator () () { return useless<T, sizeof(T)>::load(&value); }
+		void operator += (T v) {
+			useless<T, sizeof(T)>::store(&value,
+					useless<T, sizeof(T)>::load(&value) + v);
+		}
+		bool operator == (const struct var<T> v) const { return useless<T, sizeof(T)>::load(&value) == useless<T, sizeof(T)>::load(&v.value); }
+
+		T value;
+	};
+
+	class backoff_t
+	{
+	 public:
+		typedef int debug_info_param;
+		void yield(debug_info_param info) { }
+		void yield() { }
+	};
+
+
+	typedef backoff_t backoff;
+	typedef backoff_t linear_backoff;
+	typedef backoff_t exp_backoff;
+
+}
+
+#endif /* __UNRELACY_H__ */
diff --git a/cdschecker_modified_benchmarks/linuxrwlocks/Makefile b/cdschecker_modified_benchmarks/linuxrwlocks/Makefile
new file mode 100644
index 0000000..b0c4612
--- /dev/null
+++ b/cdschecker_modified_benchmarks/linuxrwlocks/Makefile
@@ -0,0 +1,11 @@
+include ../benchmarks.mk
+
+TESTNAME = linuxrwlocks
+
+all: $(TESTNAME)
+
+$(TESTNAME): $(TESTNAME).cc
+	$(CXX) -o $@ $< $(CXXFLAGS) $(LDFLAGS)
+
+clean:
+	rm -f $(TESTNAME) *.o
diff --git a/cdschecker_modified_benchmarks/linuxrwlocks/linuxrwlocks.cc b/cdschecker_modified_benchmarks/linuxrwlocks/linuxrwlocks.cc
new file mode 100644
index 0000000..73e3a68
--- /dev/null
+++ b/cdschecker_modified_benchmarks/linuxrwlocks/linuxrwlocks.cc
@@ -0,0 +1,118 @@
+#include <stdio.h>
+#include "cds_threads.h"
+#include "cds_atomic.h"
+
+#include "librace.h"
+
+#define RW_LOCK_BIAS            0x00100000
+#define WRITE_LOCK_CMP          RW_LOCK_BIAS
+
+/** Example implementation of linux rw lock along with 2 thread test
+ *  driver... */
+
+typedef union {
+	atomic_int lock;
+} rwlock_t;
+
+static inline int read_can_lock(rwlock_t *lock)
+{
+	return atomic_load_explicit(&lock->lock, memory_order_relaxed) > 0;
+}
+
+static inline int write_can_lock(rwlock_t *lock)
+{
+	return atomic_load_explicit(&lock->lock, memory_order_relaxed) == RW_LOCK_BIAS;
+}
+
+static inline void read_lock(rwlock_t *rw)
+{
+	int priorvalue = atomic_fetch_sub_explicit(&rw->lock, 1, memory_order_acquire);
+	while (priorvalue <= 0) {
+		atomic_fetch_add_explicit(&rw->lock, 1, memory_order_relaxed);
+		while (atomic_load_explicit(&rw->lock, memory_order_relaxed) <= 0) {
+			thrd_yield();
+		}
+		priorvalue = atomic_fetch_sub_explicit(&rw->lock, 1, memory_order_relaxed);
+	}
+}
+
+static inline void write_lock(rwlock_t *rw)
+{
+	int priorvalue = atomic_fetch_sub_explicit(&rw->lock, RW_LOCK_BIAS, memory_order_acquire);
+	while (priorvalue != RW_LOCK_BIAS) {
+		atomic_fetch_add_explicit(&rw->lock, RW_LOCK_BIAS, memory_order_relaxed);
+		while (atomic_load_explicit(&rw->lock, memory_order_relaxed) != RW_LOCK_BIAS) {
+			thrd_yield();
+		}
+		priorvalue = atomic_fetch_sub_explicit(&rw->lock, RW_LOCK_BIAS, memory_order_relaxed);
+	}
+}
+
+static inline int read_trylock(rwlock_t *rw)
+{
+	int priorvalue = atomic_fetch_sub_explicit(&rw->lock, 1, memory_order_acquire);
+	if (priorvalue > 0)
+		return 1;
+
+	atomic_fetch_add_explicit(&rw->lock, 1, memory_order_relaxed);
+	return 0;
+}
+
+static inline int write_trylock(rwlock_t *rw)
+{
+	int priorvalue = atomic_fetch_sub_explicit(&rw->lock, RW_LOCK_BIAS, memory_order_acquire);
+	if (priorvalue == RW_LOCK_BIAS)
+		return 1;
+
+	atomic_fetch_add_explicit(&rw->lock, RW_LOCK_BIAS, memory_order_relaxed);
+	return 0;
+}
+
+static inline void read_unlock(rwlock_t *rw)
+{
+	atomic_fetch_add_explicit(&rw->lock, 1, memory_order_release);
+}
+
+static inline void write_unlock(rwlock_t *rw)
+{
+	atomic_fetch_add_explicit(&rw->lock, RW_LOCK_BIAS, memory_order_release);
+}
+
+rwlock_t mylock;
+int shareddata;
+
+void a()
+{
+//	std::this_thread::sleep_for(std::chrono::milliseconds(10));
+	int i, rs;
+	for(i = 0; i < 2; i++) {
+		if ((i % 2) == 0) {
+			read_lock(&mylock);
+			rs = load_32(&shareddata);
+			read_unlock(&mylock);
+		} else {
+			write_lock(&mylock);
+			std::this_thread::yield();
+			store_32(&shareddata,(unsigned int)i);
+			write_unlock(&mylock);
+		}
+	}
+}
+
+int user_main(int argc, char **argv)
+{
+	//thrd_t t1, t2;
+	atomic_init(&mylock.lock, RW_LOCK_BIAS);
+
+	std::thread t1(a);
+	std::thread t2(a);
+	//thrd_create(&t1, (thrd_start_t)&a, NULL);
+	//thrd_create(&t2, (thrd_start_t)&a, NULL);
+
+	t1.join();
+	t2.join();
+	//thrd_join(t1);
+	//thrd_join(t2);
+
+	return 0;
+}
diff --git a/cdschecker_modified_benchmarks/mcs-lock/Makefile b/cdschecker_modified_benchmarks/mcs-lock/Makefile
new file mode 100644
index 0000000..5a311b3
--- /dev/null
+++ b/cdschecker_modified_benchmarks/mcs-lock/Makefile
@@ -0,0 +1,11 @@
+include ../benchmarks.mk
+
+TESTNAME = mcs-lock
+
+all: $(TESTNAME)
+
+$(TESTNAME): $(TESTNAME).cc $(TESTNAME).h
+	$(CXX) -o $@ $< $(CXXFLAGS) $(LDFLAGS)
+
+clean:
+	rm -f $(TESTNAME) *.o
diff --git a/cdschecker_modified_benchmarks/mcs-lock/mcs-lock.cc b/cdschecker_modified_benchmarks/mcs-lock/mcs-lock.cc
new file mode 100644
index 0000000..4fc4f0f
--- /dev/null
+++ b/cdschecker_modified_benchmarks/mcs-lock/mcs-lock.cc
@@ -0,0 +1,43 @@
+#include <stdio.h>
+#include "cds_threads.h"
+
+#include "mcs-lock.h"
+
+/* For data race instrumentation */
+#include "librace.h"
+
+struct mcs_mutex *mutex;
+static uint32_t shared;
+
+void threadA(void *arg)
+{
+//	std::this_thread::sleep_for(std::chrono::milliseconds(10));
+	mcs_mutex::guard g(mutex);
+	printf("store: %d\n", 17);
+	store_32(&shared, 17);
+	mutex->unlock(&g);
+	mutex->lock(&g);
+	printf("load: %u\n", load_32(&shared));
+}
+
+void threadB(void *arg)
+{
+//	std::this_thread::sleep_for(std::chrono::milliseconds(10));
+	mcs_mutex::guard g(mutex);
+	printf("load: %u\n", load_32(&shared));
+	mutex->unlock(&g);
+	mutex->lock(&g);
+	printf("store: %d\n", 17);
+	store_32(&shared, 17);
+}
+
+int user_main(int argc, char **argv)
+{
+	mutex = new mcs_mutex();
+
+	std::thread A(threadA, (void *)NULL);
+	std::thread B(threadB, (void *)NULL);
+	A.join();
+	B.join();
+	return 0;
+}
diff --git a/cdschecker_modified_benchmarks/mcs-lock/mcs-lock.h b/cdschecker_modified_benchmarks/mcs-lock/mcs-lock.h
new file mode 100644
index 0000000..d54e19b
--- /dev/null
+++ b/cdschecker_modified_benchmarks/mcs-lock/mcs-lock.h
@@ -0,0 +1,93 @@
+// mcs on stack
+
+#include <atomic>
+#include <unrelacy.h>
+
+struct mcs_node {
+	std::atomic<mcs_node *> next;
+	std::atomic<int> gate;
+
+	mcs_node() {
+		next.store(0);
+		gate.store(0);
+	}
+};
+
+struct mcs_mutex {
+public:
+	// tail is null when lock is not held
+	std::atomic<mcs_node *> m_tail;
+
+	mcs_mutex() {
+		m_tail.store( NULL );
+	}
+	~mcs_mutex() {
+		ASSERT( m_tail.load() == NULL );
+	}
+
+	class guard {
+	public:
+		mcs_mutex * m_t;
+		mcs_node    m_node; // node held on the stack
+
+		guard(mcs_mutex * t) : m_t(t) { t->lock(this); }
+		~guard() { m_t->unlock(this); }
+	};
+
+	void lock(guard * I) {
+		mcs_node * me = &(I->m_node);
+
+		// set up my node :
+		// not published yet so relaxed :
+		me->next.store(NULL, std::mo_relaxed );
+		me->gate.store(1, std::mo_relaxed );
+
+		// publish my node as the new tail :
+		mcs_node * pred = m_tail.exchange(me, std::mo_acq_rel);
+		if ( pred != NULL ) {
+			// (*1) race here
+			// unlock of pred can see me in the tail before I fill next
+
+			// publish me to previous lock-holder :
+			pred->next.store(me, std::mo_release );
+
+			// (*2) pred not touched any more       
+
+			// now this is the spin -
+			// wait on predecessor setting my flag -
+			rl::linear_backoff bo;
+			while ( me->gate.load(std::mo_relaxed) ) {
+				thrd_yield();
+			}
+		}
+	}
+
+	void unlock(guard * I) {
+		mcs_node * me = &(I->m_node);
+
+		mcs_node * next = me->next.load(std::mo_acquire);
+		if ( next == NULL )
+		{
+			mcs_node * tail_was_me = me;
+			if ( m_tail.compare_exchange_strong( tail_was_me,NULL,std::mo_acq_rel) ) {
+				// got null in tail, mutex is unlocked
+				return;
+			}
+
+			// (*1) catch the race :
+			rl::linear_backoff bo;
+			for(;;) {
+				next = me->next.load(std::mo_relaxed);
+				if ( next != NULL )
+					break;
+				thrd_yield();
+			}
+		}
+
+		// (*2) - store to next must be done,
+		//  so no locker can be viewing my node any more        
+
+		// let next guy in :
+		next->gate.store( 0, std::mo_release );
+	}
+};
diff --git a/cdschecker_modified_benchmarks/mpmc-queue/Makefile b/cdschecker_modified_benchmarks/mpmc-queue/Makefile
new file mode 100644
index 0000000..560074f
--- /dev/null
+++ b/cdschecker_modified_benchmarks/mpmc-queue/Makefile
@@ -0,0 +1,24 @@
+include ../benchmarks.mk
+
+TESTNAME = mpmc-queue
+#TESTS = mpmc-queue mpmc-1r2w mpmc-2r1w mpmc-queue-rdwr
+#TESTS += mpmc-queue-noinit mpmc-1r2w-noinit mpmc-2r1w-noinit mpmc-rdwr-noinit
+TESTS = mpmc-queue
+
+all: $(TESTS)
+
+#mpmc-queue: CPPFLAGS += -DCONFIG_MPMC_READERS=2 -DCONFIG_MPMC_WRITERS=2
+mpmc-queue: CXXFLAGS += -DCONFIG_MPMC_READERS=0 -DCONFIG_MPMC_WRITERS=0 -DCONFIG_MPMC_RDWR=2
+mpmc-queue-rdwr: CPPFLAGS += -DCONFIG_MPMC_READERS=0 -DCONFIG_MPMC_WRITERS=0 -DCONFIG_MPMC_RDWR=2
+mpmc-1r2w: CPPFLAGS += -DCONFIG_MPMC_READERS=1 -DCONFIG_MPMC_WRITERS=2
+mpmc-2r1w: CPPFLAGS += -DCONFIG_MPMC_READERS=2 -DCONFIG_MPMC_WRITERS=1
+mpmc-queue-noinit: CPPFLAGS += -DCONFIG_MPMC_READERS=2 -DCONFIG_MPMC_WRITERS=2 -DCONFIG_MPMC_NO_INITIAL_ELEMENT
+mpmc-1r2w-noinit: CPPFLAGS += -DCONFIG_MPMC_READERS=1 -DCONFIG_MPMC_WRITERS=2 -DCONFIG_MPMC_NO_INITIAL_ELEMENT
+mpmc-2r1w-noinit: CPPFLAGS += -DCONFIG_MPMC_READERS=2 -DCONFIG_MPMC_WRITERS=1 -DCONFIG_MPMC_NO_INITIAL_ELEMENT
+mpmc-rdwr-noinit: CPPFLAGS += -DCONFIG_MPMC_READERS=0 -DCONFIG_MPMC_WRITERS=0 -DCONFIG_MPMC_RDWR=2 -DCONFIG_MPMC_NO_INITIAL_ELEMENT
+
+$(TESTS): $(TESTNAME).cc $(TESTNAME).h
+	$(CXX) -o $@ $< $(CXXFLAGS) $(LDFLAGS)
+
+clean:
+	rm -f $(TESTS) *.o
diff --git a/cdschecker_modified_benchmarks/mpmc-queue/mpmc-queue.cc b/cdschecker_modified_benchmarks/mpmc-queue/mpmc-queue.cc
new file mode 100644
index 0000000..038fac3
--- /dev/null
+++ b/cdschecker_modified_benchmarks/mpmc-queue/mpmc-queue.cc
@@ -0,0 +1,143 @@
+#include <inttypes.h>
+#include "cds_threads.h"
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+
+#include <librace.h>
+
+#include "mpmc-queue.h"
+
+void threadA(struct mpmc_boundq_1_alt<int32_t, sizeof(int32_t)> *queue)
+{
+//	std::this_thread::sleep_for(std::chrono::milliseconds(10));
+	int32_t *bin = queue->write_prepare();
+	store_32(bin, 1);
+	queue->write_publish();
+}
+
+void threadB(struct mpmc_boundq_1_alt<int32_t, sizeof(int32_t)> *queue)
+{
+//	std::this_thread::sleep_for(std::chrono::milliseconds(10));
+	int32_t *bin;
+	while ((bin = queue->read_fetch()) != NULL) {
+		printf("Read: %d\n", load_32(bin));
+		queue->read_consume();
+	}
+}
+
+void threadC(struct mpmc_boundq_1_alt<int32_t, sizeof(int32_t)> *queue)
+{
+//	std::this_thread::sleep_for(std::chrono::milliseconds(10));
+	int32_t *bin = queue->write_prepare();
+	store_32(bin, 1);
+	queue->write_publish();
+
+	while ((bin = queue->read_fetch()) != NULL) {
+		printf("Read: %d\n", load_32(bin));
+		queue->read_consume();
+	}
+}
+
+#define MAXREADERS 3
+#define MAXWRITERS 3
+#define MAXRDWR 3
+
+#ifdef CONFIG_MPMC_READERS
+#define DEFAULT_READERS (CONFIG_MPMC_READERS)
+#else
+#define DEFAULT_READERS 2
+#endif
+
+#ifdef CONFIG_MPMC_WRITERS
+#define DEFAULT_WRITERS (CONFIG_MPMC_WRITERS)
+#else
+#define DEFAULT_WRITERS 2
+#endif
+
+#ifdef CONFIG_MPMC_RDWR
+#define DEFAULT_RDWR (CONFIG_MPMC_RDWR)
+#else
+#define DEFAULT_RDWR 0
+#endif
+
+int readers = DEFAULT_READERS, writers = DEFAULT_WRITERS, rdwr = DEFAULT_RDWR;
+
+void print_usage()
+{
+	printf("Error: use the following options\n"
+		" -r <num>              Choose number of reader threads\n"
+		" -w <num>              Choose number of writer threads\n");
+	exit(EXIT_FAILURE);
+}
+
+void process_params(int argc, char **argv)
+{
+	const char *shortopts = "hr:w:";
+	int opt;
+	bool error = false;
+
+	while (!error && (opt = getopt(argc, argv, shortopts)) != -1) {
+		switch (opt) {
+		case 'h':
+			print_usage();
+			break;
+		case 'r':
+			readers = atoi(optarg);
+			break;
+		case 'w':
+			writers = atoi(optarg);
+			break;
+		default: /* '?' */
+			error = true;
+			break;
+		}
+	}
+
+	if (writers < 1 || writers > MAXWRITERS)
+		error = true;
+	if (readers < 1 || readers > MAXREADERS)
+		error = true;
+
+	if (error)
+		print_usage();
+}
+
+int user_main(int argc, char **argv)
+{
+	struct mpmc_boundq_1_alt<int32_t, sizeof(int32_t)> queue;
+	std::thread A[MAXWRITERS], B[MAXREADERS], C[MAXRDWR];
+
+	/* Note: optarg() / optind is broken in model-checker - workaround is
+	 * to just copy&paste this test a few times */
+	//process_params(argc, argv);
+	printf("%d reader(s), %d writer(s)\n", readers, writers);
+
+#ifndef CONFIG_MPMC_NO_INITIAL_ELEMENT
+	printf("Adding initial element\n");
+	int32_t *bin = queue.write_prepare();
+	store_32(bin, 17);
+	queue.write_publish();
+#endif
+
+	printf("Start threads\n");
+
+	for (int i = 0; i < writers; i++)
+		A[i] = std::thread(threadA, &queue);
+	for (int i = 0; i < readers; i++)
+		B[i] = std::thread(threadB, &queue);
+
+	for (int i = 0; i < rdwr; i++)
+		C[i] = std::thread(threadC, &queue);
+
+	for (int i = 0; i < writers; i++)
+		A[i].join();
+	for (int i = 0; i < readers; i++)
+		B[i].join();
+	for (int i = 0; i < rdwr; i++)
+		C[i].join();
+
+	printf("Threads complete\n");
+
+	return 0;
+}
diff --git a/cdschecker_modified_benchmarks/mpmc-queue/mpmc-queue.h b/cdschecker_modified_benchmarks/mpmc-queue/mpmc-queue.h
new file mode 100644
index 0000000..f86bec4
--- /dev/null
+++ b/cdschecker_modified_benchmarks/mpmc-queue/mpmc-queue.h
@@ -0,0 +1,97 @@
+#include "cds_atomic.h"
+#include <unrelacy.h>
+
+template <typename t_element, size_t t_size>
+struct mpmc_boundq_1_alt
+{
+private:
+
+	// elements should generally be cache-line-size padded :
+	t_element               m_array[t_size];
+
+	// rdwr counts the reads & writes that have started
+	atomic<unsigned int>    m_rdwr;
+	// "read" and "written" count the number completed
+	atomic<unsigned int>    m_read;
+	atomic<unsigned int>    m_written;
+
+public:
+
+	mpmc_boundq_1_alt()
+	{
+		m_rdwr = 0;
+		m_read = 0;
+		m_written = 0;
+	}
+
+	//-----------------------------------------------------
+
+	t_element * read_fetch() {
+		unsigned int rdwr = m_rdwr.load(mo_acquire);
+		unsigned int rd,wr;
+		for(;;) {
+			rd = (rdwr>>16) & 0xFFFF;
+			wr = rdwr & 0xFFFF;
+
+			if ( wr == rd ) // empty
+				return NULL;
+
+			if ( m_rdwr.compare_exchange_weak(rdwr,rdwr+(1<<16),mo_acquire) )
+				break;
+			else
+				thrd_yield();
+		}
+
+		// (*1)
+		rl::backoff bo;
+		while ( (m_written.load(mo_acquire) & 0xFFFF) != wr ) {
+			thrd_yield();
+		}
+
+		t_element * p = & ( m_array[ rd % t_size ] );
+
+		return p;
+	}
+
+	void read_consume() {
+		m_read.fetch_add(1,mo_release);
+	}
+
+	//-----------------------------------------------------
+
+	t_element * write_prepare() {
+		unsigned int rdwr = m_rdwr.load(mo_acquire);
+		unsigned int rd,wr;
+		for(;;) {
+			rd = (rdwr>>16) & 0xFFFF;
+			wr = rdwr & 0xFFFF;
+
+			if ( wr == ((rd + t_size)&0xFFFF) ) // full
+				return NULL;
+
+			if ( m_rdwr.compare_exchange_weak(rdwr,(rd<<16) | ((wr+1)&0xFFFF),mo_acq_rel) )
+				break;
+			else
+				thrd_yield();
+		}
+
+		// (*1)
+		rl::backoff bo;
+		while ( (m_read.load(mo_acquire) & 0xFFFF) != rd ) {
+			thrd_yield();
+		}
+
+		t_element * p = & ( m_array[ wr % t_size ] );
+
+		return p;
+	}
+
+	void write_publish()
+	{
+		m_written.fetch_add(1,mo_relaxed);
+	}
+
+	//-----------------------------------------------------
+
+
+};
diff --git a/cdschecker_modified_benchmarks/ms-queue-tsan11/Makefile b/cdschecker_modified_benchmarks/ms-queue-tsan11/Makefile
new file mode 100755
index 0000000..151ad71
--- /dev/null
+++ b/cdschecker_modified_benchmarks/ms-queue-tsan11/Makefile
@@ -0,0 +1,17 @@
+include ../benchmarks.mk
+
+TESTNAME = ms-queue
+
+HEADERS = my_queue.h
+OBJECTS = main.o my_queue.o
+
+all: $(TESTNAME)
+
+$(TESTNAME): $(HEADERS) $(OBJECTS)
+	$(CXX) -o $@ $(OBJECTS) $(CXXFLAGS) $(LDFLAGS)
+
+%.o: %.c
+	$(CXX) -c -o $@ $< $(CXXFLAGS)
+
+clean:
+	rm -f $(TESTNAME) *.o
diff --git a/cdschecker_modified_benchmarks/ms-queue-tsan11/main.cc b/cdschecker_modified_benchmarks/ms-queue-tsan11/main.cc
new file mode 100755
index 0000000..e4bb181
--- /dev/null
+++ b/cdschecker_modified_benchmarks/ms-queue-tsan11/main.cc
@@ -0,0 +1,87 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include "cds_threads.h"
+
+#include "my_queue.h"
+#include "model-assert.h"
+
+static int procs = 4;
+static queue_t *queue;
+static thrd_t *threads;
+static unsigned int *input;
+static unsigned int *output;
+static int num_threads;
+
+int get_thread_num()
+{
+	//thrd_t curr = thrd_current();
+	int i;
+	printf("thread id: %d\n", std::this_thread::get_id());
+	for (i = 0; i < num_threads; i++)
+		if (std::this_thread::get_id() == threads[i].get_id())
+			return i;
+	MODEL_ASSERT(0);
+	return -1;
+}
+
+bool succ1, succ2;
+
+static void main_task(void *param)
+{
+	unsigned int val;
+	int pid = *((int *)param);
+	if (!pid) {
+		input[0] = 17;
+		enqueue(queue, input[0]);
+		succ1 = dequeue(queue, &output[0]);
+		//printf("Dequeue: %d\n", output[0]);
+	} else {
+		input[1] = 37;
+		enqueue(queue, input[1]);
+		succ2 = dequeue(queue, &output[1]);
+	}
+}
+
+int user_main(int argc, char **argv)
+{
+	int i;
+	int *param;
+	unsigned int in_sum = 0, out_sum = 0;
+
+	queue = (queue_t *)calloc(1, sizeof(*queue));
+	MODEL_ASSERT(queue);
+
+	num_threads = procs;
+	threads = (std::thread *)malloc(num_threads * sizeof(std::thread));
+	param = (int *)malloc(num_threads * sizeof(*param));
+	input = (unsigned *)calloc(num_threads, sizeof(*input));
+	output = (unsigned *)calloc(num_threads, sizeof(*output));
+
+	init_queue(queue, num_threads);
+	for (i = 0; i < num_threads; i++) {
+		param[i] = i;
+		//threads[i] = std::thread(main_task, &param[i]);
+                new (&threads[i])std::thread(main_task, &param[i]);
+	}
+	for (i = 0; i < num_threads; i++)
+		threads[i].join();
+
+	for (i = 0; i < num_threads; i++) {
+		in_sum += input[i];
+		out_sum += output[i];
+	}
+	for (i = 0; i < num_threads; i++)
+		printf("input[%d] = %u\n", i, input[i]);
+	for (i = 0; i < num_threads; i++)
+		printf("output[%d] = %u\n", i, output[i]);
+	if (succ1 && succ2)
+		MODEL_ASSERT(in_sum == out_sum);
+	else
+		MODEL_ASSERT (false);
+
+	free(param);
+	free(threads);
+	free(queue);
+
+	return 0;
+}
diff --git a/cdschecker_modified_benchmarks/ms-queue-tsan11/main.o b/cdschecker_modified_benchmarks/ms-queue-tsan11/main.o
new file mode 100644
index 0000000000000000000000000000000000000000..e340deb1b402cb864dd2bef8be5a4329d4f69cdf
GIT binary patch
literal 289240
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

literal 0
HcmV?d00001

diff --git a/cdschecker_modified_benchmarks/ms-queue-tsan11/my_queue.cc b/cdschecker_modified_benchmarks/ms-queue-tsan11/my_queue.cc
new file mode 100755
index 0000000..be84c7d
--- /dev/null
+++ b/cdschecker_modified_benchmarks/ms-queue-tsan11/my_queue.cc
@@ -0,0 +1,161 @@
+#include "cds_threads.h"
+#include <stdlib.h>
+#include "librace.h"
+#include "model-assert.h"
+
+#include "my_queue.h"
+
+#define relaxed memory_order_relaxed
+#define release memory_order_release
+#define acquire memory_order_acquire
+
+#define MAX_FREELIST 4 /* Each thread can own up to MAX_FREELIST free nodes */
+#define INITIAL_FREE 2 /* Each thread starts with INITIAL_FREE free nodes */
+
+#define POISON_IDX 0x666
+
+static unsigned int (*free_lists)[MAX_FREELIST];
+
+/* Search this thread's free list for a "new" node */
+static unsigned int new_node()
+{
+	int i;
+	int t = get_thread_num();
+	for (i = 0; i < MAX_FREELIST; i++) {
+		unsigned int node = load_32(&free_lists[t][i]);
+		if (node) {
+			store_32(&free_lists[t][i], 0);
+			return node;
+		}
+	}
+	/* free_list is empty? */
+	MODEL_ASSERT(0);
+	return 0;
+}
+
+/* Place this node index back on this thread's free list */
+static void reclaim(unsigned int node)
+{
+	int i;
+	int t = get_thread_num();
+
+	/* Don't reclaim NULL node */
+	MODEL_ASSERT(node);
+
+	for (i = 0; i < MAX_FREELIST; i++) {
+		/* Should never race with our own thread here */
+		unsigned int idx = load_32(&free_lists[t][i]);
+
+		/* Found empty spot in free list */
+		if (idx == 0) {
+			store_32(&free_lists[t][i], node);
+			return;
+		}
+	}
+	/* free list is full? */
+	MODEL_ASSERT(0);
+}
+
+void init_queue(queue_t *q, int num_threads)
+{
+	int i, j;
+
+	/* Initialize each thread's free list with INITIAL_FREE pointers */
+	/* The actual nodes are initialized with poison indexes */
+	free_lists = (unsigned (*)[MAX_FREELIST])malloc(num_threads * sizeof(*free_lists));
+	for (i = 0; i < num_threads; i++) {
+		for (j = 0; j < INITIAL_FREE; j++) {
+			free_lists[i][j] = 2 + i * MAX_FREELIST + j;
+			atomic_init(&q->nodes[free_lists[i][j]].next, MAKE_POINTER(POISON_IDX, 0));
+		}
+	}
+
+	/* initialize queue */
+	atomic_init(&q->head, MAKE_POINTER(1, 0));
+	atomic_init(&q->tail, MAKE_POINTER(1, 0));
+	atomic_init(&q->nodes[1].next, MAKE_POINTER(0, 0));
+}
+
+void enqueue(queue_t *q, unsigned int val)
+{
+	int success = 0;
+	unsigned int node;
+	pointer tail;
+	pointer next;
+	pointer tmp;
+
+	node = new_node();
+	store_32(&q->nodes[node].value, val);
+	tmp = atomic_load_explicit(&q->nodes[node].next, relaxed);
+	set_ptr(&tmp, 0); // NULL
+	atomic_store_explicit(&q->nodes[node].next, tmp, relaxed);
+
+	while (!success) {
+		tail = atomic_load_explicit(&q->tail, acquire);
+		next = atomic_load_explicit(&q->nodes[get_ptr(tail)].next, acquire);
+		if (tail == atomic_load_explicit(&q->tail, relaxed)) {
+
+			/* Check for uninitialized 'next' */
+			MODEL_ASSERT(get_ptr(next) != POISON_IDX);
+
+			if (get_ptr(next) == 0) { // == NULL
+				pointer value = MAKE_POINTER(node, get_count(next) + 1);
+				success = atomic_compare_exchange_strong_explicit(&q->nodes[get_ptr(tail)].next,
+						&next, value, release, release);
+			}
+			if (!success) {
+				unsigned int ptr = get_ptr(atomic_load_explicit(&q->nodes[get_ptr(tail)].next, acquire));
+				pointer value = MAKE_POINTER(ptr,
+						get_count(tail) + 1);
+				atomic_compare_exchange_strong_explicit(&q->tail,
+						&tail, value,
+						release, release);
+				thrd_yield();
+			}
+		}
+	}
+	atomic_compare_exchange_strong_explicit(&q->tail,
+			&tail,
+			MAKE_POINTER(node, get_count(tail) + 1),
+			release, release);
+}
+
+bool dequeue(queue_t *q, unsigned int *retVal)
+{
+	int success = 0;
+	pointer head;
+	pointer tail;
+	pointer next;
+
+	while (!success) {
+		head = atomic_load_explicit(&q->head, acquire);
+		tail = atomic_load_explicit(&q->tail, relaxed);
+		next = atomic_load_explicit(&q->nodes[get_ptr(head)].next, acquire);
+		if (atomic_load_explicit(&q->head, relaxed) == head) {
+			if (get_ptr(head) == get_ptr(tail)) {
+
+				/* Check for uninitialized 'next' */
+				MODEL_ASSERT(get_ptr(next) != POISON_IDX);
+
+				if (get_ptr(next) == 0) { // NULL
+					return false; // NULL
+				}
+				atomic_compare_exchange_strong_explicit(&q->tail,
+						&tail,
+						MAKE_POINTER(get_ptr(next), get_count(tail) + 1),
+						release, release);
+				thrd_yield();
+			} else {
+				*retVal = load_32(&q->nodes[get_ptr(next)].value);
+				success = atomic_compare_exchange_strong_explicit(&q->head,
+						&head,
+						MAKE_POINTER(get_ptr(next), get_count(head) + 1),
+						release, release);
+				if (!success)
+					thrd_yield();
+			}
+		}
+	}
+	reclaim(get_ptr(head));
+	return true;
+}
diff --git a/cdschecker_modified_benchmarks/ms-queue-tsan11/my_queue.h b/cdschecker_modified_benchmarks/ms-queue-tsan11/my_queue.h
new file mode 100755
index 0000000..45849a4
--- /dev/null
+++ b/cdschecker_modified_benchmarks/ms-queue-tsan11/my_queue.h
@@ -0,0 +1,31 @@
+#include "cds_atomic.h"
+
+#define MAX_NODES			0xf
+
+typedef unsigned long long pointer;
+typedef atomic_ullong pointer_t;
+
+#define MAKE_POINTER(ptr, count)	((((pointer)count) << 32) | ptr)
+#define PTR_MASK 0xffffffffLL
+#define COUNT_MASK (0xffffffffLL << 32)
+
+static inline void set_count(pointer *p, unsigned int val) { *p = (*p & ~COUNT_MASK) | ((pointer)val << 32); }
+static inline void set_ptr(pointer *p, unsigned int val) { *p = (*p & ~PTR_MASK) | val; }
+static inline unsigned int get_count(pointer p) { return (p & COUNT_MASK) >> 32; }
+static inline unsigned int get_ptr(pointer p) { return p & PTR_MASK; }
+
+typedef struct node {
+	unsigned int value;
+	pointer_t next;
+} node_t;
+
+typedef struct {
+	pointer_t head;
+	pointer_t tail;
+	node_t nodes[MAX_NODES + 1];
+} queue_t;
+
+void init_queue(queue_t *q, int num_threads);
+void enqueue(queue_t *q, unsigned int val);
+bool dequeue(queue_t *q, unsigned int *retVal);
+int get_thread_num();
diff --git a/cdschecker_modified_benchmarks/ms-queue-tsan11/my_queue.o b/cdschecker_modified_benchmarks/ms-queue-tsan11/my_queue.o
new file mode 100644
index 0000000000000000000000000000000000000000..306682fad916e48ae0fdb4c072c55692f5589c2b
GIT binary patch
literal 285376
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

literal 0
HcmV?d00001

diff --git a/cdschecker_modified_benchmarks/ms-queue/Makefile b/cdschecker_modified_benchmarks/ms-queue/Makefile
new file mode 100644
index 0000000..c42add1
--- /dev/null
+++ b/cdschecker_modified_benchmarks/ms-queue/Makefile
@@ -0,0 +1,19 @@
+include ../benchmarks.mk
+
+TESTNAME = ms-queue
+
+HEADERS = my_queue.h
+OBJECTS = main.o my_queue.o
+
+CXXFLAGS += -I /scratch/fuzzer/random-fuzzer/include 
+
+all: $(TESTNAME)
+
+$(TESTNAME): $(HEADERS) $(OBJECTS)
+	$(CC) -o $@ $(OBJECTS) $(CFLAGS) $(LDFLAGS)
+
+%.o: %.c
+	$(CC) -c -o $@ $(CFLAGS)
+
+clean:
+	rm -f $(TESTNAME) *.o
diff --git a/cdschecker_modified_benchmarks/ms-queue/main.cc b/cdschecker_modified_benchmarks/ms-queue/main.cc
new file mode 100644
index 0000000..fc31f9c
--- /dev/null
+++ b/cdschecker_modified_benchmarks/ms-queue/main.cc
@@ -0,0 +1,88 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <threads.h>
+//#include "cds_threads.h"
+
+#include "my_queue.h"
+#include "model-assert.h"
+
+#define user_main main
+
+static int procs = 4;
+static queue_t *queue;
+static thrd_t *threads;
+static unsigned int *input;
+static unsigned int *output;
+static int num_threads;
+
+int get_thread_num()
+{
+	thrd_t curr = thrd_current();
+	int i;
+	for (i = 0; i < num_threads; i++)
+		if (curr.priv == threads[i].priv)
+			return i;
+	MODEL_ASSERT(0);
+	return -1;
+}
+
+bool succ1, succ2;
+
+static void main_task(void *param)
+{
+	int pid = *((int *)param);
+	if (!pid) {
+		input[0] = 17;
+		enqueue(queue, input[0]);
+		succ1 = dequeue(queue, &output[0]);
+		//printf("Dequeue: %d\n", output[0]);
+	} else {
+		input[1] = 37;
+		enqueue(queue, input[1]);
+		succ2 = dequeue(queue, &output[1]);
+	}
+}
+
+int user_main(int argc, char **argv)
+{
+	int i;
+	int *param;
+	unsigned int in_sum = 0, out_sum = 0;
+
+	queue = (queue_t *)calloc(1, sizeof(*queue));
+	MODEL_ASSERT(queue);
+
+	num_threads = procs;
+	threads = (thrd_t *)malloc(num_threads * sizeof(thrd_t));
+	param = (int *)malloc(num_threads * sizeof(*param));
+	input = (unsigned *)calloc(num_threads, sizeof(*input));
+	output = (unsigned *)calloc(num_threads, sizeof(*output));
+
+	init_queue(queue, num_threads);
+	for (i = 0; i < num_threads; i++) {
+		param[i] = i;
+		thrd_create(&threads[i], main_task, &param[i]);
+	}
+	for (i = 0; i < num_threads; i++)
+		thrd_join(threads[i]);
+
+	for (i = 0; i < num_threads; i++) {
+		in_sum += input[i];
+		out_sum += output[i];
+	}
+	for (i = 0; i < num_threads; i++)
+		printf("input[%d] = %u\n", i, input[i]);
+	for (i = 0; i < num_threads; i++)
+		printf("output[%d] = %u\n", i, output[i]);
+/*
+	if (succ1 && succ2)
+		MODEL_ASSERT(in_sum == out_sum);
+	else
+		MODEL_ASSERT(false);
+*/
+	free(param);
+	free(threads);
+	free(queue);
+
+	return 0;
+}
diff --git a/cdschecker_modified_benchmarks/ms-queue/my_queue.c.correct b/cdschecker_modified_benchmarks/ms-queue/my_queue.c.correct
new file mode 100644
index 0000000..b868d2e
--- /dev/null
+++ b/cdschecker_modified_benchmarks/ms-queue/my_queue.c.correct
@@ -0,0 +1,260 @@
+#include <threads.h>
+#include <stdlib.h>
+#include "librace.h"
+#include "model-assert.h"
+
+#include "queue.h"
+
+#define relaxed memory_order_relaxed
+#define release memory_order_release
+#define acquire memory_order_acquire
+
+#define MAX_FREELIST 4 /* Each thread can own up to MAX_FREELIST free nodes */
+#define INITIAL_FREE 2 /* Each thread starts with INITIAL_FREE free nodes */
+
+#define POISON_IDX 0x666
+
+static unsigned int (*free_lists)[MAX_FREELIST];
+
+/* Search this thread's free list for a "new" node */
+static unsigned int new_node()
+{
+	int i;
+	int t = get_thread_num();
+	for (i = 0; i < MAX_FREELIST; i++) {
+		//unsigned int node = load_32(&free_lists[t][i]);
+		unsigned int node = free_lists[t][i];
+		if (node) {
+			//store_32(&free_lists[t][i], 0);
+			free_lists[t][i] = 0;
+			return node;
+		}
+	}
+	/* free_list is empty? */
+	MODEL_ASSERT(0);
+	return 0;
+}
+
+/* Simulate the fact that when a node got recycled, it will get assigned to the
+ * same queue or for other usage */
+void simulateRecycledNodeUpdate(queue_t *q, unsigned int node) {
+	atomic_store_explicit(&q->nodes[node].next, -1, memory_order_release);
+}
+
+
+/* Place this node index back on this thread's free list */
+static void reclaim(unsigned int node)
+{
+	int i;
+	int t = get_thread_num();
+
+	/* Don't reclaim NULL node */
+	//MODEL_ASSERT(node);
+
+	for (i = 0; i < MAX_FREELIST; i++) {
+		/* Should never race with our own thread here */
+		//unsigned int idx = load_32(&free_lists[t][i]);
+		unsigned int idx = free_lists[t][i];
+
+		/* Found empty spot in free list */
+		if (idx == 0) {
+			//store_32(&free_lists[t][i], node);
+			free_lists[t][i] = node;
+			return;
+		}
+	}
+	/* free list is full? */
+	//MODEL_ASSERT(0);
+}
+
+void init_queue(queue_t *q, int num_threads)
+{
+	int i, j;
+
+	/* Initialize each thread's free list with INITIAL_FREE pointers */
+	/* The actual nodes are initialized with poison indexes */
+	free_lists = ( unsigned int (*)[MAX_FREELIST] ) malloc(num_threads * sizeof(*free_lists));
+	for (i = 0; i < num_threads; i++) {
+		for (j = 0; j < INITIAL_FREE; j++) {
+			free_lists[i][j] = 2 + i * MAX_FREELIST + j;
+			atomic_init(&q->nodes[free_lists[i][j]].next, MAKE_POINTER(POISON_IDX, 0));
+		}
+	}
+
+	/* initialize queue */
+	atomic_init(&q->head, MAKE_POINTER(1, 0));
+	atomic_init(&q->tail, MAKE_POINTER(1, 0));
+	atomic_init(&q->nodes[1].next, MAKE_POINTER(0, 0));
+}
+
+/** @DeclareState: IntList *q;
+@Initial: q = new IntList;
+@Print:
+	model_print("\tSTATE(q): ");
+    printContainer(q);
+	model_print("\n"); */
+
+/** @Transition: STATE(q)->push_back(val);
+@Print: model_print("\tENQ #%d: val=%d\n", ID, val); */
+void enqueue(queue_t *q, unsigned int val, int n)
+{
+	int success = 0;
+	unsigned int node;
+	pointer tail;
+	pointer next;
+	pointer tmp;
+
+	node = new_node();
+	//store_32(&q->nodes[node].value, val);
+	q->nodes[node].value = val;
+	tmp = atomic_load_explicit(&q->nodes[node].next, relaxed);
+	set_ptr(&tmp, 0); // NULL
+    // XXX-known-bug-#1: This is a found bug in AutoMO, and testcase4 can reveal
+    // this known bug.
+    // To reproduce, weaken the parameter "memory_order_release" to
+    // "memory_order_relaxed", run "make" to recompile, and then run:
+    // "./run.sh ./ms-queue/testcase4 -m2 -y -u3 -tSPEC"
+	/**********    Detected KNOWN BUG (testcase4)    **********/
+	atomic_store_explicit(&q->nodes[node].next, tmp, release);
+
+	while (!success) {
+        // XXX-injection-#1: To reproduce, weaken the parameter
+        // "memory_order_acquire" to "memory_order_relaxed", run "make" to
+        // recompile, and then run:
+        // "./run.sh ./ms-queue/testcase2 -m2 -y -u3 -tSPEC"
+		/**********    Detected UL (testcase2)    **********/
+		tail = atomic_load_explicit(&q->tail, acquire);
+        // XXX-injection-#2: To reproduce, weaken the parameter
+        // "memory_order_acquire" to "memory_order_relaxed", run "make" to
+        // recompile, and then run:
+        // "./run.sh ./ms-queue/testcase4 -m2 -y -u3 -tSPEC"
+		/**********    Detected Correctness (testcase4)    **********/
+		next = atomic_load_explicit(&q->nodes[get_ptr(tail)].next, acquire);
+		if (tail == atomic_load_explicit(&q->tail, relaxed)) {
+
+			/* Check for uninitialized 'next' */
+			//MODEL_ASSERT(get_ptr(next) != POISON_IDX);
+
+			if (get_ptr(next) == 0) { // == NULL
+				pointer value = MAKE_POINTER(node, get_count(next) + 1);
+                // XXX-injection-#3: To reproduce, weaken the parameter
+                // "memory_order_release" to "memory_order_relaxed", run "make" to
+                // recompile, and then run:
+                // "./run.sh ./ms-queue/testcase1 -m2 -y -u3 -tSPEC"
+				/**********    Detected Correctness (testcase1)    **********/
+				success = atomic_compare_exchange_strong_explicit(&q->nodes[get_ptr(tail)].next,
+						&next, value, release, release);
+				/** @OPClearDefine: success */
+			}
+			if (!success) {
+                // XXX-injection-#4: To reproduce, weaken the parameter
+                // "memory_order_acquire" to "memory_order_relaxed", run "make" to
+                // recompile, and then run:
+                // "./run.sh ./ms-queue/testcase2 -m2 -y -u3 -tSPEC"
+				/**********    Detected UL (testcase2)    **********/
+				unsigned int ptr = get_ptr(atomic_load_explicit(&q->nodes[get_ptr(tail)].next, acquire));
+				pointer value = MAKE_POINTER(ptr,
+						get_count(tail) + 1);
+                // XXX-injection-#5: To reproduce, weaken the parameter
+                // "memory_order_release" to "memory_order_relaxed", run "make" to
+                // recompile, and then run:
+                // "./run.sh ./ms-queue/testcase2 -m2 -y -u3 -tSPEC"
+				/**********    Detected Correctness (testcase2)    **********/
+				atomic_compare_exchange_strong_explicit(&q->tail,
+						&tail, value,
+						release, release);
+				thrd_yield();
+			}
+		}
+	}
+
+    // XXX-injection-#6: To reproduce, weaken the parameter
+    // "memory_order_release" to "memory_order_relaxed", run "make" to
+    // recompile, and then run:
+    // "./run.sh ./ms-queue/testcase1 -m2 -y -u3 -tSPEC"
+	/**********    Detected Correctness (testcase1) **********/
+	atomic_compare_exchange_strong_explicit(&q->tail,
+			&tail,
+			MAKE_POINTER(node, get_count(tail) + 1),
+			release, release);
+}
+
+/** @Transition: S_RET = STATE(q)->empty() ? 0 : STATE(q)->front();
+if (S_RET && C_RET) STATE(q)->pop_front();
+@JustifyingPostcondition: if (!C_RET)
+    return S_RET == C_RET;
+@PostCondition: return C_RET ? *retVal  == S_RET : true;
+@Print: model_print("\tDEQ #%d: C_RET=%d && *retVal=%d && S_RET=%d\n", ID,
+            C_RET, *retVal, S_RET);
+*/
+int dequeue(queue_t *q, unsigned int *retVal, unsigned int *reclaimNode)
+{
+	int success = 0;
+	pointer head;
+	pointer tail;
+	pointer next;
+
+	while (!success) {
+        // XXX-injection-#7: To reproduce, weaken the parameter
+        // "memory_order_acquire" to "memory_order_relaxed", run "make" to
+        // recompile, and then run:
+        // "./run.sh ./ms-queue/testcase3 -m2 -y -u3 -tSPEC"
+		/**********    Detected Correctness (testcase3)    **********/
+		head = atomic_load_explicit(&q->head, acquire);
+        // To reproduce, weaken the parameter "memory_order_acquire" to
+        // "memory_order_relaxed", run "make" to recompile, and then run:
+        // "./run.sh ./ms-queue/testcase4 -m2 -y -u3 -tSPEC"
+        // XXX-known-bug-#2: This is another known bug, and testcase2 can reveal
+        // this known bug
+		/**********    Detected KNOWN BUG (testcase2)    **********/
+		tail = atomic_load_explicit(&q->tail, acquire);
+
+        // XXX-injection-#8: To reproduce, weaken the parameter
+        // "memory_order_acquire" to "memory_order_relaxed", run "make" to
+        // recompile, and then run:
+        // "./run.sh ./ms-queue/testcase1 -m2 -y -u3 -tSPEC"
+		/**********    Detected Correctness (testcase1) **********/
+		next = atomic_load_explicit(&q->nodes[get_ptr(head)].next, acquire);
+		/** @OPClearDefine: true */
+		if (atomic_load_explicit(&q->head, relaxed) == head) {
+			if (get_ptr(head) == get_ptr(tail)) {
+
+				/* Check for uninitialized 'next' */
+				MODEL_ASSERT(get_ptr(next) != POISON_IDX);
+
+				if (get_ptr(next) == 0) { // NULL
+					return false; // NULL
+				}
+
+                // XXX-injection-#9: To reproduce, weaken the parameter
+                // "memory_order_release" to "memory_order_relaxed", run "make" to
+                // recompile, and then run:
+                // "./run.sh ./ms-queue/testcase2 -m2 -y -u3 -tSPEC"
+				/**********    Detected UL (testcase2)    **********/
+				atomic_compare_exchange_strong_explicit(&q->tail,
+						&tail,
+						MAKE_POINTER(get_ptr(next), get_count(tail) + 1),
+						release, release);
+				thrd_yield();
+			} else {
+				//*retVal = load_32(&q->nodes[get_ptr(next)].value);
+				*retVal = q->nodes[get_ptr(next)].value;
+
+                // XXX-injection-#10: To reproduce, weaken the parameter
+                // "memory_order_release" to "memory_order_relaxed", run "make" to
+                // recompile, and then run:
+                // "./run.sh ./ms-queue/testcase3 -m2 -y -u3 -tSPEC"
+				/**********    Detected Correctness (testcase3)    **********/
+				success = atomic_compare_exchange_strong_explicit(&q->head,
+						&head,
+						MAKE_POINTER(get_ptr(next), get_count(head) + 1),
+						release, release);
+				if (!success)
+					thrd_yield();
+			}
+		}
+	}
+	*reclaimNode = get_ptr(head);
+	reclaim(get_ptr(head));
+	return true;
+}
diff --git a/cdschecker_modified_benchmarks/ms-queue/my_queue.cc b/cdschecker_modified_benchmarks/ms-queue/my_queue.cc
new file mode 100644
index 0000000..d746bda
--- /dev/null
+++ b/cdschecker_modified_benchmarks/ms-queue/my_queue.cc
@@ -0,0 +1,167 @@
+#include <threads.h>
+#include <stdlib.h>
+#include "librace.h"
+#include "model-assert.h"
+
+#include "my_queue.h"
+
+#define relaxed memory_order_relaxed
+#define release memory_order_release
+#define acquire memory_order_acquire
+
+#define MAX_FREELIST 4 /* Each thread can own up to MAX_FREELIST free nodes */
+#define INITIAL_FREE 2 /* Each thread starts with INITIAL_FREE free nodes */
+
+#define POISON_IDX 0x666
+
+static unsigned int (*free_lists)[MAX_FREELIST];
+
+/* Search this thread's free list for a "new" node */
+static unsigned int new_node()
+{
+	int i;
+	int t = get_thread_num();
+	for (i = 0; i < MAX_FREELIST; i++) {
+		unsigned int node = load_32(&free_lists[t][i]);
+		if (node) {
+			store_32(&free_lists[t][i], 0);
+			return node;
+		}
+	}
+	/* free_list is empty? */
+	MODEL_ASSERT(0);
+	return 0;
+}
+
+/* Place this node index back on this thread's free list */
+static void reclaim(unsigned int node)
+{
+	int i;
+	int t = get_thread_num();
+
+	/* Don't reclaim NULL node */
+	MODEL_ASSERT(node);
+
+	for (i = 0; i < MAX_FREELIST; i++) {
+		/* Should never race with our own thread here */
+		unsigned int idx = load_32(&free_lists[t][i]);
+
+		/* Found empty spot in free list */
+		if (idx == 0) {
+			store_32(&free_lists[t][i], node);
+			return;
+		}
+	}
+	/* free list is full? */
+	MODEL_ASSERT(0);
+}
+
+void init_queue(queue_t *q, int num_threads)
+{
+	int i, j;
+
+	/* Initialize each thread's free list with INITIAL_FREE pointers */
+	/* The actual nodes are initialized with poison indexes */
+	free_lists = (unsigned (*)[MAX_FREELIST])malloc(num_threads * sizeof(*free_lists));
+	for (i = 0; i < num_threads; i++) {
+		for (j = 0; j < INITIAL_FREE; j++) {
+			free_lists[i][j] = 2 + i * MAX_FREELIST + j;
+			atomic_init(&q->nodes[free_lists[i][j]].next, MAKE_POINTER(POISON_IDX, 0));
+		}
+	}
+
+	/* initialize queue */
+	atomic_init(&q->head, MAKE_POINTER(1, 0));
+	atomic_init(&q->tail, MAKE_POINTER(1, 0));
+	atomic_init(&q->nodes[1].next, MAKE_POINTER(0, 0));
+}
+
+void enqueue(queue_t *q, unsigned int val)
+{
+	int success = 0;
+	unsigned int node;
+	pointer tail;
+	pointer next;
+	pointer tmp;
+
+	node = new_node();
+	store_32(&q->nodes[node].value, val);
+	tmp = atomic_load_explicit(&q->nodes[node].next, relaxed);
+	set_ptr(&tmp, 0); // NULL
+
+	// Bug 1
+	atomic_store_explicit(&q->nodes[node].next, tmp, relaxed);
+	//atomic_store_explicit(&q->nodes[node].next, tmp, release);
+
+	while (!success) {
+		tail = atomic_load_explicit(&q->tail, acquire);
+		next = atomic_load_explicit(&q->nodes[get_ptr(tail)].next, acquire);
+		if (tail == atomic_load_explicit(&q->tail, relaxed)) {
+			/* Check for uninitialized 'next' */
+			MODEL_ASSERT(get_ptr(next) != POISON_IDX);
+
+			if (get_ptr(next) == 0) { // == NULL
+				pointer value = MAKE_POINTER(node, get_count(next) + 1);
+				success = atomic_compare_exchange_strong_explicit(&q->nodes[get_ptr(tail)].next,
+						&next, value, release, release);
+			}
+			if (!success) {
+				unsigned int ptr = get_ptr(atomic_load_explicit(&q->nodes[get_ptr(tail)].next, acquire));
+				pointer value = MAKE_POINTER(ptr,
+						get_count(tail) + 1);
+				atomic_compare_exchange_strong_explicit(&q->tail,
+						&tail, value,
+						release, release);
+				thrd_yield();
+			}
+		}
+	}
+	atomic_compare_exchange_strong_explicit(&q->tail,
+			&tail,
+			MAKE_POINTER(node, get_count(tail) + 1),
+			release, release);
+}
+
+bool dequeue(queue_t *q, unsigned int *retVal)
+{
+	int success = 0;
+	pointer head;
+	pointer tail;
+	pointer next;
+
+	while (!success) {
+		head = atomic_load_explicit(&q->head, acquire);
+
+		// Bug 2
+		tail = atomic_load_explicit(&q->tail, relaxed);
+		//tail = atomic_load_explicit(&q->tail, acquire);
+
+		next = atomic_load_explicit(&q->nodes[get_ptr(head)].next, acquire);
+		if (atomic_load_explicit(&q->head, relaxed) == head) {
+			if (get_ptr(head) == get_ptr(tail)) {
+
+				/* Check for uninitialized 'next' */
+				MODEL_ASSERT(get_ptr(next) != POISON_IDX);
+
+				if (get_ptr(next) == 0) { // NULL
+					return false; // NULL
+				}
+				atomic_compare_exchange_strong_explicit(&q->tail,
+						&tail,
+						MAKE_POINTER(get_ptr(next), get_count(tail) + 1),
+						release, release);
+				thrd_yield();
+			} else {
+				*retVal = load_32(&q->nodes[get_ptr(next)].value);
+				success = atomic_compare_exchange_strong_explicit(&q->head,
+						&head,
+						MAKE_POINTER(get_ptr(next), get_count(head) + 1),
+						release, release);
+				if (!success)
+					thrd_yield();
+			}
+		}
+	}
+	reclaim(get_ptr(head));
+	return true;
+}
diff --git a/cdschecker_modified_benchmarks/ms-queue/my_queue.h b/cdschecker_modified_benchmarks/ms-queue/my_queue.h
new file mode 100644
index 0000000..8bb8d58
--- /dev/null
+++ b/cdschecker_modified_benchmarks/ms-queue/my_queue.h
@@ -0,0 +1,32 @@
+#include <stdatomic.h>
+#include <stdbool.h>
+
+#define MAX_NODES			0xf
+
+typedef unsigned long long pointer;
+typedef atomic_ullong pointer_t;
+
+#define MAKE_POINTER(ptr, count)	((((pointer)count) << 32) | ptr)
+#define PTR_MASK 0xffffffffLL
+#define COUNT_MASK (0xffffffffLL << 32)
+
+static inline void set_count(pointer *p, unsigned int val) { *p = (*p & ~COUNT_MASK) | ((pointer)val << 32); }
+static inline void set_ptr(pointer *p, unsigned int val) { *p = (*p & ~PTR_MASK) | val; }
+static inline unsigned int get_count(pointer p) { return (p & COUNT_MASK) >> 32; }
+static inline unsigned int get_ptr(pointer p) { return p & PTR_MASK; }
+
+typedef struct node {
+	unsigned int value;
+	pointer_t next;
+} node_t;
+
+typedef struct {
+	pointer_t head;
+	pointer_t tail;
+	node_t nodes[MAX_NODES + 1];
+} queue_t;
+
+void init_queue(queue_t *q, int num_threads);
+void enqueue(queue_t *q, unsigned int val);
+bool dequeue(queue_t *q, unsigned int *retVal);
+int get_thread_num();
diff --git a/cdschecker_modified_benchmarks/spsc-queue/Makefile b/cdschecker_modified_benchmarks/spsc-queue/Makefile
new file mode 100644
index 0000000..33b9d01
--- /dev/null
+++ b/cdschecker_modified_benchmarks/spsc-queue/Makefile
@@ -0,0 +1,23 @@
+include ../benchmarks.mk
+
+TESTNAME = spsc-queue
+RELACYNAME = spsc-relacy
+
+all: $(TESTNAME)
+
+$(TESTNAME): $(TESTNAME).cc queue.h eventcount.h
+	$(CXX) -o $@ $< $(CXXFLAGS) $(LDFLAGS)
+
+relacy: $(RELACYNAME)
+
+$(RELACYNAME): spsc-relacy.cc queue-relacy.h eventcount-relacy.h
+ifdef RELACYPATH
+	$(CXX) -o $(RELACYNAME) spsc-relacy.cc -I$(RELACYPATH) -Wno-deprecated
+else
+	@echo "Please define RELACYPATH"
+	@echo "  e.g., make RELACYPATH=/path-to-relacy"
+	@exit 1
+endif
+
+clean:
+	rm -f $(TESTNAME) $(RELACYNAME) *.o
diff --git a/cdschecker_modified_benchmarks/spsc-queue/eventcount-relacy.h b/cdschecker_modified_benchmarks/spsc-queue/eventcount-relacy.h
new file mode 100644
index 0000000..9eadcf3
--- /dev/null
+++ b/cdschecker_modified_benchmarks/spsc-queue/eventcount-relacy.h
@@ -0,0 +1,64 @@
+class eventcount
+{
+public:
+	eventcount() : waiters(0)
+	{
+		count($) = 0;
+	}
+
+	void signal_relaxed()
+	{
+		unsigned cmp = count.load(std::memory_order_relaxed);
+		signal_impl(cmp);
+	}
+
+	void signal()
+	{
+		unsigned cmp = count.fetch_add(0, std::memory_order_seq_cst);
+		signal_impl(cmp);
+	}
+
+	unsigned get()
+	{
+		unsigned cmp = count.fetch_or(0x80000000,
+std::memory_order_seq_cst);
+		return cmp & 0x7FFFFFFF;
+	}
+
+	void wait(unsigned cmp)
+	{
+		unsigned ec = count.load(std::memory_order_seq_cst);
+		if (cmp == (ec & 0x7FFFFFFF))
+		{
+			guard.lock($);
+			ec = count.load(std::memory_order_seq_cst);
+			if (cmp == (ec & 0x7FFFFFFF))
+			{
+				waiters($) += 1;
+				cv.wait(guard, $);
+			}
+			guard.unlock($);
+		}
+	}
+
+private:
+	std::atomic<unsigned> count;
+	rl::var<unsigned> waiters;
+	std::mutex guard;
+	std::condition_variable cv;
+
+	void signal_impl(unsigned cmp)
+	{
+		if (cmp & 0x80000000)
+		{
+			guard.lock($);
+			while (false == count.compare_exchange_weak(cmp,
+				(cmp + 1) & 0x7FFFFFFF, std::memory_order_relaxed));
+			unsigned w = waiters($);
+			waiters($) = 0;
+			guard.unlock($);
+			if (w)
+				cv.notify_all($);
+		}
+	}
+};
diff --git a/cdschecker_modified_benchmarks/spsc-queue/eventcount.h b/cdschecker_modified_benchmarks/spsc-queue/eventcount.h
new file mode 100644
index 0000000..f2b05f7
--- /dev/null
+++ b/cdschecker_modified_benchmarks/spsc-queue/eventcount.h
@@ -0,0 +1,72 @@
+#include <unrelacy.h>
+#include <atomic>
+#include <mutex>
+#include <condition_variable>
+
+class eventcount
+{
+public:
+	eventcount() : waiters(0)
+	{
+		count = 0;
+	}
+
+	void signal_relaxed()
+	{
+		unsigned cmp = count.load(std::memory_order_relaxed);
+		signal_impl(cmp);
+	}
+
+	void signal()
+	{
+		unsigned cmp = count.fetch_add(0, std::memory_order_seq_cst);
+		signal_impl(cmp);
+	}
+
+	unsigned get()
+	{
+		unsigned cmp = count.fetch_or(0x80000000,
+std::memory_order_seq_cst);
+		return cmp & 0x7FFFFFFF;
+	}
+
+	void wait(unsigned cmp)
+	{
+		unsigned ec = count.load(std::memory_order_seq_cst);
+		if (cmp == (ec & 0x7FFFFFFF))
+		{
+			//guard.lock($);
+			std::unique_lock<std::mutex> lck(guard);
+			ec = count.load(std::memory_order_seq_cst);
+			if (cmp == (ec & 0x7FFFFFFF))
+			{
+				waiters += 1;
+				//cv.wait(guard);
+				cv.wait(lck);
+			}
+			guard.unlock($);
+			//lck.unlock();
+		}
+	}
+
+private:
+	std::atomic<unsigned> count;
+	rl::var<unsigned> waiters;
+	std::mutex guard;
+	std::condition_variable cv;
+
+	void signal_impl(unsigned cmp)
+	{
+		if (cmp & 0x80000000)
+		{
+			guard.lock($);
+			while (false == count.compare_exchange_weak(cmp,
+				(cmp + 1) & 0x7FFFFFFF, std::memory_order_relaxed));
+			unsigned w = waiters($);
+			waiters = 0;
+			guard.unlock($);
+			if (w)
+				cv.notify_all($);
+		}
+	}
+};
diff --git a/cdschecker_modified_benchmarks/spsc-queue/queue-relacy.h b/cdschecker_modified_benchmarks/spsc-queue/queue-relacy.h
new file mode 100644
index 0000000..71aac2a
--- /dev/null
+++ b/cdschecker_modified_benchmarks/spsc-queue/queue-relacy.h
@@ -0,0 +1,74 @@
+#include "eventcount-relacy.h"
+
+template<typename T>
+class spsc_queue
+{
+public:
+	spsc_queue()
+	{
+		node* n = new node ();
+		head($) = n;
+		tail($) = n;
+	}
+
+	~spsc_queue()
+	{
+		RL_ASSERT(head($) == tail($));
+		delete ((node*)head($));
+	}
+
+	void enqueue(T data)
+	{
+		node* n = new node (data);
+		head($)->next.store(n, std::memory_order_release);
+		head($) = n;
+		ec.signal_relaxed();
+	}
+
+	T dequeue()
+	{
+		T data = try_dequeue();
+		while (0 == data)
+		{
+			int cmp = ec.get();
+			data = try_dequeue();
+			if (data)
+				break;
+			ec.wait(cmp);
+			data = try_dequeue();
+			if (data)
+				break;
+		}
+		return data;
+	}
+
+private:
+	struct node
+	{
+		std::atomic<node*> next;
+		rl::var<T> data;
+
+		node(T data = T())
+			: data(data)
+		{
+			next($) = 0;
+		}
+	};
+
+	rl::var<node*> head;
+	rl::var<node*> tail;
+
+	eventcount ec;
+
+	T try_dequeue()
+	{
+		node* t = tail($);
+		node* n = t->next.load(std::memory_order_acquire);
+		if (0 == n)
+			return 0;
+		T data = n->data($);
+		delete (t);
+		tail($) = n;
+		return data;
+	}
+};
diff --git a/cdschecker_modified_benchmarks/spsc-queue/queue.h b/cdschecker_modified_benchmarks/spsc-queue/queue.h
new file mode 100644
index 0000000..c77425f
--- /dev/null
+++ b/cdschecker_modified_benchmarks/spsc-queue/queue.h
@@ -0,0 +1,77 @@
+#include <unrelacy.h>
+#include <atomic>
+
+#include "eventcount.h"
+
+template<typename T>
+class spsc_queue
+{
+public:
+	spsc_queue()
+	{
+		node* n = new node ();
+		head = n;
+		tail = n;
+	}
+
+	~spsc_queue()
+	{
+		RL_ASSERT(head == tail);
+		delete ((node*)head($));
+	}
+
+	void enqueue(T data)
+	{
+		node* n = new node (data);
+		head($)->next.store(n, std::memory_order_release);
+		head = n;
+		ec.signal_relaxed();
+	}
+
+	T dequeue()
+	{
+		T data = try_dequeue();
+		while (0 == data)
+		{
+			int cmp = ec.get();
+			data = try_dequeue();
+			if (data)
+				break;
+			ec.wait(cmp);
+			data = try_dequeue();
+			if (data)
+				break;
+		}
+		return data;
+	}
+
+private:
+	struct node
+	{
+		std::atomic<node*> next;
+		rl::var<T> data;
+
+		node(T data = T())
+			: data(data)
+		{
+			next = 0;
+		}
+	};
+
+	rl::var<node*> head;
+	rl::var<node*> tail;
+
+	eventcount ec;
+
+	T try_dequeue()
+	{
+		node* t = tail($);
+		node* n = t->next.load(std::memory_order_acquire);
+		if (0 == n)
+			return 0;
+		T data = n->data($);
+		delete (t);
+		tail = n;
+		return data;
+	}
+};
diff --git a/cdschecker_modified_benchmarks/spsc-queue/spsc-queue.cc b/cdschecker_modified_benchmarks/spsc-queue/spsc-queue.cc
new file mode 100644
index 0000000..1347f4e
--- /dev/null
+++ b/cdschecker_modified_benchmarks/spsc-queue/spsc-queue.cc
@@ -0,0 +1,34 @@
+#include "cds_threads.h"
+
+#include "queue.h"
+
+spsc_queue<int> *q;
+
+	void thread(unsigned thread_index)
+	{
+		if (0 == thread_index)
+		{
+			q->enqueue(11);
+		}
+		else
+		{
+			int d = q->dequeue();
+			RL_ASSERT(11 == d);
+		}
+	}
+
+int user_main(int argc, char **argv)
+{
+	thrd_t A, B;
+
+	q = new spsc_queue<int>();
+
+	thrd_create(&A, (thrd_start_t)&thread, (void *)0);
+	thrd_create(&B, (thrd_start_t)&thread, (void *)1);
+	thrd_join(A);
+	thrd_join(B);
+
+	delete q;
+
+	return 0;
+}
diff --git a/cdschecker_modified_benchmarks/spsc-queue/spsc-relacy.cc b/cdschecker_modified_benchmarks/spsc-queue/spsc-relacy.cc
new file mode 100644
index 0000000..37ed989
--- /dev/null
+++ b/cdschecker_modified_benchmarks/spsc-queue/spsc-relacy.cc
@@ -0,0 +1,27 @@
+#include <relacy/relacy_std.hpp>
+
+#include "queue-relacy.h"
+
+struct spsc_queue_test : rl::test_suite<spsc_queue_test, 2>
+{
+	spsc_queue<int> q;
+
+	void thread(unsigned thread_index)
+	{
+		if (0 == thread_index)
+		{
+			q.enqueue(11);
+		}
+		else
+		{
+			int d = q.dequeue();
+			RL_ASSERT(11 == d);
+		}
+	}
+};
+
+
+int main()
+{
+	rl::simulate<spsc_queue_test>();
+}
diff --git a/cdschecker_modified_benchmarks/test.sh b/cdschecker_modified_benchmarks/test.sh
new file mode 100755
index 0000000..ff2c3b5
--- /dev/null
+++ b/cdschecker_modified_benchmarks/test.sh
@@ -0,0 +1,46 @@
+#!/bin/bash
+
+EXE=$1
+TOTAL_RUN=5 #00
+CDSLIB="/scratch/fuzzer/random-fuzzer"
+export LD_LIBRARY_PATH=${CDSLIB}
+export C11TESTER='-x1'
+
+#ERROR_FILE="data-structure.log"
+TASKSET=""
+
+COUNT_DATA_RACE=0
+COUNT_TIME=0
+
+for i in `seq 1 1 $TOTAL_RUN` ; do
+#  time ${TASKSET} $EXE &> $ERROR_FILE
+#  OUTPUT=$(< $ERROR_FILE)
+
+  OUTPUT="$(/usr/bin/time -f "time: %U %S" $EXE -x1 2>&1)"
+  RACE="$(echo "$OUTPUT" | grep "race")"
+  if [ -n "$RACE" ] ; then
+    ((++COUNT_DATA_RACE))
+  fi
+
+  TIME="$(echo "$OUTPUT" | grep -o "time: .\... .\...")"
+  TIME_USER_S="$(echo "$TIME" | cut -d' ' -f2 | cut -d'.' -f1)"
+  TIME_USER_CS="$(echo "$TIME" | cut -d' ' -f2 | cut -d'.' -f2)"
+  TIME_SYSTEM_S="$(echo "$TIME" | cut -d' ' -f3 | cut -d'.' -f1)"
+  TIME_SYSTEM_CS="$(echo "$TIME" | cut -d' ' -f3 | cut -d'.' -f2)"
+
+  TIME_EXE=$((10#$TIME_USER_S * 1000 + 10#$TIME_USER_CS * 10 + 10#$TIME_SYSTEM_S * 1000 + 10#$TIME_SYSTEM_CS * 10))
+  COUNT_TIME=$((COUNT_TIME + TIME_EXE))
+done
+
+#rm $ERROR_FILE
+
+AVG_DATA_RACE=$(echo "${COUNT_DATA_RACE} * 100 / ${TOTAL_RUN}" | bc -l | xargs printf "%.1f")
+AVG_TIME_INT=$(echo "${COUNT_TIME} / ${TOTAL_RUN} + 0.5" | bc -l | xargs printf "%.0f")
+
+# -3 / log(1 - p) < n
+#NO_99=$(echo "-3 / (l(1 - (${AVG_DATA_RACE} / 100)) / l(10)) + 0.5" | bc -l | xargs printf "%.0f")
+#TIME_99=$(echo "${NO_99} * ${AVG_TIME_INT}" | bc -l)
+
+echo "Runs: $TOTAL_RUN | Data races: $COUNT_DATA_RACE | Total time: ${COUNT_TIME}ms"
+echo "Time: ${AVG_TIME_INT}ms | Race rate: ${AVG_DATA_RACE}%"
+#echo "Time: ${AVG_TIME_INT}ms | Race rate: ${AVG_DATA_RACE}% | No. 99.9%: ${NO_99} | Time 99.9%: ${TIME_99}ms"
diff --git a/cdschecker_modified_benchmarks/test_all.sh b/cdschecker_modified_benchmarks/test_all.sh
new file mode 100755
index 0000000..a7200eb
--- /dev/null
+++ b/cdschecker_modified_benchmarks/test_all.sh
@@ -0,0 +1,13 @@
+#!/bin/bash
+set -e
+set -u
+
+# Paul: skip `spsc-queue` as it deadlocks.
+
+for t in barrier chase-lev-deque dekker-fences linuxrwlocks mcs-lock mpmc-queue ms-queue; do
+  cd $t
+  echo -n "$t " 
+  ../test.sh ./$t
+  cd ..
+done
+
-- 
2.34.1