Re: Is Alpha non-other-multicopy atomic?

[Akira Yokosawa <akiyks@gmail.com>]

[+Cc: Paul]

Hello,

I reflowed your message quoted below so that it fits 78 char width.

On Fri, 28 Feb 2025 18:31:02 +0100, Ignacio Encinas Rubio wrote:
> Hello!
> 
> I recently looked at memory consistency models with a particular focus
> on hardware details and found this book to be great, but I was left
> wondering about something regarding Alpha's memory model. 
> 
> I tried to find previous discussions about this but didn't find
> anything, so I'll go ahead:
> 
> Table 15.5: Summary of Memory Ordering states that Alpha is *NOT*
> Other-Multicopy Atomic but I couldn't find the explanation for this.
> Other sources contradict this statement [1] [2].
> [3] Documents ARM's adoption of other-multicopy atomicity, using POWER
> as an example of non-other-multicopy-atomicity but fails to mention Alpha.
> 
> Furthermore, [2] models non-other-multicopy-atomicity by having "Read
> from external" (rfe) not impose ordering. Alpha's reference manual [3]
> Section 5.6.1.5 states 
> 
>   If u is a write access Pi:W<m>(x,a) and v is an overlapping read
> access Pj:R<n>(y,b), u is visible to v only if:
>     - u <- v, or
>     - u precedes v in processor issue sequence (possible only if Pi=Pjn).

As is well known, Alpha is infamous of its lack of address-dependency
guarantees.  I don't see much point in discussing whether it is multicopy
atomic or not.

That said, here is a naive litmus test on Non multicopy atomicity:

---------------------------------------------------------------------
C NMCA

(* Demonstrate no-ordering of non-multicopy atomicity
 * Result: Sometimes -- Non-multicopy atomic platforms
                            (LKMM, Armv7, POWER, etc.)
           Never     -- Other-multicopy atomic platforms (e.g., x86, Armv8)
                     -- Full-multicopy atomic platform (s390)
 *)

{}

P0(int *x, int *y)
{
	int r0;
	int r1;

	r0 = READ_ONCE(*y);
	r1 = READ_ONCE(*x);
}

P1(int *x, int *y)
{
	int r0;
	int r1;

	r0 = READ_ONCE(*y);
	r1 = READ_ONCE(*x);
}

P2(int *x, int *y)
{
	WRITE_ONCE(*x, 1);
	WRITE_ONCE(*y, 1);
}

exists (0:r0=0 /\ 0:r1=1 /\ 1:r0=1 /\ 1:r1=0)
---------------------------------------------------------------------

If you have access to an Alpha machine with 3 or more CPUs,
you should be able to run this test with the help of klitmus7.

Note that you might need to run the test against pre-4.15 Linux release.
READ_ONCE() since 4.15 has smp_mb() for Alpha to ensure that it can
be used as a start point of an address dependency.  Litmus test
above might behave differently against Linux releases of pre and post
4.15 WRT Alpha.

Also note that even if you see a result saying "Never", it does not
necessarily mean Alpha architecture is other-multicopy-atomic or stronger.
The behavior might depend on specific memory/cache system found on a
specific model of the machine, for example.

Finally, my mental model of other-multi-copy might be different from
those defined in papers you cited below. 

> 
> Which seems to confirm that Alpha was indeed other-multicopy atomic.
> 
> Best regards,
> Ignacio
> 
> 
> [1] https://arxiv.org/pdf/1707.05923 - First page
> [2] http://www0.cs.ucl.ac.uk/staff/j.alglave/these.pdf - Section 4.2.3.1
> [3] https://dl.acm.org/doi/pdf/10.1145/3158107

  ([3]: with the last-minute edit in your follow-up.)

        Thanks, Akira