Ada select multiple entries - task

Question

I'm looking for a way to select on multiple entries. I've got the following task and select block. The intention is to run multiple (2) tasks elsewhere, run until one completes, or timeout after some amount of time
task type t_startup_task is
entry start;
entry started;
end t_startup_task;
task body t_startup_task is
startup_sig : Boolean := False;
begin
accept start;
busy : loop -- wait for external flag to become true
status.read_signal (startup_sig);
if startup_sig then
exit busy;
end if;
delay 0.1;
end loop busy;
accept started;
end t_startup_task;
<...>
startup_task.start;
select
startup_task.started;
or
state.wait_done; -- other entry
abort startup_task;
return False;
or
delay 4.0;
end select;
However, this results in the following compile error:
only allowed alternative in timed entry call is delay
"or" not allowed here
What's the best way of actually doing this?

Answer 1

Unfortunately you can't use a select statement for deciding between multiple entry calls. You can however use them to decide between accepting entries, so an implementation with three tasks should work.
You can still have your return value by using an out parameter on the final entry call.
task startup_task is
entry start;
entry wait_done;
entry signalled;
entry started (success : out boolean);
end startup_task;
-- This task waits upon your other entry, then calls the startup_task
-- entry once it has completed
task startup_wait is
entry start;
end startup_wait;
task body startup_wait is
begin
accept start;
state.wait_done;
startup_task.wait_done;
end startup_wait;
-- This task contains your busy loop and calls the startup_task
-- entry once it has completed
task startup_signal is
entry start;
end startup_signal;
task body startup_signal is
begin
accept start;
busy : loop -- wait for external flag to become true
status.read_signal (startup_sig);
if startup_sig then
exit busy;
end if;
delay 0.1;
end loop busy;
startup_task.signalled;
end startup_signal;
-- This task provides the functionality of your invalid select statement,
task body startup_task is
success : boolean := False;
begin
-- These start signals ensure that the subtasks wait for synchronisation
accept start;
startup_wait.start;
startup_signal.start;
select
accept signalled;
abort startup_wait;
success := True;
or
accept wait_done;
abort startup_signal;
or
delay 4.0
abort startup_wait;
abort startup_signal;
end select;
accept started (success);
end startup_task;
<...>
result : boolean;
begin
-- this block replaces your invalid select statement
startup_task.start;
startup_task.started(result);
return result;
end;
Note, I have not tested or compiled this code, but it should give an idea towards a solution.

Answer 2

Technically, the language allows this:
select
delay 4.0;
...
then abort
select
Entry1;
...
then abort
Entry2;
...
end select;
end select;
which might do what you want. However, the best way is probably to have the tasks check in with a protected object, and wait on an entry of the PO:
protected Multi_Wait is
procedure Task1_Ready;
procedure Task2_Ready;
entry Wait_For_Either (Task_1 : out Boolean; Task_2 : out Boolean);
private -- Multi_Wait
Task1 : Boolean := False;
Task2 : Boolean := False;
end Multi_Wait;
Then your code can do
select
Multi_Wait.Wait_For_Either (Task_1 => Task_1, Task_2 => Task_2);
if not Task_1 and Task_2 then
abort T1;
return False;
end if;
or
delay 4.0;
end select;
Your tasks call the appropriate procedure instead of waiting for a 2nd entry call.