I plan on making core.atomic more consistent and easier to use. Please provide me with your feedback.


https://github.com/rymrg/drm/blob/main/atomic.d
https://github.com/rymrg/drm/blob/main/atomic_rationale.md

On Sunday, 30 May 2021 at 20:41:29 UTC, rm wrote:
> I plan on making core.atomic more consistent and easier to use. Please provide me with your feedback.
>
>
> https://github.com/rymrg/drm/blob/main/atomic.d
> https://github.com/rymrg/drm/blob/main/atomic_rationale.md

I would also make the template accept more than just integral types, and only add the increment/binop functions for integral types.

On Sunday, 30 May 2021 at 20:41:29 UTC, rm wrote:
> I plan on making core.atomic more consistent and easier to use. Please provide me with your feedback.
>
>
> https://github.com/rymrg/drm/blob/main/atomic.d
> https://github.com/rymrg/drm/blob/main/atomic_rationale.md

Definitely, the D atomic library is cumbersome to use. C++ std::atomic supports operator overloading for example.

atomicVar += 1;

will create an atomic add as atomicVar is of the atomic type. D doesn't have this and I think D should add atomic types like std::atomic<T>. I like this because then I can easily switch between atomic operations and normal operations by just changing the type and very few changes.

On 30/05/2021 23:49, Johan Engelen wrote:
> On Sunday, 30 May 2021 at 20:41:29 UTC, rm wrote:
>> I plan on making core.atomic more consistent and easier to use. Please provide me with your feedback.
>>
>>
>> https://github.com/rymrg/drm/blob/main/atomic.d
>> https://github.com/rymrg/drm/blob/main/atomic_rationale.md
> 
> I would also make the template accept more than just integral types, and only add the increment/binop functions for integral types.

The plan is to support pointers as this will be really useful for lock free data structures.
Currently `isPointer` is defined  in `core.internal.traits`. So I haven't written this usage.

On Sunday, 30 May 2021 at 20:58:56 UTC, IGotD- wrote:
> On Sunday, 30 May 2021 at 20:41:29 UTC, rm wrote:
>> I plan on making core.atomic more consistent and easier to use. Please provide me with your feedback.
>>
>>
>> https://github.com/rymrg/drm/blob/main/atomic.d
>> https://github.com/rymrg/drm/blob/main/atomic_rationale.md
>
> Definitely, the D atomic library is cumbersome to use. C++ std::atomic supports operator overloading for example.
>
> atomicVar += 1;
>
> will create an atomic add as atomicVar is of the atomic type. D doesn't have this and I think D should add atomic types like std::atomic<T>. I like this because then I can easily switch between atomic operations and normal operations by just changing the type and very few changes.

Yes, please! This should be merged ASAP.

On Sunday, 30 May 2021 at 20:41:29 UTC, rm wrote:
> I plan on making core.atomic more consistent and easier to use. Please provide me with your feedback.
>
>
> https://github.com/rymrg/drm/blob/main/atomic.d
> https://github.com/rymrg/drm/blob/main/atomic_rationale.md

I have once implemented an atomic struct like this and the first thing that happened is that you would write:


s = s + 1;

Breaking atomicity.

On Monday, 31 May 2021 at 08:18:35 UTC, Guillaume Piolat wrote:
>
> I have once implemented an atomic struct like this and the first thing that happened is that you would write:
>
>
> s = s + 1;
>
> Breaking atomicity.

Yes, so the programmers must be aware of this. In C++ only the unary -= and += are supported and -- and ++.

Is it possible to overload binary operators so that they cause an compiler error? In order achieve the same s = s + 1; you need to write.

s.store(s.load() + 1)

However, the assignment operator writing s = 1 is nice instead of s.store(1).

On 31/05/2021 11:18, Guillaume Piolat wrote:
> 
> I have once implemented an atomic struct like this and the first thing that happened is that you would write:
> 
> 
> s = s + 1;
> 
> Breaking atomicity.

I don't consider this a problem. In this case you have a load and a store. This is a non-atomic RMW. On the other hand, you do get sequential consistency synchronization from this process.