tools/memory-model: Use "buf" and "flag" for message-passing tests

The use of "x" and "y" for message-passing tests is fine for people
familiar with memory models and litmus-test nomenclature, but is a bit
obtuse for others.  This commit therefore substitutes "buf" for "x" and
"flag" for "y" for the MP tests.  There are a few special-case MP tests
that use locks and these are unchanged.  There is another MP test that
uses pointers, and this is changed to name the pointer "p".

Reported-by: Johannes Weiner <hannes@cmpxchg.org>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>

diff --git a/tools/memory-model/litmus-tests/MP+fencewmbonceonce+fencermbonceonce.litmus b/tools/memory-model/litmus-tests/MP+fencewmbonceonce+fencermbonceonce.litmus
index e04b71b0ce2b0d403d43856eb9495bf45ad5117d..f15e501849dd57872f7b15009e21cf1560aabbcf 100644 (file)
--- a/tools/memory-model/litmus-tests/MP+fencewmbonceonce+fencermbonceonce.litmus
+++ b/tools/memory-model/litmus-tests/MP+fencewmbonceonce+fencermbonceonce.litmus
@@ -9,25 +9,25 @@ C MP+fencewmbonceonce+fencermbonceonce
  *)
 
 {
-       int x;
-       int y;
+       int buf;
+       int flag;
 }
 
-P0(int *x, int *y)
+P0(int *buf, int *flag)
 {
-       WRITE_ONCE(*x, 1);
+       WRITE_ONCE(*buf, 1);
        smp_wmb();
-       WRITE_ONCE(*y, 1);
+       WRITE_ONCE(*flag, 1);
 }
 
-P1(int *x, int *y)
+P1(int *buf, int *flag)
 {
        int r0;
        int r1;
 
-       r0 = READ_ONCE(*y);
+       r0 = READ_ONCE(*flag);
        smp_rmb();
-       r1 = READ_ONCE(*x);
+       r1 = READ_ONCE(*buf);
 }
 
 exists (1:r0=1 /\ 1:r1=0)

diff --git a/tools/memory-model/litmus-tests/MP+onceassign+derefonce.litmus b/tools/memory-model/litmus-tests/MP+onceassign+derefonce.litmus
index 18df682b08b2c706c107788d0c7332ce0dc0d6d6..ed8ee9bde0c9879ac7153867b2ff86481177c33b 100644 (file)
--- a/tools/memory-model/litmus-tests/MP+onceassign+derefonce.litmus
+++ b/tools/memory-model/litmus-tests/MP+onceassign+derefonce.litmus
@@ -10,24 +10,24 @@ C MP+onceassign+derefonce
  *)
 
 {
+       int *p=y;
        int x;
-       int *y=z;
-       int z=0;
+       int y=0;
 }
 
-P0(int *x, int **y)
+P0(int *x, int **p)
 {
        WRITE_ONCE(*x, 1);
-       rcu_assign_pointer(*y, x);
+       rcu_assign_pointer(*p, x);
 }
 
-P1(int *x, int **y)
+P1(int *x, int **p)
 {
        int *r0;
        int r1;
 
        rcu_read_lock();
-       r0 = rcu_dereference(*y);
+       r0 = rcu_dereference(*p);
        r1 = READ_ONCE(*r0);
        rcu_read_unlock();
 }

diff --git a/tools/memory-model/litmus-tests/MP+polocks.litmus b/tools/memory-model/litmus-tests/MP+polocks.litmus
index 63e0f67c9b9d77407ac6056cf56c37ec5a900d34..4b0c2edcc029b488220137f81b988cbe04c55847 100644 (file)
--- a/tools/memory-model/litmus-tests/MP+polocks.litmus
+++ b/tools/memory-model/litmus-tests/MP+polocks.litmus
@@ -13,27 +13,27 @@ C MP+polocks
 
 {
        spinlock_t mylock;
-       int x;
-       int y;
+       int buf;
+       int flag;
 }
 
-P0(int *x, int *y, spinlock_t *mylock)
+P0(int *buf, int *flag, spinlock_t *mylock)
 {
-       WRITE_ONCE(*x, 1);
+       WRITE_ONCE(*buf, 1);
        spin_lock(mylock);
-       WRITE_ONCE(*y, 1);
+       WRITE_ONCE(*flag, 1);
        spin_unlock(mylock);
 }
 
-P1(int *x, int *y, spinlock_t *mylock)
+P1(int *buf, int *flag, spinlock_t *mylock)
 {
        int r0;
        int r1;
 
        spin_lock(mylock);
-       r0 = READ_ONCE(*y);
+       r0 = READ_ONCE(*flag);
        spin_unlock(mylock);
-       r1 = READ_ONCE(*x);
+       r1 = READ_ONCE(*buf);
 }
 
 exists (1:r0=1 /\ 1:r1=0)

diff --git a/tools/memory-model/litmus-tests/MP+poonceonces.litmus b/tools/memory-model/litmus-tests/MP+poonceonces.litmus
index 68180a403e5c3bb15ceda79f3491342cc044c8eb..3010bbaec46c6b67e3f30feb1afe5d5ad4ee383b 100644 (file)
--- a/tools/memory-model/litmus-tests/MP+poonceonces.litmus
+++ b/tools/memory-model/litmus-tests/MP+poonceonces.litmus
@@ -8,23 +8,23 @@ C MP+poonceonces
  *)
 
 {
-       int x;
-       int y;
+       int buf;
+       int flag;
 }
 
-P0(int *x, int *y)
+P0(int *buf, int *flag)
 {
-       WRITE_ONCE(*x, 1);
-       WRITE_ONCE(*y, 1);
+       WRITE_ONCE(*buf, 1);
+       WRITE_ONCE(*flag, 1);
 }
 
-P1(int *x, int *y)
+P1(int *buf, int *flag)
 {
        int r0;
        int r1;
 
-       r0 = READ_ONCE(*y);
-       r1 = READ_ONCE(*x);
+       r0 = READ_ONCE(*flag);
+       r1 = READ_ONCE(*buf);
 }
 
 exists (1:r0=1 /\ 1:r1=0)

diff --git a/tools/memory-model/litmus-tests/MP+pooncerelease+poacquireonce.litmus b/tools/memory-model/litmus-tests/MP+pooncerelease+poacquireonce.litmus
index 19f3e6874b50e53f1e58f29558bf6ef161eef763..21e825d5dea6577213622ae66368cb1dc6c0714a 100644 (file)
--- a/tools/memory-model/litmus-tests/MP+pooncerelease+poacquireonce.litmus
+++ b/tools/memory-model/litmus-tests/MP+pooncerelease+poacquireonce.litmus
@@ -9,23 +9,23 @@ C MP+pooncerelease+poacquireonce
  *)
 
 {
-       int x;
-       int y;
+       int buf;
+       int flag;
 }
 
-P0(int *x, int *y)
+P0(int *buf, int *flag)
 {
-       WRITE_ONCE(*x, 1);
-       smp_store_release(y, 1);
+       WRITE_ONCE(*buf, 1);
+       smp_store_release(flag, 1);
 }
 
-P1(int *x, int *y)
+P1(int *buf, int *flag)
 {
        int r0;
        int r1;
 
-       r0 = smp_load_acquire(y);
-       r1 = READ_ONCE(*x);
+       r0 = smp_load_acquire(flag);
+       r1 = READ_ONCE(*buf);
 }
 
 exists (1:r0=1 /\ 1:r1=0)

diff --git a/tools/memory-model/litmus-tests/MP+porevlocks.litmus b/tools/memory-model/litmus-tests/MP+porevlocks.litmus
index 4ac189adf41ed7f8531700592c458afeddb01499..9691d55b4e21cbe2eae3f3c0fa57ba76b78de7a1 100644 (file)
--- a/tools/memory-model/litmus-tests/MP+porevlocks.litmus
+++ b/tools/memory-model/litmus-tests/MP+porevlocks.litmus
@@ -13,27 +13,27 @@ C MP+porevlocks
 
 {
        spinlock_t mylock;
-       int x;
-       int y;
+       int buf;
+       int flag;
 }
 
-P0(int *x, int *y, spinlock_t *mylock)
+P0(int *buf, int *flag, spinlock_t *mylock)
 {
        int r0;
        int r1;
 
-       r0 = READ_ONCE(*y);
+       r0 = READ_ONCE(*flag);
        spin_lock(mylock);
-       r1 = READ_ONCE(*x);
+       r1 = READ_ONCE(*buf);
        spin_unlock(mylock);
 }
 
-P1(int *x, int *y, spinlock_t *mylock)
+P1(int *buf, int *flag, spinlock_t *mylock)
 {
        spin_lock(mylock);
-       WRITE_ONCE(*x, 1);
+       WRITE_ONCE(*buf, 1);
        spin_unlock(mylock);
-       WRITE_ONCE(*y, 1);
+       WRITE_ONCE(*flag, 1);
 }
 
 exists (0:r0=1 /\ 0:r1=0)