- This clause specifies the priority model for real-time systems. In
addition, the methods for specifying priorities are defined.
- The form of a pragma Priority is as follows:
- The form of a pragma Interrupt_Priority is as follows:
Name Resolution Rules
- The expected type for the expression in a Priority or Interrupt_Priority
pragma is Integer.
- 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.
- 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.
- The following declarations exist in package System:
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;
Default_Priority : constant Priority := (Priority'First + Priority'Last)/2;
- 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
- 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.
- 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.
- 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.
- The effect of specifying such a pragma in a protected_definition is
discussed in D.3.
- 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.
- Likewise, the priority value is associated with the environment task if
the pragma appears in the declarative_part of the main subprogram.
- 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
- 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
- During activation, a task being activated inherits the active
priority of the its activator (see 9.2).
- During rendezvous, the task accepting the entry call inherits the
active priority of the caller (see 9.5.3).
- During a protected action on a protected object, a task inherits
the ceiling priority of the protected object (see 9.5 and D.3).
- In all of these cases, the priority ceases to be inherited as soon as
the condition calling for the inheritance no longer exists.
- The range of System.Interrupt_Priority shall include at least one value.
- The range of System.Priority shall include at least 30 values.
(4) The priority expression can include references to discriminants of
the enclosing type.
(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.
(6) An implementation may provide a non-standard mode in which tasks
inherit priorities under conditions other than those specified above.
-- Email comments, additions, corrections, gripes, kudos, etc. to:
Page last generated: 95-03-12