Subversion Repositories openrisc

-- C940002.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 protected object provides coordinated access to shared

--      data.  Check that it can implement a semaphore-like construct using a

--      parameterless procedure which allows a specific maximum number of tasks

--      to run and excludes all others

--

-- TEST DESCRIPTION:

--      Implement a counting semaphore type that can be initialized to a

--      specific number of available resources.  Declare an entry for

--      requesting a resource and a procedure for releasing it.  Declare an

--      object of this type, initialized to two resources.  Declare and start

--      three tasks each of which asks for a resource.  Verify that only two

--      resources are granted and that the last task in is queued.

--

--

-- CHANGE HISTORY:

--      06 Dec 94   SAIC    ACVC 2.0

--

--!

package C940002_0 is

     -- Semaphores

  protected type Semaphore_Type (Resources_Available : Integer :=1) is

    entry Request;

    procedure Release;

    function Available return Integer;

  private

    Currently_Available : Integer := Resources_Available;

  end Semaphore_Type;

  Max_Resources : constant Integer := 2;

  Resource      : Semaphore_Type (Max_Resources);

end C940002_0;

 -- Semaphores;

          --========================================================--

package body C940002_0 is

          -- Semaphores

  protected body Semaphore_Type is

    entry Request when Currently_Available >0 is  -- when granted, secures

    begin                                         -- a resource

      Currently_Available := Currently_Available - 1;

    end Request;

    procedure Release is                          -- when called, releases

    begin                                         -- a resource

      Currently_Available := Currently_Available + 1;

    end Release;

    function Available return Integer is          -- returns number of

    begin                                         -- available resources

      return Currently_Available;

    end Available;

  end Semaphore_Type;

end C940002_0;

 -- Semaphores;

          --========================================================--

package C940002_1 is

     -- Task_Pkg

  task type Requesting_Task is

     entry Done;                        -- call on Done instructs the task

  end Requesting_Task;                  -- to release resource

  type Task_Ptr is access Requesting_Task;

  protected Counter is

    procedure Increment;

    procedure Decrement;

    function Number return integer;

  private

    Count : Integer := 0;

  end Counter;

  protected Hold_Lock is

    procedure Lock;

    procedure Unlock;

    function  Locked return Boolean;

  private

    Lock_State  : Boolean := true;        -- starts out locked

  end Hold_Lock;

end C940002_1;

 -- Task_Pkg

          --========================================================--

with Report;

with C940002_0;

  -- Semaphores;

package body C940002_1 is

          -- Task_Pkg is

  protected body Counter is

    procedure Increment is

      begin

        Count := Count + 1;

      end Increment;

    procedure Decrement is

      begin

        Count := Count - 1;

      end Decrement;

    function Number return Integer is

      begin

        return Count;

      end Number;

  end Counter;

  protected body Hold_Lock is

    procedure Lock is

    begin

      Lock_State := true;

    end Lock;

    procedure Unlock is

    begin

      Lock_State := false;

    end Unlock;

    function  Locked return Boolean is

    begin

      return Lock_State;

    end Locked;

  end Hold_Lock;

  task body Requesting_Task is

  begin

    C940002_0.Resource.Request;        -- request a resource

                                       -- if resource is not available,

                                       -- task will be queued to wait

    Counter.Increment;                 -- add to count of resources obtained

    Hold_Lock.Unlock;                  -- and unlock Lock - system is stable;

                                       -- status may now be queried

    accept Done do                     -- hold resource until Done is called

      C940002_0.Resource.Release;      -- release the resource and

      Counter.Decrement;               -- note release

    end Done;

  exception

    when others => Report.Failed ("Unexpected Exception in Requesting_Task");

  end Requesting_Task;

end C940002_1;

 -- Task_Pkg;

          --========================================================--

with Report;

with ImpDef;

with C940002_0,

  -- Semaphores,

     C940002_1;

  -- Task_Pkg;

procedure C940002 is

  package Semaphores renames C940002_0;

  package Task_Pkg renames C940002_1;

  Ptr1,

  Ptr2,

  Ptr3 : Task_Pkg.Task_Ptr;

  Num  : Integer;

  procedure Spinlock is

    begin

      -- loop until unlocked

      while Task_Pkg.Hold_Lock.Locked loop

        delay ImpDef.Minimum_Task_Switch;

      end loop;

      Task_Pkg.Hold_Lock.Lock;

    end Spinlock;

begin

  Report.Test ("C940002", "Check that a protected record can be used to " &

                          "control access to resources");

  if (Task_Pkg.Counter.Number /=0)

  or (Semaphores.Resource.Available /= 2) then

    Report.Failed ("Wrong initial conditions");

  end if;

  Ptr1 := new Task_Pkg.Requesting_Task;   -- newly allocated task requests

                                   -- resource; request for resource should

                                   -- be granted

  Spinlock;                        -- ensure that task obtains resource

                                   -- Task 1 waiting for call to Done

                                   -- One resource assigned to task 1

                                   -- One resource still available

  if (Task_Pkg.Counter.Number /= 1)

  or (Semaphores.Resource.Available /= 1) then

    Report.Failed ("Resource not assigned to task 1");

  end if;

  Ptr2 := new Task_Pkg.Requesting_Task;   -- newly allocated task requests

                                   -- resource; request for resource should

                                   -- be granted

  Spinlock;                        -- ensure that task obtains resource

                                   -- Task 1 waiting for call to Done

                                   -- Task 2 waiting for call to Done

                                   -- Resources held by tasks 1 and 2

                                   -- No resources available

  if (Task_Pkg.Counter.Number /= 2)

  or (Semaphores.Resource.Available /= 0) then

    Report.Failed ("Resource not assigned to task 2");

  end if;

  Ptr3 := new Task_Pkg.Requesting_Task;   -- newly allocated task requests

                                   -- resource; request for resource should

                                   -- be denied and task queued to wait for

                                   -- next available resource

  Ptr1.all.Done;                   -- Task 1 releases resource and lock

                                   -- Resource should be given to queued task

  Spinlock;                        -- ensure that resource is released

                                   -- Task 1 holds no resource

                                   -- One resource still assigned to task 2

                                   -- One resource assigned to task 3

                                   -- No resources available

  if (Task_Pkg.Counter.Number /= 2)

  or (Semaphores.Resource.Available /= 0) then

    Report.Failed ("Resource not properly released/assigned to task 3");

  end if;

  Ptr2.all.Done;                   -- Task 2 releases resource and lock

                                   -- No outstanding request for resource

                                   -- Tasks 1 and 2 hold no resources

                                   -- One resource assigned to task 3

                                   -- One resource available

  if (Task_Pkg.Counter.Number /= 1)

  or (Semaphores.Resource.Available /= 1) then

    Report.Failed ("Resource not properly released from task 2");

  end if;

  Ptr3.all.Done;                   -- Task 3 releases resource and lock

                                   -- All resources released

                                   -- All tasks terminated (or close)

                                   -- Two resources available

  if (Task_Pkg.Counter.Number /=0)

  or (Semaphores.Resource.Available /= 2) then

    Report.Failed ("Resource not properly released from task 3");

  end if;

  Report.Result;

end C940002;