clang/test/linuxrwlocks.c

   1 #include <stdio.h>
   2 #include <threads.h>
   3
   4 #include "libinterface.h"
   5
   6 #define RW_LOCK_BIAS            0x00100000
   7 #define WRITE_LOCK_CMP          RW_LOCK_BIAS
   8
   9 /** Example implementation of linux rw lock along with 2 thread test
  10  *  driver... */
  11
  12 typedef union {
  13         int lock;
  14 } rwlock_t;
  15
  16 static inline void read_lock(MCID _mrw, rwlock_t *rw)
  17 {
  18         MCID _rmw0 = MC2_nextRMW(MCID_NODEP, MCID_NODEP, MCID_NODEP);
  19         int priorvalue=rmw_32(ADD, &rw->lock, /* dummy */ 0, ((unsigned int)-1));
  20
  21         MC2_enterLoop();
  22         while (true) {
  23                 MCID _br0;
  24
  25                 int _cond0 = priorvalue <= 0;
  26                 MCID _cond0_m = MC2_function(1, sizeof(_cond0), _cond0, _rmw0);
  27                 if (_cond0) {_br0 = MC2_branchUsesID(_cond0_m, 1, 2, true);
  28
  29                         MC2_merge(_br0);
  30                 } else {
  31                         _br0 = MC2_branchUsesID(_cond0_m, 0, 2, true);
  32                         break;
  33                 }
  34
  35                 MCID _rmw1 = MC2_nextRMW(MCID_NODEP, MCID_NODEP, MCID_NODEP);
  36                 rmw_32(ADD, &rw->lock, /* dummy */ 0, 1);
  37
  38                 MC2_enterLoop();
  39                 while (true) {
  40                         MCID _mstatus; _mstatus=MC2_nextOpLoadOffset(_mrw, MC2_OFFSET(rwlock_t *, lock)); int status = load_32(&rw->lock);
  41                         MCID _br1;
  42
  43                         int _cond1 = status > 0;
  44                         MCID _cond1_m = MC2_function(1, sizeof(_cond1), _cond1, _mstatus);
  45                         if (_cond1) {_br1 = MC2_branchUsesID(_cond1_m, 1, 2, true);
  46
  47                                 MC2_merge(_br1);
  48                         } else {
  49                                 _br1 = MC2_branchUsesID(_cond1_m, 0, 2, true);
  50                                 break;
  51                         }
  52                         MC2_yield();
  53                 }
  54 MC2_exitLoop();
  55
  56
  57                 MCID _rmw2 = MC2_nextRMW(MCID_NODEP, MCID_NODEP, MCID_NODEP);
  58                 priorvalue=rmw_32(ADD, &rw->lock, /* dummy */ 0, ((unsigned int)-1));
  59                 MC2_loopIterate();
  60         }
  61 MC2_exitLoop();
  62
  63 }
  64
  65 static inline void write_lock(MCID _mrw, rwlock_t *rw)
  66 {
  67         MCID _rmw3 = MC2_nextRMW(MCID_NODEP, MCID_NODEP, MCID_NODEP);
  68         int priorvalue=rmw_32(ADD, &rw->lock, /* dummy */ 0, ((unsigned int)-(RW_LOCK_BIAS)));
  69         MC2_enterLoop();
  70         while(true) {
  71
  72                 MCID _br2;
  73
  74                 int _cond2 = priorvalue != 1048576;
  75                 MCID _cond2_m = MC2_function(1, sizeof(_cond2), _cond2, _rmw3);
  76                 if (_cond2) {_br2 = MC2_branchUsesID(_cond2_m, 1, 2, true);
  77
  78                         MC2_merge(_br2);
  79                 } else {
  80                         _br2 = MC2_branchUsesID(_cond2_m, 0, 2, true);
  81                         break;
  82                 }
  83
  84                 MCID _rmw4 = MC2_nextRMW(MCID_NODEP, MCID_NODEP, MCID_NODEP);
  85                 rmw_32(ADD, &rw->lock, /* dummy */ 0, RW_LOCK_BIAS);
  86
  87                 MC2_enterLoop();
  88                 while (true) {
  89                         MCID _mstatus; _mstatus=MC2_nextOpLoadOffset(_mrw, MC2_OFFSET(rwlock_t *, lock)); int status = load_32(&rw->lock);
  90                         MCID _br3;
  91
  92                         int _cond3 = status != 1048576;
  93                         MCID _cond3_m = MC2_function(1, sizeof(_cond3), _cond3, _mstatus);
  94                         if (_cond3) {_br3 = MC2_branchUsesID(_cond3_m, 1, 2, true);
  95
  96                                 MC2_merge(_br3);
  97                         } else {
  98                                 _br3 = MC2_branchUsesID(_cond3_m, 0, 2, true);
  99                                 break;
 100                         }
 101                         MC2_yield();
 102                 }
 103 MC2_exitLoop();
 104
 105
 106                 MCID _rmw5 = MC2_nextRMW(MCID_NODEP, MCID_NODEP, MCID_NODEP);
 107                 priorvalue=rmw_32(ADD, &rw->lock, /* dummy */ 0, ((unsigned int)-(RW_LOCK_BIAS)));
 108         }
 109 MC2_exitLoop();
 110
 111 }
 112
 113 static inline bool write_trylock(MCID _mrw, rwlock_t *rw, MCID * retval)
 114 {
 115         MCID _rmw6 = MC2_nextRMW(MCID_NODEP, MCID_NODEP, MCID_NODEP);
 116         int priorvalue=rmw_32(ADD, &rw->lock, /* dummy */ 0, ((unsigned int)-(RW_LOCK_BIAS)));
 117
 118         MCID _fn0; int flag = priorvalue != RW_LOCK_BIAS;
 119         _fn0 = MC2_function(1, sizeof (flag), flag, _rmw6);
 120         MCID _br4;
 121         if (flag) {_br4 = MC2_branchUsesID(_fn0, 1, 2, true);
 122
 123                 MC2_merge(_br4);
 124         } else {
 125                 _br4 = MC2_branchUsesID(_fn0, 0, 2, true);
 126                 MCID _rmw7 = MC2_nextRMW(MCID_NODEP, MCID_NODEP, MCID_NODEP);
 127                 rmw_32(ADD, &rw->lock, /* dummy */ 0, RW_LOCK_BIAS);
 128                 MC2_merge(_br4);
 129         }
 130
 131         *retval = _fn0;
 132         return flag;
 133 }
 134
 135 static inline void read_unlock(MCID _mrw, rwlock_t *rw)
 136 {
 137         MCID _rmw8 = MC2_nextRMW(MCID_NODEP, MCID_NODEP, MCID_NODEP);
 138         rmw_32(ADD, &rw->lock, /* dummy */ 0, 1);
 139 }
 140
 141 static inline void write_unlock(MCID _mrw, rwlock_t *rw)
 142 {
 143         MCID _rmw9 = MC2_nextRMW(MCID_NODEP, MCID_NODEP, MCID_NODEP);
 144         rmw_32(ADD, &rw->lock, /* dummy */ 0, RW_LOCK_BIAS);
 145 }
 146
 147 MCID _mmylock; rwlock_t mylock;
 148 int shareddata;
 149
 150 static void foo() {
 151         MCID _rv0;
 152         int flag=write_trylock(MCID_NODEP, &mylock, &_rv0);
 153         MCID _br5;
 154         if (flag) {
 155                 _br5 = MC2_branchUsesID(_rv0, 1, 2, true);
 156                 write_unlock(MCID_NODEP, &mylock);
 157                 MC2_merge(_br5);
 158         } else { _br5 = MC2_branchUsesID(_rv0, 0, 2, true); MC2_merge(_br5);
 159          }
 160 }
 161
 162 static void a(void *obj)
 163 {
 164         int i;
 165         MC2_enterLoop();
 166         for(i=0;i<13;i++)
 167                 foo();
 168 MC2_exitLoop();
 169
 170 }
 171
 172 int user_main(int argc, char **argv)
 173 {
 174         thrd_t t1, t2;
 175         //, t3, t4;
 176         MC2_nextOpStoreOffset(_mmylock, MC2_OFFSET(rwlock_t, lock), MCID_NODEP);
 177         store_32(&mylock.lock, RW_LOCK_BIAS);
 178
 179         thrd_create(&t1, (thrd_start_t)&a, NULL);
 180         thrd_create(&t2, (thrd_start_t)&a, NULL);
 181         //      thrd_create(&t3, (thrd_start_t)&a, NULL);
 182         //      thrd_create(&t4, (thrd_start_t)&a, NULL);
 183
 184         thrd_join(t1);
 185         thrd_join(t2);
 186         //      thrd_join(t3);
 187         //      thrd_join(t4);
 188
 189         return 0;
 190 }