Contents Index Search Previous Next
D.5 Dynamic Priorities
1
This clause specifies how the base priority of
a task can be modified or queried at run time.
Static Semantics
2
The following language-defined
library package exists:
3
with System;
with Ada.Task_Identification; -- See C.7.1
package Ada.Dynamic_Priorities is
4
procedure Set_Priority(Priority : in System.Any_Priority;
T : in Ada.Task_Identification.Task_ID :=
Ada.Task_Identification.Current_Task);
5
function Get_Priority (T : Ada.Task_Identification.Task_ID :=
Ada.Task_Identification.Current_Task)
return System.Any_Priority;
6
end Ada.Dynamic_Priorities;
Dynamic Semantics
7
The procedure Set_Priority sets the base priority
of the specified task to the specified Priority value. Set_Priority has
no effect if the task is terminated.
8
The function Get_Priority returns T's current
base priority.
Tasking_Error is raised if the task
is terminated.
9
Program_Error is raised by
Set_Priority and Get_Priority if T is equal to Null_Task_ID.
10
Setting the task's base priority to the new value
takes place as soon as is practical but not while the task is performing
a protected action. This setting occurs no later then the next abort
completion point of the task T (see
9.8).
Bounded (Run-Time) Errors
11
If a task is blocked on a
protected entry call, and the call is queued, it is a bounded error to
raise its base priority above the ceiling priority of the corresponding
protected object. When an entry call is cancelled, it is a bounded error
if the priority of the calling task is higher than the ceiling priority
of the corresponding protected object.
In either
of these cases, either Program_Error is raised in the task that called
the entry, or its priority is temporarily lowered, or both, or neither.
Erroneous Execution
12
If any subprogram in this
package is called with a parameter T that specifies a task object that
no longer exists, the execution of the program is erroneous.
Metrics
13
The implementation
shall document the following metric:
14
- The execution time of a call to Set_Priority,
for the nonpreempting case, in processor clock cycles. This is measured
for a call that modifies the priority of a ready task that is not running
(which cannot be the calling one), where the new base priority of the
affected task is lower than the active priority of the calling task,
and the affected task is not on any entry queue and is not executing
a protected operation.
15
22 Setting a task's base
priority affects task dispatching. First, it can change the task's active
priority. Second, under the standard task dispatching policy it always
causes the task to move to the tail of the ready queue corresponding
to its active priority, even if the new base priority is unchanged.
16
23 Under the priority queuing
policy, setting a task's base priority has an effect on a queued entry
call if the task is blocked waiting for the call. That is, setting the
base priority of a task causes the priority of a queued entry call from
that task to be updated and the call to be removed and then reinserted
in the entry queue at the new priority (see D.4),
unless the call originated from the triggering_statement
of an asynchronous_select.
17
24 The effect of two or
more Set_Priority calls executed in parallel on the same task is defined
as executing these calls in some serial order.
18
25 The rule for when Tasking_Error
is raised for Set_Priority or Get_Priority is different from the rule
for when Tasking_Error is raised on an entry call (see 9.5.3).
In particular, setting or querying the priority of a completed or an
abnormal task is allowed, so long as the task is not yet terminated.
19
26 Changing the priorities
of a set of tasks can be performed by a series of calls to Set_Priority
for each task separately. For this to work reliably, it should be done
within a protected operation that has high enough ceiling priority to
guarantee that the operation completes without being preempted by any
of the affected tasks.
Contents Index Search Previous Next Legal