D.10 Synchronous Task Control
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:
package Ada.Synchronous_Task_Control
with Preelaborate, Nonblocking, Global =>
in out synchronized is
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)
with Nonblocking => False;
private
... --
not specified by the language
end Ada.Synchronous_Task_Control;
The type Suspension_Object is a by-reference type.
The following language-defined
package exists:
with Ada.Real_Time;
package Ada.Synchronous_Task_Control.EDF
with Nonblocking, Global =>
in out synchronized is
procedure Suspend_Until_True_And_Set_Deadline
(S :
in out Suspension_Object;
TS :
in Ada.Real_Time.Time_Span)
with Nonblocking => False;
end Ada.Synchronous_Task_Control.EDF;
Dynamic Semantics
An object of the type Suspension_Object has two visible
states: True and False. Upon initialization, its value is set to False.
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.
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.
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.
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 can be raised, the task can proceed without
suspending, or the task can suspend, potentially indefinitely. The state
of the suspension object can end up either True or False.
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.
NOTE More complex schemes, such as
setting the deadline relative to when Set_True is called, can be programmed
using a protected object.
Ada 2005 and 2012 Editions sponsored in part by Ada-Europe
