D.10 Synchronous Task Control
{
AI05-0299-1}
[This subclause 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.]
Static Semantics
The following language-defined
package exists:
{
AI95-00362-01}
package Ada.Synchronous_Task_Control
is
pragma Preelaborate(Synchronous_Task_Control);
type Suspension_Object
is limited private;
procedure Set_True(S :
in out Suspension_Object);
procedure Set_False(S :
in out Suspension_Object);
function Current_State(S : Suspension_Object)
return Boolean;
procedure Suspend_Until_True(S :
in out Suspension_Object);
private
... --
not specified by the language
end Ada.Synchronous_Task_Control;
The type Suspension_Object is a by-reference type.
Implementation Note: {
AI95-00318-02}
The implementation can ensure this by, for example, making the full view
an explicitly limited record type.
{
AI05-0168-1}
The following language-defined package exists:
{
AI05-0168-1}
package Ada.Synchronous_Task_Control.EDF
is
procedure Suspend_Until_True_And_Set_Deadline
(S :
in out Suspension_Object;
TS :
in Ada.Real_Time.Time_Span);
end Ada.Synchronous_Task_Control.EDF;
Dynamic Semantics
{
AI95-00114-01}
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.
{
AI95-00114-01}
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.
{
AI95-00114-01}
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.
Program_Error
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).
{
AI05-0168-1}
{
AI05-0269-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.
Implementation Requirements
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.
37 {
AI05-0168-1}
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
{
AI95-00362-01}
Synchronous_Task_Control is now Preelaborated, so
it can be used in preelaborated units.
Extensions to Ada 2005
{
AI05-0168-1}
Child package Ada.Synchronous_Task_Control.EDF is
new.
Ada 2005 and 2012 Editions sponsored in part by Ada-Europe
