OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [ada/] [acats/] [tests/] [c9/] [c954011.a] - Blame information for rev 720

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 720 jeremybenn
-- C954011.A
2
--
3
--                             Grant of Unlimited Rights
4
--
5
--     Under contracts F33600-87-D-0337, F33600-84-D-0280, MDA903-79-C-0687,
6
--     F08630-91-C-0015, and DCA100-97-D-0025, the U.S. Government obtained
7
--     unlimited rights in the software and documentation contained herein.
8
--     Unlimited rights are defined in DFAR 252.227-7013(a)(19).  By making
9
--     this public release, the Government intends to confer upon all
10
--     recipients unlimited rights  equal to those held by the Government.
11
--     These rights include rights to use, duplicate, release or disclose the
12
--     released technical data and computer software in whole or in part, in
13
--     any manner and for any purpose whatsoever, and to have or permit others
14
--     to do so.
15
--
16
--                                    DISCLAIMER
17
--
18
--     ALL MATERIALS OR INFORMATION HEREIN RELEASED, MADE AVAILABLE OR
19
--     DISCLOSED ARE AS IS.  THE GOVERNMENT MAKES NO EXPRESS OR IMPLIED
20
--     WARRANTY AS TO ANY MATTER WHATSOEVER, INCLUDING THE CONDITIONS OF THE
21
--     SOFTWARE, DOCUMENTATION OR OTHER INFORMATION RELEASED, MADE AVAILABLE
22
--     OR DISCLOSED, OR THE OWNERSHIP, MERCHANTABILITY, OR FITNESS FOR A
23
--     PARTICULAR PURPOSE OF SAID MATERIAL.
24
--*
25
--
26
-- OBJECTIVE:
27
--      Check that a requeue is placed on the correct entry; that the
28
--      original caller waits for the completion of the requeued rendezvous;
29
--      that the original caller continues after the rendezvous.
30
--      Specifically, this test checks requeue to an entry in a different
31
--      task, requeue where the entry has parameters, and requeue with
32
--      abort.
33
--
34
-- TEST DESCRIPTION:
35
--      In the Distributor task, requeue two successive calls on the entries
36
--      of two separate target tasks.  Each task in each of the  paths adds
37
--      identifying information in the transaction being passed.  This
38
--      information is checked by the Message tasks on completion ensuring that
39
--      the requeues have been placed on the correct queues.
40
--
41
--      This series of tests uses a simulation of a transaction driven
42
--      processing system.  Line Drivers accept input from an external source
43
--      and build them into transaction records.  These records are then
44
--      encapsulated in message tasks which remain extant for the life of the
45
--      transaction in the system. The message tasks put themselves on the
46
--      input queue of a Distributor which, from information in the
47
--      transaction and/or system load conditions forwards them to other
48
--      operating tasks. These in turn might forward the transactions to yet
49
--      other tasks for further action.  The routing is, in real life,
50
--      dynamic and unpredictable at the time of message generation. All
51
--      rerouting in this  model is done by means of requeues.
52
--
53
--
54
-- CHANGE HISTORY:
55
--      06 Dec 94   SAIC    ACVC 2.0
56
--      26 Nov 95   SAIC    Fixed problems with shared global variables
57
--                          for ACVC 2.0.1
58
--
59
--!
60
 
61
with Report;
62
with ImpDef;
63
 
64
procedure C954011 is
65
 
66
 
67
   -- Arbitrary test values
68
   Credit_Return : constant := 1;
69
   Debit_Return  : constant := 2;
70
 
71
   type Transaction_Code is (Credit, Debit);
72
 
73
   type Transaction_Record;
74
   type acc_Transaction_Record is access Transaction_Record;
75
   type Transaction_Record is
76
      record
77
         ID               : integer := 0;
78
         Code             : Transaction_Code := Debit;
79
         Account_Number   : integer := 0;
80
         Stock_Number     : integer := 0;
81
         Quantity         : integer := 0;
82
         Return_Value     : integer := 0;
83
         TC_Message_Count : integer := 0;
84
         TC_Thru_Distrib  : Boolean := false;
85
      end record;
86
 
87
   protected type Message_Mgr is
88
      procedure Mark_Complete;
89
      function Is_Complete return Boolean;
90
   private
91
      Complete : Boolean := False;
92
   end Message_Mgr;
93
 
94
   protected body Message_Mgr is
95
      procedure Mark_Complete is
96
      begin
97
         Complete := True;
98
      end Mark_Complete;
99
 
100
      Function Is_Complete return Boolean is
101
      begin
102
         return Complete;
103
      end Is_Complete;
104
   end Message_Mgr;
105
 
106
   TC_Debit_Message  : Message_Mgr;
107
   TC_Credit_Message : Message_Mgr;
108
 
109
 
110
   task type Message_Task is
111
      entry Accept_Transaction (In_Transaction : acc_Transaction_Record);
112
   end Message_Task;
113
   type acc_Message_Task is access Message_Task;
114
 
115
   task Line_Driver is
116
      entry Start;
117
   end Line_Driver;
118
 
119
   task Distributor is
120
      entry Input(Transaction : acc_Transaction_Record);
121
   end Distributor;
122
 
123
   task Credit_Computation is
124
      entry Input(Transaction : acc_Transaction_Record);
125
   end Credit_Computation;
126
 
127
   task Debit_Computation is
128
      entry Input(Transaction : acc_Transaction_Record);
129
   end Debit_Computation;
130
 
131
 
132
 
133
   -- Assemble messages received from an external source
134
   --   Creates a message task for each. The message tasks remain extant
135
   --   for the life of the messages in the system.
136
   --      The Line Driver task would normally be designed to loop continuously
137
   --      creating the messages as input is received.  Simulate this
138
   --      but limit it to two dummy messages for this test and allow it
139
   --      to terminate at that point
140
   --
141
   task body Line_Driver is
142
      Current_ID : integer := 1;
143
      TC_Last_was_for_credit : Boolean := false;
144
 
145
      procedure Build_Credit_Record
146
                              ( Next_Transaction : acc_Transaction_Record ) is
147
         Dummy_Account : constant integer := 100;
148
      begin
149
            Next_Transaction.ID := Current_ID;
150
            Next_Transaction.Code := Credit;
151
 
152
            Next_Transaction.Account_Number := Dummy_Account;
153
            Current_ID := Current_ID + 1;
154
      end Build_Credit_Record;
155
 
156
 
157
      procedure Build_Debit_Record
158
                              ( Next_Transaction : acc_Transaction_Record ) is
159
         Dummy_Account : constant integer := 200;
160
      begin
161
            Next_Transaction.ID := Current_ID;
162
            Next_Transaction.Code := Debit;
163
 
164
            Next_Transaction.Account_Number := Dummy_Account;
165
            Current_ID := Current_ID + 1;
166
      end Build_Debit_Record;
167
 
168
   begin
169
 
170
      accept Start;      -- Wait for trigger from Main
171
 
172
      for i in 1..2 loop  -- arbitrarily limit to two messages for the test
173
         declare
174
            -- Create a task for the next message
175
            Next_Message_Task : acc_Message_Task := new Message_Task;
176
            -- Create a record for it
177
            Next_Transaction : acc_Transaction_Record
178
                                                 := new Transaction_Record;
179
         begin
180
            if TC_Last_was_for_credit then
181
               Build_Debit_Record ( Next_Transaction );
182
            else
183
               Build_Credit_Record( Next_Transaction );
184
               TC_Last_was_for_credit := true;
185
            end if;
186
            Next_Message_Task.Accept_Transaction ( Next_Transaction );
187
         end;   -- declare
188
      end loop;
189
 
190
   exception
191
      when others =>
192
         Report.Failed ("Unexpected exception in Line_Driver");
193
   end Line_Driver;
194
 
195
 
196
 
197
 
198
   task body Message_Task is
199
 
200
      TC_Original_Transaction_Code : Transaction_Code;
201
      This_Transaction : acc_Transaction_Record := new Transaction_Record;
202
 
203
   begin
204
      accept Accept_Transaction (In_Transaction : acc_Transaction_Record) do
205
         This_Transaction.all := In_Transaction.all;
206
      end Accept_Transaction;
207
 
208
      -- Note the original code to ensure correct return
209
      TC_Original_Transaction_Code := This_Transaction.Code;
210
 
211
      -- Queue up on Distributor's Input queue
212
      Distributor.Input ( This_Transaction );
213
      -- This task will now wait for the requeued rendezvous
214
      -- to complete before proceeding
215
 
216
      -- After the required computations have been performed
217
      -- return the Transaction_Record appropriately (probably to an output
218
      -- line driver)
219
      null;            -- stub
220
 
221
 
222
      -- The following is all Test Control Code
223
 
224
      -- Check that the return values are as expected
225
      if TC_Original_Transaction_Code /= This_Transaction.Code then
226
         -- Incorrect rendezvous
227
         Report.Failed ("Message Task: Incorrect code returned");
228
      end if;
229
 
230
      if This_Transaction.Code = Credit then
231
         if This_Transaction.Return_Value     /= Credit_Return or
232
            This_Transaction.TC_Message_Count /= 1             or not
233
            This_Transaction.TC_Thru_Distrib     then
234
               Report.Failed ("Expected path not traversed");
235
         end if;
236
         TC_Credit_Message.Mark_Complete;
237
      else
238
         if This_Transaction.Return_Value     /= Debit_Return or
239
            This_Transaction.TC_Message_Count /= 1             or not
240
            This_Transaction.TC_Thru_Distrib      then
241
               Report.Failed ("Expected path not traversed");
242
         end if;
243
         TC_Debit_Message.Mark_Complete;
244
      end if;
245
 
246
   exception
247
      when others =>
248
         Report.Failed ("Unexpected exception in Message_Task");
249
 
250
   end Message_Task;
251
 
252
 
253
 
254
   -- Dispose each input Transaction_Record to the appropriate
255
   -- computation tasks
256
   --
257
   task body Distributor is
258
 
259
   begin
260
      loop
261
         select
262
            accept Input (Transaction : acc_Transaction_Record) do
263
               -- Mark the message as having passed through the distributor
264
               Transaction.TC_Thru_Distrib := true;
265
 
266
               -- Pass this transaction on the appropriate computation
267
               -- task
268
               case Transaction.Code is
269
                  when Credit =>
270
                     requeue Credit_Computation.Input with abort;
271
                  when Debit =>
272
                     requeue Debit_Computation.Input with abort;
273
               end case;
274
            end Input;
275
         or
276
            terminate;
277
         end select;
278
      end loop;
279
 
280
   exception
281
      when others =>
282
         Report.Failed ("Unexpected exception in Distributor");
283
   end Distributor;
284
 
285
 
286
 
287
   -- Computation task.
288
   --   Note:  After the computation is performed in this task and the
289
   --          accept body is completed the rendezvous in the original
290
   --          message task is completed.
291
   --
292
   task body Credit_Computation is
293
      Message_Count   : integer := 0;
294
   begin
295
      loop
296
         select
297
            accept Input ( Transaction : acc_Transaction_Record) do
298
               -- Perform the computations required for this transaction
299
               null;      -- stub
300
 
301
               -- For the test:
302
               if not Transaction.TC_Thru_Distrib then
303
                  Report.Failed
304
                         ("Credit Task: Wrong queue, Distributor bypassed");
305
               end if;
306
               if Transaction.code /= Credit then
307
                  Report.Failed
308
                         ("Credit Task: Requeue delivered to the wrong queue");
309
               end if;
310
 
311
               -- for the test plug a known value and count
312
               Transaction.Return_Value := Credit_Return;
313
               -- one, and only one message should pass through
314
               Message_Count := Message_Count + 1;
315
               Transaction.TC_Message_Count := Message_Count;
316
            end Input;
317
         or
318
            terminate;
319
         end select;
320
      end loop;
321
   exception
322
      when others =>
323
         Report.Failed ("Unexpected exception in Credit_Computation");
324
   end Credit_Computation;
325
 
326
 
327
 
328
   -- Computation task.
329
   --   Note:  After the computation is performed in this task and the
330
   --          accept body is completed the rendezvous in the original
331
   --          message task is completed.
332
   --
333
   task body Debit_Computation is
334
      Message_Count   : integer := 0;
335
   begin
336
      loop
337
         select
338
            accept Input (Transaction : acc_Transaction_Record) do
339
               -- Perform the computations required for this message
340
               null;      -- stub
341
 
342
               -- For the test:
343
               if not Transaction.TC_Thru_Distrib then
344
                  Report.Failed
345
                         ("Debit Task: Wrong queue, Distributor bypassed");
346
               end if;
347
               if Transaction.code /= Debit then
348
                  Report.Failed
349
                         ("Debit Task: Requeue delivered to the wrong queue");
350
               end if;
351
 
352
               -- for the test plug a known value and count
353
               Transaction.Return_Value := Debit_Return;
354
               -- one, and only one, message should pass through
355
               Message_Count := Message_Count + 1;
356
               Transaction.TC_Message_Count := Message_Count;
357
            end Input;
358
         or
359
            terminate;
360
         end select;
361
      end loop;
362
   exception
363
      when others =>
364
         Report.Failed ("Unexpected exception in Debit_Computation");
365
 
366
 
367
   end Debit_Computation;
368
 
369
 
370
begin -- c954011
371
 
372
   Report.Test ("C954011", "Requeue from task body to task entry");
373
 
374
   Line_Driver.Start;        -- Start the test
375
 
376
   -- Ensure that the message tasks complete before reporting the result
377
   while not (TC_Credit_Message.Is_Complete and
378
              TC_Debit_Message.Is_Complete) loop
379
      delay ImpDef.Minimum_Task_Switch;
380
   end loop;
381
 
382
   Report.Result;
383
 
384
end C954011;

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.