------------------------------------------------------------------------------ ------------------------------------------------------------------------------ -- Cheddar is a GNU GPL real-time scheduling analysis tool. -- This program provides services to automatically check schedulability and -- other performance criteria of real-time architecture models. -- -- Copyright (C) 2002-2016, Frank Singhoff, Alain Plantec, Jerome Legrand -- -- The Cheddar project was started in 2002 by -- Frank Singhoff, Lab-STICC UMR 6285 laboratory, Université de Bretagne Occidentale -- -- Cheddar has been published in the "Agence de Protection des Programmes/France" in 2008. -- Since 2008, Ellidiss technologies also contributes to the development of -- Cheddar and provides industrial support. -- -- The full list of contributors and sponsors can be found in AUTHORS.txt and SPONSORS.txt -- -- 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: 1249 $ -- $Date: 2014-08-28 07:02:15 +0200 (Fri, 28 Aug 2014) $ -- $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; with text_io; use text_io; with debug; use debug; package body Scheduler.Hierarchical.round_robin is procedure Initialize (A_Scheduler : in out Hierarchical_round_robin_Scheduler) is begin Reset (A_Scheduler); A_Scheduler.parameters.scheduler_type := Hierarchical_Cyclic_Protocol; end Initialize; function Copy (A_Scheduler : in Hierarchical_round_robin_Scheduler) return Generic_Scheduler_Ptr is Ptr : Hierarchical_round_robin_Scheduler_Ptr; begin Ptr := new Hierarchical_round_robin_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_round_robin_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_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 -- Reset the quantum of the global scheduler -- my_scheduler.used_quantum:= 0; -- Reset index on local address space scheduler -- my_scheduler.address_space_index := 0; -- Save local address schedulers -- My_Scheduler.Local_Scheduler := my_schedulers; -- Do local scheduler initializations -- for i in 0..My_Scheduler.Local_Scheduler.nb_entries -1 loop Specific_Scheduler_Initialization (My_Scheduler.Local_Scheduler.entries(i).scheduler.all, Si, Processor_Name, address_space_scheduler_ptr(My_Scheduler.Local_Scheduler.entries(i)).entity.name, My_Tasks, my_schedulers, My_Resources, My_Buffers, My_Messages, Msg); end loop; end Specific_Scheduler_Initialization; procedure Do_Election (My_Scheduler : in out Hierarchical_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; With_jitters : in Boolean; With_minimize_preemption : in Boolean; Event_To_Generate : in Time_Unit_Event_Type_Boolean_Table; Elected : in out Tasks_Range; No_Task : in out Boolean) is A_Item : Time_Unit_Event_ptr; begin -- Call the scheduler associated to the current address space -- No method dispatch => some scheduler are not allowed -- put_debug("Active address space is " & to_string(address_space_scheduler_ptr(My_Scheduler.Local_Scheduler.entries(My_Scheduler.address_space_index)).entity.name), very_verbose ); Do_Election ( My_Scheduler.Local_Scheduler.entries(My_Scheduler.address_space_index). scheduler.all, Si, Result, Msg, Current_Time, Processor_Name, address_space_scheduler_ptr(My_Scheduler.Local_Scheduler.entries(My_Scheduler.address_space_index)). entity.name, My_Dependencies, With_Offsets, With_Precedencies, With_Resources, with_jitters, with_minimize_preemption, Event_To_Generate, Elected, No_Task); -- generate an address space activation event for this first entry in the scheduling table -- in the beginning of the simulation -- if current_time = 0 then if Event_To_Generate (address_space_Activation) then A_Item := new Time_Unit_Event (address_space_activation); A_Item.activation_address_space := address_space_scheduler_ptr(My_Scheduler.Local_Scheduler.entries(my_scheduler.address_space_index)).entity.name; A_Item.duration:= Get_Quantum (My_Scheduler); add (Result.all, 0, a_item); end if; end if; ------------------------------------------------------ -- Update variables for multi core scheduling ------------------------------------------------------ -- Assign the task to the current core unit and put it -- in the already run state -- my_scheduler.corresponding_core_unit:= My_Scheduler.Local_Scheduler.entries(My_Scheduler.address_space_index).scheduler.corresponding_core_unit; -- Check if we must switch the activated/schedulable address space -- With Round robin, We switch when the global scheduler quantum is exhausted -- My_Scheduler.used_quantum := My_Scheduler.used_quantum + 1; if Get_Quantum (My_Scheduler) >= My_Scheduler.used_quantum then -- Address space switching -- put_debug("Change of running address space", very_verbose); -- generate address space activation event -- if Event_To_Generate (address_space_Activation) then A_Item := new Time_Unit_Event (address_space_activation); A_Item.activation_address_space := address_space_scheduler_ptr(My_Scheduler.Local_Scheduler.entries(my_scheduler.address_space_index)).entity.name; A_Item.duration:= Get_Quantum (My_Scheduler); add (Result.all, current_time, a_item); end if; -- Do Address space switch -- My_Scheduler.used_quantum := 0; My_Scheduler.address_space_index := My_Scheduler.address_space_index + 1; if My_Scheduler.Local_Scheduler.entries(My_Scheduler.address_space_index) = null then My_Scheduler.address_space_index := 0; end if; end if; end Do_Election; function Build_Resource (My_Scheduler : in Hierarchical_round_robin_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_round_robin_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.round_robin;