core.atomics and handling of backward MemoryOrders

[Iain Buclaw via Digitalmars-d]

On 4 Jul 2015 00:50, "rsw0x via Digitalmars-d" <digitalmars-d at puremagic.com>
wrote:
>
> On Friday, 3 July 2015 at 17:51:17 UTC, Iain Buclaw wrote:
>>
>> Hi,
>>
>> I'm currently re-writing core.atomics for GDC to switch from the old GCC
__sync_* builtins to the new (more compatible with how core.atomics is
supposed to function) __atomic_* builtins.
>>
>> https://github.com/D-Programming-GDC/GDC/pull/111
>>
>> One thing I've noticed in my reading of this, is that the following are
accepted as valid, but makes no sense.
>>
>> ---
>> atomicStore!(MemoryOrder.acq)(var, val);
>>
>> var = atomicLoad!(MemoryOrder.rel)(val);
>> ---
>>
>> I'd like to suggest that it should be considered completely valid for
both cases to throw a compilation error (using static assert).  However I'd
like the core druntime team to be on board with this.
>>
>> Regards
>> Iain.
>
>
> IIRC these flat out error on LDC, I meant to submit a bug report but I
forgot until I read this.

Good to know, as I understand it, there's currently the following behaviour
in dmd runtime.

atomicLoad!(Memoryorder.seq)  ->  issues a lock+exchange.
atomicLoad!(Memoryorder.acq)  ->  lock-free (only because of x86
guarantees).
atomicLoad!(Memoryorder.rel)  ->  issues a lock+exchange.
atomicLoad!(Memoryorder.raw)  ->  no lock.

atomicStore!(Memoryorder.seq)  ->  issues a lock+exchange.
atomicStore!(Memoryorder.acq)  ->  issues a lock+exchange.
atomicStore!(Memoryorder.rel)  ->  lock-free (only because of x86
guarantees).
atomicStore!(Memoryorder.raw)  ->  no lock.

Is it fine to consider the following (for optimisation purposes, of course
:)

atomicLoad!(Memoryorder.seq)  ->  Can be lock-free (only because of x86
guarantees), but guaranteed to do the right thing otherwise.
atomicLoad!(Memoryorder.acq)  ->  Can be lock-free (only because of x86
guarantees), but guaranteed to do the right thing otherwise.
atomicLoad!(Memoryorder.rel)  ->  static assert.
atomicLoad!(Memoryorder.raw)  ->  no lock.

atomicStore!(Memoryorder.seq)  ->  Can be lock-free (only because of x86
guarantees), but guaranteed to do the right thing otherwise.
atomicStore!(Memoryorder.acq)  ->  static assert.
atomicStore!(Memoryorder.rel)  ->  Can be lock-free (only because of x86
guarantees), but guaranteed to do the right thing otherwise.
atomicStore!(Memoryorder.raw)  ->  no lock.

Iain.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.puremagic.com/pipermail/digitalmars-d/attachments/20150704/b5f5bc6b/attachment.html>