Contents Index Search Previous Next
D.11 Asynchronous Task Control
This clause introduces a language-defined package
to do asynchronous suspend/resume on tasks. It uses a conceptual held
priority value to represent the task's held state.
The following language-defined
library package exists:
package Ada.Asynchronous_Task_Control is
procedure Hold(T : in Ada.Task_Identification.Task_ID);
procedure Continue(T : in Ada.Task_Identification.Task_ID);
function Is_Held(T : Ada.Task_Identification.Task_ID)
the Hold operation has been applied to a task, the task becomes held
For each processor there is a conceptual idle task
, which is always
ready. The base priority of the idle task is below System.Any_Priority'First.
The held priority
is a constant of the type integer whose value
is below the base priority of the idle task.
The Hold operation sets the state of T to held.
For a held task: the task's own base priority does not constitute an
inheritance source (see D.1
), and the value
of the held priority is defined to be such a source instead.
The Continue operation resets the state of T to
not-held; T's active priority is then reevaluated as described in D.1
This time, T's base priority is taken into account.
The Is_Held function returns True if and only
if T is in the held state.
As part of these operations, a check is made that
the task identified by T is not terminated.
is raised if the check fails.
Program_Error is raised
if the value of T is Null_Task_ID.
If any operation in this package
is called with a parameter T that specifies a task object that no longer
exists, the execution of the program is erroneous.
An implementation need not support Asynchronous_Task_Control
if it is infeasible to support it in the target environment.
33 It is a consequence
of the priority rules that held tasks cannot be dispatched on any processor
in a partition (unless they are inheriting priorities) since their priorities
are defined to be below the priority of any idle task.
34 The effect of calling
Get_Priority and Set_Priority on a Held task is the same as on any other
35 Calling Hold on a held
task or Continue on a non-held task has no effect.
rules affecting queuing are derived from the above rules, in addition
to the normal priority rules:
- When a held task
is on the ready queue, its priority is so low as to never reach the top
of the queue as long as there are other tasks on that queue.
- If a task is
executing in a protected action, inside a rendezvous, or is inheriting
priorities from other sources (e.g. when activated), it continues to
execute until it is no longer executing the corresponding construct.
- If a task becomes
held while waiting (as a caller) for a rendezvous to complete, the active
priority of the accepting task is not affected.
- If a task becomes
held while waiting in a selective_accept,
and an entry call is issued to one of the open entries, the corresponding
accept_alternative executes. When
the rendezvous completes, the active priority of the accepting task is
lowered to the held priority (unless it is still inheriting from other
sources), and the task does not execute until another Continue.
- The same holds
if the held task is the only task on a protected entry queue whose barrier
becomes open. The corresponding entry body executes.
Contents Index Search Previous Next Legal