cdschecker_modified_benchmarks/dekker-fences/dekker-fences.cc

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