Re: asynchronous task communication

[Charles Hixson <charleshixsn@earthlink.net>]

Thank you for your answer.

The problem with that solution is that I've been advised that I 
shouldn't have many more tasks than available cores, and that uses 2 of 
my available 6.  True, several clients could use the same postmaster, 
but it's still too resource intensive.

It's looking more and more like protected objects on the heap are the 
best answer.  I just wasn't sure that a built-in answer didn't exist.

(FWIW, I think I could get away with reducing the postmaster to only 
using one thread, but that's still too resource intensive.  Actually, 
I'll probably redesign your postmaster to be a single protected object 
on the heap, as storing a message shouldn't block for long, and reading 
a message should be even less limiting.  I'd go with messages to 
individual protected objects, but there's a feed-back interaction that 
would cause everything to lock up.)

OTOH, actual non-blocking (i.e. asynchronous) calls to either threads or 
protected items is what I really need.  These other things are 
make-shift kludges.  They centralize control that should be distributed. 
  But since the called item will want to send a message back (and 
possibly onwards)...everything freezes up unless the message sending is 
asynchronous.

On 12/31/2012 04:09 AM, Georg Bauhaus wrote:
> On 31.12.12 01:16, Charles Hixson wrote:
>>
>> The only alternative that I've come up with is to have each task have
>> an access variable to a protected type instance. This can be done, but
>> it makes the control in other parts of the program trickier.
>
> You could make the letter actively deliver itself.
>
> Just in case you do no want to write a mail box, as
> suggested by J-P. Rosen.
>
> package Letters is
>
> task type Receiver is
> entry Knock (Message : String);
> end Receiver;
>
> task type Letter (Recipient : access constant Receiver) is
> entry Write (Message : String);
> end Letter;
>
> task type Sender is
> end Sender;
>
> end Letters;
>
> package body Letters is
>
> type Text_Buffer is access constant String;
> type Letter_Pointer is access Letter;
> Receiver_In_Scope : aliased Receiver;
>
> task body Receiver is
> begin
> accept Knock (Message : String);
> end Receiver;
>
> task body Letter is
> Text : Text_Buffer;
> begin
> -- get written, then actively get sent, then be finished
> accept Write (Message : String) do
> Letter.Text := new String'(Message);
> end Write;
> Recipient.Knock (Text.all);
> end Letter;
>
> task body Sender is
>
> procedure Send;
> -- prepare a self-delivering letter
>
> procedure Send is
> Order : Letter_Pointer;
> begin
> Order := new Letter (Recipient => Receiver_In_Scope'Access);
> Order.Write ("Meet me at 10 o'clock!");
> end Send;
>
> begin
> null; -- ...
> Send;
> null; -- ...
> end Sender;
>
> end Letters;
>
>