Subversion Repositories openrisc_me

-- C954023.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 within a protected entry to a family of entries

--     in a different protected object is queued correctly

--                      Call with parameters

--                      Requeue with abort

--

-- TEST DESCRIPTION:

--      One transaction is sent through to check the paths.  After processing

--      this, the Credit task sets the "overloaded" indicator.  Once this

--      indicator is set the Distributor (a protected object) queues lower

--      priority transactions on a family of queues (Wait_for_Underload) in

--      another protected object using a requeue.  The Distributor still

--      delivers high priority transactions. After two more high priority

--      transactions have been processed by the Credit task the artificial

--      test code clears the overload condition to the threshold level that

--      allows only the items on the Medium priority queue of the family to be

--      released.  When these have been processed and checked the test code

--      then lowers the priority threshold once again, allowing the Low

--      priority items from the last queue in the family to be released,

--      processed and checked. Note: the High priority queue in the family is

--      not used.

--

--      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 C954023 is

   -- Artificial: number of messages required for this test

   subtype TC_Trans_Range is integer range 1..8;

   TC_Credit_Messages_Expected  : constant integer

                                          := TC_Trans_Range'Last - 1;

   TC_Debit_Message_Complete    : Boolean := false;

   -- Mechanism for handshaking between tasks

   protected TC_PO is

      procedure Increment_Tasks_Completed_Count;

      function  Tasks_Completed_Count return integer;

      function  First_Message_Has_Arrived return Boolean;

      procedure  Set_First_Message_Has_Arrived;

   private

      Number_Complete : integer := 0;

         Message_Arrived_Flag  : Boolean := false;

   end TC_PO;

   --

   protected body TC_PO is

      procedure Increment_Tasks_Completed_Count is

      begin

         Number_Complete := Number_Complete + 1;

      end Increment_Tasks_Completed_Count;

      function Tasks_Completed_Count return integer is

      begin

         return Number_Complete;

      end Tasks_Completed_Count;

      function  First_Message_Has_Arrived return Boolean is

         begin

            return Message_Arrived_Flag;

         end First_Message_Has_Arrived;

      procedure  Set_First_Message_Has_Arrived is

         begin

            Message_Arrived_Flag := true;

      end Set_First_Message_Has_Arrived;

   end TC_PO;

begin

   Report.Test ("C954023", "Requeue from within a protected object" &

                      " to a family of entries in another protected object");

   declare -- encapsulate the test

      -- Arbitrary test values

      Credit_Return : constant := 1;

      Debit_Return  : constant := 2;

      type Transaction_Code is (Credit, Debit);

      type App_Priority     is (Low, Medium, High);

      type Priority_Block   is array (App_Priority) of Boolean;

      type Transaction_Record;

      type acc_Transaction_Record is access Transaction_Record;

      type Transaction_Record is

         record

            ID               : integer := 0;

            Code             : Transaction_Code := Debit;

            Priority         : App_Priority := High;

            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;

      protected Distributor is

         procedure Set_Credit_Overloaded;

         procedure Clear_Overload_to_Medium;

         procedure Clear_Overload_to_Low;

         entry     Input (Transaction : acc_Transaction_Record);

      private

         Credit_Overloaded : Boolean := false;

      end Distributor;

      protected Hold is

         procedure Release_Medium;

         procedure Release_Low;

         -- Family of entry queues indexed by App_Priority

         entry Wait_for_Underload (App_Priority)

                                     (Transaction : acc_Transaction_Record);

      private

         Release : Priority_Block := (others => false);

      end Hold;

      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;

      --

      -- Dispose each input Transaction_Record to the appropriate

      -- computation tasks

      --

      protected body Distributor is

         procedure Set_Credit_Overloaded is

         begin

            Credit_Overloaded := true;

         end Set_Credit_Overloaded;

         procedure Clear_Overload_to_Medium is

         begin

            Credit_Overloaded := false;

            Hold.Release_Medium;       -- Release all held messages on Medium

                                       -- priority queue

         end Clear_Overload_to_Medium;

         procedure Clear_Overload_to_Low is

         begin

            Credit_Overloaded := false;

            Hold.Release_Low;          -- Release all held messages on Low

                                       -- priority queue

         end Clear_Overload_to_Low;

         entry Input (Transaction : acc_Transaction_Record)   when true is

                                                   -- barrier is always open

         begin

            -- Test Control: Set the indicator in the message to show it has

            -- passed through the Distributor object

            Transaction.TC_thru_Distrib := true;

            -- Pass this transaction on to the appropriate computation

            -- task but temporarily hold low-priority transactions under

            -- overload conditions

            case Transaction.Code is

               when Credit =>

                  if Credit_Overloaded and Transaction.Priority /= High then

                     -- use the appropriate queue in the family

                     requeue Hold.Wait_for_Underload(Transaction.Priority)

                                                         with abort;

                  else

                     requeue Credit_Computation.Input with abort;

                 end if;

               when Debit =>

                 requeue Debit_Computation.Input with abort;

            end case;

         end Input;

      end Distributor;

      -- Low priority Message tasks are held on the Wait_for_Underload queue

      -- while the Credit computation system is overloaded.  Once the Credit

      -- system reached underload send all queued messages immediately

      --

      protected body Hold is

         -- Once these are executed the barrier conditions for the entries

         -- are evaluated

         procedure Release_Medium is

         begin

            Release(Medium) := true;

         end Release_Medium;

         --

         procedure Release_Low is

         begin

            Release(Low) := true;

         end Release_Low;

         -- This is a family of entry queues indexed by App_Priority

         entry Wait_for_Underload  (for AP in App_Priority)

                                   (Transaction : acc_Transaction_Record)

                                                when Release(AP) is

         begin

            requeue Credit_Computation.Input with abort;

            if Wait_for_Underload(AP)'count = 0 then

               -- Queue is purged.  Set up to hold next batch

               Release(AP) := false;

            end if;

         end Wait_for_Underload;

      end Hold;

      -- 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

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

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

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

      --      cycle the generation of High medium and Low priority Credit

      --      transactions for this test. Send out one final Debit message

      --

      task body Line_Driver is

         Current_ID       : integer := 1;

         Current_Priority : App_Priority := High;

         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.Priority := Current_Priority;

               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

         for Transaction_Numb in TC_Trans_Range loop  -- TC: limit the 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

               if Transaction_Numb = TC_Trans_Range'first then

                  -- Send the first Credit message

                  Build_Credit_Record ( Next_Transaction );

                  Next_Message_Task.Accept_Transaction ( Next_Transaction );

                  -- TC: Wait until the first message has been received by the

                  -- Credit task and it has set the Overload indicator for the

                  -- Distributor

                  while not TC_PO.First_Message_Has_Arrived loop

                     delay ImpDef.Minimum_Task_Switch;

                  end loop;

               elsif Transaction_Numb = TC_Trans_Range'last then

                  -- For this test send the last transaction to the Debit task

                  -- to improve the mix

                  Build_Debit_Record( Next_Transaction );

                  Next_Message_Task.Accept_Transaction ( Next_Transaction );

               else

                  -- TC: Cycle generation of  high medium and low priority

                  -- transactions

                  if Current_Priority = High then

                     Current_Priority := Medium;

                  elsif

                     Current_Priority = Medium then

                     Current_Priority := Low;

                  else

                     Current_Priority := High;

                  end if;

                  Build_Credit_Record( Next_Transaction );

                  Next_Message_Task.Accept_Transaction ( Next_Transaction );

               end if;

            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

         -- For the test 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  /= Credit_Return   or

            not This_Transaction.TC_thru_Distrib                 then

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

            end if;

            TC_PO.Increment_Tasks_Completed_Count;

         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 - Debit");

            end if;

            TC_Debit_Message_Complete := true;

         end if;

      exception

         when others =>

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

      end Message_Task;

      -- Computation task.  After the computation is performed the rendezvous

      -- in the original message task is completed.

      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

                  -- The following is all Test Control code:

                  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;

                  -- This is checked by the Message_Task:

                  Transaction.Return_Value := Credit_Return;

                  -- Now take special action depending on which Message.

                  -- Note: The count gives the order in which the messages are

                  --       arriving at this task NOT the order in which they

                  --       were originally generated and sent out.

                  Message_Count := Message_Count + 1;

                  if Message_Count < 4 then

                     -- This is one of the first three messages which must

                     -- be High priority because we will set "Overload" after

                     -- the first, which is known to be High. The lower

                     -- priority should be waiting on the queues

                     if Transaction.Priority /= High then

                     Report.Failed

                        ("Credit Task: Lower priority trans. during overload");

                     end if;

                     if Message_Count = 1 then

                        -- After the first message :

                        Distributor.Set_Credit_Overloaded;

                        -- Now flag the Line_Driver that the second and

                        -- subsequent messages may now be sent

                        TC_PO.Set_First_Message_Has_Arrived;

                     elsif

                        Message_Count = 3 then

                        -- The two high priority transactions created

                        -- subsequent to the overload have now been processed,

                        --  release the Medium priority items

                        Distributor.Clear_Overload_to_Medium;

                     end if;

                  elsif Message_Count < 6 then

                     -- This must be one of the Medium priority messages

                     if Transaction.Priority /= Medium then

                     Report.Failed

                           ("Credit Task: Second group not Medium Priority");

                     end if;

                     if Message_Count = 5 then

                        -- The two medium priority transactions

                        -- have now been processed - release the

                        -- Low priority items

                        Distributor.Clear_Overload_to_Low;

                     end if;

                  elsif Message_Count < TC_Trans_Range'Last then

                     -- This must be one of the Low priority messages

                     if Transaction.Priority /= Low then

                     Report.Failed

                           ("Credit Task: Third group not Low Priority");

                     end if;

                  else

                     -- Too many transactions have arrived.  Duplicates?

                     -- the Debit transaction?

                     Report.Failed

                           ("Credit Task: Too many transactions");

                  end if;

               end Input;

            or

               terminate;

            end select;

         end loop;

      exception

         when others =>

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

      end Credit_Computation;

      -- Computation task.  After the computation is performed 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 -- declare

      null;

   end; -- declare (test encapsulation)

   if (TC_PO.Tasks_Completed_Count /= TC_Credit_Messages_Expected)

                                    and not TC_Debit_Message_Complete then

      Report.Failed ("Incorrect number of Message Tasks completed");

   end if;

   Report.Result;

end C954023;