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.

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

On 02/09/2015 11:46 AM, Ali Çehreli wrote:

> threads normally start one [or] more worker threads and
> send tasks to those threads

Accordingly, the following program uses just three threads:

import std.stdio;
import std.concurrency;
import std.conv;
import core.thread;

struct Terminate
{}

void main() {

    auto square_tid = spawn(&square);

    foreach (int num; 1..100) {
        square_tid.send(num);
        auto square = receiveOnly!string();
        writeln(square);
    }

    square_tid.send(Terminate());
}

void square() {
    auto i = 0;
    bool done = false;
    auto stringWorker = spawn(&stringConverter, ownerTid);

    while (!done) {
        receive (
            (Terminate message) {
                stringWorker.send(message);
                done = true;
            },

            (int num) {
                auto square = num * num;
                writeln("sqaure : Comes in with " ,
                        num , " for " , ++i , " time");
                stringWorker.send(square);
            });
    }
}

void stringConverter(Tid destination) {
    auto i = 0;
    bool done = false;

    while (!done) {
        receive (
            (Terminate message) {
                done = true;
            },

            (int num) {
                auto stringified = num.to!string;

                writeln("string : Comes in with ",
                        num, " for " , ++i , " time");
                destination.send(stringified);
            });
    }
}

Ali

On Monday, 9 February 2015 at 20:11:09 UTC, Ali Çehreli wrote:
> On 02/09/2015 11:46 AM, Ali Çehreli wrote:
>
> > threads normally start one [or] more worker threads and
> > send tasks to those threads
>
> Accordingly, the following program uses just three threads:
>
> import std.stdio;
> import std.concurrency;
> import std.conv;
> import core.thread;
>
> struct Terminate
> {}
>
> void main() {
>
>     auto square_tid = spawn(&square);
>
>     foreach (int num; 1..100) {
>         square_tid.send(num);
>         auto square = receiveOnly!string();
>         writeln(square);
>     }
>
>     square_tid.send(Terminate());
> }
>
> void square() {
>     auto i = 0;
>     bool done = false;
>     auto stringWorker = spawn(&stringConverter, ownerTid);
>
>     while (!done) {
>         receive (
>             (Terminate message) {
>                 stringWorker.send(message);
>                 done = true;
>             },
>
>             (int num) {
>                 auto square = num * num;
>                 writeln("sqaure : Comes in with " ,
>                         num , " for " , ++i , " time");
>                 stringWorker.send(square);
>             });
>     }
> }
>
> void stringConverter(Tid destination) {
>     auto i = 0;
>     bool done = false;
>
>     while (!done) {
>         receive (
>             (Terminate message) {
>                 done = true;
>             },
>
>             (int num) {
>                 auto stringified = num.to!string;
>
>                 writeln("string : Comes in with ",
>                         num, " for " , ++i , " time");
>                 destination.send(stringified);
>             });
>     }
> }
>
> Ali

Hi Ali,

Thanks for your book :) I am using it for learning D. I want the stringConverter to send a message to square which in turn messages the main function with string "hello". So are you saying that message is not delivered to square from stringWorker. How does embedding the receive call inside the int in stackoverflow answer receives the message? It seems silly but how can I keep my threads alive to receive messages? Thanks a lot again. Please correct me if I am wrong anywhere.

On 02/09/2015 12:34 PM, xtreak wrote:

> I want the stringConverter to send a message to square which in
> turn messages the main function with string "hello".

Your code did almost that but there was a bug (which I've pointed out).

> So are you saying that message is not delivered to square from
> stringWorker.

Not in your code due to that bug but the program that I've shown does exactly what you want.

> How does embedding the receive call inside the int in
> stackoverflow answer receives the message?

Once one receive() is executed, the program flow continues with further expressions. The suggestion that you received was making square() wait a second message. It need not be "embedded" at all. All it is needed was a second receive() call. That's all... However, that is not what you intended anyway.

You wanted stringConverter() to send a message to main(). So, just forget about that embeded receive and either do what my program did or fix the bug. :) (See my earlier message.)

> It seems silly but how can I keep my threads alive to receive
> messages?

By having an infinite loop like 'while (!done)'. (Please see my program.)

Ali