D.2.2 Task Dispatching PragmasThe Standard Task Dispatching Policy
0.1/2
{
AI95-00355-01}
[This clause allows a single task dispatching policy
to be defined for all priorities, or the range of priorities to be split
into subranges that are assigned individual dispatching policies.]
Syntax
1
The form of a
pragma
Task_Dispatching_Policy is as follows:
2
pragma Task_Dispatching_Policy(
policy_identifier);
2.1/2
2.2/2
Name Resolution Rules
2.3/2
Legality Rules
3/2
3.a/2
This paragraph
was deleted.Implementation defined:
Implementation-defined policy_identifiers
allowed in a pragma
Task_Dispatching_Policy.
3.1/2
3.2/2
Static Semantics
3.3/2
3.4/2
{
AI95-00355-01}
Pragma
Priority_Specific_Dispatching specifies the task dispatching policy for
the specified range of priorities. Tasks with base priorities within
the range of priorities specified in a Priority_Specific_Dispatching
pragma have their active priorities determined according to the specified
dispatching policy. Tasks with active priorities within the range of
priorities specified in a Priority_Specific_Dispatching pragma are dispatched
according to the specified dispatching policy. 3.b/2
Reason: {
AI95-00355-01}
Each ready queue is managed by exactly one policy.
Anything else would be chaos. The ready queue is determined by the active
priority. However, how the active priority is calculated is determined
by the policy; in order to break out of this circle, we have to say that
the active priority is calculated by the method determined by the policy
of the base priority.
3.5/3
{
AI95-00355-01}
{
AI05-0262-1}
If a partition contains one or more Priority_Specific_Dispatching
pragmas, the
dispatching policy for priorities not covered by any Priority_Specific_Dispatching
pragmas is FIFO_Within_Priorities.Post-Compilation Rules
4/2
{
AI95-00355-01}
A Task_Dispatching_Policy pragma
is a configuration pragma.
A Priority_Specific_Dispatching
pragma is a configuration pragma. 4.1/2
{
AI95-00355-01}
The priority ranges specified in more than one
Priority_Specific_Dispatching pragma within the same partition shall
not be overlapping.4.2/2
{
AI95-00355-01}
If a partition contains one or more Priority_Specific_Dispatching
pragmas it shall not contain a Task_Dispatching_Policy pragma.5/2
This paragraph was
deleted.{
AI95-00333-01}
If the FIFO_Within_Priorities policy is specified
for a partition, then the Ceiling_Locking policy (see D.3)
shall also be specified for the partition.
Dynamic Semantics
6/2
{
AI95-00355-01}
[A
task dispatching policy specifies the details
of task dispatching that are not covered by the basic task dispatching
model. These rules govern when tasks are inserted into and deleted from
the ready queues
, and whether a task is inserted
at the head or the tail of the queue for its active priority.]
A single The
task dispatching policy is specified by a Task_Dispatching_Policy
configuration
pragma.
Pragma Priority_Specific_Dispatching
assigns distinct dispatching policies to subranges of System.Any_Priority. If
no such pragma appears in any of the program units comprising a partition,
the task dispatching policy for that partition is unspecified.6.1/2
{
AI95-00355-01}
If neither pragma
applies to any of the program units comprising a partition, the task
dispatching policy for that partition is unspecified.6.2/3
{
AI95-00355-01}
{
AI05-0262-1}
If a partition contains one or more Priority_Specific_Dispatching
pragmas, a
task dispatching point occurs for the currently running task of a processor
whenever there is a non-empty ready queue for that processor with a higher
priority than the priority of the running task.6.a/2
Discussion: If
we have priority specific dispatching then we want preemption across
the entire range of priorities. That prevents higher priority tasks from
being blocked by lower priority tasks that have a different policy. On
the other hand, if we have a single policy for the entire partition,
we want the characteristics of that policy to apply for preemption; specifically,
we may not require any preemption. Note that policy Non_Preemptive_FIFO_Within_Priorities
is not allowed in a priority specific dispatching pragma.
6.3/2
{
AI95-00355-01}
A task that has its base priority changed may move
from one dispatching policy to another. It is immediately subject to
the new dispatching policy.6.b/2
Ramification: Once
subject to the new dispatching policy, it may be immediately preempted
or dispatched, according the rules of the new policy.
Paragraphs
7 through 13 were moved to D.2.3.
7/2
{
AI95-00321-01}
The language defines only one task dispatching
policy, FIFO_Within_Priorities; when this policy is in effect, modifications
to the ready queues occur only as follows:8/2
{
AI95-00321-01}
When a blocked task becomes ready, it is added
at the tail of the ready queue for its active priority.9/2
{
AI95-00321-01}
When the active priority of a ready task that is
not running changes, or the setting of its base priority takes effect,
the task is removed from the ready queue for its old active priority
and is added at the tail of the ready queue for its new active priority,
except in the case where the active priority is lowered due to the loss
of inherited priority, in which case the task is added at the head of
the ready queue for its new active priority.10/2
{
AI95-00321-01}
When the setting of the base priority of a running
task takes effect, the task is added to the tail of the ready queue for
its active priority.11/2
{
AI95-00321-01}
When a task executes a delay_statement
that does not result in blocking, it is added to the tail of the ready
queue for its active priority. 11.a/2
Ramification: If
the delay does result in blocking, the task moves to the “delay
queue”, not to the ready queue.
12/2
{
AI95-00321-01}
Each of
the events specified above is a task dispatching point (see D.2.1).13/2
{
AI95-00321-01}
In addition, when a task is preempted, it is added
at the head of the ready queue for its active priority.Implementation Requirements
13.1/2
{
AI95-00333-01}
{
AI95-00355-01}
An implementation shall allow, for a single partition,
both the locking policy (see D.3) to be specified
as Ceiling_Locking and also one or more Priority_Specific_Dispatching
pragmas to be given. Documentation Requirements
Paragraphs
14 through 16 were moved to D.2.3.
14/2
{
AI95-00321-01}
Priority inversion is
the duration for which a task remains at the head of the highest priority
ready queue while the processor executes a lower priority task. The implementation
shall document: 15/2
{
AI95-00321-01}
The maximum priority inversion a user task can
experience due to activity of the implementation (on behalf of lower
priority tasks), and16/2
{
AI95-00321-01}
whether execution of a task can be preempted by
the implementation processing of delay expirations for lower priority
tasks, and if so, for how long. 16.a/2
This paragraph
was deleted.Implementation defined:
Implementation-defined aspects of priority
inversion.
Implementation Permissions
17/2
{
AI95-00256-01}
Implementations are allowed to define other task dispatching policies,
but need not support more than one
task dispatching such
policy per partition.
18/2
{
AI95-00355-01}
An implementation need not support pragma
Priority_Specific_Dispatching if it is infeasible to support it in the
target environment. [For optimization purposes,]
an implementation may alter the points at which task dispatching occurs,
in an implementation defined manner. However, a delay_statement
always corresponds to at least one task dispatching point.18.a/2
Implementation defined: Implementation
defined task dispatching policies.
Paragraphs
19 through 21 were deleted.
19/2
14 {
AI95-00321-01}
If the active priority of a running task is lowered
due to loss of inherited priority (as it is on completion of a protected
operation) and there is a ready task of the same active priority that
is not running, the running task continues to run (provided that there
is no higher priority task).20/2
15 {
AI95-00321-01}
The setting of a task's base priority as a result
of a call to Set_Priority does not always take effect immediately when
Set_Priority is called. The effect of setting the task's base priority
is deferred while the affected task performs a protected action.21/2
16 {
AI95-00321-01}
Setting the base priority of a ready task causes
the task to move to the end of the queue for its active priority, regardless
of whether the active priority of the task actually changes.Extensions to Ada 95
21.a/2
{
AI95-00333-01}
Amendment Correction:
It is no longer required to specify Ceiling_Locking with the language-defined
task dispatching policies; we only require that implementations allow
them to be used together.21.b/3
{
AI95-00355-01}
{
AI05-0005-1}
Pragma Priority_Specific_Dispatching is
new; it allows the specification of specifying different policies for different priorities. Wording Changes from Ada 95
21.c/2
{
AI95-00256-01}
Clarified that an implementation need support only
one task dispatching policy (of any kind, language-defined or otherwise)
per partition.21.d/2
{
AI95-00321-01}
This description is simplified to describe only
the rules for the Task_Dispatching_Policy pragma that are common to all
policies. In particular, rules about preemption are moved elsewhere.
This makes it easier to add other policies (which may not involve preemption).
Ada 2005 and 2012 Editions sponsored in part by Ada-Europe
