Mailbox limits and dead/livelocks?

[Enerqi]

The actors in std.concurrency - in this example it's 
non-deterministic whether the process may or may not hang. I'm 
confused as to why. I have set the mailbox sizes to 1. But the 
message flow seems simple enough. I don't see how the message 
limit of 1 is blocking everything, I am catching Variant messages 
so nothing should be in the mailbox unread.


----------
import core.thread;
import std.algorithm;
import std.concurrency;
import std.stdio;

int main(string[] args)
{
     Tid[2] tids;
     bool[Tid] response_flags;
     for(auto i=0; i < 2; ++i)
     {
	tids[i] = spawn(&blah1, thisTid);		
         response_flags[tids[i]] = false;
     }

     auto receive_count = 0;
	
     setMaxMailboxSize(thisTid, 1, OnCrowding.block);
	
     while(! reduce!"a && b"(response_flags))
     {
	writeln(response_flags, " ", receive_count);
         receive((Tid some_blah_id, int done)
                 {					
                     assert(done == 42);
                     ++receive_count;
                     response_flags[some_blah_id] = true;					
                 },
                 (Variant v)
                 {
                     writeln("Unexpected message: ", v, " type ", 
v.type());
                 }
                 );		
     }

     return 0;
}

void blah1(Tid parent)
{
     setMaxMailboxSize(thisTid, 1, OnCrowding.block);
     auto subtid = spawn(&subsub, thisTid, parent);

     send(subtid, thisTid, false);
     receive((bool got)
	    {
	        assert(got);
	    },
	    (Variant v)
	    {
                 writeln("Unexpected message: ", v, " type ", 
v.type());
             });
     send(subtid, thisTid, 10);
     receive((int got)
	    {
	        assert(got == 11);
	    },
	    (Variant v)
	    {
                 writeln("Unexpected message: ", v, " type ", 
v.type());
             });
}

void subsub(Tid parent, Tid grandparent)
{
     setMaxMailboxSize(thisTid, 1, OnCrowding.block);
     receive((Tid parent, bool whatever)
             {
	        assert(!whatever);
	    },
	    (Variant v)
	    {
                 writeln("Unexpected message: ", v, " type ", 
v.type());
             });
     send(parent, true);
     receive((Tid parent, int n)
             {
                 assert(n == 10);
	    },
	    (Variant v)
	    {
                 writeln("Unexpected message: ", v, " type ", 
v.type());
             });
     send(parent, 11);

     send(grandparent, parent, 42);
}

----------


Cheers.