Ada Reference Manual (Ada 2022) — Legal Information

# D.10 Synchronous Task Control

1/3
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

2
The following language-defined package exists:
3/5
package Ada.Synchronous_Task_Control
with Preelaborate, Nonblocking, Global => in out synchronized is
4/5
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;
5
The type Suspension_Object is a by-reference type.
5.1/3
The following language-defined package exists:
5.2/5
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

6/2
An object of the type Suspension_Object has two visible states: True and False. Upon initialization, its value is set to False.
7/2
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.
8
Current_State returns the current state of the object.
9/2
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.
10/5
Program_Error is raised upon calling Suspend_Until_True if another task is already waiting on that suspension object.
10.1/5
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

10.2/5
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

11
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.
12/3
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