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
|
-- C954A02.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 if a task requeued with abort on a protected entry queue
-- is aborted, the protected entry call is canceled and the aborted
-- task becomes completed.
--
-- 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). Attempt to abort the requesting
-- task. Verify that it is aborted, that the requeued entry call is
-- canceled, and that the corresponding entry body is not executed.
--
-- 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 C954A02_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 C954A02_0;
--==================================================================--
with Report;
with ImpDef;
with F954A00; -- Printer device abstraction.
use F954A00;
pragma Elaborate(F954a00);
package body C954A02_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 task 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 C954A02_0;
--==================================================================--
with Report;
with ImpDef;
with F954A00; -- Printer device abstraction.
with C954A02_0; -- Printer server abstraction.
use C954A02_0;
use F954A00;
procedure C954A02 is
-- Length of time which simulates a very long process
Long_Enough : constant Duration := ImpDef.Clear_Ready_Queue;
--==============================================--
task Print_Request; -- Send a print request.
task body Print_Request is
My_File : constant String := "MYFILE.DAT";
begin
Printer_Server.Print (My_File); -- Invoke requeue statement.
Report.Failed ("Task continued execution following entry call");
exception
when others =>
Report.Failed ("Exception raised in Print_Request task");
end Print_Request;
--==============================================--
begin -- Main program.
Report.Test ("C954A02", "Abort a requeue on a Protected entry");
-- To pass this test, the following must be true:
--
-- (A) The abort of Print_Request takes place immediately.
-- (B) The Done_Printing entry call is canceled, and the corresponding
-- entry body is not executed.
--
-- Call the entry Verify_Results. The entry call will not be accepted
-- until after Print_Request has been requeued to Done_Printing.
Printer_Server.Verify_Results; -- Accepted after Print_Request is
-- requeued to Done_Printing.
-- Verify that the Done_Printing entry call has not been completed.
--
if Printer(1).Is_Done then
Report.Failed ("Target entry of requeue executed prematurely");
else
-- Simulate an application which needs access to the printer within
-- a specified time, and which aborts the current printer job if time
-- runs out.
select
Printer(1).Done_Printing; -- Wait for printer to come free.
or
delay Long_Enough; -- Print job took too long.
abort Print_Request; -- Abort print job.
end select;
Printer_Server.Verify_Results; -- Abortion completion point: force
-- Print_Request abort to complete.
-- Verify (A): that Print_Request has been aborted.
-- Note: the test will hang if the task as not been aborted
--
while not Print_Request'Terminated loop
delay ImpDef.Minimum_Task_Switch;
end loop;
-- Verify (B): that the Done_Printing entry call was canceled, and
-- the corresponding entry body was not executed.
--
-- Set the barrier of the entry to true, then check that the entry
-- body is not executed. If the entry call is NOT canceled, the
-- entry body will execute when the barrier is set true.
Printer(1).Handle_Interrupt; -- Simulate a printer interrupt,
-- signaling that printing is
-- done.
if Printer(1).Is_Done then
Report.Failed ("Entry call was not canceled");
end if;
end if;
Report.Result;
end C954A02;
|
