linux-kernel.vger.kernel.org archive mirror
 help / color / mirror / Atom feed
From: "Paul E. McKenney" <paulmck@linux.vnet.ibm.com>
To: Peter Zijlstra <peterz@infradead.org>
Cc: Will Deacon <will.deacon@arm.com>,
	Alan Stern <stern@rowland.harvard.edu>,
	LKMM Maintainers -- Akira Yokosawa <akiyks@gmail.com>,
	Andrea Parri <andrea.parri@amarulasolutions.com>,
	Boqun Feng <boqun.feng@gmail.com>,
	David Howells <dhowells@redhat.com>,
	Jade Alglave <j.alglave@ucl.ac.uk>,
	Luc Maranget <luc.maranget@inria.fr>,
	Nicholas Piggin <npiggin@gmail.com>,
	Kernel development list <linux-kernel@vger.kernel.org>
Subject: Re: [PATCH 2/2] tools/memory-model: Add write ordering by release-acquire and by locks
Date: Fri, 22 Jun 2018 09:40:48 -0700	[thread overview]
Message-ID: <20180622164048.GR3593@linux.vnet.ibm.com> (raw)
In-Reply-To: <20180622103129.GQ2476@hirez.programming.kicks-ass.net>

On Fri, Jun 22, 2018 at 12:31:29PM +0200, Peter Zijlstra wrote:
> On Fri, Jun 22, 2018 at 10:55:47AM +0100, Will Deacon wrote:
> > On Fri, Jun 22, 2018 at 09:09:28AM +0100, Will Deacon wrote:
> > > On Thu, Jun 21, 2018 at 01:27:12PM -0400, Alan Stern wrote:
> > > > More than one kernel developer has expressed the opinion that the LKMM
> > > > should enforce ordering of writes by release-acquire chains and by
> > > > locking.  In other words, given the following code:
> > > > 
> > > > 	WRITE_ONCE(x, 1);
> > > > 	spin_unlock(&s):
> > > > 	spin_lock(&s);
> > > > 	WRITE_ONCE(y, 1);
> 
> So this is the one I'm relying on and really want sorted.
> 
> > > > or the following:
> > > > 
> > > > 	smp_store_release(&x, 1);
> > > > 	r1 = smp_load_acquire(&x);	// r1 = 1
> > > > 	WRITE_ONCE(y, 1);
> 
> Reading back some of the old threads [1], it seems the direct
> translation of the first into acquire-release would be:
> 
> 	WRITE_ONCE(x, 1);
> 	smp_store_release(&s, 1);
> 	r1 = smp_load_acquire(&s);
> 	WRITE_ONCE(y, 1);
> 
> Which is I think easier to make happen than the second example you give.
> 
> > > > the stores to x and y should be propagated in order to all other CPUs,
> > > > even though those other CPUs might not access the lock s or be part of
> > > > the release-acquire chain.  In terms of the memory model, this means
> > > > that rel-rf-acq-po should be part of the cumul-fence relation.
> > > > 
> > > > All the architectures supported by the Linux kernel (including RISC-V)
> > > > do behave this way, albeit for varying reasons.  Therefore this patch
> > > > changes the model in accordance with the developers' wishes.
> > > 
> > > Interesting...
> > > 
> > > I think the second example would preclude us using LDAPR for load-acquire,
> > > so I'm surprised that RISC-V is ok with this. For example, the first test
> > > below is allowed on arm64.
> > > 
> > > I also think this would break if we used DMB LD to implement load-acquire
> > > (second test below).
> > > 
> > > So I'm not a big fan of this change, and I'm surprised this works on all
> > > architectures. What's the justification?
> > 
> > I also just realised that this prevents Power from using ctrl+isync to
> > implement acquire, should they wish to do so.
> 
> They in fact do so on chips lacking LWSYNC, see how PPC_ACQUIRE_BARRIER
> (as used by atomic_*_acquire) turns into ISYNC (note however that they
> do not use PPC_ACQUIRE_BARRIER for smp_load_acquire -- because there's
> no CTRL there).

PowerPC -could- use a load-compare-branch-isync sequence to implement
smp_load_acquire(), but as you say it instead uses lwsync, falling
back to sync on CPUs not implementing lwsync.

Locking should work either way because even if lock acquisition uses isync
(leveraging the fact that the "stcwx." instruction affects condition
codes and branches back when someone else already holds the lock),
lock release still uses lwsync (or sync on systems not having lwsync).

							Thanx, Paul

> [1] https://lkml.kernel.org/r/20171128095850.rhtnx6e2qxep5npa@hirez.programming.kicks-ass.net
> 


  parent reply	other threads:[~2018-06-22 16:38 UTC|newest]

Thread overview: 55+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2018-06-21 17:27 [PATCH 2/2] tools/memory-model: Add write ordering by release-acquire and by locks Alan Stern
2018-06-21 18:04 ` Peter Zijlstra
2018-06-22  3:34   ` Paul E. McKenney
2018-06-22  8:08     ` Peter Zijlstra
2018-06-22  8:09 ` Will Deacon
2018-06-22  9:55   ` Will Deacon
2018-06-22 10:31     ` Peter Zijlstra
2018-06-22 10:38       ` Will Deacon
2018-06-22 11:25         ` Andrea Parri
2018-06-22 16:40       ` Paul E. McKenney [this message]
2018-06-22 18:09   ` Alan Stern
2018-06-22 18:30     ` Will Deacon
2018-06-22 19:11       ` Alan Stern
2018-06-22 20:53         ` Paul E. McKenney
2018-07-04 11:53         ` Will Deacon
2018-06-25  8:19       ` Andrea Parri
2018-07-03 17:28         ` Alan Stern
2018-07-04 11:28           ` Paul E. McKenney
2018-07-04 12:13             ` Will Deacon
2018-07-05 14:23               ` Alan Stern
2018-07-05 15:31                 ` Paul E. McKenney
2018-07-04 12:11           ` Will Deacon
2018-07-05 14:00             ` Andrea Parri
2018-07-05 14:44               ` Will Deacon
2018-07-05 15:16                 ` Daniel Lustig
2018-07-05 15:35                   ` Daniel Lustig
2018-07-05 14:21             ` Alan Stern
2018-07-05 14:46               ` Will Deacon
2018-07-05 14:57                 ` Alan Stern
2018-07-05 15:15                   ` Will Deacon
2018-07-05 15:09               ` Andrea Parri
2018-07-06 20:37                 ` Alan Stern
2018-07-06 21:10                   ` Paul E. McKenney
2018-07-09 16:52                     ` Will Deacon
2018-07-09 17:29                       ` Daniel Lustig
2018-07-09 19:18                         ` Alan Stern
2018-07-05 15:31               ` Paul E. McKenney
2018-07-05 15:39                 ` Andrea Parri
2018-07-05 16:58                   ` Paul E. McKenney
2018-07-05 17:06                     ` Andrea Parri
2018-07-05 15:44                 ` Daniel Lustig
2018-07-05 16:22                   ` Will Deacon
2018-07-05 16:56                     ` Paul E. McKenney
2018-07-05 18:12                       ` Daniel Lustig
2018-07-05 18:38                         ` Andrea Parri
2018-07-05 18:44                           ` Andrea Parri
2018-07-05 23:32                             ` Paul E. McKenney
2018-07-05 23:31                           ` Paul E. McKenney
2018-07-06  9:25                       ` Will Deacon
2018-07-06 14:14                         ` Paul E. McKenney
2018-06-25  7:32     ` Peter Zijlstra
2018-06-25  8:29       ` Andrea Parri
2018-06-25  9:06         ` Peter Zijlstra
2018-06-22  9:06 ` Andrea Parri
2018-06-22 19:23   ` Alan Stern

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20180622164048.GR3593@linux.vnet.ibm.com \
    --to=paulmck@linux.vnet.ibm.com \
    --cc=akiyks@gmail.com \
    --cc=andrea.parri@amarulasolutions.com \
    --cc=boqun.feng@gmail.com \
    --cc=dhowells@redhat.com \
    --cc=j.alglave@ucl.ac.uk \
    --cc=linux-kernel@vger.kernel.org \
    --cc=luc.maranget@inria.fr \
    --cc=npiggin@gmail.com \
    --cc=peterz@infradead.org \
    --cc=stern@rowland.harvard.edu \
    --cc=will.deacon@arm.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).