---------------------------------------------------- ---------------------------- ------------------------------------------------------------------------------ -- 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: 209 $ -- $Date: 2008-06-29 14:47:31 +0200 (dim., 29 juin 2008) $ -- $Author: singhoff $ ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ with Scheduler; use Scheduler; with Scheduling_Analysis; use Scheduling_Analysis; use Scheduling_Analysis.Double_Tasks_Parameters_Package; with Scheduler.Fixed_Priority; use Scheduler.Fixed_Priority; with Scheduler.Fixed_Priority.Hpf; use Scheduler.Fixed_Priority.Hpf; package body Scheduler.Hierarchical.cyclic is procedure Initialize (A_Scheduler : in out Hierarchical_cyclic_Scheduler) is begin Reset (A_Scheduler); A_Scheduler.parameters.scheduler_type := Hierarchical_Cyclic_Protocol; A_Scheduler.address_space_index := 0; end Initialize; function Copy (A_Scheduler : in Hierarchical_cyclic_Scheduler) return Generic_Scheduler_Ptr is Ptr : Hierarchical_cyclic_Scheduler_Ptr; begin Ptr := new Hierarchical_cyclic_Scheduler; Ptr.parameters := A_Scheduler.parameters; Ptr.Previously_Elected := A_Scheduler.Previously_Elected; return Generic_Scheduler_Ptr (Ptr); end Copy; procedure Check_Before_Scheduling (My_Scheduler : in Hierarchical_cyclic_Scheduler; My_Tasks : in Tasks_Set; Processor_Name : in Unbounded_String) is begin null; end Check_Before_Scheduling; procedure Specific_Scheduler_Initialization (My_Scheduler : in out Hierarchical_cyclic_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 -- Save local address schedulers -- My_Scheduler.Local_Scheduler := my_schedulers; -- Do local scheduler initializations -- for i in scheduler_range loop if (My_Scheduler.Local_Scheduler (i) /= null) then Specific_Scheduler_Initialization (My_Scheduler.Local_Scheduler (i).scheduler.all, Si, Processor_Name, My_Scheduler.Local_Scheduler (i).address_space_name, My_Tasks, my_schedulers, My_Resources, My_Buffers, My_Messages, Msg); end if; end loop; end Specific_Scheduler_Initialization; procedure Do_Election (My_Scheduler : in out Hierarchical_cyclic_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 begin -- Call the scheduler associated to the current address space -- No method dispatch => some scheduler are not allowed -- Do_Election (Hpf_Scheduler ( My_Scheduler.Local_Scheduler (My_Scheduler.address_space_index). scheduler.all), Si, Result, Msg, Current_Time, Processor_Name, My_Scheduler.Local_Scheduler (My_Scheduler.address_space_index). address_space_name, My_Dependencies, With_Offsets, With_Precedencies, With_Resources, Event_To_Generate, Elected, No_Task); -- Check if we must switch the activated/schedulable address space -- My_Scheduler.Local_Scheduler (My_Scheduler.address_space_index).used_cpu := My_Scheduler.Local_Scheduler (My_Scheduler.address_space_index). used_cpu + 1; if My_Scheduler.Local_Scheduler (My_Scheduler.address_space_index). used_cpu >= Get_Quantum ( My_Scheduler.Local_Scheduler (My_Scheduler.address_space_index). scheduler.all) then -- Address space switching -- My_Scheduler.Local_Scheduler (My_Scheduler.address_space_index). used_cpu := 0; My_Scheduler.address_space_index := My_Scheduler.address_space_index + 1; if My_Scheduler.Local_Scheduler (My_Scheduler.address_space_index) = null then My_Scheduler.address_space_index := 0; end if; -- Reset task wake up time at address space wake up time -- for I in 0 .. Si.Number_Of_Tasks - 1 loop if (Si.Tcbs (I).Tsk.address_space_name = My_Scheduler.Local_Scheduler (My_Scheduler.address_space_index) .address_space_name) then Si.Tcbs (I).Wake_Up_Time := Current_Time + 1; end if; end loop; end if; end Do_Election; function Build_Resource (My_Scheduler : in Hierarchical_cyclic_Scheduler; A_Resource : Generic_Resource_Ptr) return Shared_Resource_Ptr is New_A_Resource : Fixed_Priority_Resource_Ptr; begin New_A_Resource := new Fixed_Priority_Resource; New_A_Resource.Shared := A_Resource; -- Set priority ceiling of the resource -- New_A_Resource.Priority_Ceiling := Low_Priority; return Shared_Resource_Ptr (New_A_Resource); end Build_Resource; function Build_Tcb (My_Scheduler : in Hierarchical_cyclic_Scheduler; A_Task : Generic_Task_Ptr) return Tcb_Ptr is A_Tcb : Hpf_Tcb_Ptr; begin A_Tcb := new Hpf_Tcb; Initialize (Tcb (A_Tcb.all), A_Task); Initialize (Fixed_Priority_Tcb (A_Tcb.all)); Initialize (A_Tcb.all); return Tcb_Ptr (A_Tcb); end Build_Tcb; end Scheduler.Hierarchical.cyclic;