dekker-fences/dekker-fences-wildcard-backup.cc

   1 /*
   2  * Dekker's critical section algorithm, implemented with fences.
   3  *
   4  * URL:
   5  *   http://www.justsoftwaresolutions.co.uk/threading/
   6  */
   7
   8 #include <atomic>
   9 #include <threads.h>
  10
  11 #include "librace.h"
  12 #include "wildcard.h"
  13
  14 std::atomic<bool> flag0, flag1;
  15 std::atomic<int> turn;
  16
  17 //uint32_t var = 0;
  18 std::atomic_int var;
  19
  20 void p0(void *arg)
  21 {
  22         flag0.store(true, wildcard(1));
  23         std::atomic_thread_fence(wildcard(2)); // seq_cst
  24
  25         while (flag1.load(wildcard(3)))
  26         {
  27                 if (turn.load(wildcard(4)) != 0)
  28                 {
  29                         flag0.store(false, wildcard(5));
  30                         while (turn.load(wildcard(6)) != 0)
  31                         {
  32                                 thrd_yield();
  33                         }
  34                         flag0.store(true, wildcard(7));
  35                         std::atomic_thread_fence(wildcard(8)); // seq_cst
  36                 } else
  37                         thrd_yield();
  38         }
  39         std::atomic_thread_fence(wildcard(9)); // acquire
  40
  41         // critical section
  42         //store_32(&var, 1);
  43         var.store(1, std::memory_order_relaxed);
  44
  45         turn.store(1, wildcard(10));
  46         std::atomic_thread_fence(wildcard(11)); // release
  47         flag0.store(false, wildcard(12));
  48 }
  49
  50 void p1(void *arg)
  51 {
  52         flag1.store(true, wildcard(13));
  53         std::atomic_thread_fence(wildcard(14)); // seq_cst
  54
  55         while (flag0.load(wildcard(15)))
  56         {
  57                 if (turn.load(wildcard(16)) != 1)
  58                 {
  59                         flag1.store(false, wildcard(17));
  60                         while (turn.load(wildcard(18)) != 1)
  61                         {
  62                                 thrd_yield();
  63                         }
  64                         flag1.store(true, wildcard(19));
  65                         std::atomic_thread_fence(wildcard(20)); // seq_cst
  66                 } else
  67                         thrd_yield();
  68         }
  69         std::atomic_thread_fence(wildcard(21)); // acquire
  70
  71         // critical section
  72         //store_32(&var, 2);
  73         var.store(2, std::memory_order_relaxed);
  74
  75         turn.store(0, wildcard(22));
  76         std::atomic_thread_fence(wildcard(23)); // release
  77         flag1.store(false, wildcard(24));
  78 }
  79
  80 int user_main(int argc, char **argv)
  81 {
  82         thrd_t a, b;
  83
  84         flag0 = false;
  85         flag1 = false;
  86         turn = 0;
  87         atomic_init(&var, 0);
  88
  89         thrd_create(&a, p0, NULL);
  90         thrd_create(&b, p1, NULL);
  91
  92         thrd_join(a);
  93         thrd_join(b);
  94
  95         return 0;
  96 }