bench.sh: fixup Brian D.'s script change

[model-checker-benchmarks.git] / include / unrelacy.h

diff --git a/include/unrelacy.h b/include/unrelacy.h
index f4d75e8648c88dd6d9b7f5053dbc986ac394b9e0..729d76fdc24b9ae10705dd762fabd01e844a0c93 100644 (file)
--- a/include/unrelacy.h
+++ b/include/unrelacy.h
@@ -1,9 +1,22 @@
+#ifndef __UNRELACY_H__
+#define __UNRELACY_H__
+
 #include <stdatomic.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <mutex>
+#include <condition_variable>
+
+#include <model-assert.h>
+#include <librace.h>
 
 #define $
 
-/* Should re-define to something meaningful */
-#define ASSERT(expr)
+#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
@@ -13,6 +26,58 @@
 
 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:
@@ -27,3 +92,5 @@ namespace rl {
        typedef backoff_t exp_backoff;
 
 }
+
+#endif /* __UNRELACY_H__ */