D.10 Synchronous Task Control
[This subclause describes a language-defined private semaphore (suspension
object), which can be used for two-stage suspend
as a simple building block for implementing higher-level queues.]
The following language-defined
Preelaborate, Nonblocking, Global => in out synchronized is(Synchronous_Task_Control);
Suspension_Object is limited private
Set_True(S : in out
Set_False(S : in out
Current_State(S : Suspension_Object) return
Suspend_Until_True(S : in out
with Nonblocking => False
... -- not specified by the language
The type Suspension_Object is a by-reference type.
The implementation can ensure this by, for example, making the full view
an explicitly limited record type.
The following language-defined package exists:
with Nonblocking, Global => in out synchronized is
(S : in out
TS : in
with Nonblocking => False
An object of the type Suspension_Object has two visible states: True
and False. Upon initialization, its value is set to False.
Discussion: This object is assumed to
be private to the declaring task, i.e. only that task will call Suspend_Until_True
on this object, and the count of callers is at most one. Other tasks
can, of course, change and query the state of this object.
The operations Set_True and Set_False are atomic with respect to each
other and with respect to Suspend_Until_True; they set the state to True
and False respectively.
Current_State returns the current state of the object.
Discussion: This state can change immediately
after the operation returns.
The procedure Suspend_Until_True blocks the calling task until the state
of the object S is True; at that point the task becomes ready and the
state of the object becomes False.
is raised upon calling Suspend_Until_True if another task is already
waiting on that suspension object. Suspend_Until_True
is a potentially blocking operation (see 9.5.1).
The procedure Suspend_Until_True_And_Set_Deadline blocks the calling
task until the state of the object S is True; at that point the task
becomes ready with a deadline of Ada.Real_Time.Clock + TS, and the state
of the object becomes False. Program_Error is raised upon calling Suspend_Until_True_And_Set_Deadline
if another task is already waiting on that suspension object. Suspend_Until_True_And_Set_Deadline is a potentially blocking operation.
Bounded (Run-Time) Errors
It is a bounded error for two or more tasks to
call Suspend_Until_True on the same Suspension_Object concurrently. For
each task, Program_Error might be raised, the task might proceed without
suspending, or the task might suspend, potentially indefinitely. The
state of the suspension object might end up either True or False.
The implementation is required to allow the calling
of Set_False and Set_True during any protected action, even one that
has its ceiling priority in the Interrupt_Priority range.
More complex schemes, such as setting the deadline relative to when Set_True
is called, can be programmed using a protected object.
Extensions to Ada 95
Synchronous_Task_Control is now Preelaborated, so
it can be used in preelaborated units.
Extensions to Ada 2005
Child package Ada.Synchronous_Task_Control.EDF is
Wording Changes from Ada 2012
Correction: Clarified that Suspend_Until_True
should only be called from a single task, and what happens if that is
Ada 2005 and 2012 Editions sponsored in part by Ada-Europe