1 ------------------------------------------------------------------------------
3 -- GNU ADA RUN-TIME LIBRARY (GNARL) COMPONENTS --
5 -- S Y S T E M . T A S K I N G . U T I L I T I E S --
9 -- Copyright (C) 1992-2002, Free Software Foundation, Inc. --
11 -- GNARL is free software; you can redistribute it and/or modify it under --
12 -- terms of the GNU General Public License as published by the Free Soft- --
13 -- ware Foundation; either version 2, or (at your option) any later ver- --
14 -- sion. GNARL is distributed in the hope that it will be useful, but WITH- --
15 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
16 -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
17 -- for more details. You should have received a copy of the GNU General --
18 -- Public License distributed with GNARL; see file COPYING. If not, write --
19 -- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
20 -- MA 02111-1307, USA. --
22 -- As a special exception, if other files instantiate generics from this --
23 -- unit, or you link this unit with other files to produce an executable, --
24 -- this unit does not by itself cause the resulting executable to be --
25 -- covered by the GNU General Public License. This exception does not --
26 -- however invalidate any other reasons why the executable file might be --
27 -- covered by the GNU Public License. --
29 -- GNARL was developed by the GNARL team at Florida State University. --
30 -- Extensive contributions were provided by Ada Core Technologies, Inc. --
32 ------------------------------------------------------------------------------
34 -- This package provides RTS Internal Declarations.
35 -- These declarations are not part of the GNARLI
38 -- Turn off polling, we do not want ATC polling to take place during
39 -- tasking operations. It causes infinite loops and other problems.
41 with System.Tasking.Debug;
42 -- used for Known_Tasks
44 with System.Task_Primitives.Operations;
45 -- used for Write_Lock
53 with System.Tasking.Initialization;
54 -- Used for Defer_Abort
56 -- Locked_Abort_To_Level
58 with System.Tasking.Queuing;
59 -- used for Dequeue_Call
62 with System.Tasking.Debug;
65 with System.Parameters;
66 -- used for Single_Lock
69 with System.Traces.Tasking;
70 -- used for Send_Trace_Info
72 with Unchecked_Conversion;
74 package body System.Tasking.Utilities is
76 package STPO renames System.Task_Primitives.Operations;
81 use Task_Primitives.Operations;
84 use System.Traces.Tasking;
90 -- Similar to Locked_Abort_To_Level (Self_ID, T, 0), but:
91 -- (1) caller should be holding no locks except RTS_Lock when Single_Lock
92 -- (2) may be called for tasks that have not yet been activated
93 -- (3) always aborts whole task
95 procedure Abort_One_Task (Self_ID : Task_ID; T : Task_ID) is
97 if Parameters.Runtime_Traces then
98 Send_Trace_Info (T_Abort, Self_ID, T);
103 if T.Common.State = Unactivated then
104 T.Common.Activator := null;
105 T.Common.State := Terminated;
107 Cancel_Queued_Entry_Calls (T);
109 elsif T.Common.State /= Terminated then
110 Initialization.Locked_Abort_To_Level (Self_ID, T, 0);
120 -- Compiler interface only: Do not call from within the RTS,
122 -- except in the implementation of Ada.Task_Identification.
123 -- This must be called to implement the abort statement.
124 -- Much of the actual work of the abort is done by the abortee,
125 -- via the Abort_Handler signal handler, and propagation of the
126 -- Abort_Signal special exception.
128 procedure Abort_Tasks (Tasks : Task_List) is
129 Self_Id : constant Task_ID := STPO.Self;
134 Initialization.Defer_Abort_Nestable (Self_Id);
137 -- Really should not be nested deferral here.
138 -- Patch for code generation error that defers abort before
139 -- evaluating parameters of an entry call (at least, timed entry
140 -- calls), and so may propagate an exception that causes abort
141 -- to remain undeferred indefinitely. See C97404B. When all
142 -- such bugs are fixed, this patch can be removed.
146 for J in Tasks'Range loop
148 Abort_One_Task (Self_Id, C);
154 if C.Pending_ATC_Level > 0 then
155 P := C.Common.Parent;
158 if P.Pending_ATC_Level = 0 then
159 Abort_One_Task (Self_Id, C);
163 P := P.Common.Parent;
167 C := C.Common.All_Tasks_Link;
171 Initialization.Undefer_Abort_Nestable (Self_Id);
174 -------------------------------
175 -- Cancel_Queued_Entry_Calls --
176 -------------------------------
178 -- This should only be called by T, unless T is a terminated previously
181 procedure Cancel_Queued_Entry_Calls (T : Task_ID) is
182 Next_Entry_Call : Entry_Call_Link;
183 Entry_Call : Entry_Call_Link;
184 Self_Id : constant Task_ID := STPO.Self;
187 pragma Unreferenced (Caller);
188 -- Should this be removed ???
191 pragma Unreferenced (Level);
192 -- Should this be removed ???
195 pragma Assert (T = Self or else T.Common.State = Terminated);
197 for J in 1 .. T.Entry_Num loop
198 Queuing.Dequeue_Head (T.Entry_Queues (J), Entry_Call);
200 while Entry_Call /= null loop
202 -- Leave Entry_Call.Done = False, since this is cancelled
204 Caller := Entry_Call.Self;
205 Entry_Call.Exception_To_Raise := Tasking_Error'Identity;
206 Queuing.Dequeue_Head (T.Entry_Queues (J), Next_Entry_Call);
207 Level := Entry_Call.Level - 1;
209 Write_Lock (Entry_Call.Self);
210 Initialization.Wakeup_Entry_Caller
211 (Self_Id, Entry_Call, Cancelled);
212 Unlock (Entry_Call.Self);
214 Entry_Call.State := Done;
215 Entry_Call := Next_Entry_Call;
218 end Cancel_Queued_Entry_Calls;
220 ------------------------
221 -- Exit_One_ATC_Level --
222 ------------------------
224 -- Call only with abort deferred and holding lock of Self_Id.
225 -- This is a bit of common code for all entry calls.
226 -- The effect is to exit one level of ATC nesting.
228 -- If we have reached the desired ATC nesting level, reset the
229 -- requested level to effective infinity, to allow further calls.
230 -- In any case, reset Self_Id.Aborting, to allow re-raising of
233 procedure Exit_One_ATC_Level (Self_ID : Task_ID) is
235 Self_ID.ATC_Nesting_Level := Self_ID.ATC_Nesting_Level - 1;
238 (Debug.Trace (Self_ID, "EOAL: exited to ATC level: " &
239 ATC_Level'Image (Self_ID.ATC_Nesting_Level), 'A'));
241 pragma Assert (Self_ID.ATC_Nesting_Level >= 1);
243 if Self_ID.Pending_ATC_Level < ATC_Level_Infinity then
244 if Self_ID.Pending_ATC_Level = Self_ID.ATC_Nesting_Level then
245 Self_ID.Pending_ATC_Level := ATC_Level_Infinity;
246 Self_ID.Aborting := False;
248 -- Force the next Undefer_Abort to re-raise Abort_Signal
251 (Self_ID.Pending_ATC_Level < Self_ID.ATC_Nesting_Level);
253 if Self_ID.Aborting then
254 Self_ID.ATC_Hack := True;
255 Self_ID.Pending_Action := True;
259 end Exit_One_ATC_Level;
261 ----------------------
262 -- Make_Independent --
263 ----------------------
265 procedure Make_Independent is
266 Self_Id : constant Task_ID := STPO.Self;
267 Environment_Task : constant Task_ID := STPO.Environment_Task;
268 Parent : constant Task_ID := Self_Id.Common.Parent;
269 Parent_Needs_Updating : Boolean := False;
270 Master_of_Task : Integer;
273 if Self_Id.Known_Tasks_Index /= -1 then
274 Known_Tasks (Self_Id.Known_Tasks_Index) := null;
277 Initialization.Defer_Abort (Self_Id);
283 Write_Lock (Environment_Task);
284 Write_Lock (Self_Id);
286 pragma Assert (Parent = Environment_Task
287 or else Self_Id.Master_of_Task = Library_Task_Level);
289 Master_of_Task := Self_Id.Master_of_Task;
290 Self_Id.Master_of_Task := Independent_Task_Level;
292 -- The run time assumes that the parent of an independent task is the
295 if Parent /= Environment_Task then
297 -- We can not lock three tasks at the same time, so defer the
298 -- operations on the parent.
300 Parent_Needs_Updating := True;
301 Self_Id.Common.Parent := Environment_Task;
304 -- Update Independent_Task_Count that is needed for the GLADE
305 -- termination rule. See also pending update in
306 -- System.Tasking.Stages.Check_Independent
308 Independent_Task_Count := Independent_Task_Count + 1;
312 -- Changing the parent after creation is not trivial. Do not forget
313 -- to update the old parent counts, and the new parent (i.e. the
314 -- Environment_Task) counts.
316 if Parent_Needs_Updating then
318 Parent.Awake_Count := Parent.Awake_Count - 1;
319 Parent.Alive_Count := Parent.Alive_Count - 1;
320 Environment_Task.Awake_Count := Environment_Task.Awake_Count + 1;
321 Environment_Task.Alive_Count := Environment_Task.Alive_Count + 1;
325 -- In case the environment task is already waiting for children to
327 -- ??? There may be a race condition if the environment task was not in
328 -- master completion sleep when this task was created, but now is
330 if Environment_Task.Common.State = Master_Completion_Sleep and then
331 Master_of_Task = Environment_Task.Master_Within
333 Environment_Task.Common.Wait_Count :=
334 Environment_Task.Common.Wait_Count - 1;
337 Unlock (Environment_Task);
343 Initialization.Undefer_Abort (Self_Id);
344 end Make_Independent;
350 procedure Make_Passive (Self_ID : Task_ID; Task_Completed : Boolean) is
351 C : Task_ID := Self_ID;
352 P : Task_ID := C.Common.Parent;
354 Master_Completion_Phase : Integer;
363 if Task_Completed then
364 Self_ID.Common.State := Terminated;
366 if Self_ID.Awake_Count = 0 then
368 -- We are completing via a terminate alternative.
369 -- Our parent should wait in Phase 2 of Complete_Master.
371 Master_Completion_Phase := 2;
373 pragma Assert (Task_Completed);
374 pragma Assert (Self_ID.Terminate_Alternative);
375 pragma Assert (Self_ID.Alive_Count = 1);
378 -- We are NOT on a terminate alternative.
379 -- Our parent should wait in Phase 1 of Complete_Master.
381 Master_Completion_Phase := 1;
382 pragma Assert (Self_ID.Awake_Count = 1);
385 -- We are accepting with a terminate alternative.
388 if Self_ID.Open_Accepts = null then
390 -- Somebody started a rendezvous while we had our lock open.
391 -- Skip the terminate alternative.
402 Self_ID.Terminate_Alternative := True;
403 Master_Completion_Phase := 0;
405 pragma Assert (Self_ID.Terminate_Alternative);
406 pragma Assert (Self_ID.Awake_Count >= 1);
409 if Master_Completion_Phase = 2 then
411 -- Since our Awake_Count is zero but our Alive_Count
412 -- is nonzero, we have been accepting with a terminate
413 -- alternative, and we now have been told to terminate
414 -- by a completed master (in some ancestor task) that
415 -- is waiting (with zero Awake_Count) in Phase 2 of
418 pragma Debug (Debug.Trace (Self_ID, "Make_Passive: Phase 2", 'M'));
420 pragma Assert (P /= null);
422 C.Alive_Count := C.Alive_Count - 1;
424 if C.Alive_Count > 0 then
430 -- C's count just went to zero, indicating that
431 -- all of C's dependents are terminated.
432 -- C has a parent, P.
435 -- C's count just went to zero, indicating that all of C's
436 -- dependents are terminated. C has a parent, P. Notify P that
437 -- C and its dependents have all terminated.
439 P.Alive_Count := P.Alive_Count - 1;
440 exit when P.Alive_Count > 0;
444 P := C.Common.Parent;
446 -- Environment task cannot have terminated yet
448 pragma Assert (P /= null);
454 pragma Assert (P.Awake_Count /= 0);
456 if P.Common.State = Master_Phase_2_Sleep
457 and then C.Master_of_Task = P.Master_Within
459 pragma Assert (P.Common.Wait_Count > 0);
460 P.Common.Wait_Count := P.Common.Wait_Count - 1;
462 if P.Common.Wait_Count = 0 then
463 Wakeup (P, Master_Phase_2_Sleep);
472 -- We are terminating in Phase 1 or Complete_Master,
473 -- or are accepting on a terminate alternative.
475 C.Awake_Count := C.Awake_Count - 1;
477 if Task_Completed then
478 pragma Assert (Self_ID.Awake_Count = 0);
479 C.Alive_Count := C.Alive_Count - 1;
482 if C.Awake_Count > 0 or else P = null then
492 -- C's count just went to zero, indicating that all of C's
493 -- dependents are terminated or accepting with terminate alt.
494 -- C has a parent, P.
497 -- Notify P that C has gone passive.
499 P.Awake_Count := P.Awake_Count - 1;
501 if Task_Completed and then C.Alive_Count = 0 then
502 P.Alive_Count := P.Alive_Count - 1;
505 exit when P.Awake_Count > 0;
509 P := C.Common.Parent;
519 -- P has non-passive dependents.
521 if P.Common.State = Master_Completion_Sleep
522 and then C.Master_of_Task = P.Master_Within
526 (Self_ID, "Make_Passive: Phase 1, parent waiting", 'M'));
528 -- If parent is in Master_Completion_Sleep, it
529 -- cannot be on a terminate alternative, hence
530 -- it cannot have Awake_Count of zero.
532 pragma Assert (P.Common.Wait_Count > 0);
533 P.Common.Wait_Count := P.Common.Wait_Count - 1;
535 if P.Common.Wait_Count = 0 then
536 Wakeup (P, Master_Completion_Sleep);
542 (Self_ID, "Make_Passive: Phase 1, parent awake", 'M'));
550 end System.Tasking.Utilities;