Fix all benchmarks to use yield

All benchmarks now call thrd_yield when appropriate so that they terminate with the -y option.

diff --git a/barrier/barrier.h b/barrier/barrier.h
index 6970816eabf19f620f6e4f578091e92982468268..dd5d39c0c7d9f56f112a35bb2c7befed1e23cdd9 100644 (file)
--- a/barrier/barrier.h
+++ b/barrier/barrier.h
@@ -18,7 +18,7 @@ class spinning_barrier {
                } else {
                        /* Run in circles and scream like a little girl.  */
                        while (step_.load () == step)
-                               ;
+                               thrd_yield();
                        return false;
                }
        }

diff --git a/bench.sh b/bench.sh
index c32924b8b68080a13ac39739d944a54e0571ac2d..94d041fb401f6174a3e9d6dde47cda1a130c0510 100755 (executable)
--- a/bench.sh
+++ b/bench.sh
@@ -26,7 +26,7 @@ TESTS+=" mpmc-queue/mpmc-1r2w-noinit"
 TESTS+=" mpmc-queue/mpmc-queue-noinit"
 TESTS+=" linuxrwlocks/linuxrwlocks"
 
-MODEL_ARGS="-f 10 -m 2 -e 1"
+MODEL_ARGS="-y -m 2"
 COUNT=0
 
 function run_test {

diff --git a/dekker-fences/dekker-fences.cc b/dekker-fences/dekker-fences.cc
index 81f609846cd2a8777a707ba12eedec38a9534068..eb38d5cc25cde22870e1597dc436e3dc21272234 100644 (file)
--- a/dekker-fences/dekker-fences.cc
+++ b/dekker-fences/dekker-fences.cc
@@ -27,10 +27,12 @@ void p0(void *arg)
                        flag0.store(false,std::memory_order_relaxed);
                        while (turn.load(std::memory_order_relaxed) != 0)
                        {
+                               thrd_yield();
                        }
                        flag0.store(true,std::memory_order_relaxed);
                        std::atomic_thread_fence(std::memory_order_seq_cst);
-               }
+               } else
+                       thrd_yield();
        }
        std::atomic_thread_fence(std::memory_order_acquire);
 
@@ -54,10 +56,12 @@ void p1(void *arg)
                        flag1.store(false,std::memory_order_relaxed);
                        while (turn.load(std::memory_order_relaxed) != 1)
                        {
+                               thrd_yield();
                        }
                        flag1.store(true,std::memory_order_relaxed);
                        std::atomic_thread_fence(std::memory_order_seq_cst);
-               }
+               } else
+                       thrd_yield();
        }
        std::atomic_thread_fence(std::memory_order_acquire);
 

diff --git a/linuxrwlocks/linuxrwlocks.c b/linuxrwlocks/linuxrwlocks.c
index 7e317aa9fcf019b91336823985d5054c9b23166d..be3550e11e3c8f8740b4c1a47458180f57994a3a 100644 (file)
--- a/linuxrwlocks/linuxrwlocks.c
+++ b/linuxrwlocks/linuxrwlocks.c
@@ -29,9 +29,9 @@ static inline void read_lock(rwlock_t *rw)
        int priorvalue = atomic_fetch_sub_explicit(&rw->lock, 1, memory_order_acquire);
        while (priorvalue <= 0) {
                atomic_fetch_add_explicit(&rw->lock, 1, memory_order_relaxed);
-               do {
-                       priorvalue = atomic_load_explicit(&rw->lock, memory_order_relaxed);
-               } while (priorvalue <= 0);
+               while (atomic_load_explicit(&rw->lock, memory_order_relaxed) <= 0) {
+                       thrd_yield();
+               }
                priorvalue = atomic_fetch_sub_explicit(&rw->lock, 1, memory_order_acquire);
        }
 }
@@ -41,9 +41,9 @@ static inline void write_lock(rwlock_t *rw)
        int priorvalue = atomic_fetch_sub_explicit(&rw->lock, RW_LOCK_BIAS, memory_order_acquire);
        while (priorvalue != RW_LOCK_BIAS) {
                atomic_fetch_add_explicit(&rw->lock, RW_LOCK_BIAS, memory_order_relaxed);
-               do {
-                       priorvalue = atomic_load_explicit(&rw->lock, memory_order_relaxed);
-               } while (priorvalue != RW_LOCK_BIAS);
+               while (atomic_load_explicit(&rw->lock, memory_order_relaxed) != RW_LOCK_BIAS) {
+                       thrd_yield();
+               }
                priorvalue = atomic_fetch_sub_explicit(&rw->lock, RW_LOCK_BIAS, memory_order_acquire);
        }
 }

diff --git a/mcs-lock/mcs-lock.h b/mcs-lock/mcs-lock.h
index 2d39f2f6cab8d2aa5b10f5cd6e1b9092a818955e..4b808f7c3c9b9bbc7effe6b4e6c570f2712e5232 100644 (file)
--- a/mcs-lock/mcs-lock.h
+++ b/mcs-lock/mcs-lock.h
@@ -57,7 +57,7 @@ public:
                        // wait on predecessor setting my flag -
                        rl::linear_backoff bo;
                        while ( me->gate.load(std::mo_acquire) ) {
-                               bo.yield();
+                               thrd_yield();
                        }
                }
        }
@@ -80,7 +80,7 @@ public:
                                next = me->next.load(std::mo_acquire);
                                if ( next != NULL )
                                        break;
-                               bo.yield();
+                               thrd_yield();
                        }
                }
 

diff --git a/mpmc-queue/mpmc-queue.h b/mpmc-queue/mpmc-queue.h
index f73ab992e0b1fcfbbf962b067c204cdb75b9578f..dc2b5618771774238c1c16f97efa87262da182a4 100644 (file)
--- a/mpmc-queue/mpmc-queue.h
+++ b/mpmc-queue/mpmc-queue.h
@@ -43,7 +43,7 @@ public:
                // (*1)
                rl::backoff bo;
                while ( (m_written.load(mo_acquire) & 0xFFFF) != wr ) {
-                       bo.yield();
+                       thrd_yield();
                }
 
                t_element * p = & ( m_array[ rd % t_size ] );
@@ -74,7 +74,7 @@ public:
                // (*1)
                rl::backoff bo;
                while ( (m_read.load(mo_acquire) & 0xFFFF) != rd ) {
-                       bo.yield();
+                       thrd_yield();
                }
 
                t_element * p = & ( m_array[ wr % t_size ] );