Annotated Ada Reference ManualLegal Information
Contents   Index   References   Search   Previous   Next 

D.1 Task Priorities

{AI05-0299-1} [This subclause clause specifies the priority model for real-time systems. In addition, the methods for specifying priorities are defined.] 
Paragraphs 2 through 6 were moved to Annex J, “Obsolescent Features”. 


{AI05-0229-1} The form of a pragma Priority is as follows: 
  pragma Priority(expression);
{AI05-0229-1} The form of a pragma Interrupt_Priority is as follows: 
  pragma Interrupt_Priority[(expression);]

Name Resolution Rules

{AI05-0229-1} The expected type for the expression in a Priority or Interrupt_Priority pragma is Integer. 

Static Semantics

  {AI05-0229-1} For a task type (including the anonymous type of a single_task_declaration), protected type (including the anonymous type of a single_protected_declaration), or subprogram, the following language-defined representation aspects may be specified:
The aspect Priority is an expression, which shall be of type Integer.
Aspect Description for Priority: Priority of a task object or type, or priority of a protected object or type; the priority is not in the interrupt range.

The aspect Interrupt_Priority is an expression, which shall be of type Integer.
Aspect Description for Interrupt_Priority: Priority of a task object or type, or priority of a protected object or type; the priority is in the interrupt range.

Legality Rules

This paragraph was deleted.{AI05-0229-1} 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.
{AI05-0229-1} If the For a Priority aspect is specified for a subprogram 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.
Reason: This value is needed before it gets elaborated, when the environment task starts executing. 
  {AI05-0229-1} At most one of the Priority and Interrupt_Priority aspects may be specified for a given entity.
Ramification: This includes specifying via pragmas (see J.15.11). Note that 13.1 prevents multiple specifications of a single representation aspect by any means. 
  {AI05-0229-1} Neither of the Priority or Interrupt_Priority aspects shall be specified for a synchronized interface type.

Static Semantics

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;
Implementation defined: The declarations of Any_Priority and Priority.
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.]
 This paragraph was deleted.{AI05-0229-1} 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

 {AI05-0229-1} The A Priority aspect pragma has no effect if it is specified for it occurs in the declarative_part of the subprogram_body of a subprogram other than the main subprogram; the Priority value is not associated with any task.
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. 
Implementation defined: Implementation-defined execution resources.
 {AI05-0229-1} The effect of specifying a Priority or Interrupt_Priority aspect for a protected type or single_protected_declaration such a pragma in a protected_definition is discussed in D.3.
 {AI05-0229-1} The expression specified for the in a Priority or Interrupt_Priority aspect of a task pragma that appears in a task_definition is evaluated for each task object (see 9.1). For the a Priority aspect pragma, the value of the expression is converted to the subtype Priority; for the an Interrupt_Priority aspect pragma, this value is converted to the subtype Any_Priority. The priority value is then associated with the task object whose task declaration specifies the aspect task_definition contains the pragma.
 {AI05-0229-1} Likewise, the priority value is associated with the environment task if the aspect is specified for pragma appears in the declarative_part of the main subprogram.
 {AI05-0229-1} The initial value of a task's base priority is specified by default or by means of a Priority or Interrupt_Priority aspect 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 an aspect a pragma is the base priority of the task that creates it at the time of creation (see 9.1). If the aspect a pragma Priority is not specified for 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).]
 {AI95-00357-01} 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 unless otherwise specified for a particular task dispatching policy. Other sources of priority inheritance are specified under the following conditions: 
Discussion: Other parts of the annex, e.g. D.11, define other sources of priority inheritance. 
{8652/0072} {AI95-00092-01} 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.
{8652/0072} {AI95-00092-01} During rendezvous, the task accepting the entry call inherits the active priority of the entry call caller (see 9.5.3 and D.4).
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.

Implementation Requirements

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  {AI05-0248-1} An implementation may provide a nonstandard non-standard mode in which tasks inherit priorities under conditions other than those specified above. 
Ramification: {AI05-0229-1} The use of a Priority or Interrupt_Priority aspect pragma does not require the package System to be named in a with_clause for the enclosing compilation_unit.

Extensions to Ada 83

The priority of a task is per-object and not per-type.
Priorities need not be static anymore (except for the main subprogram).

Wording Changes from Ada 83

The description of the Priority pragma has been moved to this annex.

Wording Changes from Ada 95

{8652/0072} {AI95-00092-01} Corrigendum: Clarified that dynamic priority changes are not transitive - that is, they don't apply to tasks that are being activated by or in rendezvous with the task that had its priority changed.
{AI95-00357-01} Generalized the definition of priority inheritance to take into account the differences between the existing and new dispatching policies. 

Extensions to Ada 2005

{AI05-0229-1} Aspects Priority and Interrupt_Priority are new; pragmas Priority and Interrupt_Priority are now obsolescent. 

Contents   Index   References   Search   Previous   Next 
Ada-Europe Ada 2005 and 2012 Editions sponsored in part by Ada-Europe