Contents Index Previous Next
9.10 Shared Variables
Static Semantics
1
If two
different objects, including nonoverlapping parts of the same object,
are
independently addressable, they can be manipulated concurrently
by two different tasks without synchronization. Normally, any two nonoverlapping
objects are independently addressable. However, if packing, record layout,
or Component_Size is specified for a given composite object, then it
is implementation defined whether or not two nonoverlapping parts of
that composite object are independently addressable.
Dynamic Semantics
2
Separate tasks normally
proceed independently and concurrently with one another. However, task
interactions can be used to synchronize the actions of two or more tasks
to allow, for example, meaningful communication by the direct updating
and reading of variables shared between the tasks. The actions of two
different tasks are synchronized in this sense when an action of one
task
signals an action of the other task;
an
action A1 is defined to signal an action A2 under the following circumstances:
3
- If A1 and A2 are part of the execution of the same task,
and the language rules require A1 to be performed before A2;
4
- If A1 is the action of an activator that initiates the
activation of a task, and A2 is part of the execution of the task that
is activated;
5
- If A1 is part of the activation of a task, and A2 is the
action of waiting for completion of the activation;
6
- If A1 is part of the execution of a task, and A2 is the
action of waiting for the termination of the task;
6.1/1
- If A1 is the termination of a task T, and A2 is either
the evaluation of the expression T'Terminated or a call to Ada.Task_Identification.Is_Terminated
with an actual parameter that identifies T (see C.7.1);
7
- If A1 is the action of issuing an entry call, and A2 is
part of the corresponding execution of the appropriate entry_body
or accept_statement.
8
- If A1 is part of the execution of an accept_statement
or entry_body, and A2 is the action
of returning from the corresponding entry call;
9
- If A1 is part of the execution of a protected procedure
body or entry_body for a given protected
object, and A2 is part of a later execution of an entry_body
for the same protected object;
10
- If A1 signals some action that in turn signals A2.
Erroneous Execution
11
Given
an action of assigning to an object, and an action of reading or updating
a part of the same object (or of a neighboring object if the two are
not independently addressable), then the execution of the actions is
erroneous unless the actions are
sequential.
Two
actions are sequential if one of the following is true:
12
- One action signals the other;
13
- Both actions occur as part of the execution of the same
task;
14
- Both actions occur as part of protected actions on the
same protected object, and at most one of the actions is part of a call
on a protected function of the protected object.
15
A
pragma
Atomic or Atomic_Components may also be used to ensure that certain reads
and updates are sequential -- see
C.6.
Contents Index Previous Next Legal