benchmarks/satcheck-precompiled/dekker/dekker-fences_unannotated.c

   1 /*
   2  * Dekker's critical section algorithm, implemented with fences.
   3  * Translated to C by Patrick Lam <prof.lam@gmail.com>
   4  *
   5  * URL:
   6  *   http://www.justsoftwaresolutions.co.uk/threading/
   7  */
   8
   9 #include <threads.h>
  10 #include <stdbool.h>
  11 #include "libinterface.h"
  12
  13 /* atomic */ int flag0, flag1;
  14 /* atomic */ int turn;
  15
  16 #define true 1
  17 #define false 0
  18 #define NULL 0
  19
  20 /* uint32_t */ int var = 0;
  21
  22 void p0() {
  23         store_32(&flag0, true);
  24         // std::atomic_thread_fence(std::memory_order_seq_cst);
  25
  26         int f1, t;
  27         while (true)
  28         {
  29                 f1 = load_32(&flag1);
  30                 if (!f1) {
  31                         break;
  32                 }
  33
  34
  35                 t = load_32(&turn);
  36
  37                 if (t) {
  38                         store_32(&flag0, false);
  39                         while(1) {
  40                                 t = load_32(&turn);
  41                                 if (!t) {
  42                                         break;
  43                                 }
  44
  45                                 MC2_yield();
  46                         }
  47
  48                         store_32(&flag0, true);
  49                 } else {
  50                         MC2_yield();
  51                 }
  52         }
  53
  54         // std::atomic_thread_fence(std::memory_order_acquire);
  55
  56         // critical section
  57         store_32(&var, 1);
  58
  59         store_32(&turn, 1);
  60         // std::atomic_thread_fence(std::memory_order_release);
  61         store_32(&flag0, false);
  62 }
  63
  64 void p1() {
  65         store_32(&flag1, true);
  66         // std::atomic_thread_fence(std::memory_order_seq_cst);
  67
  68         int f0, t;
  69         while (true) {
  70                 int f0 = load_32(&flag0);
  71                 if (!f0) {
  72                         break;
  73                 }
  74
  75                 t = load_32(&turn);
  76
  77                 if (!t) {
  78                         store_32(&flag1, false);
  79                         while (1) {
  80                                 t = load_32(&turn);
  81                                 if (t)
  82                                         break;
  83                                 MC2_yield();
  84                         }
  85
  86                         store_32(&flag1, true);
  87                         // std::atomic_thread_fence(std::memory_order_seq_cst);
  88                 } else {
  89                         MC2_yield();
  90                 }
  91         }
  92
  93         // std::atomic_thread_fence(std::memory_order_acquire);
  94
  95         // critical section
  96         store_32(&var, 2);
  97
  98         store_32(&turn, 0);
  99         // std::atomic_thread_fence(std::memory_order_release);
 100         store_32(&flag1, false);
 101 }
 102
 103 void p0l(void *a) {
 104         int i;
 105         for(i=0;i<PROBLEMSIZE;i++) {
 106                 p0();
 107         }
 108 }
 109
 110
 111 void p1l(void *a) {
 112         int i;
 113         for(i=0;i<PROBLEMSIZE;i++) {
 114                 p1();
 115         }
 116 }
 117
 118
 119 int user_main(int argc, char **argv)
 120 {
 121         thrd_t a, b;
 122
 123         store_32(&flag0, false);
 124
 125         store_32(&flag1, false);
 126
 127         store_32(&turn, 0);
 128
 129         thrd_create(&a, p0l, NULL);
 130         thrd_create(&b, p1l, NULL);
 131
 132         thrd_join(a);
 133         thrd_join(b);
 134
 135         return 0;
 136 }