- This clause specifies how the base priority of a task can be modified or
queried at run time.
- The following language-defined library package exists:
with Ada.Task_Identification; -- See C.7.1
package Ada.Dynamic_Priorities is
procedure Set_Priority(Priority : in System.Any_Priority;
T : in Ada.Task_Identification.Task_ID :=
function Get_Priority (T : Ada.Task_Identification.Task_ID :=
- 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
- The function Get_Priority returns T's current base priority. Tasking_Error is raised if the task is terminated.
- Program_Error is raised by Set_Priority and Get_Priority if T is equal to
- 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
Bounded (Run-Time) Errors
- 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.
- 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
- The implementation shall document the following metric:
- 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.
(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.
(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.
(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
(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.
(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.
-- Email comments, additions, corrections, gripes, kudos, etc. to:
Page last generated: 95-03-12