include/unrelacy.h

   1 #ifndef __UNRELACY_H__
   2 #define __UNRELACY_H__
   3
   4 #include <stdatomic.h>
   5 #include <stdlib.h>
   6 #include <stdio.h>
   7 #include <mutex>
   8 #include <condition_variable>
   9
  10 #include <model-assert.h>
  11 #include <librace.h>
  12
  13 #define $
  14 #ifndef ASSRT
  15 #define ASSERT(expr) MODEL_ASSERT(expr)
  16 #endif
  17 #define RL_ASSERT(expr) MODEL_ASSERT(expr)
  18
  19 #define RL_NEW new
  20 #define RL_DELETE(expr) delete expr
  21
  22 #define mo_seqcst memory_order_seq_cst
  23 #define mo_release memory_order_release
  24 #define mo_acquire memory_order_acquire
  25 #define mo_acq_rel memory_order_acq_rel
  26 #define mo_relaxed memory_order_relaxed
  27
  28 #define seq_cst memory_order_seq_cst
  29 #define release memory_order_release
  30 #define acquire memory_order_acquire
  31 #define acq_rel memory_order_acq_rel
  32 #define relaxed memory_order_relaxed
  33
  34 namespace rl {
  35
  36         /* This 'useless' struct is declared just so we can use partial template
  37          * specialization in our store and load functions. */
  38         template <typename T, size_t n>
  39         struct useless {
  40                 static void store(void *addr, T val);
  41                 static T load(const void *addr);
  42         };
  43
  44         template <typename T>
  45         struct useless<T, 1> {
  46                 static void store(void *addr, T val) { store_8(addr, (uint8_t)val); }
  47                 static T load(const void *addr) { return (T)load_8(addr); }
  48         };
  49
  50         template <typename T>
  51         struct useless<T, 2> {
  52                 static void store(void *addr, T val) { store_16(addr, (uint16_t)val); }
  53                 static T load(const void *addr) { return (T)load_16(addr); }
  54         };
  55
  56         template <typename T>
  57         struct useless<T, 4> {
  58                 static void store(void *addr, T val) { store_32(addr, (uint32_t)val); }
  59                 static T load(const void *addr) { return (T)load_32(addr); }
  60         };
  61
  62         template <typename T>
  63         struct useless<T, 8> {
  64                 static void store(void *addr, T val) { store_64(addr, (uint64_t)val); }
  65                 static T load(const void *addr) { return (T)load_64(addr); }
  66         };
  67
  68         template <typename T>
  69         struct var {
  70                 var() { useless<T, sizeof(T)>::store(&value, 0); }
  71                 var(T v) { useless<T, sizeof(T)>::store(&value, v); }
  72                 var(var const& r) {
  73                         value = r.value;
  74                 }
  75                 ~var() { }
  76
  77                 void operator = (T v) { useless<T, sizeof(T)>::store(&value, v); }
  78                 T operator () () { return useless<T, sizeof(T)>::load(&value); }
  79                 void operator += (T v) {
  80                         useless<T, sizeof(T)>::store(&value,
  81                                         useless<T, sizeof(T)>::load(&value) + v);
  82                 }
  83                 bool operator == (const struct var<T> v) const { return useless<T, sizeof(T)>::load(&value) == useless<T, sizeof(T)>::load(&v.value); }
  84
  85                 T value;
  86         };
  87
  88         class backoff_t
  89         {
  90          public:
  91                 typedef int debug_info_param;
  92                 void yield(debug_info_param info) { }
  93                 void yield() { }
  94         };
  95
  96
  97         typedef backoff_t backoff;
  98         typedef backoff_t linear_backoff;
  99         typedef backoff_t exp_backoff;
 100
 101 }
 102
 103 #endif /* __UNRELACY_H__ */