std.functional.memoize : thread local or __gshared memoization?

[Jonathan M Davis via Digitalmars-d]

On Tuesday, May 30, 2017 19:00:12 Kagamin via Digitalmars-d wrote:
> On Saturday, 27 May 2017 at 16:27:46 UTC, Ola Fosheim Grøstad
>
> wrote:
> > If the semantics in C is that everything is typed shared then
> > it should also be treated as such when D interfaces with C and
> > C like type-semantics.
>
> Then you would need to laboriously mark everything related to C
> as shared, which would be quite different from C workflow.

Everything is shared is C, but it's not marked as shared, so even though
almost all of it is used as if it were thread-local, it isn't actually
guaranteed to be so. This means that if you were being paranoid about it,
you'd have to treat every C API as shared, but that is completely
impractical and rarely fits what the C API actually does. In the vast
majority of cases, if the C code were translated to D code, it would be
translated as thread-local and be just fine. Well-behaved C code acts like D
code in that it segregates code that operates on data as if it's on one
thread and code that operates on data that's shared across threads, even if
C doesn't have the helper attributes that D does.

So, when dealing with a C API and shared, it's a bit like dealing with
@system/@trusted and C APIs. With @system/@trusted, it's up to the
programmer to figure out what's safe and what isn't based on what the API
does. If it's appropriately memory-safe, then it's okay to mark it as
@trusted, and if there's a problem, then you know that you need to dig into
the C code to fix it. If it's not memory-safe, then it needs to be marked
with @system (or nothing), and the programmer needs to make sure that they
use it correctly in order to make the code that uses it memory-safe.

With C APIs and shared, the programmer needs to be sure of whether it's
thread-safe to treat that API call as if it's operating on thread-local
data, or whether it needs to be treated as operating on shared data, and
then mutexes need to be used as appropriate. Fortunately, it's usually
clear, and in the vast majority of cases, treating the C function as
operating on thread-local data is just fine. But it is true that you need to
be a bit careful when binding to C APIs to make sure that something which
isn't thread-safe is not treated as thread-local.

- Jonathan M Davis