Subversion Repositories openrisc

-- C954022.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:
--      In an entry body requeue the call to the same entry.  Check that the
--      items go to the right queue and that they are placed back on the end 
--      of the queue
--
-- TEST DESCRIPTION:
--      Simulate part of a message handling application where the messages are
--      composed of several segments.  The sequence of the segments within the
--      message is specified by Seg_Sequence_No.   The segments are handled by
--      different tasks and finally forwarded to an output driver.  The
--      segments can arrive in any order but must be assembled into the proper
--      sequence for final output.  There is a Sequencer task interposed
--      before the Driver.  This takes the segments of the message off the
--      Ordering_Queue and those that are in the right order it sends on to
--      the driver; those that are out of order it places back on the end of
--      the queue.
--
--      The test just simulates the arrival of the segments at the Sequencer.
--      The task generating the segments handshakes with the Sequencer during
--      the  "Await Arrival" phase  ensuring that the three segments of a
--      message arrive in REVERSE order (the End-of-Message segment arrives
--      first and the Header last).  In the first cycle the sequencer pulls
--      segments off the queue and puts them back on the end till it
--      encounters the header.  It checks the sequence of the ones it pulls
--      off in case the segments are being put back on in the wrong part of
--      the queue.  Having cycled once through it no longer verifies the
--      sequence - it just executes the "application" code for the correct
--      order for dispatch to the driver.
-- 
--      In this simple example no attempt is made to address segments of
--      another message arriving or any other error conditions (such as
--      missing segments, timing etc.)
-- 
--
-- CHANGE HISTORY:
--      06 Dec 94   SAIC    ACVC 2.0
--      07 Nov 95   SAIC    ACVC 2.0.1
--
--!

with Report;
with ImpDef;

procedure C954022 is

   -- These global Booleans are set when failure conditions inside Protected
   -- objects are encountered.  Report.Failed cannot be called within
   -- the object or a Bounded Error would occur
   --
   TC_Failed_1 : Boolean := false;
   TC_Failed_2 : Boolean := false;
   TC_Failed_3 : Boolean := false;

begin


   Report.Test ("C954022", "Check Requeue to the same Protected Entry");
   
   declare  -- encapsulate the test

      type Segment_Sequence is range 1..8;
      Header : constant Segment_Sequence := Segment_Sequence'first;

      type Message_Segment is record
         ID              : integer;            -- Message ID
         Seg_Sequence_No : Segment_Sequence;   -- Within the message
         Segs_In_Message : integer;            -- Total segs this message
         EOM             : Boolean := false;   -- true for final msg segment
         Alpha           : string (1..128);
      end record;
      type acc_Message_Segment is access Message_Segment;

      task TC_Simulate_Arrival;
   
      task type Carrier_Task is
         entry Input ( Segment : acc_Message_Segment );
      end Carrier_Task;
      type acc_Carrier_Task is access Carrier_Task;
   
      protected Sequencer is
         function  TC_Arrivals return integer;
         entry Input          ( Segment : acc_Message_Segment );
         entry Ordering_Queue ( Segment : acc_Message_Segment );
      private
         Number_of_Segments_Arrived  : integer := 0;
         Number_of_Segments_Expected : integer := 0;
         Next_Needed : Segment_Sequence := Header;
         All_Segments_Arrived : Boolean := false;
         Seen_EOM             : Boolean := false;

         TC_First_Cycle       : Boolean := true;
         TC_Expected_Sequence : Segment_Sequence := Header+2;

      end Sequencer;
   

      task Output_Driver is
         entry Input ( Segment : acc_Message_Segment );
      end Output_Driver;
   

      -- Simulate the arrival of three message segments in REVERSE order
      --
      task body TC_Simulate_Arrival is
         begin
            for i in 1..3 loop
               declare
                  -- Create a task for the next message segment
                  Next_Segment_Task : acc_Carrier_Task := new Carrier_Task;
                  -- Create a record for the next segment
                  Next_Segment : acc_Message_Segment := new Message_Segment;
               begin
                  if i = 1 then 
                     -- Build the EOM segment as the first to "send"
                     Next_Segment.Seg_Sequence_No := Header + 2;
                     Next_Segment.Segs_In_Message := 3;
                     Next_Segment.EOM := true;
                  elsif i = 2 then
                     -- Wait for the first segment to arrive at the Sequencer
                     -- before "sending" the second
                     while Sequencer.TC_Arrivals < 1 loop
                        delay ImpDef.Minimum_Task_Switch;
                     end loop;
                     -- Build the segment
                     Next_Segment.Seg_Sequence_No := Header +1;
                  else
                     -- Wait for the second segment to arrive at the Sequencer
                     -- before "sending" the third
                     while Sequencer.TC_Arrivals < 2 loop
                        delay ImpDef.Minimum_Task_Switch;
                     end loop;                  
                     -- Build the segment. The last segment (in order) to
                     -- arrive will be the "header" segment
                     Next_Segment.Seg_Sequence_No := Header;
                  end if;
                  -- pass the record to its carrier
                  Next_Segment_Task.Input ( Next_Segment );
               end;
            end loop;
 

      exception
         when others => 
              Report.Failed ("Unexpected Exception in TC_Simulate_Arrival");
      end TC_Simulate_Arrival;
   

      -- One of these is generated for each message segment and the flow 
      -- of the segments through the system is controlled by the calls the
      -- task makes and the requeues of those calls
      --
      task body Carrier_Task is
         This_Segment : acc_Message_Segment := new Message_Segment;
      begin
         accept Input ( Segment : acc_Message_Segment ) do
            This_Segment.all := Segment.all;
         end Input;
         null; --:: stub.  Pass the segment around the application as needed

         -- Now output the segment to the Output_Driver.  First we have to 
         -- go through the Sequencer.  
         Sequencer.Input ( This_Segment );
      exception
         when others => 
              Report.Failed ("Unexpected Exception in Carrier_Task");
      end Carrier_Task;
   
      -- Store segments on the Ordering_Queue then deliver them in the correct
      -- sequence to the Output_Driver.
      --
      protected body Sequencer is

         function  TC_Arrivals return integer is
         begin
            return Number_of_Segments_Arrived;
         end TC_Arrivals;

         
         -- Segments arriving at the Input queue are counted and checked
         -- against the total number of segments for the message.  They
         -- are requeued onto the ordering queue where they are held until
         -- all the segments have arrived.
         entry Input ( Segment : acc_Message_Segment ) when true is
         begin
            -- check for EOM, if so get the number of segments in the message
            -- Note: in this portion of code no attempt is made to address
            -- reset for new message , end conditions, missing segments, 
            -- segments of a different message etc.
            Number_of_Segments_Arrived := Number_of_Segments_Arrived + 1;
            if Segment.EOM then
               Number_of_Segments_Expected := Segment.Segs_In_Message;
               Seen_EOM := true;
            end if;

            if Seen_EOM then
               if Number_of_Segments_Arrived = Number_of_Segments_Expected then
                  -- This is the last segment for this message
                  All_Segments_Arrived := true;    -- clear the barrier
               end if;
            end if;

            requeue Ordering_Queue;

            -- At this exit point the entry queue barriers are evaluated

         end Input;


         entry Ordering_Queue ( Segment : acc_Message_Segment )
                                                  when All_Segments_Arrived is
            begin

            --=====================================================
            -- This part is all Test_Control code

            if TC_First_Cycle then 
               -- Check the order of the original three
               if Segment.Seg_Sequence_No /= TC_Expected_Sequence then
                  -- The segments are not being pulled off in the 
                  -- expected sequence.  This could occur if the 
                  -- requeue is not putting them back on the end.
                  TC_Failed_3 := true;
               end if; -- sequence check
               -- Decrement the expected sequence
               if TC_Expected_Sequence /= Header then
                  TC_Expected_Sequence := TC_Expected_Sequence - 1;
               else 
                  TC_First_Cycle := false; -- This is the Header - the
                                           -- first two segments are
                                           -- back on the queue
               end if; -- decrementing
            end if; -- first cycle 
            --=====================================================

            -- And this is the Application code
            if Segment.Seg_Sequence_No = Next_Needed then
               if Segment.EOM then
                  Next_Needed := Header;  -- reset for next message
                  -- :: other resets not shown
               else
                  Next_Needed := Next_Needed + 1;
               end if;
               requeue Output_Driver.Input  with abort;
               -- set to Report Failed - Requeue did not complete entry body
               TC_Failed_1 := true;
            else
               -- Not the next needed - put it back on the queue
               --    NOTE: here we are requeueing to the same entry
               requeue Sequencer.Ordering_Queue;
               -- set to Report Failed - Requeue did not complete entry body
               TC_Failed_2 := true;
            end if;
         end Ordering_Queue;
      end Sequencer;
   

      task body Output_Driver is
         This_Segment : acc_Message_Segment := new Message_Segment;

         TC_Expected_Sequence : Segment_Sequence := Segment_Sequence'first;
         TC_Segment_Total : integer := 0;
         TC_Expected_Total : integer := 3;
      begin
         loop
            -- Note: normally we would expect this Accept to be in a select 
            -- with terminate.  For the test we exit the loop on completion
            -- to give better control
            accept Input ( Segment : acc_Message_Segment ) do 
               This_Segment.all := Segment.all;
            end Input;
   
            null;  --::: stub - output the next segment of the message

            -- The following is all test control code
            --
            if This_Segment.Seg_Sequence_No /= TC_Expected_Sequence then
               Report.Failed ("Output_Driver: Segment out of sequence");
            end if;
            TC_Expected_Sequence := TC_Expected_Sequence + 1;

            -- Now count the number of segments
            TC_Segment_Total := TC_Segment_Total + 1;

            -- Check the number and exit loop when complete
            -- There must be exactly TC_Expected_Total in number and
            --    the last one must be EOM
            --    (test will hang if < TC_Expected_Total arrive
            --    without EOM)
            if This_Segment.EOM then
               -- This is the last segment.
               if TC_Segment_Total /= TC_Expected_Total then
                  Report.Failed ("EOM and wrong number of segments");
               end if;
               exit;   -- the loop and terminate the task
            elsif TC_Segment_Total = TC_Expected_Total then
               Report.Failed ("No EOM found");
               exit;
            end if;
         end loop;
      exception
         when others => 
              Report.Failed ("Unexpected Exception in Output_Driver");
      end Output_Driver;


   begin  

      null;

   end; -- encapsulation

   if TC_Failed_1 then
      Report.Failed ("Requeue did not complete entry body - 1");
   end if;

   if TC_Failed_2 then
      Report.Failed ("Requeue did not complete entry body - 2");
   end if;

   if TC_Failed_3 then
      Report.Failed ("Sequencer: Segment out of sequence");
   end if;

   Report.Result;
   
end C954022;