9.3 Task Dependence - Termination of Tasks
This Reference Manual output has not been verified, and may contain omissions or errors. Report any problems on the tracking issue
Each task (other than an environment task — see 10.2) depends on one or more masters (see 7.6.1), as follows:
- If the task is created by the evaluation of an
allocatorfor a given named access type, it depends on each master that includes the elaboration of the declaration of the ultimate ancestor of the given access type. 3
- If the task is created by the elaboration of an
object_declaration, it depends on each master that includes this elaboration. 3.1/2
- Otherwise, the task depends on the master of the outermost object of which it is a part (as determined by the accessibility level of that object — see 3.10.2 and 7.6.1), as well as on any master whose execution includes that of the master of the outermost object.
Furthermore, if a task depends on a given master, it is defined to depend on the task that executes the master, and (recursively) on any master of that task.
A task is said to be completed when the execution of its corresponding
task_body is completed. A task is said to be terminated when any finalization of the
task_body has been performed (see 7.6.1). [The first step of finalizing a master (including a
task_body) is to wait for the termination of any tasks dependent on the master.] The task executing the master is blocked until all the dependents have terminated. [Any remaining finalization is then performed and the master is left.]
Completion of a task (and the corresponding
task_body) can occur when the task is blocked at a
select_statement with an open
terminate_alternative (see 9.7.1); the open
terminate_alternative is selected if and only if the following conditions are satisfied:
- The task depends on some completed master; and
- Each task that depends on the master considered is either already terminated or similarly blocked at a
select_statementwith an open
When both conditions are satisfied, the task considered becomes completed, together with all tasks that depend on the master considered that are not yet completed.
terminate_alternatives. The tasks are not callable during the finalization. In some ways it is as though they were aborted.
object_renaming_declarationdefines a new view of an existing entity and hence creates no further dependence.
select_statements with open
terminate_alternatives ensure that the collective completion can occur only when there are no remaining active tasks that can call one of the tasks being collectively completed.
select_statements with open
terminate_alternatives, and become completed collectively, their finalization actions proceed concurrently.
- the raising of an exception during the elaboration of the
declarative_partof the corresponding
- the completion of the
handled_sequence_of_statementsof the corresponding
- the selection of an open
select_statementin the corresponding
- the abort of the task.
Example of task dependence:
declare type Global is access Server; -- see 9.1 A, B : Server; G : Global; begin -- activation of A and B declare type Local is access Server; X : Global := new Server; -- activation of X.all L : Local := new Server; -- activation of L.all C : Server; begin -- activation of C G := X; -- both G and X designate the same task object ... end; -- await termination of C and L.all (but not X.all) ... end; -- await termination of A, B, and G.all
Wording Changes from Ada 83
task_bodyof the environment task (see 10.2). Therefore, the environment task has to wait for them before performing library level finalization and terminating the partition. In Ada 83 the requirement to wait for tasks that depended on library packages was not as clear.
terminate_alternatives. This is because finalization still occurs for such tasks, and this happens after selecting the
terminate_alternative, but before termination.
Wording Changes from Ada 95
allocators, such as function returns.