From: Andrea Parri <andrea.parri@amarulasolutions.com>
To: Daniel Lustig <dlustig@nvidia.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>,
Peter Zijlstra <peterz@infradead.org>,
Paul McKenney <paulmck@linux.vnet.ibm.com>,
Alan Stern <stern@rowland.harvard.edu>,
Will Deacon <will.deacon@arm.com>,
Akira Yokosawa <akiyks@gmail.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>,
Nick Piggin <npiggin@gmail.com>,
Linux Kernel Mailing List <linux-kernel@vger.kernel.org>
Subject: Re: [PATCH v2] tools/memory-model: Add extra ordering for locks and remove it for ordinary release/acquire
Date: Fri, 13 Jul 2018 11:07:11 +0200 [thread overview]
Message-ID: <20180713090637.GA10601@andrea> (raw)
In-Reply-To: <11b27d32-4a8a-3f84-0f25-723095ef1076@nvidia.com>
On Thu, Jul 12, 2018 at 07:05:39PM -0700, Daniel Lustig wrote:
> On 7/12/2018 11:10 AM, Linus Torvalds wrote:
> > On Thu, Jul 12, 2018 at 11:05 AM Peter Zijlstra <peterz@infradead.org> wrote:
> >>
> >> The locking pattern is fairly simple and shows where RCpc comes apart
> >> from expectation real nice.
> >
> > So who does RCpc right now for the unlock-lock sequence? Somebody
> > mentioned powerpc. Anybody else?
> >
> > How nasty would be be to make powerpc conform? I will always advocate
> > tighter locking and ordering rules over looser ones..
> >
> > Linus
>
> RISC-V probably would have been RCpc if we weren't having this discussion.
> Depending on how we map atomics/acquire/release/unlock/lock, we can end up
> producing RCpc, "RCtso" (feel free to find a better name here...), or RCsc
> behaviors, and we're trying to figure out which we actually need.
>
> I think the debate is this:
>
> Obviously programmers would prefer just to have RCsc and not have to figure out
> all the complexity of the other options. On x86 or architectures with native
> RCsc operations (like ARMv8), that's generally easy enough to get.
>
> For weakly-ordered architectures that use fences for ordering (including
> PowerPC and sometimes RISC-V, see below), though, it takes extra fences to go
> from RCpc to either "RCtso" or RCsc. People using these architectures are
> concerned about whether there's a negative performance impact from those extra
> fences.
>
> However, some scheduler code, some RCU code, and probably some other examples
> already implicitly or explicitly assume unlock()/lock() provides stronger
> ordering than RCpc. So, we have to decide whether to:
> 1) define unlock()/lock() to enforce "RCtso" or RCsc, insert more fences on
> PowerPC and RISC-V accordingly, and probably negatively regress PowerPC
> 2) leave unlock()/lock() as enforcing only RCpc, fix any code that currently
> assumes something stronger than RCpc is being provided, and hope people don't
> get it wrong in the future
> 3) some mixture like having unlock()/lock() be "RCtso" but smp_store_release()/
> smp_cond_load_acquire() be only RCpc
>
> Also, FWIW, if other weakly-ordered architectures come along in the future and
> also use any kind of lightweight fence rather than native RCsc operations,
> they'll likely be in the same boat as RISC-V and Power here, in the sense of
> not providing RCsc by default either.
>
> Is that a fair assessment everyone?
It's for me, thank you! And as we've seen, there are arguments for each of
the above three choices. I'm afraid that (despite Linus's statement ;-)),
my preference would currently go to (2).
>
>
>
> I can also not-so-briefly summarize RISC-V's status here, since I think there's
> been a bunch of confusion about where we're coming from:
>
> First of all, I promise we're not trying to start a fight about all this :)
> We're trying to understand the LKMM requirements so we know what instructions
> to use.
>
> With that, the easy case: RISC-V is RCsc if we use AMOs or load-reserved/
> store-conditional, all of which have RCsc .aq and .rl bits:
>
> (a) ...
> amoswap.w.rl x0, x0, [lock] // unlock()
> ...
> loop:
> amoswap.w.aq a0, t1, [lock] // lock()
> bnez a0, loop // lock()
> (b) ...
>
> (a) is ordered before (b) here, regardless of (a) and (b). Likewise for our
> load-reserved/store-conditional instructions, which also have .aq and rl.
> That's similiar to how ARM behaves, and is no problem. We're happy with that
> too.
>
> Unfortunately, we don't (currently?) have plain load-acquire or store-release
> opcodes in the ISA. (That's a different discussion...) For those, we need
> fences instead. And that's where it gets messier.
>
> RISC-V *would* end up providing only RCpc if we use what I'd argue is the most
> "natural" fence-based mapping for store-release operations, and then pair that
> with LR/SC:
>
> (a) ...
> fence rw,w // unlock()
> sw x0, [lock] // unlock()
> ...
> loop:
> lr.w.aq a0, [lock] // lock()
> sc.w t1, [lock] // lock()
> bnez loop // lock()
> (b) ...
>
> However, if (a) and (b) are loads to different addresses, then (a) is not
> ordered before (b) here. One unpaired RCsc operation is not a full fence.
> Clearly "fence rw,w" is not sufficient if the scheduler, RCU, and elsewhere
> depend on "RCtso" or RCsc.
>
> RISC-V can get back to "RCtso", matching PowerPC, by using a stronger fence:
Or by using a "fence r,rw" in the lock() (without the .aq), as current code
does ;-) though I'm not sure how the current solution would compare to the
.tso mapping...
Andrea
>
> (a) ...
> fence.tso // unlock(), fence.tso == fence rw,w + fence r,r
> sw x0, [lock] // unlock()
> ...
> loop:
> lr.w.aq a0, [lock] // lock()
> sc.w t1, [lock] // lock()
> bnez loop // lock()
> (b) ...
>
> (a) is ordered before (b), unless (a) is a store and (b) is a load to a
> different address.
>
> (Modeling note: this example is why I asked for Alan's v3 patch over the v2
> patch, which I believe would only have worked if the fence.tso were at the end)
>
> To get full RCsc here, we'd need a fence rw,rw in between the unlock store and
> the lock load, much like PowerPC would I believe need a heavyweight sync:
>
> (a) ...
> fence rw,w // unlock()
> sw x0, [lock] // unlock()
> ...
> fence rw,rw // can attach either to lock() or to unlock()
> ...
> loop:
> lr.w.aq a0, [lock] // lock()
> sc.w t1, [lock] // lock()
> bnez loop // lock()
> (b) ...
>
> In general, RISC-V's fence.tso will suffice wherever PowerPC's lwsync does, and
> RISC-V's fence rw,rw will suffice wherever PowerPC's full sync does. If anyone
> is claiming RISC-V is suddenly proposing to go weaker than all the other major
> architectures, that's a mischaracterization.
>
> All in all: if LKMM wants RCsc, we can do it, but it's not free for RISC-V (or
> Power). If LKMM wants RCtso, we can do that too, and that's in between. If
> LKMM wants RCpc, we can do that, and it's the fastest of the bunch. No I don't
> have concrete numbers either... And RISC-V implementations are going to vary
> pretty widely anyway.
>
> Hope that helps. Please correct anything I screwed up or mischaracterized.
>
> Dan
next prev parent reply other threads:[~2018-07-13 9:07 UTC|newest]
Thread overview: 84+ messages / expand[flat|nested] mbox.gz Atom feed top
2018-07-09 20:01 [PATCH v2] tools/memory-model: Add extra ordering for locks and remove it for ordinary release/acquire Alan Stern
2018-07-09 21:45 ` Paul E. McKenney
2018-07-10 13:57 ` Alan Stern
2018-07-10 16:25 ` Paul E. McKenney
[not found] ` <Pine.LNX.4.44L0.1807101416390.1449-100000@iolanthe.rowland.org>
2018-07-10 19:58 ` [PATCH v3] " Paul E. McKenney
2018-07-10 20:24 ` Alan Stern
2018-07-10 20:31 ` Paul E. McKenney
2018-07-11 9:43 ` Will Deacon
2018-07-11 15:42 ` Paul E. McKenney
2018-07-11 16:17 ` Andrea Parri
2018-07-11 18:03 ` Paul E. McKenney
2018-07-11 16:34 ` Peter Zijlstra
2018-07-11 18:10 ` Paul E. McKenney
2018-07-10 9:38 ` [PATCH v2] " Andrea Parri
2018-07-10 14:48 ` Alan Stern
2018-07-10 15:24 ` Andrea Parri
2018-07-10 15:34 ` Alan Stern
2018-07-10 23:14 ` Andrea Parri
2018-07-11 9:43 ` Will Deacon
2018-07-11 12:34 ` Andrea Parri
2018-07-11 12:54 ` Andrea Parri
2018-07-11 15:57 ` Will Deacon
2018-07-11 16:28 ` Andrea Parri
2018-07-11 17:00 ` Peter Zijlstra
2018-07-11 17:50 ` Daniel Lustig
2018-07-12 8:34 ` Andrea Parri
2018-07-12 9:29 ` Peter Zijlstra
2018-07-12 7:40 ` Peter Zijlstra
2018-07-12 9:34 ` Peter Zijlstra
2018-07-12 9:45 ` Will Deacon
2018-07-13 2:17 ` Daniel Lustig
2018-07-12 11:52 ` Andrea Parri
2018-07-12 12:01 ` Andrea Parri
2018-07-12 12:11 ` Peter Zijlstra
2018-07-12 13:48 ` Peter Zijlstra
2018-07-12 16:19 ` Paul E. McKenney
2018-07-12 17:04 ` Alan Stern
2018-07-12 17:14 ` Will Deacon
2018-07-12 17:28 ` Paul E. McKenney
2018-07-12 18:05 ` Peter Zijlstra
2018-07-12 18:10 ` Linus Torvalds
2018-07-12 19:52 ` Andrea Parri
2018-07-12 20:24 ` Andrea Parri
2018-07-13 2:05 ` Daniel Lustig
2018-07-13 4:03 ` Paul E. McKenney
2018-07-13 9:07 ` Andrea Parri [this message]
2018-07-13 9:35 ` Will Deacon
2018-07-13 17:16 ` Linus Torvalds
2018-07-13 19:06 ` Andrea Parri
2018-07-14 1:51 ` Alan Stern
2018-07-14 2:58 ` Linus Torvalds
2018-07-16 2:31 ` Paul E. McKenney
2018-07-13 11:08 ` Peter Zijlstra
2018-07-13 13:15 ` Michael Ellerman
2018-07-13 16:42 ` Peter Zijlstra
2018-07-13 19:56 ` Andrea Parri
2018-07-16 14:40 ` Michael Ellerman
2018-07-16 19:01 ` Peter Zijlstra
2018-07-16 19:30 ` Linus Torvalds
2018-07-17 14:45 ` Michael Ellerman
2018-07-17 16:19 ` Linus Torvalds
2018-07-17 18:33 ` Paul E. McKenney
2018-07-17 18:42 ` Peter Zijlstra
2018-07-17 19:40 ` Paul E. McKenney
2018-07-17 19:47 ` Alan Stern
2018-07-17 18:44 ` Linus Torvalds
2018-07-17 18:49 ` Linus Torvalds
2018-07-17 19:42 ` Paul E. McKenney
2018-07-17 19:37 ` Alan Stern
2018-07-17 20:13 ` Linus Torvalds
2018-07-17 19:38 ` Paul E. McKenney
2018-07-17 19:40 ` Andrea Parri
2018-07-17 19:52 ` Paul E. McKenney
2018-07-18 12:31 ` Michael Ellerman
2018-07-18 13:16 ` Michael Ellerman
2018-07-12 17:52 ` Andrea Parri
2018-07-12 20:43 ` Alan Stern
2018-07-12 21:13 ` Andrea Parri
2018-07-12 21:23 ` Andrea Parri
2018-07-12 18:33 ` Peter Zijlstra
2018-07-12 17:45 ` Andrea Parri
2018-07-10 16:56 ` Daniel Lustig
[not found] ` <Pine.LNX.4.44L0.1807101315140.1449-100000@iolanthe.rowland.org>
2018-07-10 23:31 ` Andrea Parri
2018-07-11 14:19 ` 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=20180713090637.GA10601@andrea \
--to=andrea.parri@amarulasolutions.com \
--cc=akiyks@gmail.com \
--cc=boqun.feng@gmail.com \
--cc=dhowells@redhat.com \
--cc=dlustig@nvidia.com \
--cc=j.alglave@ucl.ac.uk \
--cc=linux-kernel@vger.kernel.org \
--cc=luc.maranget@inria.fr \
--cc=npiggin@gmail.com \
--cc=paulmck@linux.vnet.ibm.com \
--cc=peterz@infradead.org \
--cc=stern@rowland.harvard.edu \
--cc=torvalds@linux-foundation.org \
--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).