CVS difference for ai12s/ai12-0171-1.txt

Differences between 1.8 and version 1.9
Log of other versions for file ai12s/ai12-0171-1.txt

--- ai12s/ai12-0171-1.txt	2016/10/06 04:09:17	1.8
+++ ai12s/ai12-0171-1.txt	2016/11/11 03:53:52	1.9
@@ -1,5 +1,7 @@
-!standard D.10(7/2)                                   16-10-02  AI12-0171-1/01
+!standard D.10(11)                                   16-11-10  AI12-0171-1/02
 !class binding interpretation 15-10-05
+!status Amendment 1-2012 16-11-10
+!status ARG Approved 8-0-1  16-10-09
 !status work item 15-10-05
 !status received 15-07-10
 !priority Low
@@ -76,11 +78,10 @@
    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. Program_Error might be
-  raised in one or more of the tasks; alternatively, it might result in
-  none of the tasks suspending, or in one or more of the tasks
-  suspending, potentially indefinitely, with the state of the
-  Suspension_Object ending up either True or False.
+  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.
 
 !discussion
 
@@ -93,21 +94,22 @@
 
 Here are some comments on the example:
 
-(1) The technique shown in the example will work only for exactly two
+(1) AARM D.10(6.a) implies that design intent was that only a single task ever
+calls Suspend_Until_True.
+
+(2) The technique shown in the example will work only for exactly two
 tasks. But exactly two of anything happens very, very rarely in practice --
-after all, the fundemental rule of programming language design is that a
+after all, the fundamental rule of programming language design is that a
 language feature should be usable zero, one, or many times. Something that
 is usable exactly twice violates that.
 
-(2) AARM D.10(6.a) implies that design intent was that only a single task ever
-calls Suspend_Until_True.
-
 (3) With the introduction of the Max_Entry_Queue_Length aspect (see
 AI12-0164-1), it is trivial to declare a protected object without a queue.
 One hopes that implementations will take advantage of this aspect to create
 lightweight POs when Max_Entry_Queue_Length is set to 1 (after all, this is
 the primary purpose of the aspect). This means that it ought to be possible
-to declare a lightweight PO that allows additional calls. Such a PO could be
+to declare a lightweight PO that allows multiple simultaneous calls to
+Suspend_Until_True. Such a PO could be
 
     protected type SO with Max_Entry_Queue_Length => 1 is
         procedure Set_True;
@@ -139,6 +141,26 @@
 	    null;
 	end Suspend_Until_True;
     end SO;
+
+!corrigendum D.10(11)
+
+@dinsa
+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. 
+@dinst
+@s8<@i<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.
+
 
 !ASIS
 

Questions? Ask the ACAA Technical Agent