Le 21/11/2019 à 23:08, David Young a écrit :
On Thu, Nov 21, 2019 at 07:19:51PM +0100, Maxime Villard wrote:
Le 18/11/2019 à 19:49, David Holland a écrit :
On Sun, Nov 17, 2019 at 02:35:43PM +, Mindaugas Rasiukevicius wrote:
> David Holland wrote:
> > > I see the potential source of confusion, but just think about: what
> > > could "atomic" possibly mean for loads or stores? A load is just a
> > > load, there is no RMW cycle, conceptually; inter-locking the operation
> > > does not make sense. For anybody who attempts to reason about this,
> > > it should not be too confusing, plus there are man pages.
> >
> > ...that it's not torn.
> >
> > As far as names... there are increasingly many slightly different
> > types of atomic and semiatomic operations.
> >
> > I think it would be helpful if someone came up with a comprehensive
> > naming scheme for all of them (including ones we don't currently have
> > that we're moderately likely to end up with later...)
>
> Yes, the meaning of "atomic" has different flavours and describes different
> set of properties in different fields (operating systems vs databases vs
> distributed systems vs ...) and, as we can see, even within the fields.
>
> Perhaps not ideal, but "atomic loads/stores" and "relaxed" are already the
> dominant terms.
Yes, but "relaxed" means something else... let me be clearer since I
wasn't before: I would expect e.g. atomic_inc_32_relaxed() to be
distinguished from atomic_inc_32() or maybe atomic_inc_32_ordered() by
whether or not multiple instances of it are globally ordered, not by
whether or not it's actually atomic relative to other cpus.
Checking the prior messages indicates we aren't currently talking
about atomic_inc_32_relaxed() but only about atomic_load_32_relaxed()
and atomic_store_32_relaxed(), which would be used together to
generate a local counter. This is less misleading, but I'm still not
convinced it's a good choice of names given that we might reasonably
later on want to have atomic_inc_32_relaxed() and
atomic_inc_32_ordered() that differ as above.
> I think it is pointless to attempt to reinvent the wheel
> here. It is terminology used by C11 (and C++11) and accepted by various
> technical literature and, at this point, by academia (if you look at the
> recent papers on memory models -- it's pretty much settled). These terms
> are not too bad; it could be worse; and this bit is certainly not the worst
> part of C11. So, I would just move on.
Is it settled? My experience with the academic literature has been
that everyone uses their own terminology and the same words are
routinely found to have subtly different meanings from one paper to
the next and occasionally even within the same paper. :-/ But I
haven't been paying much attention lately due to being preoccupied
with other things.
So in the end which name do we use? Are people really unhappy with _racy()?
At least it has a general meaning, and does not imply atomicity or ordering.
_racy() doesn't really get at the intended meaning, and everything in
C11 is racy unless you arrange otherwise by using mutexes, atomics, etc.
The suffix has very little content.
Names such as load_/store_fully() or load_/store_entire() or
load_/store_completely() get to the actual semantics: at the program
step implied by the load_/store_entire() expression, the memory
constituting the named variable is loaded/stored in its entirety. In
other words, the load cannot be drawn out over more than one local
program step. Whether or not the load/store is performed in one step
with respect to interrupts or other threads is not defined.
Sounds like the right definition of the semantic. However:
I feel like load_entire() and store_entire() get to the heart of the
matter while being easy to speak, but _fully() or _completely() seem
fine.
I'm not a really big fan of _entire(), because it gives the impression that
the load/store is not entire otherwise - which it is, but just possibly not
in one step.
How about _onestep()? Or _nosplit()?
