Worker is not finished while sending message to intermediate worker

[Ali Çehreli via Digitalmars-d-learn]

On 02/09/2015 08:00 AM, xtreak wrote:
> I am using "programming in D" to learn about D language. I wrote a
> simple program that spawns a worker and sends it a number to receive its
> square as a string. The worker 1 gets the number squares it and sends to
> worker 2 (a different function) to get casted as string which is
> returned to the worker 1 and thus it returns it to the main function
> call. I can write the whole thing in a single thread. I wrote it to
> understand about workers better. I used receive to get the worker 1 act
> as per the input. The program is as follows
>
> import std.stdio;
> import std.concurrency;
> import std.conv;
> import core.thread;
>
> void main() {
>
>    foreach (int num; 1..100) {
>      auto square_tid = spawn(&square);
>      square_tid.send(num);
>      auto square = receiveOnly!string();
>      writeln(square);
>    }
> }
>
>
> void square() {
>    static i = 0;
>    receive (
>         (int num) {
>           auto square = num * num;
>           writeln("sqaure : Comes in with " , num , " for " , ++i , "
> time");
>           auto stringWorker = spawn(&stringConverter);
>           stringWorker.send(thisTid, square, ownerTid);
>         },
>         (Tid tid, string str) {
>           writeln("comes in string");
>           send(tid, "hello");
>         });
> }
>
> void stringConverter() {
>    static i = 0;
>    auto params = receiveOnly!(Tid, int, Tid)();
>    auto stringified = to!string(params[1]); // Stringify the square
>    writeln("string : Comes in with " , params[1], " for " , ++i , " time");
>    params[0].send(params[2], stringified); // params[0] - square
> function tid, // params[2] - main function tid
> }
>
>
> I got the answer from stackoverflow @
> https://stackoverflow.com/questions/28128383/worker-is-not-finished-while-sending-message-to-intermediate-worker.
> But the person who answered my question asked me to post back to dlang
> learn to learn more about it. As I spawn the function and a send a
> message to stringConverter as it sends a message to the square function
> why do I need to embed another receive call inside the int case as
> indicated in the answer. How can I avoid embedding the receive call and
> why does the person in the second answer used while(1) to receive the
> message.

Let me answer your question about 'value' first. You said on StackOverflow:

 > Why does it have the value >= 0 as its obvious in the code.

I decided to use the value received to keep the example as simple as 
possible. Note that later examples use a special type Terminate to 
request termination:

       int value = 0;
       while (value >= 0) {         // <-- Yes, obvious at first
         value = receiveOnly!int(); // <-- But may change here
         // ...
       }

In message passing, threads normally start one more worker threads and 
send tasks to those threads. In your example, your thread threads that 
live for a very short time. In the case of square(), it creates a thread 
for every request that it receives.

There is technically nothing wrong with that. However, it will be a good 
idea to ensure that threads are alive when messages are sent to them. 
This is not the case in your code.

For example, square() starts a thread, sends a message to it, and leaves 
the receive() call. When stringConverter() sends the message, that 
message will go to the main() thread. square() has executed its 
receive() call and about to exit. In other words, the message "comes in 
string" will never be printed.

Again, nothing wrong with it; just stating the obvious... :)

If you want main() to receive stringConverter()'s message, then there is 
a bug in stringConverter() because it sends the message to square() 
which will never receive it:

     params[0].send(/* ... */);

should be

     params[2].send(/* ... */);

And then main() complains because it should receive just a string:

   Unexpected message type: expected 'string', got 
'std.typecons.Tuple!(Tid, string).Tuple'

so the call should actually be

   params[2].send(stringified);

Now it works. :)

Ali