Precise GC state

[Petar]

On Monday, 27 November 2017 at 06:36:27 UTC, Ola Fosheim Grostad 
wrote:
> On Monday, 27 November 2017 at 05:47:49 UTC, Dmitry Olshansky 
> wrote:
>> likely via RAII. Not to mention cheap (thread-local) Ref 
>> Counting, C++ and many other language have to use atomics 
>> which makes RC costly.
>
> No, you dont. Nobody in their right mind would do so in C++ as 
> a general solution. Seems there is trend in doing D-advocacy 
> based on the assumption that programmers using other languages 
> are crazy these days.
>
> In C++ sync is manual, which is the only efficient way to do 
> it. Proving correctness for an efficient general solution is an 
> unsolved theoretical problem. You can do it for high level 
> mechanisms, but not low level atm.
>
> Rust and Pony claims to have solutions, but they are not 
> general. D most certainly does not have it and never will.
>
> When threading is a libray type then you cannot achieve more in 
> D than you can achieve in C++, i.e. Shared is not going to do 
> more than a C++ library type with a separate static analysis 
> tool.

What I think Dmitry meant is that shared_ptr<T> uses atomic 
instructions for the reference counting (though you need to use 
atomic_shared_ptr, or atomic_* function if you want to modify the 
shared_ptr itself) and you can't opt out of that even if you're 
not sharing the shared_ptr with other threads. On the other hand 
in D, a properly designed SharedPtr(T) will use atomic 
instructions for reference counting, only if it's payload type T 
is has the 'shared' type qualifier. And if you have 
'shared(SharedPtr(T))', only then you'll have atomic instructions 
for the SharedPtr struct itself, but unlike shared_ptr<T>, you 
won't have access to the non-thread safe methods.