Subversion Repositories openrisc

------------------------------------------------------------------------------
--                                                                          --
--                 GNAT RUN-TIME LIBRARY (GNARL) COMPONENTS                 --
--                                                                          --
--              S Y S T E M . T A S K I N G . U T I L I T I E S             --
--                                                                          --
--                                  B o d y                                 --
--                                                                          --
--         Copyright (C) 1992-2011, Free Software Foundation, Inc.          --
--                                                                          --
-- GNARL is free software; you can  redistribute it  and/or modify it under --
-- terms of the  GNU General Public License as published  by the Free Soft- --
-- ware  Foundation;  either version 3,  or (at your option) any later ver- --
-- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
-- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
-- or FITNESS FOR A PARTICULAR PURPOSE.                                     --
--                                                                          --
-- As a special exception under Section 7 of GPL version 3, you are granted --
-- additional permissions described in the GCC Runtime Library Exception,   --
-- version 3.1, as published by the Free Software Foundation.               --
--                                                                          --
-- You should have received a copy of the GNU General Public License and    --
-- a copy of the GCC Runtime Library Exception along with this program;     --
-- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    --
-- <http://www.gnu.org/licenses/>.                                          --
--                                                                          --
-- GNARL was developed by the GNARL team at Florida State University.       --
-- Extensive contributions were provided by Ada Core Technologies, Inc.     --
--                                                                          --
------------------------------------------------------------------------------
 
--  This package provides RTS Internal Declarations
 
--  These declarations are not part of the GNARLI
 
pragma Polling (Off);
--  Turn off polling, we do not want ATC polling to take place during tasking
--  operations. It causes infinite loops and other problems.
 
with System.Tasking.Debug;
with System.Task_Primitives.Operations;
with System.Tasking.Initialization;
with System.Tasking.Queuing;
with System.Parameters;
with System.Traces.Tasking;
 
package body System.Tasking.Utilities is
 
   package STPO renames System.Task_Primitives.Operations;
 
   use Parameters;
   use Tasking.Debug;
   use Task_Primitives;
   use Task_Primitives.Operations;
 
   use System.Traces;
   use System.Traces.Tasking;
 
   --------------------
   -- Abort_One_Task --
   --------------------
 
   --  Similar to Locked_Abort_To_Level (Self_ID, T, 0), but:
   --    (1) caller should be holding no locks except RTS_Lock when Single_Lock
   --    (2) may be called for tasks that have not yet been activated
   --    (3) always aborts whole task
 
   procedure Abort_One_Task (Self_ID : Task_Id; T : Task_Id) is
   begin
      if Parameters.Runtime_Traces then
         Send_Trace_Info (T_Abort, Self_ID, T);
      end if;
 
      Write_Lock (T);
 
      if T.Common.State = Unactivated then
         T.Common.Activator := null;
         T.Common.State := Terminated;
         T.Callable := False;
         Cancel_Queued_Entry_Calls (T);
 
      elsif T.Common.State /= Terminated then
         Initialization.Locked_Abort_To_Level (Self_ID, T, 0);
      end if;
 
      Unlock (T);
   end Abort_One_Task;
 
   -----------------
   -- Abort_Tasks --
   -----------------
 
   --  This must be called to implement the abort statement.
   --  Much of the actual work of the abort is done by the abortee,
   --  via the Abort_Handler signal handler, and propagation of the
   --  Abort_Signal special exception.
 
   procedure Abort_Tasks (Tasks : Task_List) is
      Self_Id : constant Task_Id := STPO.Self;
      C       : Task_Id;
      P       : Task_Id;
 
   begin
      --  If pragma Detect_Blocking is active then Program_Error must be
      --  raised if this potentially blocking operation is called from a
      --  protected action.
 
      if System.Tasking.Detect_Blocking
        and then Self_Id.Common.Protected_Action_Nesting > 0
      then
         raise Program_Error with "potentially blocking operation";
      end if;
 
      Initialization.Defer_Abort_Nestable (Self_Id);
 
      --  ?????
      --  Really should not be nested deferral here.
      --  Patch for code generation error that defers abort before
      --  evaluating parameters of an entry call (at least, timed entry
      --  calls), and so may propagate an exception that causes abort
      --  to remain undeferred indefinitely. See C97404B. When all
      --  such bugs are fixed, this patch can be removed.
 
      Lock_RTS;
 
      for J in Tasks'Range loop
         C := Tasks (J);
         Abort_One_Task (Self_Id, C);
      end loop;
 
      C := All_Tasks_List;
 
      while C /= null loop
         if C.Pending_ATC_Level > 0 then
            P := C.Common.Parent;
 
            while P /= null loop
               if P.Pending_ATC_Level = 0 then
                  Abort_One_Task (Self_Id, C);
                  exit;
               end if;
 
               P := P.Common.Parent;
            end loop;
         end if;
 
         C := C.Common.All_Tasks_Link;
      end loop;
 
      Unlock_RTS;
      Initialization.Undefer_Abort_Nestable (Self_Id);
   end Abort_Tasks;
 
   -------------------------------
   -- Cancel_Queued_Entry_Calls --
   -------------------------------
 
   --  This should only be called by T, unless T is a terminated previously
   --  unactivated task.
 
   procedure Cancel_Queued_Entry_Calls (T : Task_Id) is
      Next_Entry_Call : Entry_Call_Link;
      Entry_Call      : Entry_Call_Link;
      Self_Id         : constant Task_Id := STPO.Self;
 
      Caller : Task_Id;
      pragma Unreferenced (Caller);
      --  Should this be removed ???
 
      Level : Integer;
      pragma Unreferenced (Level);
      --  Should this be removed ???
 
   begin
      pragma Assert (T = Self or else T.Common.State = Terminated);
 
      for J in 1 .. T.Entry_Num loop
         Queuing.Dequeue_Head (T.Entry_Queues (J), Entry_Call);
 
         while Entry_Call /= null loop
 
            --  Leave Entry_Call.Done = False, since this is cancelled
 
            Caller := Entry_Call.Self;
            Entry_Call.Exception_To_Raise := Tasking_Error'Identity;
            Queuing.Dequeue_Head (T.Entry_Queues (J), Next_Entry_Call);
            Level := Entry_Call.Level - 1;
            Unlock (T);
            Write_Lock (Entry_Call.Self);
            Initialization.Wakeup_Entry_Caller
              (Self_Id, Entry_Call, Cancelled);
            Unlock (Entry_Call.Self);
            Write_Lock (T);
            Entry_Call.State := Done;
            Entry_Call := Next_Entry_Call;
         end loop;
      end loop;
   end Cancel_Queued_Entry_Calls;
 
   ------------------------
   -- Exit_One_ATC_Level --
   ------------------------
 
   --  Call only with abort deferred and holding lock of Self_Id.
   --  This is a bit of common code for all entry calls.
   --  The effect is to exit one level of ATC nesting.
 
   --  If we have reached the desired ATC nesting level, reset the
   --  requested level to effective infinity, to allow further calls.
   --  In any case, reset Self_Id.Aborting, to allow re-raising of
   --  Abort_Signal.
 
   procedure Exit_One_ATC_Level (Self_ID : Task_Id) is
   begin
      Self_ID.ATC_Nesting_Level := Self_ID.ATC_Nesting_Level - 1;
 
      pragma Debug
        (Debug.Trace (Self_ID, "EOAL: exited to ATC level: " &
         ATC_Level'Image (Self_ID.ATC_Nesting_Level), 'A'));
 
      pragma Assert (Self_ID.ATC_Nesting_Level >= 1);
 
      if Self_ID.Pending_ATC_Level < ATC_Level_Infinity then
         if Self_ID.Pending_ATC_Level = Self_ID.ATC_Nesting_Level then
            Self_ID.Pending_ATC_Level := ATC_Level_Infinity;
            Self_ID.Aborting := False;
         else
            --  Force the next Undefer_Abort to re-raise Abort_Signal
 
            pragma Assert
             (Self_ID.Pending_ATC_Level < Self_ID.ATC_Nesting_Level);
 
            if Self_ID.Aborting then
               Self_ID.ATC_Hack := True;
               Self_ID.Pending_Action := True;
            end if;
         end if;
      end if;
   end Exit_One_ATC_Level;
 
   ----------------------
   -- Make_Independent --
   ----------------------
 
   procedure Make_Independent is
      Self_Id               : constant Task_Id := STPO.Self;
      Environment_Task      : constant Task_Id := STPO.Environment_Task;
      Parent                : constant Task_Id := Self_Id.Common.Parent;
      Parent_Needs_Updating : Boolean := False;
      Master_of_Task        : Integer;
 
   begin
      if Self_Id.Known_Tasks_Index /= -1 then
         Known_Tasks (Self_Id.Known_Tasks_Index) := null;
      end if;
 
      Initialization.Defer_Abort (Self_Id);
 
      if Single_Lock then
         Lock_RTS;
      end if;
 
      Write_Lock (Environment_Task);
      Write_Lock (Self_Id);
 
      pragma Assert (Parent = Environment_Task
        or else Self_Id.Master_of_Task = Library_Task_Level);
 
      Master_of_Task := Self_Id.Master_of_Task;
      Self_Id.Master_of_Task := Independent_Task_Level;
 
      --  The run time assumes that the parent of an independent task is the
      --  environment task.
 
      if Parent /= Environment_Task then
 
         --  We cannot lock three tasks at the same time, so defer the
         --  operations on the parent.
 
         Parent_Needs_Updating := True;
         Self_Id.Common.Parent := Environment_Task;
      end if;
 
      --  Update Independent_Task_Count that is needed for the GLADE
      --  termination rule. See also pending update in
      --  System.Tasking.Stages.Check_Independent
 
      Independent_Task_Count := Independent_Task_Count + 1;
 
      Unlock (Self_Id);
 
      --  Changing the parent after creation is not trivial. Do not forget
      --  to update the old parent counts, and the new parent (i.e. the
      --  Environment_Task) counts.
 
      if Parent_Needs_Updating then
         Write_Lock (Parent);
         Parent.Awake_Count := Parent.Awake_Count - 1;
         Parent.Alive_Count := Parent.Alive_Count - 1;
         Environment_Task.Awake_Count := Environment_Task.Awake_Count + 1;
         Environment_Task.Alive_Count := Environment_Task.Alive_Count + 1;
         Unlock (Parent);
      end if;
 
      --  In case the environment task is already waiting for children to
      --  complete.
      --  ??? There may be a race condition if the environment task was not in
      --  master completion sleep when this task was created, but now is
 
      if Environment_Task.Common.State = Master_Completion_Sleep and then
        Master_of_Task = Environment_Task.Master_Within
      then
         Environment_Task.Common.Wait_Count :=
           Environment_Task.Common.Wait_Count - 1;
      end if;
 
      Unlock (Environment_Task);
 
      if Single_Lock then
         Unlock_RTS;
      end if;
 
      Initialization.Undefer_Abort (Self_Id);
   end Make_Independent;
 
   ------------------
   -- Make_Passive --
   ------------------
 
   procedure Make_Passive (Self_ID : Task_Id; Task_Completed : Boolean) is
      C : Task_Id := Self_ID;
      P : Task_Id := C.Common.Parent;
 
      Master_Completion_Phase : Integer;
 
   begin
      if P /= null then
         Write_Lock (P);
      end if;
 
      Write_Lock (C);
 
      if Task_Completed then
         Self_ID.Common.State := Terminated;
 
         if Self_ID.Awake_Count = 0 then
 
            --  We are completing via a terminate alternative.
            --  Our parent should wait in Phase 2 of Complete_Master.
 
            Master_Completion_Phase := 2;
 
            pragma Assert (Task_Completed);
            pragma Assert (Self_ID.Terminate_Alternative);
            pragma Assert (Self_ID.Alive_Count = 1);
 
         else
            --  We are NOT on a terminate alternative.
            --  Our parent should wait in Phase 1 of Complete_Master.
 
            Master_Completion_Phase := 1;
            pragma Assert (Self_ID.Awake_Count >= 1);
         end if;
 
      --  We are accepting with a terminate alternative
 
      else
         if Self_ID.Open_Accepts = null then
 
            --  Somebody started a rendezvous while we had our lock open.
            --  Skip the terminate alternative.
 
            Unlock (C);
 
            if P /= null then
               Unlock (P);
            end if;
 
            return;
         end if;
 
         Self_ID.Terminate_Alternative := True;
         Master_Completion_Phase := 0;
 
         pragma Assert (Self_ID.Terminate_Alternative);
         pragma Assert (Self_ID.Awake_Count >= 1);
      end if;
 
      if Master_Completion_Phase = 2 then
 
         --  Since our Awake_Count is zero but our Alive_Count
         --  is nonzero, we have been accepting with a terminate
         --  alternative, and we now have been told to terminate
         --  by a completed master (in some ancestor task) that
         --  is waiting (with zero Awake_Count) in Phase 2 of
         --  Complete_Master.
 
         pragma Debug (Debug.Trace (Self_ID, "Make_Passive: Phase 2", 'M'));
 
         pragma Assert (P /= null);
 
         C.Alive_Count := C.Alive_Count - 1;
 
         if C.Alive_Count > 0 then
            Unlock (C);
            Unlock (P);
            return;
         end if;
 
         --  C's count just went to zero, indicating that
         --  all of C's dependents are terminated.
         --  C has a parent, P.
 
         loop
            --  C's count just went to zero, indicating that all of C's
            --  dependents are terminated. C has a parent, P. Notify P that
            --  C and its dependents have all terminated.
 
            P.Alive_Count := P.Alive_Count - 1;
            exit when P.Alive_Count > 0;
            Unlock (C);
            Unlock (P);
            C := P;
            P := C.Common.Parent;
 
            --  Environment task cannot have terminated yet
 
            pragma Assert (P /= null);
 
            Write_Lock (P);
            Write_Lock (C);
         end loop;
 
         if P.Common.State = Master_Phase_2_Sleep
           and then C.Master_of_Task = P.Master_Within
         then
            pragma Assert (P.Common.Wait_Count > 0);
            P.Common.Wait_Count := P.Common.Wait_Count - 1;
 
            if P.Common.Wait_Count = 0 then
               Wakeup (P, Master_Phase_2_Sleep);
            end if;
         end if;
 
         Unlock (C);
         Unlock (P);
         return;
      end if;
 
      --  We are terminating in Phase 1 or Complete_Master,
      --  or are accepting on a terminate alternative.
 
      C.Awake_Count := C.Awake_Count - 1;
 
      if Task_Completed then
         C.Alive_Count := C.Alive_Count - 1;
      end if;
 
      if C.Awake_Count > 0 or else P = null then
         Unlock (C);
 
         if P /= null then
            Unlock (P);
         end if;
 
         return;
      end if;
 
      --  C's count just went to zero, indicating that all of C's
      --  dependents are terminated or accepting with terminate alt.
      --  C has a parent, P.
 
      loop
         --  Notify P that C has gone passive
 
         if P.Awake_Count > 0 then
            P.Awake_Count := P.Awake_Count - 1;
         end if;
 
         if Task_Completed and then C.Alive_Count = 0 then
            P.Alive_Count := P.Alive_Count - 1;
         end if;
 
         exit when P.Awake_Count > 0;
         Unlock (C);
         Unlock (P);
         C := P;
         P := C.Common.Parent;
 
         if P = null then
            return;
         end if;
 
         Write_Lock (P);
         Write_Lock (C);
      end loop;
 
      --  P has non-passive dependents
 
      if P.Common.State = Master_Completion_Sleep
        and then C.Master_of_Task = P.Master_Within
      then
         pragma Debug
           (Debug.Trace
            (Self_ID, "Make_Passive: Phase 1, parent waiting", 'M'));
 
         --  If parent is in Master_Completion_Sleep, it cannot be on a
         --  terminate alternative, hence it cannot have Wait_Count of
         --  zero. ???Except that the race condition in Make_Independent can
         --  cause Wait_Count to be zero, so we need to check for that.
 
         if P.Common.Wait_Count > 0 then
            P.Common.Wait_Count := P.Common.Wait_Count - 1;
         end if;
 
         if P.Common.Wait_Count = 0 then
            Wakeup (P, Master_Completion_Sleep);
         end if;
 
      else
         pragma Debug
           (Debug.Trace
             (Self_ID, "Make_Passive: Phase 1, parent awake", 'M'));
         null;
      end if;
 
      Unlock (C);
      Unlock (P);
   end Make_Passive;
 
end System.Tasking.Utilities;