Re: Does anyone understand how to use "shared" types with concurrency send/receive functions?

[Arek via Digitalmars-d-learn]

On Monday, 14 August 2017 at 21:27:48 UTC, Jonathan M Davis wrote:
On Monday, August 14, 2017 15:22:23 Steven Schveighoffer via 
Digitalmars-d- learn wrote:
On 8/13/17 11:40 PM, Jonathan M Davis via Digitalmars-d-learn 
wrote:
> On Saturday, August 12, 2017 18:57:44 Arek via 
> Digitalmars-d-learn
wrote:
>> I have the folowing problem:
>> I like to envelope the class object in struct to control the
>> destruction moment and then send this object to another
>> thread/fiber (or task, cause I use vibe-d).
>>
>> I can't find any method to make it working. Any ideas?
>
> Unfortunately, send and receive do not currently work with 
> shared because of issues with Variant, which they use 
> internally.

This can't be a correct statement. This is the whole point of 
shared.

What's incorrect about it? It's a longstanding issue that 
because Variant can't contain shared data, send and receive do 
not work with shared. You can send and receive mutable data 
with no indirections, and AFAIK, you can send immutable data 
(though the OP is apparently having problems with that, so I 
guess that that doesn't work completely, though I definitely 
recall doing so previously), but you get compilation errors if 
you try to send shared data. For instance, this code

import std.concurrency;

void main()
{
    static void func(Tid parent)
    {
        auto received = receiveOnly!(shared int[string]);
    }

    shared int[string] aa;

    auto tid = spawn(&func, thisTid);
    send(tid, aa);
}


I've found some simple workaround for this problem:

import std.stdio;
import std.concurrency;

struct Envelope(T) if (is(T == class)) // for simplicity of this 
example, only classes
{
        shared(T)[] obj;

        this(shared T o)
        {
                this.obj = [o];
        }

        T get() @property nothrow @nogc
        {
                return cast() obj[0];
        }
}

class A
{

}

void consumer()
{
        auto r = receiveOnly!(Envelope!(A))();
        writeln("Got: ", typeof(r).stringof);
}

void main()
{
        auto cons = spawn(&consumer);
        auto o = Envelope!A(new A());
        send(cons, o);
}

Shared object can be encapsulated in the array. In case of other 
(non-class) types the pointer can be used, and get() should 
return ref to the pointed object (after stripping off the shared 
qualifier).

send() could encapsulate itself shared objectes.

Arek