|
111
|
1 ------------------------------------------------------------------------------
|
|
|
2 -- --
|
|
|
3 -- GNAT RUN-TIME LIBRARY (GNARL) COMPONENTS --
|
|
|
4 -- --
|
|
|
5 -- S Y S T E M . T A S K I N G --
|
|
|
6 -- --
|
|
|
7 -- S p e c --
|
|
|
8 -- --
|
|
145
|
9 -- Copyright (C) 1992-2019, Free Software Foundation, Inc. --
|
|
111
|
10 -- --
|
|
|
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 3, or (at your option) any later ver- --
|
|
|
14 -- sion. GNAT 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. --
|
|
|
17 -- --
|
|
|
18 -- As a special exception under Section 7 of GPL version 3, you are granted --
|
|
|
19 -- additional permissions described in the GCC Runtime Library Exception, --
|
|
|
20 -- version 3.1, as published by the Free Software Foundation. --
|
|
|
21 -- --
|
|
|
22 -- You should have received a copy of the GNU General Public License and --
|
|
|
23 -- a copy of the GCC Runtime Library Exception along with this program; --
|
|
|
24 -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
|
|
|
25 -- <http://www.gnu.org/licenses/>. --
|
|
|
26 -- --
|
|
|
27 -- GNARL was developed by the GNARL team at Florida State University. --
|
|
|
28 -- Extensive contributions were provided by Ada Core Technologies, Inc. --
|
|
|
29 -- --
|
|
|
30 ------------------------------------------------------------------------------
|
|
|
31
|
|
|
32 -- This package provides necessary type definitions for compiler interface
|
|
|
33
|
|
|
34 -- Note: the compiler generates direct calls to this interface, via Rtsfind.
|
|
|
35 -- Any changes to this interface may require corresponding compiler changes.
|
|
|
36
|
|
|
37 with Ada.Exceptions;
|
|
|
38 with Ada.Unchecked_Conversion;
|
|
|
39
|
|
|
40 with System.Multiprocessors;
|
|
|
41 with System.Parameters;
|
|
|
42 with System.Soft_Links;
|
|
|
43 with System.Stack_Usage;
|
|
|
44 with System.Task_Info;
|
|
|
45 with System.Task_Primitives;
|
|
|
46
|
|
|
47 package System.Tasking is
|
|
|
48 pragma Preelaborate;
|
|
|
49
|
|
|
50 -------------------
|
|
|
51 -- Locking Rules --
|
|
|
52 -------------------
|
|
|
53
|
|
|
54 -- The following rules must be followed at all times, to prevent
|
|
|
55 -- deadlock and generally ensure correct operation of locking.
|
|
|
56
|
|
|
57 -- Never lock a lock unless abort is deferred
|
|
|
58
|
|
|
59 -- Never undefer abort while holding a lock
|
|
|
60
|
|
|
61 -- Overlapping critical sections must be properly nested, and locks must
|
|
|
62 -- be released in LIFO order. E.g., the following is not allowed:
|
|
|
63
|
|
|
64 -- Lock (X);
|
|
|
65 -- ...
|
|
|
66 -- Lock (Y);
|
|
|
67 -- ...
|
|
|
68 -- Unlock (X);
|
|
|
69 -- ...
|
|
|
70 -- Unlock (Y);
|
|
|
71
|
|
|
72 -- Locks with lower (smaller) level number cannot be locked
|
|
|
73 -- while holding a lock with a higher level number. (The level
|
|
|
74
|
|
|
75 -- 1. System.Tasking.PO_Simple.Protection.L (any PO lock)
|
|
|
76 -- 2. System.Tasking.Initialization.Global_Task_Lock (in body)
|
|
|
77 -- 3. System.Task_Primitives.Operations.Single_RTS_Lock
|
|
|
78 -- 4. System.Tasking.Ada_Task_Control_Block.LL.L (any TCB lock)
|
|
|
79
|
|
|
80 -- Clearly, there can be no circular chain of hold-and-wait
|
|
|
81 -- relationships involving locks in different ordering levels.
|
|
|
82
|
|
|
83 -- We used to have Global_Task_Lock before Protection.L but this was
|
|
|
84 -- clearly wrong since there can be calls to "new" inside protected
|
|
|
85 -- operations. The new ordering prevents these failures.
|
|
|
86
|
|
|
87 -- Sometimes we need to hold two ATCB locks at the same time. To allow us
|
|
|
88 -- to order the locking, each ATCB is given a unique serial number. If one
|
|
|
89 -- needs to hold locks on two ATCBs at once, the lock with lower serial
|
|
|
90 -- number must be locked first. We avoid holding three or more ATCB locks,
|
|
|
91 -- because that can easily lead to complications that cause race conditions
|
|
|
92 -- and deadlocks.
|
|
|
93
|
|
|
94 -- We don't always need to check the serial numbers, since the serial
|
|
|
95 -- numbers are assigned sequentially, and so:
|
|
|
96
|
|
|
97 -- . The parent of a task always has a lower serial number.
|
|
|
98 -- . The activator of a task always has a lower serial number.
|
|
|
99 -- . The environment task has a lower serial number than any other task.
|
|
|
100 -- . If the activator of a task is different from the task's parent,
|
|
|
101 -- the parent always has a lower serial number than the activator.
|
|
|
102
|
|
|
103 ---------------------------------
|
|
|
104 -- Task_Id related definitions --
|
|
|
105 ---------------------------------
|
|
|
106
|
|
|
107 type Ada_Task_Control_Block;
|
|
|
108
|
|
|
109 type Task_Id is access all Ada_Task_Control_Block;
|
|
|
110 for Task_Id'Size use System.Task_Primitives.Task_Address_Size;
|
|
|
111
|
|
|
112 Null_Task : constant Task_Id;
|
|
|
113
|
|
|
114 type Task_List is array (Positive range <>) of Task_Id;
|
|
|
115
|
|
|
116 function Self return Task_Id;
|
|
|
117 pragma Inline (Self);
|
|
|
118 -- This is the compiler interface version of this function. Do not call
|
|
|
119 -- from the run-time system.
|
|
|
120
|
|
|
121 function To_Task_Id is
|
|
|
122 new Ada.Unchecked_Conversion
|
|
|
123 (System.Task_Primitives.Task_Address, Task_Id);
|
|
|
124 function To_Address is
|
|
|
125 new Ada.Unchecked_Conversion
|
|
|
126 (Task_Id, System.Task_Primitives.Task_Address);
|
|
|
127
|
|
|
128 -----------------------
|
|
|
129 -- Enumeration types --
|
|
|
130 -----------------------
|
|
|
131
|
|
|
132 type Task_States is
|
|
|
133 (Unactivated,
|
|
|
134 -- TCB initialized but not task has not been created.
|
|
|
135 -- It cannot be executing.
|
|
|
136
|
|
|
137 -- Activating,
|
|
|
138 -- -- ??? Temporarily at end of list for GDB compatibility
|
|
|
139 -- -- Task has been created and is being made Runnable.
|
|
|
140
|
|
|
141 -- Active states
|
|
|
142 -- For all states from here down, the task has been activated.
|
|
|
143 -- For all states from here down, except for Terminated, the task
|
|
|
144 -- may be executing.
|
|
|
145 -- Activator = null iff it has not yet completed activating.
|
|
|
146
|
|
|
147 Runnable,
|
|
|
148 -- Task is not blocked for any reason known to Ada.
|
|
|
149 -- (It may be waiting for a mutex, though.)
|
|
|
150 -- It is conceptually "executing" in normal mode.
|
|
|
151
|
|
|
152 Terminated,
|
|
|
153 -- The task is terminated, in the sense of ARM 9.3 (5).
|
|
|
154 -- Any dependents that were waiting on terminate
|
|
|
155 -- alternatives have been awakened and have terminated themselves.
|
|
|
156
|
|
|
157 Activator_Sleep,
|
|
|
158 -- Task is waiting for created tasks to complete activation
|
|
|
159
|
|
|
160 Acceptor_Sleep,
|
|
|
161 -- Task is waiting on an accept or select with terminate
|
|
|
162
|
|
|
163 -- Acceptor_Delay_Sleep,
|
|
|
164 -- -- ??? Temporarily at end of list for GDB compatibility
|
|
|
165 -- -- Task is waiting on an selective wait statement
|
|
|
166
|
|
|
167 Entry_Caller_Sleep,
|
|
|
168 -- Task is waiting on an entry call
|
|
|
169
|
|
|
170 Async_Select_Sleep,
|
|
|
171 -- Task is waiting to start the abortable part of an
|
|
|
172 -- asynchronous select statement.
|
|
|
173
|
|
|
174 Delay_Sleep,
|
|
|
175 -- Task is waiting on a select statement with only a delay
|
|
|
176 -- alternative open.
|
|
|
177
|
|
|
178 Master_Completion_Sleep,
|
|
|
179 -- Master completion has two phases.
|
|
|
180 -- In Phase 1 the task is sleeping in Complete_Master
|
|
|
181 -- having completed a master within itself,
|
|
|
182 -- and is waiting for the tasks dependent on that master to become
|
|
|
183 -- terminated or waiting on a terminate Phase.
|
|
|
184
|
|
|
185 Master_Phase_2_Sleep,
|
|
|
186 -- In Phase 2 the task is sleeping in Complete_Master
|
|
|
187 -- waiting for tasks on terminate alternatives to finish
|
|
|
188 -- terminating.
|
|
|
189
|
|
|
190 -- The following are special uses of sleep, for server tasks
|
|
|
191 -- within the run-time system.
|
|
|
192
|
|
|
193 Interrupt_Server_Idle_Sleep,
|
|
|
194 Interrupt_Server_Blocked_Interrupt_Sleep,
|
|
|
195 Timer_Server_Sleep,
|
|
|
196 AST_Server_Sleep,
|
|
|
197
|
|
|
198 Asynchronous_Hold,
|
|
|
199 -- The task has been held by Asynchronous_Task_Control.Hold_Task
|
|
|
200
|
|
|
201 Interrupt_Server_Blocked_On_Event_Flag,
|
|
|
202 -- The task has been blocked on a system call waiting for a
|
|
|
203 -- completion event/signal to occur.
|
|
|
204
|
|
|
205 Activating,
|
|
|
206 -- Task has been created and is being made Runnable
|
|
|
207
|
|
|
208 Acceptor_Delay_Sleep
|
|
|
209 -- Task is waiting on an selective wait statement
|
|
|
210 );
|
|
|
211
|
|
|
212 type Call_Modes is
|
|
|
213 (Simple_Call, Conditional_Call, Asynchronous_Call, Timed_Call);
|
|
|
214
|
|
|
215 type Select_Modes is (Simple_Mode, Else_Mode, Terminate_Mode, Delay_Mode);
|
|
|
216
|
|
|
217 subtype Delay_Modes is Integer;
|
|
|
218
|
|
|
219 -------------------------------
|
|
|
220 -- Entry related definitions --
|
|
|
221 -------------------------------
|
|
|
222
|
|
|
223 Null_Entry : constant := 0;
|
|
|
224
|
|
|
225 Max_Entry : constant := Integer'Last;
|
|
|
226
|
|
|
227 Interrupt_Entry : constant := -2;
|
|
|
228
|
|
|
229 Cancelled_Entry : constant := -1;
|
|
|
230
|
|
|
231 type Entry_Index is range Interrupt_Entry .. Max_Entry;
|
|
|
232
|
|
|
233 Null_Task_Entry : constant := Null_Entry;
|
|
|
234
|
|
|
235 Max_Task_Entry : constant := Max_Entry;
|
|
|
236
|
|
|
237 type Task_Entry_Index is new Entry_Index
|
|
|
238 range Null_Task_Entry .. Max_Task_Entry;
|
|
|
239
|
|
|
240 type Entry_Call_Record;
|
|
|
241
|
|
|
242 type Entry_Call_Link is access all Entry_Call_Record;
|
|
|
243
|
|
|
244 type Entry_Queue is record
|
|
|
245 Head : Entry_Call_Link;
|
|
|
246 Tail : Entry_Call_Link;
|
|
|
247 end record;
|
|
|
248
|
|
|
249 type Task_Entry_Queue_Array is
|
|
|
250 array (Task_Entry_Index range <>) of Entry_Queue;
|
|
|
251
|
|
|
252 -- A data structure which contains the string names of entries and entry
|
|
|
253 -- family members.
|
|
|
254
|
|
|
255 type String_Access is access all String;
|
|
|
256
|
|
|
257 ----------------------------------
|
|
|
258 -- Entry_Call_Record definition --
|
|
|
259 ----------------------------------
|
|
|
260
|
|
|
261 type Entry_Call_State is
|
|
|
262 (Never_Abortable,
|
|
|
263 -- the call is not abortable, and never can be
|
|
|
264
|
|
|
265 Not_Yet_Abortable,
|
|
|
266 -- the call is not abortable, but may become so
|
|
|
267
|
|
|
268 Was_Abortable,
|
|
|
269 -- the call is not abortable, but once was
|
|
|
270
|
|
|
271 Now_Abortable,
|
|
|
272 -- the call is abortable
|
|
|
273
|
|
|
274 Done,
|
|
|
275 -- the call has been completed
|
|
|
276
|
|
|
277 Cancelled
|
|
|
278 -- the call was asynchronous, and was cancelled
|
|
|
279 );
|
|
|
280 pragma Ordered (Entry_Call_State);
|
|
|
281
|
|
|
282 -- Never_Abortable is used for calls that are made in a abort deferred
|
|
|
283 -- region (see ARM 9.8(5-11), 9.8 (20)). Such a call is never abortable.
|
|
|
284
|
|
|
285 -- The Was_ vs. Not_Yet_ distinction is needed to decide whether it is OK
|
|
|
286 -- to advance into the abortable part of an async. select stmt. That is
|
|
|
287 -- allowed iff the mode is Now_ or Was_.
|
|
|
288
|
|
|
289 -- Done indicates the call has been completed, without cancellation, or no
|
|
|
290 -- call has been made yet at this ATC nesting level, and so aborting the
|
|
|
291 -- call is no longer an issue. Completion of the call does not necessarily
|
|
|
292 -- indicate "success"; the call may be returning an exception if
|
|
|
293 -- Exception_To_Raise is non-null.
|
|
|
294
|
|
|
295 -- Cancelled indicates the call was cancelled, and so aborting the call is
|
|
|
296 -- no longer an issue.
|
|
|
297
|
|
|
298 -- The call is on an entry queue unless State >= Done, in which case it may
|
|
|
299 -- or may not be still Onqueue.
|
|
|
300
|
|
|
301 -- Please do not modify the order of the values, without checking all uses
|
|
|
302 -- of this type. We rely on partial "monotonicity" of
|
|
|
303 -- Entry_Call_Record.State to avoid locking when we access this value for
|
|
|
304 -- certain tests. In particular:
|
|
|
305
|
|
|
306 -- 1) Once State >= Done, we can rely that the call has been
|
|
|
307 -- completed. If State >= Done, it will not
|
|
|
308 -- change until the task does another entry call at this level.
|
|
|
309
|
|
|
310 -- 2) Once State >= Was_Abortable, we can rely that the call has
|
|
|
311 -- been queued abortably at least once, and so the check for
|
|
|
312 -- whether it is OK to advance to the abortable part of an
|
|
|
313 -- async. select statement does not need to lock anything.
|
|
|
314
|
|
|
315 type Restricted_Entry_Call_Record is record
|
|
|
316 Self : Task_Id;
|
|
|
317 -- ID of the caller
|
|
|
318
|
|
|
319 Mode : Call_Modes;
|
|
|
320
|
|
|
321 State : Entry_Call_State;
|
|
|
322 pragma Atomic (State);
|
|
|
323 -- Indicates part of the state of the call.
|
|
|
324 --
|
|
|
325 -- Protection: If the call is not on a queue, it should only be
|
|
|
326 -- accessed by Self, and Self does not need any lock to modify this
|
|
|
327 -- field.
|
|
|
328 --
|
|
|
329 -- Once the call is on a queue, the value should be something other
|
|
|
330 -- than Done unless it is cancelled, and access is controller by the
|
|
|
331 -- "server" of the queue -- i.e., the lock of Checked_To_Protection
|
|
|
332 -- (Call_Target) if the call record is on the queue of a PO, or the
|
|
|
333 -- lock of Called_Target if the call is on the queue of a task. See
|
|
|
334 -- comments on type declaration for more details.
|
|
|
335
|
|
|
336 Uninterpreted_Data : System.Address;
|
|
|
337 -- Data passed by the compiler
|
|
|
338
|
|
|
339 Exception_To_Raise : Ada.Exceptions.Exception_Id;
|
|
|
340 -- The exception to raise once this call has been completed without
|
|
|
341 -- being aborted.
|
|
|
342 end record;
|
|
|
343 pragma Suppress_Initialization (Restricted_Entry_Call_Record);
|
|
|
344
|
|
|
345 -------------------------------------------
|
|
|
346 -- Task termination procedure definition --
|
|
|
347 -------------------------------------------
|
|
|
348
|
|
|
349 -- We need to redefine here these types (already defined in
|
|
|
350 -- Ada.Task_Termination) for avoiding circular dependencies.
|
|
|
351
|
|
|
352 type Cause_Of_Termination is (Normal, Abnormal, Unhandled_Exception);
|
|
|
353 -- Possible causes for task termination:
|
|
|
354 --
|
|
|
355 -- Normal means that the task terminates due to completing the
|
|
|
356 -- last sentence of its body, or as a result of waiting on a
|
|
|
357 -- terminate alternative.
|
|
|
358
|
|
|
359 -- Abnormal means that the task terminates because it is being aborted
|
|
|
360
|
|
|
361 -- handled_Exception means that the task terminates because of exception
|
|
|
362 -- raised by the execution of its task_body.
|
|
|
363
|
|
|
364 type Termination_Handler is access protected procedure
|
|
|
365 (Cause : Cause_Of_Termination;
|
|
|
366 T : Task_Id;
|
|
|
367 X : Ada.Exceptions.Exception_Occurrence);
|
|
|
368 -- Used to represent protected procedures to be executed when task
|
|
|
369 -- terminates.
|
|
|
370
|
|
|
371 ------------------------------------
|
|
|
372 -- Dispatching domain definitions --
|
|
|
373 ------------------------------------
|
|
|
374
|
|
|
375 -- We need to redefine here these types (already defined in
|
|
|
376 -- System.Multiprocessor.Dispatching_Domains) for avoiding circular
|
|
|
377 -- dependencies.
|
|
|
378
|
|
|
379 type Dispatching_Domain is
|
|
|
380 array (System.Multiprocessors.CPU range <>) of Boolean;
|
|
|
381 -- A dispatching domain needs to contain the set of processors belonging
|
|
|
382 -- to it. This is a processor mask where a True indicates that the
|
|
|
383 -- processor belongs to the dispatching domain.
|
|
|
384 -- Do not use the full range of CPU_Range because it would create a very
|
|
|
385 -- long array. This way we can use the exact range of processors available
|
|
|
386 -- in the system.
|
|
|
387
|
|
|
388 type Dispatching_Domain_Access is access Dispatching_Domain;
|
|
|
389
|
|
|
390 System_Domain : Dispatching_Domain_Access;
|
|
|
391 -- All processors belong to default system dispatching domain at start up.
|
|
|
392 -- We use a pointer which creates the actual variable for the reasons
|
|
|
393 -- explained bellow in Dispatching_Domain_Tasks.
|
|
|
394
|
|
|
395 Dispatching_Domains_Frozen : Boolean := False;
|
|
|
396 -- True when the main procedure has been called. Hence, no new dispatching
|
|
|
397 -- domains can be created when this flag is True.
|
|
|
398
|
|
|
399 type Array_Allocated_Tasks is
|
|
|
400 array (System.Multiprocessors.CPU range <>) of Natural;
|
|
|
401 -- At start-up time, we need to store the number of tasks attached to
|
|
|
402 -- concrete processors within the system domain (we can only create
|
|
|
403 -- dispatching domains with processors belonging to the system domain and
|
|
|
404 -- without tasks allocated).
|
|
|
405
|
|
|
406 type Array_Allocated_Tasks_Access is access Array_Allocated_Tasks;
|
|
|
407
|
|
|
408 Dispatching_Domain_Tasks : Array_Allocated_Tasks_Access;
|
|
|
409 -- We need to store whether there are tasks allocated to concrete
|
|
|
410 -- processors in the default system dispatching domain because we need to
|
|
|
411 -- check it before creating a new dispatching domain. Two comments about
|
|
|
412 -- why we use a pointer here and not in package Dispatching_Domains:
|
|
|
413 --
|
|
|
414 -- 1) We use an array created dynamically in procedure Initialize which
|
|
|
415 -- is called at the beginning of the initialization of the run-time
|
|
|
416 -- library. Declaring a static array here in the spec would not work
|
|
|
417 -- across different installations because it would get the value of
|
|
|
418 -- Number_Of_CPUs from the machine where the run-time library is built,
|
|
|
419 -- and not from the machine where the application is executed. That is
|
|
|
420 -- the reason why we create the array (CPU'First .. Number_Of_CPUs) at
|
|
|
421 -- execution time in the procedure body, ensuring that the function
|
|
|
422 -- Number_Of_CPUs is executed at execution time (the same trick as we
|
|
|
423 -- use for System_Domain).
|
|
|
424 --
|
|
|
425 -- 2) We have moved this declaration from package Dispatching_Domains
|
|
|
426 -- because when we use a pragma CPU, the affinity is passed through the
|
|
|
427 -- call to Create_Task. Hence, at this point, we may need to update the
|
|
|
428 -- number of tasks associated to the processor, but we do not want to
|
|
|
429 -- force a dependency from this package on Dispatching_Domains.
|
|
|
430
|
|
|
431 ------------------------------------
|
|
|
432 -- Task related other definitions --
|
|
|
433 ------------------------------------
|
|
|
434
|
|
|
435 type Activation_Chain is limited private;
|
|
|
436 -- Linked list of to-be-activated tasks, linked through
|
|
|
437 -- Activation_Link. The order of tasks on the list is irrelevant, because
|
|
|
438 -- the priority rules will ensure that they actually start activating in
|
|
|
439 -- priority order.
|
|
|
440
|
|
|
441 type Activation_Chain_Access is access all Activation_Chain;
|
|
|
442
|
|
|
443 type Task_Procedure_Access is access procedure (Arg : System.Address);
|
|
|
444
|
|
|
445 type Access_Boolean is access all Boolean;
|
|
|
446
|
|
|
447 function Detect_Blocking return Boolean;
|
|
|
448 pragma Inline (Detect_Blocking);
|
|
|
449 -- Return whether the Detect_Blocking pragma is enabled
|
|
|
450
|
|
|
451 function Storage_Size (T : Task_Id) return System.Parameters.Size_Type;
|
|
|
452 -- Retrieve from the TCB of the task the allocated size of its stack,
|
|
|
453 -- either the system default or the size specified by a pragma. This is in
|
|
|
454 -- general a non-static value that can depend on discriminants of the task.
|
|
|
455
|
|
|
456 type Bit_Array is array (Integer range <>) of Boolean;
|
|
|
457 pragma Pack (Bit_Array);
|
|
|
458
|
|
|
459 subtype Debug_Event_Array is Bit_Array (1 .. 16);
|
|
|
460
|
|
|
461 Global_Task_Debug_Event_Set : Boolean := False;
|
|
|
462 -- Set True when running under debugger control and a task debug event
|
|
|
463 -- signal has been requested.
|
|
|
464
|
|
|
465 ----------------------------------------------
|
|
|
466 -- Ada_Task_Control_Block (ATCB) definition --
|
|
|
467 ----------------------------------------------
|
|
|
468
|
|
|
469 -- Notes on protection (synchronization) of TRTS data structures
|
|
|
470
|
|
|
471 -- Any field of the TCB can be written by the activator of a task when the
|
|
|
472 -- task is created, since no other task can access the new task's
|
|
|
473 -- state until creation is complete.
|
|
|
474
|
|
|
475 -- The protection for each field is described in a comment starting with
|
|
|
476 -- "Protection:".
|
|
|
477
|
|
|
478 -- When a lock is used to protect an ATCB field, this lock is simply named
|
|
|
479
|
|
|
480 -- Some protection is described in terms of tasks related to the
|
|
|
481 -- ATCB being protected. These are:
|
|
|
482
|
|
|
483 -- Self: The task which is controlled by this ATCB
|
|
|
484 -- Acceptor: A task accepting a call from Self
|
|
|
485 -- Caller: A task calling an entry of Self
|
|
|
486 -- Parent: The task executing the master on which Self depends
|
|
|
487 -- Dependent: A task dependent on Self
|
|
|
488 -- Activator: The task that created Self and initiated its activation
|
|
|
489 -- Created: A task created and activated by Self
|
|
|
490
|
|
|
491 -- Note: The order of the fields is important to implement efficiently
|
|
|
492 -- tasking support under gdb.
|
|
|
493 -- Currently gdb relies on the order of the State, Parent, Base_Priority,
|
|
|
494 -- Task_Image, Task_Image_Len, Call and LL fields.
|
|
|
495
|
|
|
496 -------------------------
|
|
|
497 -- Common ATCB section --
|
|
|
498 -------------------------
|
|
|
499
|
|
|
500 -- Section used by all GNARL implementations (regular and restricted)
|
|
|
501
|
|
|
502 type Common_ATCB is limited record
|
|
|
503 State : Task_States;
|
|
|
504 pragma Atomic (State);
|
|
|
505 -- Encodes some basic information about the state of a task,
|
|
|
506 -- including whether it has been activated, whether it is sleeping,
|
|
|
507 -- and whether it is terminated.
|
|
|
508 --
|
|
|
509 -- Protection: Self.L
|
|
|
510
|
|
|
511 Parent : Task_Id;
|
|
|
512 -- The task on which this task depends.
|
|
|
513 -- See also Master_Level and Master_Within.
|
|
|
514
|
|
|
515 Base_Priority : System.Any_Priority;
|
|
|
516 -- Base priority, not changed during entry calls, only changed
|
|
|
517 -- via dynamic priorities package.
|
|
|
518 --
|
|
|
519 -- Protection: Only written by Self, accessed by anyone
|
|
|
520
|
|
|
521 Base_CPU : System.Multiprocessors.CPU_Range;
|
|
|
522 -- Base CPU, only changed via dispatching domains package.
|
|
|
523 --
|
|
|
524 -- Protection: Self.L
|
|
|
525
|
|
|
526 Current_Priority : System.Any_Priority;
|
|
|
527 -- Active priority, except that the effects of protected object
|
|
|
528 -- priority ceilings are not reflected. This only reflects explicit
|
|
|
529 -- priority changes and priority inherited through task activation
|
|
|
530 -- and rendezvous.
|
|
|
531 --
|
|
|
532 -- Ada 95 notes: In Ada 95, this field will be transferred to the
|
|
|
533 -- Priority field of an Entry_Calls component when an entry call is
|
|
|
534 -- initiated. The Priority of the Entry_Calls component will not change
|
|
|
535 -- for the duration of the call. The accepting task can use it to boost
|
|
|
536 -- its own priority without fear of its changing in the meantime.
|
|
|
537 --
|
|
|
538 -- This can safely be used in the priority ordering of entry queues.
|
|
|
539 -- Once a call is queued, its priority does not change.
|
|
|
540 --
|
|
|
541 -- Since an entry call cannot be made while executing a protected
|
|
|
542 -- action, the priority of a task will never reflect a priority ceiling
|
|
|
543 -- change at the point of an entry call.
|
|
|
544 --
|
|
|
545 -- Protection: Only written by Self, and only accessed when Acceptor
|
|
|
546 -- accepts an entry or when Created activates, at which points Self is
|
|
|
547 -- suspended.
|
|
|
548
|
|
|
549 Protected_Action_Nesting : Natural;
|
|
|
550 pragma Atomic (Protected_Action_Nesting);
|
|
|
551 -- The dynamic level of protected action nesting for this task. This
|
|
|
552 -- field is needed for checking whether potentially blocking operations
|
|
|
553 -- are invoked from protected actions. pragma Atomic is used because it
|
|
|
554 -- can be read/written from protected interrupt handlers.
|
|
|
555
|
|
|
556 Task_Image : String (1 .. System.Parameters.Max_Task_Image_Length);
|
|
|
557 -- Hold a string that provides a readable id for task, built from the
|
|
|
558 -- variable of which it is a value or component.
|
|
|
559
|
|
|
560 Task_Image_Len : Natural;
|
|
|
561 -- Actual length of Task_Image
|
|
|
562
|
|
|
563 Call : Entry_Call_Link;
|
|
|
564 -- The entry call that has been accepted by this task.
|
|
|
565 --
|
|
|
566 -- Protection: Self.L. Self will modify this field when Self.Accepting
|
|
|
567 -- is False, and will not need the mutex to do so. Once a task sets
|
|
145
|
568 -- Pending_ATC_Level = Level_Completed_Task, no other task can access
|
|
|
569 -- this field.
|
|
111
|
570
|
|
|
571 LL : aliased Task_Primitives.Private_Data;
|
|
|
572 -- Control block used by the underlying low-level tasking service
|
|
|
573 -- (GNULLI).
|
|
|
574 --
|
|
|
575 -- Protection: This is used only by the GNULLI implementation, which
|
|
|
576 -- takes care of all of its synchronization.
|
|
|
577
|
|
|
578 Task_Arg : System.Address;
|
|
|
579 -- The argument to task procedure. Provide a handle for discriminant
|
|
|
580 -- information.
|
|
|
581 --
|
|
|
582 -- Protection: Part of the synchronization between Self and Activator.
|
|
|
583 -- Activator writes it, once, before Self starts executing. Thereafter,
|
|
|
584 -- Self only reads it.
|
|
|
585
|
|
|
586 Task_Alternate_Stack : System.Address;
|
|
|
587 -- The address of the alternate signal stack for this task, if any
|
|
|
588 --
|
|
|
589 -- Protection: Only accessed by Self
|
|
|
590
|
|
|
591 Task_Entry_Point : Task_Procedure_Access;
|
|
|
592 -- Information needed to call the procedure containing the code for
|
|
|
593 -- the body of this task.
|
|
|
594 --
|
|
|
595 -- Protection: Part of the synchronization between Self and Activator.
|
|
|
596 -- Activator writes it, once, before Self starts executing. Self reads
|
|
|
597 -- it, once, as part of its execution.
|
|
|
598
|
|
|
599 Compiler_Data : System.Soft_Links.TSD;
|
|
|
600 -- Task-specific data needed by the compiler to store per-task
|
|
|
601 -- structures.
|
|
|
602 --
|
|
|
603 -- Protection: Only accessed by Self
|
|
|
604
|
|
|
605 All_Tasks_Link : Task_Id;
|
|
|
606 -- Used to link this task to the list of all tasks in the system
|
|
|
607 --
|
|
|
608 -- Protection: RTS_Lock
|
|
|
609
|
|
|
610 Activation_Link : Task_Id;
|
|
|
611 -- Used to link this task to a list of tasks to be activated
|
|
|
612 --
|
|
|
613 -- Protection: Only used by Activator
|
|
|
614
|
|
|
615 Activator : Task_Id;
|
|
|
616 pragma Atomic (Activator);
|
|
|
617 -- The task that created this task, either by declaring it as a task
|
|
|
618 -- object or by executing a task allocator. The value is null iff Self
|
|
|
619 -- has completed activation.
|
|
|
620 --
|
|
|
621 -- Protection: Set by Activator before Self is activated, and
|
|
|
622 -- only modified by Self after that. Can be read by any task via
|
|
|
623 -- Ada.Task_Identification.Activation_Is_Complete; hence Atomic.
|
|
|
624
|
|
|
625 Wait_Count : Natural;
|
|
|
626 -- This count is used by a task that is waiting for other tasks. At all
|
|
|
627 -- other times, the value should be zero. It is used differently in
|
|
|
628 -- several different states. Since a task cannot be in more than one of
|
|
|
629 -- these states at the same time, a single counter suffices.
|
|
|
630 --
|
|
|
631 -- Protection: Self.L
|
|
|
632
|
|
|
633 -- Activator_Sleep
|
|
|
634
|
|
|
635 -- This is the number of tasks that this task is activating, i.e. the
|
|
|
636 -- children that have started activation but have not completed it.
|
|
|
637 --
|
|
|
638 -- Protection: Self.L and Created.L. Both mutexes must be locked, since
|
|
|
639 -- Self.Activation_Count and Created.State must be synchronized.
|
|
|
640
|
|
|
641 -- Master_Completion_Sleep (phase 1)
|
|
|
642
|
|
|
643 -- This is the number dependent tasks of a master being completed by
|
|
|
644 -- Self that are activated, but have not yet terminated, and are not
|
|
|
645 -- waiting on a terminate alternative.
|
|
|
646
|
|
|
647 -- Master_Completion_2_Sleep (phase 2)
|
|
|
648
|
|
|
649 -- This is the count of tasks dependent on a master being completed by
|
|
|
650 -- Self which are waiting on a terminate alternative.
|
|
|
651
|
|
|
652 Elaborated : Access_Boolean;
|
|
|
653 -- Pointer to a flag indicating that this task's body has been
|
|
|
654 -- elaborated. The flag is created and managed by the
|
|
|
655 -- compiler-generated code.
|
|
|
656 --
|
|
|
657 -- Protection: The field itself is only accessed by Activator. The flag
|
|
|
658 -- that it points to is updated by Master and read by Activator; access
|
|
|
659 -- is assumed to be atomic.
|
|
|
660
|
|
|
661 Activation_Failed : Boolean;
|
|
|
662 -- Set to True if activation of a chain of tasks fails,
|
|
|
663 -- so that the activator should raise Tasking_Error.
|
|
|
664
|
|
|
665 Task_Info : System.Task_Info.Task_Info_Type;
|
|
|
666 -- System-specific attributes of the task as specified by the
|
|
|
667 -- Task_Info pragma.
|
|
|
668
|
|
|
669 Analyzer : System.Stack_Usage.Stack_Analyzer;
|
|
|
670 -- For storing information used to measure the stack usage
|
|
|
671
|
|
|
672 Global_Task_Lock_Nesting : Natural;
|
|
|
673 -- This is the current nesting level of calls to
|
|
|
674 -- System.Tasking.Initialization.Lock_Task. This allows a task to call
|
|
|
675 -- Lock_Task multiple times without deadlocking. A task only locks
|
|
|
676 -- Global_Task_Lock when its Global_Task_Lock_Nesting goes from 0 to 1,
|
|
|
677 -- and only unlocked when it goes from 1 to 0.
|
|
|
678 --
|
|
|
679 -- Protection: Only accessed by Self
|
|
|
680
|
|
|
681 Fall_Back_Handler : Termination_Handler;
|
|
|
682 -- This is the fall-back handler that applies to the dependent tasks of
|
|
|
683 -- the task.
|
|
|
684 --
|
|
|
685 -- Protection: Self.L
|
|
|
686
|
|
|
687 Specific_Handler : Termination_Handler;
|
|
|
688 -- This is the specific handler that applies only to this task, and not
|
|
|
689 -- any of its dependent tasks.
|
|
|
690 --
|
|
|
691 -- Protection: Self.L
|
|
|
692
|
|
|
693 Debug_Events : Debug_Event_Array;
|
|
|
694 -- Word length array of per task debug events, of which 11 kinds are
|
|
|
695 -- currently defined in System.Tasking.Debugging package.
|
|
|
696
|
|
|
697 Domain : Dispatching_Domain_Access;
|
|
|
698 -- Domain is the dispatching domain to which the task belongs. It is
|
|
|
699 -- only changed via dispatching domains package. This field is made
|
|
|
700 -- part of the Common_ATCB, even when restricted run-times (namely
|
|
|
701 -- Ravenscar) do not use it, because this way the field is always
|
|
|
702 -- available to the underlying layers to set the affinity and we do not
|
|
|
703 -- need to do different things depending on the situation.
|
|
|
704 --
|
|
|
705 -- Protection: Self.L
|
|
|
706 end record;
|
|
|
707
|
|
|
708 ---------------------------------------
|
|
|
709 -- Restricted_Ada_Task_Control_Block --
|
|
|
710 ---------------------------------------
|
|
|
711
|
|
|
712 -- This type should only be used by the restricted GNARLI and by restricted
|
|
|
713 -- GNULL implementations to allocate an ATCB (see System.Task_Primitives.
|
|
|
714 -- Operations.New_ATCB) that will take significantly less memory.
|
|
|
715
|
|
|
716 -- Note that the restricted GNARLI should only access fields that are
|
|
|
717 -- present in the Restricted_Ada_Task_Control_Block structure.
|
|
|
718
|
|
|
719 type Restricted_Ada_Task_Control_Block (Entry_Num : Task_Entry_Index) is
|
|
|
720 limited record
|
|
|
721 Common : Common_ATCB;
|
|
|
722 -- The common part between various tasking implementations
|
|
|
723
|
|
|
724 Entry_Call : aliased Restricted_Entry_Call_Record;
|
|
|
725 -- Protection: This field is used on entry call "queues" associated
|
|
|
726 -- with protected objects, and is protected by the protected object
|
|
|
727 -- lock.
|
|
|
728 end record;
|
|
|
729 pragma Suppress_Initialization (Restricted_Ada_Task_Control_Block);
|
|
|
730
|
|
|
731 Interrupt_Manager_ID : Task_Id;
|
|
|
732 -- This task ID is declared here to break circular dependencies.
|
|
|
733 -- Also declare Interrupt_Manager_ID after Task_Id is known, to avoid
|
|
|
734 -- generating unneeded finalization code.
|
|
|
735
|
|
|
736 -----------------------
|
|
|
737 -- List of all Tasks --
|
|
|
738 -----------------------
|
|
|
739
|
|
|
740 All_Tasks_List : Task_Id;
|
|
|
741 -- Global linked list of all tasks
|
|
|
742
|
|
|
743 ------------------------------------------
|
|
|
744 -- Regular (non restricted) definitions --
|
|
|
745 ------------------------------------------
|
|
|
746
|
|
|
747 --------------------------------
|
|
|
748 -- Master Related Definitions --
|
|
|
749 --------------------------------
|
|
|
750
|
|
|
751 subtype Master_Level is Integer;
|
|
|
752 subtype Master_ID is Master_Level;
|
|
|
753
|
|
|
754 -- Normally, a task starts out with internal master nesting level one
|
|
|
755 -- larger than external master nesting level. It is incremented by one by
|
|
|
756 -- Enter_Master, which is called in the task body only if the compiler
|
|
|
757 -- thinks the task may have dependent tasks. It is set to 1 for the
|
|
|
758 -- environment task, the level 2 is reserved for server tasks of the
|
|
|
759 -- run-time system (the so called "independent tasks"), and the level 3 is
|
|
|
760 -- for the library level tasks. Foreign threads which are detected by
|
|
|
761 -- the run-time have a level of 0, allowing these tasks to be easily
|
|
|
762 -- distinguished if needed.
|
|
|
763
|
|
|
764 Foreign_Task_Level : constant Master_Level := 0;
|
|
|
765 Environment_Task_Level : constant Master_Level := 1;
|
|
|
766 Independent_Task_Level : constant Master_Level := 2;
|
|
|
767 Library_Task_Level : constant Master_Level := 3;
|
|
|
768
|
|
|
769 -------------------
|
|
|
770 -- Priority info --
|
|
|
771 -------------------
|
|
|
772
|
|
|
773 Unspecified_Priority : constant Integer := System.Priority'First - 1;
|
|
|
774
|
|
|
775 Priority_Not_Boosted : constant Integer := System.Priority'First - 1;
|
|
|
776 -- Definition of Priority actually has to come from the RTS configuration
|
|
|
777
|
|
|
778 subtype Rendezvous_Priority is Integer
|
|
|
779 range Priority_Not_Boosted .. System.Any_Priority'Last;
|
|
|
780
|
|
|
781 -------------------
|
|
|
782 -- Affinity info --
|
|
|
783 -------------------
|
|
|
784
|
|
|
785 Unspecified_CPU : constant := -1;
|
|
|
786 -- No affinity specified
|
|
|
787
|
|
|
788 ------------------------------------
|
|
|
789 -- Rendezvous related definitions --
|
|
|
790 ------------------------------------
|
|
|
791
|
|
|
792 No_Rendezvous : constant := 0;
|
|
|
793
|
|
|
794 Max_Select : constant Integer := Integer'Last;
|
|
|
795 -- RTS-defined
|
|
|
796
|
|
|
797 subtype Select_Index is Integer range No_Rendezvous .. Max_Select;
|
|
|
798 -- type Select_Index is range No_Rendezvous .. Max_Select;
|
|
|
799
|
|
|
800 subtype Positive_Select_Index is
|
|
|
801 Select_Index range 1 .. Select_Index'Last;
|
|
|
802
|
|
|
803 type Accept_Alternative is record
|
|
|
804 Null_Body : Boolean;
|
|
|
805 S : Task_Entry_Index;
|
|
|
806 end record;
|
|
|
807
|
|
|
808 type Accept_List is
|
|
|
809 array (Positive_Select_Index range <>) of Accept_Alternative;
|
|
|
810
|
|
|
811 type Accept_List_Access is access constant Accept_List;
|
|
|
812
|
|
|
813 -----------------------------------
|
|
|
814 -- ATC_Level related definitions --
|
|
|
815 -----------------------------------
|
|
|
816
|
|
|
817 Max_ATC_Nesting : constant Natural := 20;
|
|
145
|
818 -- The maximum number of nested asynchronous select statements supported
|
|
|
819 -- by the runtime.
|
|
111
|
820
|
|
145
|
821 subtype ATC_Level_Base is Integer range -1 .. Max_ATC_Nesting;
|
|
|
822 -- Indicates the number of nested asynchronous task control statements
|
|
|
823 -- or entries a task is in.
|
|
|
824
|
|
|
825 Level_Completed_Task : constant ATC_Level_Base := -1;
|
|
|
826 -- ATC_Level of a task that has "completed". A task reaches the completed
|
|
|
827 -- state after an abort, exception propagation, or normal exit.
|
|
111
|
828
|
|
145
|
829 Level_No_ATC_Occurring : constant ATC_Level_Base := 0;
|
|
|
830 -- ATC_Level of a task not executing a entry call or an asynchronous
|
|
|
831 -- select statement.
|
|
|
832
|
|
|
833 Level_No_Pending_Abort : constant ATC_Level_Base := ATC_Level_Base'Last;
|
|
|
834 -- ATC_Level when there is no pending abort
|
|
111
|
835
|
|
145
|
836 subtype ATC_Level is ATC_Level_Base range
|
|
|
837 Level_No_ATC_Occurring .. Level_No_Pending_Abort - 1;
|
|
|
838 -- Nested ATC_Levels valid during the execution of a task
|
|
111
|
839
|
|
145
|
840 subtype ATC_Level_Index is ATC_Level range
|
|
|
841 Level_No_ATC_Occurring + 1 .. ATC_Level'Last;
|
|
|
842 -- ATC_Levels valid when a task is executing an entry call or asynchronous
|
|
|
843 -- task control statements.
|
|
111
|
844
|
|
|
845 ----------------------------------
|
|
|
846 -- Entry_Call_Record definition --
|
|
|
847 ----------------------------------
|
|
|
848
|
|
|
849 type Entry_Call_Record is record
|
|
|
850 Self : Task_Id;
|
|
|
851 -- ID of the caller
|
|
|
852
|
|
|
853 Mode : Call_Modes;
|
|
|
854
|
|
|
855 State : Entry_Call_State;
|
|
|
856 pragma Atomic (State);
|
|
|
857 -- Indicates part of the state of the call
|
|
|
858 --
|
|
|
859 -- Protection: If the call is not on a queue, it should only be
|
|
|
860 -- accessed by Self, and Self does not need any lock to modify this
|
|
|
861 -- field. Once the call is on a queue, the value should be something
|
|
|
862 -- other than Done unless it is cancelled, and access is controller by
|
|
|
863 -- the "server" of the queue -- i.e., the lock of Checked_To_Protection
|
|
|
864 -- (Call_Target) if the call record is on the queue of a PO, or the
|
|
|
865 -- lock of Called_Target if the call is on the queue of a task. See
|
|
|
866 -- comments on type declaration for more details.
|
|
|
867
|
|
|
868 Uninterpreted_Data : System.Address;
|
|
|
869 -- Data passed by the compiler
|
|
|
870
|
|
|
871 Exception_To_Raise : Ada.Exceptions.Exception_Id;
|
|
|
872 -- The exception to raise once this call has been completed without
|
|
|
873 -- being aborted.
|
|
|
874
|
|
|
875 Prev : Entry_Call_Link;
|
|
|
876
|
|
|
877 Next : Entry_Call_Link;
|
|
|
878
|
|
|
879 Level : ATC_Level;
|
|
|
880 -- One of Self and Level are redundant in this implementation, since
|
|
|
881 -- each Entry_Call_Record is at Self.Entry_Calls (Level). Since we must
|
|
|
882 -- have access to the entry call record to be reading this, we could
|
|
|
883 -- get Self from Level, or Level from Self. However, this requires
|
|
|
884 -- non-portable address arithmetic.
|
|
|
885
|
|
|
886 E : Entry_Index;
|
|
|
887
|
|
|
888 Prio : System.Any_Priority;
|
|
|
889
|
|
|
890 -- The above fields are those that there may be some hope of packing.
|
|
|
891 -- They are gathered together to allow for compilers that lay records
|
|
|
892 -- out contiguously, to allow for such packing.
|
|
|
893
|
|
|
894 Called_Task : Task_Id;
|
|
|
895 pragma Atomic (Called_Task);
|
|
|
896 -- Use for task entry calls. The value is null if the call record is
|
|
|
897 -- not in use. Conversely, unless State is Done and Onqueue is false,
|
|
|
898 -- Called_Task points to an ATCB.
|
|
|
899 --
|
|
|
900 -- Protection: Called_Task.L
|
|
|
901
|
|
|
902 Called_PO : System.Address;
|
|
|
903 pragma Atomic (Called_PO);
|
|
|
904 -- Similar to Called_Task but for protected objects
|
|
|
905 --
|
|
|
906 -- Note that the previous implementation tried to merge both
|
|
|
907 -- Called_Task and Called_PO but this ended up in many unexpected
|
|
|
908 -- complications (e.g having to add a magic number in the ATCB, which
|
|
|
909 -- caused gdb lots of confusion) with no real gain since the
|
|
|
910 -- Lock_Server implementation still need to loop around chasing for
|
|
|
911 -- pointer changes even with a single pointer.
|
|
|
912
|
|
|
913 Acceptor_Prev_Call : Entry_Call_Link;
|
|
|
914 -- For task entry calls only
|
|
|
915
|
|
|
916 Acceptor_Prev_Priority : Rendezvous_Priority := Priority_Not_Boosted;
|
|
|
917 -- For task entry calls only. The priority of the most recent prior
|
|
|
918 -- call being serviced. For protected entry calls, this function should
|
|
|
919 -- be performed by GNULLI ceiling locking.
|
|
|
920
|
|
|
921 Cancellation_Attempted : Boolean := False;
|
|
|
922 pragma Atomic (Cancellation_Attempted);
|
|
|
923 -- Cancellation of the call has been attempted.
|
|
|
924 -- Consider merging this into State???
|
|
|
925
|
|
|
926 With_Abort : Boolean := False;
|
|
|
927 -- Tell caller whether the call may be aborted
|
|
|
928 -- ??? consider merging this with Was_Abortable state
|
|
|
929
|
|
|
930 Needs_Requeue : Boolean := False;
|
|
|
931 -- Temporary to tell acceptor of task entry call that
|
|
|
932 -- Exceptional_Complete_Rendezvous needs to do requeue.
|
|
|
933 end record;
|
|
|
934
|
|
|
935 ------------------------------------
|
|
|
936 -- Task related other definitions --
|
|
|
937 ------------------------------------
|
|
|
938
|
|
|
939 type Access_Address is access all System.Address;
|
|
|
940 -- Anonymous pointer used to implement task attributes (see s-tataat.adb
|
|
|
941 -- and a-tasatt.adb)
|
|
|
942
|
|
|
943 pragma No_Strict_Aliasing (Access_Address);
|
|
|
944 -- This type is used in contexts where aliasing may be an issue (see
|
|
|
945 -- for example s-tataat.adb), so we avoid any incorrect aliasing
|
|
|
946 -- assumptions.
|
|
|
947
|
|
|
948 ----------------------------------------------
|
|
|
949 -- Ada_Task_Control_Block (ATCB) definition --
|
|
|
950 ----------------------------------------------
|
|
|
951
|
|
|
952 type Entry_Call_Array is array (ATC_Level_Index) of
|
|
|
953 aliased Entry_Call_Record;
|
|
|
954
|
|
|
955 type Atomic_Address is mod Memory_Size;
|
|
|
956 pragma Atomic (Atomic_Address);
|
|
|
957 type Attribute_Array is
|
|
|
958 array (1 .. Parameters.Max_Attribute_Count) of Atomic_Address;
|
|
|
959 -- Array of task attributes. The value (Atomic_Address) will either be
|
|
|
960 -- converted to a task attribute if it fits, or to a pointer to a record
|
|
|
961 -- by Ada.Task_Attributes.
|
|
|
962
|
|
|
963 type Task_Serial_Number is mod 2 ** Long_Long_Integer'Size;
|
|
|
964 -- Used to give each task a unique serial number. We want 64-bits for this
|
|
|
965 -- type to get as much uniqueness as possible (2**64 is operationally
|
|
|
966 -- infinite in this context, but 2**32 perhaps could recycle). We use
|
|
|
967 -- Long_Long_Integer (which in the normal case is always 64-bits) rather
|
|
|
968 -- than 64-bits explicitly to allow codepeer to analyze this unit when
|
|
|
969 -- a target configuration file forces the maximum integer size to 32.
|
|
|
970
|
|
|
971 type Ada_Task_Control_Block (Entry_Num : Task_Entry_Index) is limited record
|
|
|
972 Common : Common_ATCB;
|
|
|
973 -- The common part between various tasking implementations
|
|
|
974
|
|
|
975 Entry_Calls : Entry_Call_Array;
|
|
|
976 -- An array of entry calls
|
|
|
977 --
|
|
|
978 -- Protection: The elements of this array are on entry call queues
|
|
|
979 -- associated with protected objects or task entries, and are protected
|
|
|
980 -- by the protected object lock or Acceptor.L, respectively.
|
|
|
981
|
|
|
982 New_Base_Priority : System.Any_Priority;
|
|
|
983 -- New value for Base_Priority (for dynamic priorities package)
|
|
|
984 --
|
|
|
985 -- Protection: Self.L
|
|
|
986
|
|
|
987 Open_Accepts : Accept_List_Access;
|
|
|
988 -- This points to the Open_Accepts array of accept alternatives passed
|
|
|
989 -- to the RTS by the compiler-generated code to Selective_Wait. It is
|
|
|
990 -- non-null iff this task is ready to accept an entry call.
|
|
|
991 --
|
|
|
992 -- Protection: Self.L
|
|
|
993
|
|
|
994 Chosen_Index : Select_Index;
|
|
|
995 -- The index in Open_Accepts of the entry call accepted by a selective
|
|
|
996 -- wait executed by this task.
|
|
|
997 --
|
|
|
998 -- Protection: Written by both Self and Caller. Usually protected by
|
|
|
999 -- Self.L. However, once the selection is known to have been written it
|
|
|
1000 -- can be accessed without protection. This happens after Self has
|
|
|
1001 -- updated it itself using information from a suspended Caller, or
|
|
|
1002 -- after Caller has updated it and awakened Self.
|
|
|
1003
|
|
131
|
1004 Master_Of_Task : Master_Level;
|
|
111
|
1005 -- The task executing the master of this task, and the ID of this task's
|
|
|
1006 -- master (unique only among masters currently active within Parent).
|
|
|
1007 --
|
|
|
1008 -- Protection: Set by Activator before Self is activated, and read
|
|
|
1009 -- after Self is activated.
|
|
|
1010
|
|
|
1011 Master_Within : Master_Level;
|
|
|
1012 -- The ID of the master currently executing within this task; that is,
|
|
|
1013 -- the most deeply nested currently active master.
|
|
|
1014 --
|
|
|
1015 -- Protection: Only written by Self, and only read by Self or by
|
|
|
1016 -- dependents when Self is attempting to exit a master. Since Self will
|
|
|
1017 -- not write this field until the master is complete, the
|
|
|
1018 -- synchronization should be adequate to prevent races.
|
|
|
1019
|
|
|
1020 Alive_Count : Natural := 0;
|
|
|
1021 -- Number of tasks directly dependent on this task (including itself)
|
|
|
1022 -- that are still "alive", i.e. not terminated.
|
|
|
1023 --
|
|
|
1024 -- Protection: Self.L
|
|
|
1025
|
|
|
1026 Awake_Count : Natural := 0;
|
|
|
1027 -- Number of tasks directly dependent on this task (including itself)
|
|
|
1028 -- still "awake", i.e., are not terminated and not waiting on a
|
|
|
1029 -- terminate alternative.
|
|
|
1030 --
|
|
|
1031 -- Invariant: Awake_Count <= Alive_Count
|
|
|
1032
|
|
|
1033 -- Protection: Self.L
|
|
|
1034
|
|
|
1035 -- Beginning of flags
|
|
|
1036
|
|
|
1037 Aborting : Boolean := False;
|
|
|
1038 pragma Atomic (Aborting);
|
|
|
1039 -- Self is in the process of aborting. While set, prevents multiple
|
|
|
1040 -- abort signals from being sent by different aborter while abort
|
|
|
1041 -- is acted upon. This is essential since an aborter which calls
|
|
|
1042 -- Abort_To_Level could set the Pending_ATC_Level to yet a lower level
|
|
|
1043 -- (than the current level), may be preempted and would send the
|
|
|
1044 -- abort signal when resuming execution. At this point, the abortee
|
|
|
1045 -- may have completed abort to the proper level such that the
|
|
|
1046 -- signal (and resulting abort exception) are not handled any more.
|
|
|
1047 -- In other words, the flag prevents a race between multiple aborters
|
|
|
1048 --
|
|
|
1049 -- Protection: protected by atomic access.
|
|
|
1050
|
|
|
1051 ATC_Hack : Boolean := False;
|
|
|
1052 pragma Atomic (ATC_Hack);
|
|
|
1053 -- ?????
|
|
|
1054 -- Temporary fix, to allow Undefer_Abort to reset Aborting in the
|
|
|
1055 -- handler for Abort_Signal that encloses an async. entry call.
|
|
|
1056 -- For the longer term, this should be done via code in the
|
|
|
1057 -- handler itself.
|
|
|
1058
|
|
|
1059 Callable : Boolean := True;
|
|
|
1060 -- It is OK to call entries of this task
|
|
|
1061
|
|
|
1062 Dependents_Aborted : Boolean := False;
|
|
|
1063 -- This is set to True by whichever task takes responsibility for
|
|
|
1064 -- aborting the dependents of this task.
|
|
|
1065 --
|
|
|
1066 -- Protection: Self.L
|
|
|
1067
|
|
|
1068 Interrupt_Entry : Boolean := False;
|
|
|
1069 -- Indicates if one or more Interrupt Entries are attached to the task.
|
|
|
1070 -- This flag is needed for cleaning up the Interrupt Entry bindings.
|
|
|
1071
|
|
|
1072 Pending_Action : Boolean := False;
|
|
|
1073 -- Unified flag indicating some action needs to be take when abort
|
|
|
1074 -- next becomes undeferred. Currently set if:
|
|
|
1075 -- . Pending_Priority_Change is set
|
|
|
1076 -- . Pending_ATC_Level is changed
|
|
|
1077 -- . Requeue involving POs
|
|
|
1078 -- (Abortable field may have changed and the Wait_Until_Abortable
|
|
|
1079 -- has to recheck the abortable status of the call.)
|
|
|
1080 -- . Exception_To_Raise is non-null
|
|
|
1081 --
|
|
|
1082 -- Protection: Self.L
|
|
|
1083 --
|
|
|
1084 -- This should never be reset back to False outside of the procedure
|
|
|
1085 -- Do_Pending_Action, which is called by Undefer_Abort. It should only
|
|
|
1086 -- be set to True by Set_Priority and Abort_To_Level.
|
|
|
1087
|
|
|
1088 Pending_Priority_Change : Boolean := False;
|
|
|
1089 -- Flag to indicate pending priority change (for dynamic priorities
|
|
|
1090 -- package). The base priority is updated on the next abort
|
|
|
1091 -- completion point (aka. synchronization point).
|
|
|
1092 --
|
|
|
1093 -- Protection: Self.L
|
|
|
1094
|
|
|
1095 Terminate_Alternative : Boolean := False;
|
|
|
1096 -- Task is accepting Select with Terminate Alternative
|
|
|
1097 --
|
|
|
1098 -- Protection: Self.L
|
|
|
1099
|
|
|
1100 -- End of flags
|
|
|
1101
|
|
|
1102 -- Beginning of counts
|
|
|
1103
|
|
145
|
1104 ATC_Nesting_Level : ATC_Level := Level_No_ATC_Occurring;
|
|
111
|
1105 -- The dynamic level of ATC nesting (currently executing nested
|
|
|
1106 -- asynchronous select statements) in this task.
|
|
|
1107
|
|
|
1108 -- Protection: Self_ID.L. Only Self reads or updates this field.
|
|
|
1109 -- Decrementing it deallocates an Entry_Calls component, and care must
|
|
|
1110 -- be taken that all references to that component are eliminated before
|
|
|
1111 -- doing the decrement. This in turn will require locking a protected
|
|
|
1112 -- object (for a protected entry call) or the Acceptor's lock (for a
|
|
|
1113 -- task entry call). No other task should attempt to read or modify
|
|
|
1114 -- this value.
|
|
|
1115
|
|
|
1116 Deferral_Level : Natural := 1;
|
|
|
1117 -- This is the number of times that Defer_Abort has been called by
|
|
|
1118 -- this task without a matching Undefer_Abort call. Abortion is only
|
|
|
1119 -- allowed when this zero. It is initially 1, to protect the task at
|
|
|
1120 -- startup.
|
|
|
1121
|
|
|
1122 -- Protection: Only updated by Self; access assumed to be atomic
|
|
|
1123
|
|
145
|
1124 Pending_ATC_Level : ATC_Level_Base := Level_No_Pending_Abort;
|
|
|
1125 -- Indicates the ATC level to which this task is currently being
|
|
|
1126 -- aborted. Two special values exist:
|
|
|
1127 --
|
|
|
1128 -- * Level_Completed_Task: the task has completed.
|
|
|
1129 --
|
|
|
1130 -- * Level_No_Pending_Abort: the task is not being aborted to any
|
|
|
1131 -- level.
|
|
|
1132 --
|
|
|
1133 -- All other values indicate the task has not completed. This should
|
|
|
1134 -- ONLY be modified by Abort_To_Level and Exit_One_ATC_Level.
|
|
111
|
1135 --
|
|
|
1136 -- Protection: Self.L
|
|
|
1137
|
|
|
1138 Serial_Number : Task_Serial_Number;
|
|
|
1139 -- Monotonic counter to provide some way to check locking rules/ordering
|
|
|
1140
|
|
|
1141 Known_Tasks_Index : Integer := -1;
|
|
|
1142 -- Index in the System.Tasking.Debug.Known_Tasks array
|
|
|
1143
|
|
|
1144 User_State : Long_Integer := 0;
|
|
|
1145 -- User-writeable location, for use in debugging tasks; also provides a
|
|
|
1146 -- simple task specific data.
|
|
|
1147
|
|
|
1148 Free_On_Termination : Boolean := False;
|
|
|
1149 -- Deallocate the ATCB when the task terminates. This flag is normally
|
|
|
1150 -- False, and is set True when Unchecked_Deallocation is called on a
|
|
|
1151 -- non-terminated task so that the associated storage is automatically
|
|
|
1152 -- reclaimed when the task terminates.
|
|
|
1153
|
|
|
1154 Attributes : Attribute_Array := (others => 0);
|
|
|
1155 -- Task attributes
|
|
|
1156
|
|
|
1157 -- IMPORTANT Note: the Entry_Queues field is last for efficiency of
|
|
|
1158 -- access to other fields, do not put new fields after this one.
|
|
|
1159
|
|
|
1160 Entry_Queues : Task_Entry_Queue_Array (1 .. Entry_Num);
|
|
|
1161 -- An array of task entry queues
|
|
|
1162 --
|
|
|
1163 -- Protection: Self.L. Once a task has set Self.Stage to Completing, it
|
|
|
1164 -- has exclusive access to this field.
|
|
|
1165 end record;
|
|
|
1166
|
|
|
1167 --------------------
|
|
|
1168 -- Initialization --
|
|
|
1169 --------------------
|
|
|
1170
|
|
|
1171 procedure Initialize;
|
|
|
1172 -- This procedure constitutes the first part of the initialization of the
|
|
|
1173 -- GNARL. This includes creating data structures to make the initial thread
|
|
|
1174 -- into the environment task. The last part of the initialization is done
|
|
|
1175 -- in System.Tasking.Initialization or System.Tasking.Restricted.Stages.
|
|
|
1176 -- All the initializations used to be in Tasking.Initialization, but this
|
|
|
1177 -- is no longer possible with the run time simplification (including
|
|
|
1178 -- optimized PO and the restricted run time) since one cannot rely on
|
|
|
1179 -- System.Tasking.Initialization being present, as was done before.
|
|
|
1180
|
|
|
1181 procedure Initialize_ATCB
|
|
|
1182 (Self_ID : Task_Id;
|
|
|
1183 Task_Entry_Point : Task_Procedure_Access;
|
|
|
1184 Task_Arg : System.Address;
|
|
|
1185 Parent : Task_Id;
|
|
|
1186 Elaborated : Access_Boolean;
|
|
|
1187 Base_Priority : System.Any_Priority;
|
|
|
1188 Base_CPU : System.Multiprocessors.CPU_Range;
|
|
|
1189 Domain : Dispatching_Domain_Access;
|
|
|
1190 Task_Info : System.Task_Info.Task_Info_Type;
|
|
|
1191 Stack_Size : System.Parameters.Size_Type;
|
|
|
1192 T : Task_Id;
|
|
|
1193 Success : out Boolean);
|
|
|
1194 -- Initialize fields of the TCB for task T, and link into global TCB
|
|
|
1195 -- structures. Call this only with abort deferred and holding RTS_Lock.
|
|
|
1196 -- Self_ID is the calling task (normally the activator of T). Success is
|
|
|
1197 -- set to indicate whether the TCB was successfully initialized.
|
|
|
1198
|
|
|
1199 private
|
|
|
1200
|
|
|
1201 Null_Task : constant Task_Id := null;
|
|
|
1202
|
|
|
1203 type Activation_Chain is limited record
|
|
|
1204 T_ID : Task_Id;
|
|
|
1205 end record;
|
|
|
1206
|
|
|
1207 -- Activation_Chain is an in-out parameter of initialization procedures and
|
|
|
1208 -- it must be passed by reference because the init proc may terminate
|
|
|
1209 -- abnormally after creating task components, and these must be properly
|
|
|
1210 -- registered for removal (Expunge_Unactivated_Tasks). The "limited" forces
|
|
|
1211 -- Activation_Chain to be a by-reference type; see RM-6.2(4).
|
|
|
1212
|
|
|
1213 function Number_Of_Entries (Self_Id : Task_Id) return Entry_Index;
|
|
|
1214 -- Given a task, return the number of entries it contains
|
|
|
1215 end System.Tasking;
|
