Re: Is Intel exceptionally unsuccessful as an architecture designer?

On Mon, 23 Sep 2024 22:46:47 +0000, Chris M. Thomasson wrote:

On 9/23/2024 3:32 PM, MitchAlsup1 wrote:

>
I got rid of all MemBars and still have a fairly relaxed memory model.

>
That is interesting to me! It's sort-of "out of the box" so to speak?
How can a programmer take advantage of the relaxed aspect of your model?
>

Touch a DRAM location and one gets causal order.
Touch a MM I/O location and one gets sequential consistency
Touch a config space location and one gets strongly ordering
Touch ROM and one gets unordered access.
You see, the memory <ordering> model is not tied to a CPU state, but
to what LD and ST instructions touch.

>

Think of allowing a rouge thread to pound a CAS with random data wrt the
comparand, trying to get it to fail... Of course this can be modifying a
reservation granule wrt LL/SC side of things, right? Pessimistic (CAS)
vs Optimistic (LL/SC)?

>
Or methodological (ESM).

>
Still, how does live lock get eluded in your system? Think along the
lines of a "rouge" thread causing havoc? Banging on cache lines ect...
;^o

ESM switches modes automagically. It starts out as Optimistic, and when
that fails, it switches to methodological {note by the time the failure
has been detected, the core is now sequentially consistent and will be
performing the 'event' in program order and sequentially consistent.
Should the methodological event fail, the core will ask the ATOMIC
request granter using all of the addresses. IF this succeeds, then the
core is allowed to NAK interference so that it will succeed. Upon
success, those addresses are removed from the granter.
So, for example:: a timer goes off and every core tries to pick a
thread of the wait queue. The first access will likely fail, the
second access will fail but the granter counted the amount of
interference. So the third request is to a thread nobody else
is attempting to dequeue. First 2 requests were to the element
at the front of the queue, third requests is to a thread indexed
down the queue by the interference number.
Thus BigO( n^3 ) becomes BigO( 3 ). In practice BigO(n^3) becomes
BigO(ln2(n)) due to random arrival and departure.