1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
|
-- C954A03.A
--
-- Grant of Unlimited Rights
--
-- Under contracts F33600-87-D-0337, F33600-84-D-0280, MDA903-79-C-0687,
-- F08630-91-C-0015, and DCA100-97-D-0025, the U.S. Government obtained
-- unlimited rights in the software and documentation contained herein.
-- Unlimited rights are defined in DFAR 252.227-7013(a)(19). By making
-- this public release, the Government intends to confer upon all
-- recipients unlimited rights equal to those held by the Government.
-- These rights include rights to use, duplicate, release or disclose the
-- released technical data and computer software in whole or in part, in
-- any manner and for any purpose whatsoever, and to have or permit others
-- to do so.
--
-- DISCLAIMER
--
-- ALL MATERIALS OR INFORMATION HEREIN RELEASED, MADE AVAILABLE OR
-- DISCLOSED ARE AS IS. THE GOVERNMENT MAKES NO EXPRESS OR IMPLIED
-- WARRANTY AS TO ANY MATTER WHATSOEVER, INCLUDING THE CONDITIONS OF THE
-- SOFTWARE, DOCUMENTATION OR OTHER INFORMATION RELEASED, MADE AVAILABLE
-- OR DISCLOSED, OR THE OWNERSHIP, MERCHANTABILITY, OR FITNESS FOR A
-- PARTICULAR PURPOSE OF SAID MATERIAL.
--*
--
-- OBJECTIVE:
-- Check that a requeue statement in an accept_statement with
-- parameters may requeue the entry call to a protected entry with no
-- parameters. Check that, if the call is queued on the new entry's
-- queue, the original caller remains blocked after the requeue, but
-- the accept_statement containing the requeue is completed.
--
-- Note that this test uses a requeue "with abort," although it does not
-- check that such a requeued caller can be aborted; that feature is
-- tested elsewhere.
--
-- TEST DESCRIPTION:
-- Declare a protected type which simulates a printer device driver
-- (foundation code).
--
-- Declare a task which simulates a printer server for multiple printers.
--
-- For the protected type, declare an entry with a barrier that is set
-- false by a protected procedure (which simulates starting a print job
-- on the printer), and is set true by a second protected procedure (which
-- simulates a handler called when the printer interrupts, indicating
-- that printing is done).
--
-- For the task, declare an entry whose corresponding accept statement
-- contains a call to first protected procedure of the protected type
-- (which sets the barrier of the protected entry to false), followed by
-- a requeue with abort to the protected entry. Declare a second entry
-- which does nothing.
--
-- Declare a "requesting" task which calls the printer server task entry
-- (and thus executes the requeue). Verify that, following the requeue,
-- the requesting task remains blocked. Call the second entry of the
-- printer server task (the acceptance of this entry call verifies that
-- the requeue statement completed the entry call by the requesting task.
-- Call the second protected procedure of the protected type (the
-- interrupt handler) and verify that the protected entry completes for
-- the requesting task (which verifies that the requeue statement queued
-- the first task object to the protected entry).
--
-- TEST FILES:
-- This test depends on the following foundation code:
--
-- F954A00.A
--
--
-- CHANGE HISTORY:
-- 06 Dec 94 SAIC ACVC 2.0
-- 10 Oct 96 SAIC Added pragma elaborate.
--
--!
package C954A03_0 is -- Printer server abstraction.
-- Simulate a system with multiple printers. The entry Print requests
-- that data be printed on the next available printer. The entry call
-- is accepted when a printer is available, and completes when printing
-- is done.
task Printer_Server is
entry Print (File_Name : String); -- Test the requeue statement.
entry Verify_Results; -- Artifice for test purposes.
end Printer_Server;
end C954A03_0;
--==================================================================--
with Report;
with ImpDef;
with F954A00; -- Printer device abstraction.
use F954A00;
pragma Elaborate(F954a00);
package body C954A03_0 is -- Printer server abstraction.
task body Printer_Server is
Printers_Busy : Boolean := True;
Index : Printer_ID := 1;
Print_Accepted : Boolean := False;
begin
loop
-- Wait for a printer to become available:
while Printers_Busy loop
Printers_Busy := False; -- Exit loop if
-- entry accepted.
select
Printer(Index).Done_Printing; -- Accepted immed.
-- when printer is
-- available.
else
Index := 1 + (Index mod Number_Of_Printers);-- Entry not immed.
Printers_Busy := True; -- accepted; keep
end select; -- looping.
-- Allow other tasks to get control
delay ImpDef.Minimum_Task_Switch;
end loop;
-- Value of Index
-- at loop exit
-- identifies the
-- avail. printer.
-- Wait for a print request or terminate:
select
accept Print (File_Name : String) do
Print_Accepted := True; -- Allow
-- Verify_Results
-- to be accepted.
Printer(Index).Start_Printing (File_Name); -- Begin printing on
-- the available
-- -- -- printer.
-- Requeue is tested here --
-- --
-- Requeue caller so
requeue Printer(Index).Done_Printing -- server task free
with abort; -- to accept other
end Print; -- requests.
or
-- Guard ensures that Verify_Results cannot be accepted
-- until after Print has been accepted. This avoids a
-- race condition in the main program.
when Print_Accepted => accept Verify_Results; -- Artifice for
-- testing purposes.
or
terminate;
end select;
end loop;
exception
when others =>
Report.Failed ("Exception raised in Printer_Server task");
end Printer_Server;
end C954A03_0;
--==================================================================--
with Report;
with ImpDef;
with F954A00; -- Printer device abstraction.
with C954A03_0; -- Printer server abstraction.
use C954A03_0;
use F954A00;
procedure C954A03 is
Long_Enough : constant Duration := ImpDef.Clear_Ready_Queue;
--==============================================--
Task_Completed : Boolean := False; -- Testing flag.
protected Interlock is -- Artifice for test purposes.
entry Wait; -- Wait for lock to be released.
procedure Release; -- Release the lock.
private
Locked : Boolean := True;
end Interlock;
protected body Interlock is
entry Wait when not Locked is -- Calls are queued until after
-- -- Release is called.
begin
Task_Completed := True;
end Wait;
procedure Release is -- Called by Print_Request.
begin
Locked := False;
end Release;
end Interlock;
--==============================================--
task Print_Request is -- Send a print request.
end Print_Request;
task body Print_Request is
My_File : constant String := "MYFILE.DAT";
begin
Printer_Server.Print (My_File); -- Invoke requeue statement.
Interlock.Release; -- Allow main to continue.
exception
when others =>
Report.Failed ("Exception raised in Print_Request task");
end Print_Request;
--==============================================--
begin -- Main program.
Report.Test ("C954A03", "Requeue from an Accept with parameters" &
" to a Protected Entry without parameters");
-- To pass this test, the following must be true:
--
-- (A) The Print entry call made by the task Print_Request must be
-- completed by the requeue statement.
-- (B) Print_Request must remain blocked following the requeue.
-- (C) Print_Request must be queued on the Done_Printing queue of
-- Printer(1).
-- (D) Print_Request must continue execution after Done_Printing is
-- complete.
--
-- First, verify (A): that the Print entry call is complete.
--
-- Call the entry Verify_Results. If the requeue statement completed the
-- entry call to Print, the entry call to Verify_Results should be
-- accepted. Since the main will hang if this is NOT the case, make this
-- a timed entry call.
select
Printer_Server.Verify_Results; -- Accepted if requeue completed
-- entry call to Print.
or
delay Long_Enough; -- Time out otherwise.
Report.Failed ("Requeue did not complete entry call");
end select;
-- Now verify (B): that Print_Request remains blocked following the
-- requeue. Also verify that Done_Printing (the entry to which
-- Print_Request should have been queued) has not yet executed.
if Printer(1).Is_Done then
Report.Failed ("Target entry of requeue executed prematurely");
elsif Print_Request'Terminated then
Report.Failed ("Caller did not remain blocked after the requeue");
else
-- Verify (C): that Print_Request is queued on the
-- Done_Printing queue of Printer(1).
--
-- Set the barrier for Printer(1).Done_Printing to true. Check
-- that the Done flag is updated and that Print_Request terminates.
Printer(1).Handle_Interrupt; -- Simulate a printer interrupt,
-- signaling that printing is
-- done.
-- The Done_Printing entry body will complete before the next
-- protected action is called (Printer(1).Is_Done).
if not Printer(1).Is_Done then
Report.Failed ("Caller was not requeued on target entry");
end if;
-- Finally, verify (D): that Print_Request continues after Done_Printing
-- completes.
--
-- After Done_Printing completes, there is a potential race condition
-- between the main program and Print_Request. The protected object
-- Interlock is provided to ensure that the check of whether
-- Print_Request continued is made *after* it has had a chance to do so.
-- The main program waits until the statement in Print_Request following
-- the requeue-causing statement has executed, then checks to see
-- whether Print_Request did in fact continue executing.
--
-- Note that the test will hang here if Print_Request does not continue
-- executing following the completion of the requeued entry call.
Interlock.Wait; -- Wait until Print_Request is
-- done.
if not Task_Completed then
Report.Failed ("Caller remained blocked after target " &
"entry released");
end if;
-- Wait for Print_Request to finish before calling Report.Result.
while not Print_Request'Terminated loop
delay ImpDef.Minimum_Task_Switch;
end loop;
end if;
Report.Result;
end C954A03;
|
