* Asynchronous communication between protected types
@ 1998-07-21 0:00 Scott James
1998-07-22 0:00 ` Anonymous
0 siblings, 1 reply; 2+ messages in thread
From: Scott James @ 1998-07-21 0:00 UTC (permalink / raw)
I'm trying to connect concurrent objects via an asynchronous
message. I was hoping to do this entirely with protected objects,
however, cannot seem to do so. The difficulty I have is that even if I
put the receiver into a loop (waiting on a send entry) it seems that
*some* task has to start the receiver, so I will still need one (Ada)
task per (active) receiver.
About the best I can come up is the following code.
This is acceptable for my purposes but I was curious if I
could trick this into working using only protected types.
(and without the distribution annex's Asynchronous Pragma
either :-)
(some code snippets borrowed from _Concurrency in Ada (95)_)
-----------------------------------------------------------
with Ada.Text_IO;
procedure Test_Persistent is
type Messages is (Run, Die);
protected type Persistent_Signals is
procedure Send (Message: Messages);
entry Wait (Message: out Messages);
private
Message: Messages;
Signal_Arrived: Boolean:=False;
end Persistent_Signals;
protected body Persistent_Signals is
procedure Send (Message: Messages) is
begin
Persistent_Signals.Message:=Message;
Signal_Arrived:=True;
end Send;
entry Wait (Message: out messages) when Signal_Arrived is
begin
Signal_Arrived:=False;
Message:=Persistent_Signals.Message;
end Wait;
end Persistent_Signals;
type Access_To_Persistent_Signals is access Persistent_Signals;
task type Processes is
entry Initialize (With_Signal: Access_To_Persistent_Signals);
end Processes;
task body Processes is
Message: Messages;
Signal: Access_To_Persistent_Signals;
begin
accept Initialize (With_Signal: Access_To_Persistent_Signals) do
Signal:=With_Signal;
end Initialize;
loop
Signal.Wait (Message);
case Message is
when Run =>
Ada.Text_IO.Put_Line ("I'm running");
when Die =>
exit;
end case;
end loop;
end Processes;
Process: Processes;
Signal: Access_To_Persistent_Signals;
begin
Signal:=new Persistent_Signals;
Process.Initialize (Signal);
for I in 1 .. 4 loop
Signal.Send (Run);
delay 0.5;
end loop;
Signal.Send (Die);
end Test_Persistent;
--
Dr. Scott James james@mcci-arl-va.com
^ permalink raw reply [flat|nested] 2+ messages in thread
* Re: Asynchronous communication between protected types
1998-07-21 0:00 Asynchronous communication between protected types Scott James
@ 1998-07-22 0:00 ` Anonymous
0 siblings, 0 replies; 2+ messages in thread
From: Anonymous @ 1998-07-22 0:00 UTC (permalink / raw)
On 21 Jul 1998 15:43:56 GMT, james@sandy.mcci-arl-va.com (Scott James)
wrote:
> I'm trying to connect concurrent objects via an asynchronous
> message. I was hoping to do this entirely with protected objects,
> however, cannot seem to do so. The difficulty I have is that even if I
> put the receiver into a loop (waiting on a send entry) it seems that
> *some* task has to start the receiver, so I will still need one (Ada)
> task per (active) receiver.
> ...
I assume that by "start the receiver", you mean call the initialize
entry. Ada allows you to avoid that:
with Ada.Text_IO;
procedure Test_Persistent is
type Messages is (Run, Die);
protected type Persistent_Signals is
procedure Send (Message: in Messages);
entry Wait (Message: out Messages);
private
Message: Messages;
Signal_Arrived: Boolean:=False;
end Persistent_Signals;
protected body Persistent_Signals is
procedure Send (Message: in Messages) is
begin
Persistent_Signals.Message:=Message;
Signal_Arrived:=True;
end Send;
entry Wait (Message: out messages) when Signal_Arrived is
begin
Signal_Arrived:=False;
Message:=Persistent_Signals.Message;
end Wait;
end Persistent_Signals;
task type Processes (Signal : access Persistent_Signals);
task body Processes is
Message: Messages;
begin
loop
Signal.Wait (Message => Message);
case Message is
when Run =>
Ada.Text_IO.Put_Line ("I'm running");
when Die =>
exit;
end case;
end loop;
end Processes;
Signal : aliased Persistent_Signals;
Process: Processes (Signal => Signal'access);
begin
for I in 1 .. 4 loop
Signal.Send (Message => Run);
delay 0.5;
end loop;
Signal.Send (Message => Die);
end Test_Persistent;
This compiles and runs fine on GNAT 3.10p1/Win95.
Jeff Carter PGP:1024/440FBE21
My real e-mail address: ( carter @ innocon . com )
"I fart in your general direction."
Monty Python & the Holy Grail
Posted with Spam Hater - see
http://www.compulink.co.uk/~net-services/spam/
^ permalink raw reply [flat|nested] 2+ messages in thread
end of thread, other threads:[~1998-07-22 0:00 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
1998-07-21 0:00 Asynchronous communication between protected types Scott James
1998-07-22 0:00 ` Anonymous
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox