5.1 Simple and Compound Statements - Sequences of Statements
Term entry: parallel
construct — executable construct that defines multiple activities
of a single task that can proceed in parallel, via the execution of multiple
logical threads of control
Syntax
Name Resolution Rules
Legality Rules
Static Semantics
The scope of a declaration starts at the place
of the declaration itself (see
8.2). In the
case of a label, loop, or block name, it follows from this rule that
the scope of the implicit declaration starts before the first explicit
occurrence of the corresponding name, since this occurrence is either
in a statement label, a
loop_statement,
a
block_statement,
or a
goto_statement.
An implicit declaration in a
block_statement
may hide a declaration given in an outer program unit or
block_statement
(according to the usual rules of hiding explained in
8.3).
We cannot consider
the
label
to be a defining occurrence. An example that can tell the difference
is this:
declare
-- Label Foo is implicitly declared here.
begin
for Foo in ... loop
...
<<Foo>> -- Illegal.
...
end loop;
end;
{
AI05-0299-1}
{
AI12-0449-1}
The label in this example is hidden from itself by the loop parameter
with the same name; the example is illegal. We considered creating a
new syntactic category name, separate from
direct_name
and
selector_name,
for use in the case of statement labels. However, that would confuse
the rules in
8.3 Clause
8, so we didn't do it.
Reason: The semantics of a
goto_statement
is defined in terms of the statement having (following) that label. Thus
we ensure that every label has a following statement, which might be
implicit.
Dynamic Semantics
{
AI95-00318-02}
A
transfer of control is the run-time action
of an
exit_statement,
return statement,
goto_statement,
or
requeue_statement,
selection of a
terminate_alternative,
raising of an exception, or an abort, which causes the next action performed
to be one other than what would normally be expected from the other rules
of the language. [As explained in
7.6.1,
a transfer of control can cause the execution of constructs to be completed
and then left, which may trigger finalization.]
Ramification: It could be completed by
reaching the end of it, or by a transfer of control.
{
AI12-0119-1}
Within a parallel construct, if a transfer of control
out of the construct is initiated by one of the logical threads of control,
an attempt is made to cancel
all other logical threads of control initiated by the parallel construct.
Once all other logical threads of control of the construct either complete
or are canceled, the transfer of control occurs. If two or more logical
threads of control of the same construct initiate such a transfer of
control concurrently, one of them is chosen arbitrarily and the others
are canceled.
{
AI12-0119-1}
When a logical thread of control is canceled, the
cancellation causes it to complete as though it had performed a transfer
of control to the point where it would have finished its execution. Such
a cancellation is deferred while the logical thread of control is executing
within an abort-deferred operation (see 9.8),
and may be deferred further, but not past a point where the logical thread
initiates a new nested parallel construct or reaches an exception handler
that is outside such an abort-deferred operation.
Bounded (Run-Time) Errors
{
AI12-0119-1}
{
AI12-0442-1}
During the execution of a parallel
construct, it is a bounded error to invoke an operation that is potentially
blocking (see 9.5). Program_Error is raised
if the error is detected by the implementation; otherwise, the execution
of the potentially blocking operation can either proceed normally, or
it can result in the indefinite blocking of some or all of the logical
threads of control making up the current task.
NOTE A
statement_identifier
that appears immediately within the declarative region of a named
loop_statement
or an
accept_statement
is nevertheless implicitly declared immediately within the declarative
region of the innermost enclosing body or
block_statement;
in other words, the expanded name for a named statement is not affected
by whether the statement occurs inside or outside a named loop or an
accept_statement
— only nesting within
block_statements
is relevant to the form of its expanded name.
Discussion:
Each comment in the following example gives the expanded name associated
with an entity declared in the task body:
task body Compute is
Sum : Integer := 0; -- Compute.Sum
begin
Outer: -- Compute.Outer
for I in 1..10 loop -- Compute.Outer.I
Blk: -- Compute.Blk
declare
Sum : Integer := 0; -- Compute.Blk.Sum
begin
accept Ent(I : out Integer; J : in Integer) do
-- Compute.Ent.I, Compute.Ent.J
Compute.Ent.I := Compute.Outer.I;
Inner: -- Compute.Blk.Inner
for J in 1..10 loop
-- Compute.Blk.Inner.J
Sum := Sum + Compute.Blk.Inner.J * Compute.Ent.J;
end loop Inner;
end Ent;
Compute.Sum := Compute.Sum + Compute.Blk.Sum;
end Blk;
end loop Outer;
Record_Result(Sum);
end Compute;
Examples
Examples of labeled
statements:
<<Here>> <<Ici>> <<Aqui>> <<Hier>> null;
<<After>> X := 1;
Extensions to Ada 83
Wording Changes from Ada 83
We define the syntactic category
statement_identifier
to simplify the description. It is used for labels, loop names, and block
names. We define the entity associated with the implicit declarations
of statement names.
Completion includes completion caused by a transfer
of control, although RM83-5.1(6) did not take this view.
Extensions to Ada 95
Extensions to Ada 2005
Extensions to Ada 2012
Ada 2005 and 2012 Editions sponsored in part by Ada-Europe