Contents Index Previous Next
D.1 Task Priorities
1
[This clause specifies the priority model for
real-time systems. In addition, the methods for specifying priorities
are defined.]
Syntax
2
The form of
a pragma Priority is as follows:
3
pragma Priority(
expression);
4
The form of
a pragma Interrupt_Priority is as
follows:
5
pragma Interrupt_Priority[(
expression)];
Name Resolution Rules
6
{expected type (Priority pragma
argument) [partial]} {expected
type (Interrupt_Priority pragma argument) [partial]} The
expected type for the
expression
in a Priority or Interrupt_Priority pragma is Integer.
Legality Rules
7
A Priority pragma is allowed only immediately
within a task_definition, a protected_definition,
or the declarative_part of a subprogram_body.
An Interrupt_Priority pragma is allowed only immediately within a task_definition
or a protected_definition. At most
one such pragma shall appear within a given construct.
8
For a Priority pragma that appears in the declarative_part
of a subprogram_body, the expression
shall be static, and its value shall be in the range of System.Priority.
8.a
Reason: This value is needed
before it gets elaborated, when the environment task starts executing.
Static Semantics
9
The following declarations
exist in package System:
10
subtype Any_Priority is Integer range implementation-defined;
subtype Priority is Any_Priority
range Any_Priority'First .. implementation-defined;
subtype Interrupt_Priority is Any_Priority
range Priority'Last+1 .. Any_Priority'Last;
11
Default_Priority : constant Priority := (Priority'First + Priority'Last)/2;
11.a
Implementation defined: The
declarations of Any_Priority and Priority.
12
The full range of priority values supported by
an implementation is specified by the subtype Any_Priority. The subrange
of priority values that are high enough to require the blocking of one
or more interrupts is specified by the subtype Interrupt_Priority. [The
subrange of priority values below System.Interrupt_Priority'First is
specified by the subtype System.Priority.]
13
The priority specified by a Priority or Interrupt_Priority
pragma is the value of the expression
in the pragma, if any. If there is no expression
in an Interrupt_Priority pragma, the priority value is Interrupt_Priority'Last.
Dynamic Semantics
14
A Priority pragma has no effect if it occurs
in the declarative_part of the subprogram_body
of a subprogram other than the main subprogram.
15
{task priority}
{priority} {priority
inheritance} {base priority}
{active priority} A
task priority is an integer value that indicates a degree of urgency
and is the basis for resolving competing demands of tasks for resources. Unless
otherwise specified, whenever tasks compete for processors or other implementation-defined
resources, the resources are allocated to the task with the highest priority
value. The
base priority of a task is the priority with which it was
created, or to which it was later set by Dynamic_Priorities.Set_Priority (see
D.5). At all times, a task also has an
active priority,
which generally reflects its base priority as well as any priority it inherits
from other sources.
Priority inheritance is the process by which the
priority of a task or other entity (e.g. a protected object; see
D.3)
is used in the evaluation of another task's active priority.
15.a
Implementation defined: Implementation-defined
execution resources.
16
The effect of specifying such a pragma
in a
protected_definition is discussed
in
D.3.
17
{creation (of a task
object)} The
expression
in a Priority or Interrupt_Priority pragma that appears in a
task_definition
is evaluated for each task object (see
9.1). For a
Priority pragma, the value of the
expression
is converted to the subtype Priority; for an Interrupt_Priority pragma, this
value is converted to the subtype Any_Priority. The priority value is then associated
with the task object whose
task_definition
contains the pragma.
{implicit subtype conversion (pragma Priority)
[partial]} {implicit subtype conversion
(pragma Interrupt_Priority) [partial]}
18
Likewise, the priority value is associated with
the environment task if the pragma appears in the declarative_part
of the main subprogram.
19
The initial value of a task's base
priority is specified by default or by means of a Priority or Interrupt_Priority
pragma. [After a task is created, its base priority can be changed only by a
call to Dynamic_Priorities.Set_Priority (see
D.5).]
The initial base priority of a task in the absence of a pragma is the base priority
of the task that creates it at the time of creation (see
9.1).
If a pragma Priority does not apply to the main subprogram, the initial base
priority of the environment task is System.Default_Priority. [The task's active
priority is used when the task competes for processors. Similarly, the task's
active priority is used to determine the task's position in any queue when Priority_Queuing
is specified (see
D.4).]
20
At any
time, the active priority of a task is the maximum of all the priorities the
task is inheriting at that instant. For a task that is not held (see
D.11),
its base priority is always a source of priority inheritance. Other sources
of priority inheritance are specified under the following conditions:
20.a
Discussion: Other parts of the annex,
e.g. D.11, define other sources of priority inheritance.
21/1
- {8652/0072} During
activation, a task being activated inherits the active priority that
of
the its activator (see 9.2) had at the time
the activation was initiated.
22/1
- {8652/0072} During
rendezvous, the task accepting the entry call inherits the
active priority
of the entry callcaller (see 9.5.3
and D.4).
23
- During a protected action on a protected object, a task inherits
the ceiling priority of the protected object (see 9.5
and D.3).
24
In all of these cases, the priority ceases to
be inherited as soon as the condition calling for the inheritance no
longer exists.
Implementation Requirements
25
The range of System.Interrupt_Priority shall
include at least one value.
26
The range of System.Priority shall include at
least 30 values.
27
4 The priority expression
can include references to discriminants of the enclosing type.
28
5 It is a consequence of
the active priority rules that at the point when a task stops inheriting
a priority from another source, its active priority is re-evaluated.
This is in addition to other instances described in this Annex for such
re-evaluation.
29
6 An implementation may provide
a non-standard mode in which tasks inherit priorities under conditions
other than those specified above.
29.a
Ramification: The use of
a Priority or Interrupt_Priority pragma does not require the package
System to be named in a with_clause
for the enclosing compilation_unit.
Extensions to Ada 83
29.b
{extensions to Ada 83}
The priority of a task is per-object and not per-type.
29.c
Priorities need not be static
anymore (except for the main subprogram).
Wording Changes from Ada 83
29.d
The description of the Priority
pragma has been moved to this annex.
Contents Index Previous Next Legal