D.2.4 Non-Preemptive Dispatching
[This clause defines a non-preemptive task dispatching
The following language-defined library package
package Ada.Dispatching.Non_Preemptive is
procedure Yield_To_Same_Or_Higher renames Yield;
A call of Yield_To_Higher is a task dispatching
point for this policy. If the task at the head of the highest priority
ready queue has a higher active priority than the calling task, then
the calling task is preempted.
language-defined policies other than Non_Preemptive, a higher priority
task should never be on a ready queue while a lower priority task is
executed. Thus, for such policies, Yield_To_Higher does nothing.
Yield_To_Higher is not
a potentially blocking operation; it can be used during a protected operation.
That is allowed, as under the predefined Ceiling_Locking policy any task
with a higher priority than the protected operation cannot call the operation
(that would violate the locking policy). An implementation-defined locking
policy may need to define the semantics of Yield_To_Higher differently.
Reason: The non-preemptive
nature of this policy could cause the policies of higher priority tasks
to malfunction, missing deadlines and having unlimited priority inversion.
That would render the use of such policies impotent and misleading. As
such, this policy only makes sense for a complete system.
When Non_Preemptive_FIFO_Within_Priorities is in
effect, modifications to the ready queues occur only as follows:
When a blocked task becomes ready, it is added
at the tail of the ready queue for its active priority.
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.
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.
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.
the delay does result in blocking, the task moves to the “delay
queue”, not to the ready queue.
For this policy, blocking
or termination of a task, a non-blocking delay_statement,
a call to Yield_To_Higher, and a call to Yield_To_Same_Or_Higher or Yield
are is the only non-blocking event that is a task
dispatching points point (see D.2.1).
is always a task dispatching point even if it is not blocking. Similarly,
a call to Yield_To_Higher is never blocking, but it is a task dispatching
point In each of these cases, they can cause the current task to stop
running (it is still ready). Otherwise, the running task continues to
run until it is blocked.
An implementation shall allow, for a single partition,
both the task dispatching policy to be specified as Non_Preemptive_FIFO_Within_Priorities
and also the locking policy (see D.3) to be
specified as Ceiling_Locking.
Reason: This is
the preferred combination of the Non_Preemptive_FIFO_Within_Priorities
policy with a locking policy, and we want that combination to be portable.
Since implementations are allowed to round all
ceiling priorities in subrange System.Priority to System.Priority'Last
(see D.3), an implementation may allow a task
to execute within a protected object without raising its active priority
provided the associated protected unit does not contain any
subprograms with Interrupt_Handler or Attach_Handler specified nor does
the unit have aspect pragma Interrupt_Priority specified,
Interrupt_Handler, or Attach_Handler.
Extensions to Ada 95
Extensions to Ada 2005
Ada 2005 and 2012 Editions sponsored in part by Ada-Europe