Re: [WIP 0/3] Memory model and atomic API in Rust

[Boqun Feng]

On Fri, Mar 22, 2024 at 10:07:31PM -0400, Kent Overstreet wrote:
[...]
> > Boqun already mentioned the "mixing access sizes", which is actually
> > quite fundamental in the kernel, where we play lots of games with that
> > (typically around locking, where you find patterns line unlock writing
> > a zero to a single byte, even though the whole lock data structure is
> > a word). And sometimes the access size games are very explicit (eg
> > lib/lockref.c).
> 
> I don't think mixing access sizes should be a real barrier. On the read

Well, it actually is, since mixing access sizes is, guess what,
an undefined behavior:

(example in https://doc.rust-lang.org/std/sync/atomic/#memory-model-for-atomic-accesses)

	thread::scope(|s| {
	    // This is UB: using different-sized atomic accesses to the same data
	    s.spawn(|| atomic.store(1, Ordering::Relaxed));
	    s.spawn(|| unsafe {
		let differently_sized = transmute::<&AtomicU16, &AtomicU8>(&atomic);
		differently_sized.store(2, Ordering::Relaxed);
	    });
	});

Of course, you can say "I will just ignore the UB", but if you have to
ignore "compiler rules" to make your code work, why bother use compiler
builtin in the first place? Being UB means they are NOT guaranteed to
work.

> side we can obviously do that with a helper; the write side needs
> compiler help, but "writing just a byte out of a word" is no different
> from a compiler POV that "write a single bit", and we can already mix
> atomic_or() with atomic_add(), with both C atomics and LKMM atomics.
> 

I totally agree with your reasoning here, but maybe the standard doesn't
;-)

Regards,
Boqun