Subversion Repositories openrisc

-- C954015.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 requeued calls to task entries may, in turn, be requeued.

--      Check that the intermediate requeues are not blocked and that the

--      original caller remains blocked until the last requeue is complete.

--         This test uses:

--                      Call with parameters

--                      Requeue with abort

--

-- TEST DESCRIPTION

--      A call is placed on the input queue of the Distributor.  The

--      Distributor requeues to the Credit task; the Credit task requeues to a

--      secondary task which, in turn requeues to yet another task.  This

--      continues down the chain.  At the furthest point of the chain the

--      rendezvous is completed.  To verify the action, the furthest task

--      waits in the accept statement for a second message to arrive before

--      completing.  This second message can only arrive if none of the earlier

--      tasks in the chain are blocked waiting for completion.   Apart from

--      the two Credit messages which are used to check the requeue chain one

--      Debit message is sent to validate the mix.

--

--

--      This series of tests uses a simulation of a transaction driven

--      processing system.  Line Drivers accept input from an external source

--      and build them into transaction records.  These records are then

--      encapsulated in message tasks which remain extant for the life of the

--      transaction in the system.  The message tasks put themselves on the

--      input queue of a Distributor which, from information in the

--      transaction and/or system load conditions forwards them to other

--      operating tasks. These in turn might forward the transactions to yet

--      other tasks for further action.  The routing is, in real life, dynamic

--      and unpredictable at the time of message generation.  All rerouting in

--      this  model is done by means of requeues.

--

--

-- CHANGE HISTORY:

--      06 Dec 94   SAIC    ACVC 2.0

--

--!

with Report;

with ImpDef;

procedure C954015 is

   -- Arbitrary test values

   Credit_Return : constant := 1;

   Debit_Return  : constant := 2;

   -- Mechanism to count the number of Credit Message tasks completed

   protected TC_Tasks_Completed is

      procedure Increment;

      function  Count return integer;

   private

      Number_Complete : integer := 0;

   end TC_Tasks_Completed;

   TC_Expected_To_Complete   : constant integer := 3;

   -- Values added to the Return_Value indicating passage through the

   -- particular task

   TC_Credit_Value :  constant integer := 1;

   TC_Sub_1_Value  :  constant integer := 2;

   TC_Sub_2_Value  :  constant integer := 3;

   TC_Sub_3_Value  :  constant integer := 4;

   TC_Sub_4_Value  :  constant integer := 5;

   --

   TC_Full_Value   :  integer := TC_Credit_Value + TC_Sub_1_Value +

                                 TC_Sub_2_Value  + TC_Sub_3_Value +

                                 TC_Sub_4_Value;

   type Transaction_Code is (Credit, Debit);

   type Transaction_Record;

   type acc_Transaction_Record is access Transaction_Record;

   type Transaction_Record is

      record

         ID               : integer := 0;

         Code             : Transaction_Code := Debit;

         Account_Number   : integer := 0;

         Stock_Number     : integer := 0;

         Quantity         : integer := 0;

         Return_Value     : integer := 0;

         TC_Message_Count : integer := 0;

         TC_Thru_Distrib  : Boolean := false;

      end record;

   task type Message_Task is

      entry Accept_Transaction (In_Transaction : acc_Transaction_Record);

   end Message_Task;

   type acc_Message_Task is access Message_Task;

   task Line_Driver is

      entry Start;

   end Line_Driver;

   task Distributor is

      entry Input(Transaction : acc_Transaction_Record);

   end Distributor;

   task Credit_Computation is

      entry Input(Transaction : acc_Transaction_Record);

   end Credit_Computation;

   task Debit_Computation is

      entry Input(Transaction : acc_Transaction_Record);

   end Debit_Computation;

   -- The following are almost identical for the purpose of the test

   task Credit_Sub_1 is

      entry Input(Transaction : acc_Transaction_Record);

   end Credit_Sub_1;

   --

   task Credit_Sub_2 is

      entry Input(Transaction : acc_Transaction_Record);

   end Credit_Sub_2;

   --

   task Credit_Sub_3 is

      entry Input(Transaction : acc_Transaction_Record);

   end Credit_Sub_3;

   -- This is the last in the chain

   task Credit_Sub_4 is

      entry Input(Transaction : acc_Transaction_Record);

   end Credit_Sub_4;

   -- Mechanism to count the number of Message tasks completed (Credit)

   protected body TC_Tasks_Completed is

      procedure Increment is

      begin

         Number_Complete := Number_Complete + 1;

      end Increment;

      function Count return integer is

      begin

         return Number_Complete;

      end Count;

   end TC_Tasks_Completed;

   -- Assemble messages received from an external source

   --   Creates a message task for each. The message tasks remain extant

   --   for the life of the messages in the system.

   --      The Line Driver task would normally be designed to loop continuously

   --      creating the messages as input is received.  Simulate this

   --      but limit it to the number of dummy messages needed for this

   --      test and allow it to terminate at that point.

   --

   task body Line_Driver is

      Current_ID : integer := 1;

      TC_Last_was_for_credit : Boolean := false;

       -- Arbitrary limit for the number of messages sent for this test

      type TC_Trans_Range is range 1..3;

      procedure Build_Credit_Record

                              ( Next_Transaction : acc_Transaction_Record ) is

         Dummy_Account : constant integer := 100;

      begin

         Next_Transaction.ID := Current_ID;

         Next_Transaction.Code := Credit;

         Next_Transaction.Account_Number := Dummy_Account;

         Current_ID := Current_ID + 1;

      end Build_Credit_Record;

      procedure Build_Debit_Record

                              ( Next_Transaction : acc_Transaction_Record ) is

         Dummy_Account : constant integer := 200;

      begin

         Next_Transaction.ID := Current_ID;

         Next_Transaction.Code := Debit;

         Next_Transaction.Account_Number := Dummy_Account;

         Current_ID := Current_ID + 1;

      end Build_Debit_Record;

   begin

      accept Start;   -- wait for trigger from Main

      -- Arbitrarily limit the loop to the number needed for this test only

      for Transaction_Numb in TC_Trans_Range  loop

         declare

            -- Create a task for the next message

            Next_Message_Task : acc_Message_Task := new Message_Task;

            -- Create a record for it

            Next_Transaction : acc_Transaction_Record :=

                                                new Transaction_Record;

         begin

            -- Artificially send out in the order required

            case Transaction_Numb is

               when 1 =>

                  Build_Credit_Record( Next_Transaction );

               when 2 =>

                  Build_Credit_Record( Next_Transaction );

               when 3 =>

                  Build_Debit_Record ( Next_Transaction );

            end case;

            -- Present the record to the message task

            Next_Message_Task.Accept_Transaction ( Next_Transaction );

         end;   -- declare

      end loop;

   exception

      when others =>

         Report.Failed ("Unexpected exception in Line_Driver");

   end Line_Driver;

   task body Message_Task is

      TC_Original_Transaction_Code : Transaction_Code;

      This_Transaction : acc_Transaction_Record := new Transaction_Record;

   begin

      accept Accept_Transaction (In_Transaction : acc_Transaction_Record) do

         This_Transaction.all := In_Transaction.all;

      end Accept_Transaction;

      -- Note the original code to ensure correct return

      TC_Original_Transaction_Code := This_Transaction.Code;

      -- Queue up on Distributor's Input queue

      Distributor.Input ( This_Transaction );

      -- This task will now wait for the requeued rendezvous

      -- to complete before proceeding

      -- After the required computations have been performed

      -- return the Transaction_Record appropriately (probably to an output

      -- line driver)

      null;            -- stub

      -- The following is all Test Control Code

      -- Check that the return values are as expected

      if TC_Original_Transaction_Code /= This_Transaction.Code then

         -- Incorrect rendezvous

         Report.Failed ("Message Task: Incorrect code returned");

      end if;

      if This_Transaction.Code = Credit then

         if This_Transaction.Return_Value  /= TC_Full_Value or not

            This_Transaction.TC_Thru_Distrib       then

               Report.Failed ("Expected path not traversed - CR");

         end if;

         if

            This_Transaction.TC_Message_Count not in 1..2 then

               Report.Failed ("Incorrect Message Count");

         end if;

      else

         if This_Transaction.Return_Value  /= Debit_Return or

            This_Transaction.TC_Message_Count /= 1            or not

            This_Transaction.TC_Thru_Distrib     then

               Report.Failed ("Expected path not traversed - DB");

         end if;

      end if;

      TC_Tasks_Completed.Increment;

   exception

      when others =>

         Report.Failed ("Unexpected exception in Message_Task");

   end Message_Task;

   -- Dispose each input Transaction_Record to the appropriate

   -- computation tasks

   --

   task body Distributor is

   begin

      loop

         select

            accept Input (Transaction : acc_Transaction_Record) do

               -- Show that the message did pass through the Distributor Task

               Transaction.TC_Thru_Distrib := true;

               -- Pass this transaction on to the appropriate computation

               -- task

               case Transaction.Code is

                  when Credit =>

                     requeue Credit_Computation.Input with abort;

                  when Debit =>

                     requeue Debit_Computation.Input with abort;

               end case;

            end Input;

         or

            terminate;

         end select;

      end loop;

   exception

      when others =>

         Report.Failed ("Unexpected exception in Distributor");

   end Distributor;

   -- Computation task.

   --   Note:  After the computation is performed in this task the message is

   --   passed on for further processing to some subsidiary task.  The choice

   --   of subsidiary task is made according to criteria not specified in

   --   this test.

   --

   task body Credit_Computation is

      Message_Count   : integer := 0;

   begin

      loop

         select

            accept Input ( Transaction : acc_Transaction_Record) do

               -- Perform the computations required for this transaction

               null;      -- stub

               -- For the test:

               if not Transaction.TC_Thru_Distrib then

                  Report.Failed

                         ("Credit Task: Wrong queue, Distributor bypassed");

               end if;

               if Transaction.code /= Credit then

                  Report.Failed

                         ("Credit Task: Requeue delivered to the wrong queue");

               end if;

               -- for the test, plug a known value and count

               Transaction.Return_Value := TC_Credit_Value;

               Message_Count := Message_Count + 1;

               Transaction.TC_Message_Count := Message_Count;

               -- Depending on transaction content send it on to the

               -- some other task for further processing

               -- TC: Arbitrarily send the message on to Credit_Sub_1

               requeue Credit_Sub_1.Input with abort;

            end Input;

         or

            terminate;

         end select;

      end loop;

   exception

      when others =>

         Report.Failed ("Unexpected exception in Credit_Computation");

   end Credit_Computation;

   task body Credit_Sub_1 is

   begin

      loop

         select

            accept Input(Transaction : acc_Transaction_Record) do

               -- Process this transaction

               null;   -- stub

               -- Add the value showing passage through this task

               Transaction.Return_Value :=

                                    Transaction.Return_Value + TC_Sub_1_Value;

               -- Depending on transaction content send it on to the

               -- some other task for further processing

               -- Arbitrarily send the message on to Credit_Sub_2

               requeue Credit_Sub_2.Input with abort;

            end Input;

         or

            terminate;

         end select;

      end loop;

   exception

      when others =>

         Report.Failed ("Unexpected exception in Credit_Sub_1");

   end Credit_Sub_1;

   task body Credit_Sub_2 is

   begin

      loop

         select

            accept Input(Transaction : acc_Transaction_Record) do

               -- Process this transaction

               null;   -- stub

               -- Add the value showing passage through this task

               Transaction.Return_Value :=

                                    Transaction.Return_Value + TC_Sub_2_Value;

               -- Depending on transaction content send it on to the

               -- some other task for further processing

               -- Arbitrarily send the message on to Credit_Sub_3

               requeue Credit_Sub_3.Input with abort;

            end Input;

         or

            terminate;

         end select;

      end loop;

   exception

      when others =>

         Report.Failed ("Unexpected exception in Credit_Sub_2");

   end Credit_Sub_2;

   task body Credit_Sub_3 is

   begin

      loop

         select

            accept Input(Transaction : acc_Transaction_Record) do

               -- Process this transaction

               null;   -- stub

               -- Add the value showing passage through this task

               Transaction.Return_Value :=

                                    Transaction.Return_Value + TC_Sub_3_Value;

               -- Depending on transaction content send it on to the

               -- some other task for further processing

               -- Arbitrarily send the message on to Credit_Sub_4

               requeue Credit_Sub_4.Input with abort;

            end Input;

         or

            terminate;

         end select;

      end loop;

   exception

      when others =>

         Report.Failed ("Unexpected exception in Credit_Sub_3");

   end Credit_Sub_3;

   -- This is the last in the chain of tasks to which transactions will

   -- be requeued

   --

   task body Credit_Sub_4 is

      TC_First_Message : Boolean := true;

   begin

      loop

         select

            accept Input(Transaction : acc_Transaction_Record) do

               -- Process this transaction

               null;   -- stub

               -- Add the value showing passage through this task

               Transaction.Return_Value :=

                                    Transaction.Return_Value + TC_Sub_4_Value;

               -- TC: stay in the accept body dealing with the first message

               -- until the second arrives.  If any of the requeues are

               -- blocked the test will hang here indicating failure

               if TC_First_Message then

                  while Input'count = 0 loop

                     delay ImpDef.Minimum_Task_Switch;

                  end loop;

               TC_First_Message := false;

               end if;

               -- for the second message, just complete the rendezvous

            end Input;

         or

            terminate;

         end select;

      end loop;

   exception

      when others =>

         Report.Failed ("Unexpected exception in Credit_Sub_4");

   end Credit_Sub_4;

   -- Computation task.

   --   Note:  After the computation is performed in this task and the

   --          accept body is completed the rendezvous in the original

   --          message task is completed.

   --

   task body Debit_Computation is

      Message_Count   : integer := 0;

   begin

      loop

         select

            accept Input (Transaction : acc_Transaction_Record) do

               -- Perform the computations required for this message

               null;      -- stub

               -- For the test:

               if not Transaction.TC_Thru_Distrib then

                  Report.Failed

                         ("Debit Task: Wrong queue, Distributor bypassed");

               end if;

               if Transaction.code /= Debit then

                  Report.Failed

                         ("Debit Task: Requeue delivered to the wrong queue");

               end if;

               -- for the test plug a known value and count

               Transaction.Return_Value := Debit_Return;

               -- one, and only one, message should pass through

               Message_Count := Message_Count + 1;

               Transaction.TC_Message_Count := Message_Count;

            end Input;

         or

            terminate;

         end select;

      end loop;

   exception

      when others =>

         Report.Failed ("Unexpected exception in Debit_Computation");

   end Debit_Computation;

begin

   Report.Test ("C954015", "Test multiple levels of requeue to task entry");

   Line_Driver.Start;  -- Start the test

   -- Ensure that the message tasks completed before calling Result

   while (TC_Tasks_Completed.Count < TC_Expected_To_Complete) loop

      delay ImpDef.Minimum_Task_Switch;

   end loop;

   Report.Result;

end C954015;