----------------------------------------------- --------------------------------- ------------------------------------------------------------------------------ -- Cheddar is a GNU GPL real time scheduling analysis tool. -- This program provides services to automatically check performances -- of real time architectures. -- -- Copyright (C) 2002-2010, by Frank Singhoff, Alain Plantec, Jerome Legrand -- -- The Cheddar project was started in 2002 by -- the LISyC Team, University of Western Britanny. -- -- Since 2008, Ellidiss technologies also contributes to the development of -- Cheddar and provides industrial support. -- -- This program is free software; you can redistribute it and/or modify -- it under the terms of the GNU General Public License as published by -- the Free Software Foundation; either version 2 of the License, or -- (at your option) any later version. -- -- This program is distributed in the hope that it will be useful, -- but WITHOUT ANY WARRANTY; without even the implied warranty of -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -- GNU General Public License for more details. -- -- You should have received a copy of the GNU General Public License -- along with this program; if not, write to the Free Software -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- -- -- Contact : cheddar@listes.univ-brest.fr -- ----------------------------------------------------------------------------- -- Last update : -- $Rev: 523 $ -- $Date: 2012-09-26 15:09:39 +0200 (Wed, 26 Sep 2012) $ -- $Author: fotsing $ ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ with unbounded_strings; use unbounded_strings; with Translate; use Translate; package body Scheduler.Round_Robin is procedure Initialize (A_Tcb : in out Rr_Tcb) is begin A_Tcb.Task_Quantum := 0; end Initialize; function Build_Tcb (My_Scheduler : in Round_Robin_Scheduler; A_Task : Generic_Task_Ptr) return Tcb_Ptr is A_Tcb : Rr_Tcb_Ptr; begin A_Tcb := new Rr_Tcb; Initialize (Tcb (A_Tcb.all), A_Task); Initialize (A_Tcb.all); return Tcb_Ptr (A_Tcb); end Build_Tcb; procedure Initialize (A_Scheduler : in out Round_Robin_Scheduler) is begin Reset (A_Scheduler); A_Scheduler.parameters.scheduler_type := Round_Robin_Protocol; end Initialize; function Copy (A_Scheduler : in Round_Robin_Scheduler) return Generic_Scheduler_Ptr is Ptr : Round_Robin_Scheduler_Ptr; begin Ptr := new Round_Robin_Scheduler; Ptr.parameters := A_Scheduler.parameters; Ptr.Previously_Elected := A_Scheduler.Previously_Elected; return Generic_Scheduler_Ptr (Ptr); end Copy; procedure Bound_On_Processor_Utilization (My_Scheduler : in Round_Robin_Scheduler; My_Tasks : in Tasks_Set; Processor_Name : in Unbounded_String; Result : in out Double; Msg : in out Unbounded_String) is begin raise Invalid_Scheduler; end Bound_On_Processor_Utilization; procedure Compute_Response_Time (My_Scheduler : in Round_Robin_Scheduler; My_Tasks : in out Tasks_Set; Processor_Name : in Unbounded_String; Msg : in out Unbounded_String; Response_Time : out Response_Time_Table) is begin raise Invalid_Scheduler; end Compute_Response_Time; procedure Put (My_Scheduler : in Round_Robin_Scheduler) is begin Put (Generic_Scheduler (My_Scheduler)); end Put; procedure Check_Before_Scheduling (My_Scheduler : in Round_Robin_Scheduler; My_Tasks : in Tasks_Set; Processor_Name : in Unbounded_String) is begin null; end Check_Before_Scheduling; procedure Do_Election (My_Scheduler : in out Round_Robin_Scheduler; Si : in out Scheduling_Information; Result : in out Scheduling_Sequence_Ptr; Msg : in out Unbounded_String; Current_Time : in Natural; Processor_Name : in Unbounded_String; Address_Space_Name : in Unbounded_String; My_Dependencies : in Tasks_Dependencies_Ptr; With_Offsets : in Boolean; With_Precedencies : in Boolean; With_Resources : in Boolean; Event_To_Generate : in Time_Unit_Event_Type_Boolean_Table; Elected : in out Tasks_Range; No_Task : in out Boolean) is -- find the ready task which is directly after the task "Elected" -- I : Tasks_Range := 0; Has_A_Ready_Task : Boolean := False; First_Task : Tasks_Range := 0; begin -- Before switching to the next task, first check that -- the task quantum is not exceeded. If the current task -- can be run .... chose it -- if (My_Scheduler.parameters.quantum > 0) and (Rr_Tcb_Ptr (Si.Tcbs (My_Scheduler.Previously_Elected)).Task_Quantum /= 0) and (Si.Tcbs (My_Scheduler.Previously_Elected).Wake_Up_Time <= Current_Time) and (Si.Tcbs (My_Scheduler.Previously_Elected).Rest_Of_Capacity /= 0) and ((With_Offsets = False) or Check_Offset (Si.Tcbs (I), Current_Time)) and ((With_Precedencies = False) or Check_Precedencies (Si, My_Dependencies, Current_Time, Si.Tcbs (My_Scheduler.Previously_Elected))) then No_Task := False; Elected := My_Scheduler.Previously_Elected; Rr_Tcb_Ptr (Si.Tcbs (My_Scheduler.Previously_Elected)).Task_Quantum := Rr_Tcb_Ptr (Si.Tcbs (My_Scheduler.Previously_Elected)).Task_Quantum - 1; else -- Look for the next task -- if Si.Tcbs (My_Scheduler.Previously_Elected + 1) = null then First_Task := 0; else First_Task := My_Scheduler.Previously_Elected + 1; end if; I := First_Task; loop if (Si.Tcbs (I).Tsk.cpu_name = Processor_Name) then if (Si.Tcbs (I).assigned_core_unit = empty_string or Si.Tcbs (I).assigned_core_unit = My_Scheduler.corresponding_core_unit) and (Si.Tcbs (I).Wake_Up_Time <= Current_Time) and (Si.Tcbs (I).Rest_Of_Capacity /= 0) then if (With_Offsets = False) or Check_Offset (Si.Tcbs (I), Current_Time) then if (With_Precedencies = False) or Check_Precedencies (Si, My_Dependencies, Current_Time, Si.Tcbs (I)) then Elected := I; Has_A_Ready_Task := True; if (My_Scheduler.parameters.quantum > 0) then Rr_Tcb_Ptr (Si.Tcbs (I)).Task_Quantum := My_Scheduler.parameters.quantum - 1; end if; exit; end if; end if; end if; end if; I := I + 1; if Si.Tcbs (I) = null then I := 0; end if; exit when I = First_Task; end loop; if Has_A_Ready_Task then No_Task := False; else No_Task := True; end if; end if; end Do_Election; procedure Specific_Scheduler_Initialization (My_Scheduler : in out Round_Robin_Scheduler; Si : in out Scheduling_Information; Processor_Name : in Unbounded_String; address_space_name : in Unbounded_String; My_Tasks : in out Tasks_Set; my_schedulers : in Scheduler_table; My_Resources : in out Resources_Set; My_Buffers : in out Buffers_Set; My_Messages : in Messages_Set; Msg : in out Unbounded_String) is begin null; end Specific_Scheduler_Initialization; procedure Compute_Activation_Time (My_Scheduler : in Round_Robin_Scheduler; Si : in out Scheduling_Information; Elected : in Tasks_Range; Value : in out Natural) is begin raise Invalid_Scheduler; end Compute_Activation_Time; procedure Compute_Blocking_Time (My_Scheduler : in Round_Robin_Scheduler; My_Tasks : in Tasks_Set; My_Resources : in Resources_Set; Processor_Name : in Unbounded_String; Msg : in out Unbounded_String; Blocking_Time : out Blocking_Time_Table) is begin raise Invalid_Scheduler; end Compute_Blocking_Time; procedure Utilization_Factor_Feasibility_Test (My_Scheduler : in Round_Robin_Scheduler; My_Tasks : in Tasks_Set; Processor_Name : in Unbounded_String; Result : in out Unbounded_String) is begin Result := Result & Lb_Compute_Scheduling_Error_19 (Current_Language) & unbounded_lf; end Utilization_Factor_Feasibility_Test; end Scheduler.Round_Robin;