D.10 Synchronous Task Control
[This subclause clause
describes a language-defined private semaphore (suspension object), which
can be used for two-stage suspend
operations and as a simple building
block for implementing higher-level queues.]
The following language-defined
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
... -- 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 a
limited record type.
The following language-defined package exists:
package Ada.Synchronous_Task_Control.EDF is
(S : in out Suspension_Object;
TS : in Ada.Real_Time.Time_Span);
An object of the type Suspension_Object has two visible states: True true
and False false
Upon initialization, its value is set to False 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 true
and False false
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 true
at that point the task becomes ready and the state of the object becomes
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.
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
Extensions to Ada 95
now Preelaborated, so it can be used in preelaborated units.
Extensions to Ada 2005
Child package Ada.Synchronous_Task_Control.EDF
Ada 2005 and 2012 Editions sponsored in part by Ada-Europe