how to handle shared arrays?

[Ali Çehreli]

On 06/21/2012 12:00 PM, maarten van damme wrote:
 > I want to have two threads. One parses some content ever half hour and
 > the other continuously parses commands passed from the first thread.
 > When the second thread finished something it should send the results
 > back to the first thread who'll present it to the user.
 > The messages the second thread needs to send back is under the form of
 > an array of a struct.
 >
 > Right now I'm trying something like this:
 > 			shared (T[]) mods=cast(shared (T[]))modifications.dup;
 > 			send(tid, mods);
 >
 > This gives me a rather odd-looking errormessage:
 > C:\D\dmd2\windows\bin\..\..\src\phobos\std\variant.d(528): Error: 
function core.
 > stdc.string.memcpy (void* s1, const(void*) s2, uint n) is not 
callable using arg
 > ument types (ubyte[20u]*,shared(T[])*,uint)
 > C:\D\dmd2\windows\bin\..\..\src\phobos\std\variant.d(528): Error: 
cannot implici
 > tly convert expression (&  rhs) of type shared(T[])* to const(
 > void*)
 >
 > How should I handle arrays that I will need to send back to another 
thread?
 > Excuse me for all those questions, I'm really having a hard time
 > grasping the D threading model.

I know I am not answering your question precisely, but how about sending 
an immutable array? If the owner does not need to modify what the worker 
sends, you can pass a slice of immutable(Result) objects.

assumeUnique works is useful for the worker to convert its mutable array 
to an immutable one:

import std.stdio;
import std.exception;
import std.concurrency;

struct Command
{}

struct Result
{}

struct Exit
{}

void workerFunc(Tid owner)
{
     bool isDone = false;

     while (!isDone) {
         receive(
             (Command command) {
                 writeln("worker - received command");
                 Result[] results = [ Result(), Result() ];

                 writeln("worker - sending results");
                 owner.send(assumeUnique(results));
             },

             (Exit message) {
                 writeln("worker - exiting");
                 isDone = true;
             });
     }
}

void main()
{
     auto worker = spawn(&workerFunc, thisTid);

     foreach (i; 0 .. 3) {
         writeln("main   - sending command ", i);
         worker.send(Command());
         auto results = receiveOnly!(immutable(Result)[])();
         writeln("main   - received results: ", results);
     }

     writeln("main   - stopping worker");
     worker.send(Exit());
}

The output:

main   - sending command 0
worker - received command
worker - sending results
main   - received results: [immutable(Result)(), immutable(Result)()]
main   - sending command 1
worker - received command
worker - sending results
main   - received results: [immutable(Result)(), immutable(Result)()]
main   - sending command 2
worker - received command
worker - sending results
main   - received results: [immutable(Result)(), immutable(Result)()]
main   - stopping worker
worker - exiting

Ali

-- 
D Programming Language Tutorial: http://ddili.org/ders/d.en/index.html