------------------------------------------- ------------------------------------- ------------------------------------------------------------------------------ -- 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: 431 $ -- $Date: 2011-04-24 13:35:23 +0200 (dim., 24 avr. 2011) $ -- $Author: singhoff $ ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ with Ada.Text_IO; use Ada.Text_IO; with Sax.Readers; use Sax.Readers; with Sax.Exceptions; use Sax.Exceptions; with Sax.Locators; use Sax.Locators; with Sax.Attributes; use Sax.Attributes; with Unicode.CES; use Unicode.CES; with Unicode; use Unicode; with Offsets; use Offsets; use Offsets.Offsets_Table_Package; with Parameters; use Parameters; use Parameters.User_Defined_Parameters_Table_Package; with Ada.Strings.Unbounded; use Ada.Strings.Unbounded; with strings; use strings; with unbounded_strings; use unbounded_strings; with Dependencies; use Dependencies; with Resources; use Resources; use Resources.Resource_Accesses; with Resource_Set; use Resource_Set; use Resource_Set.Generic_Resource_Set; with Messages; use Messages; with Message_Set; use Message_Set; use Message_Set.Generic_Message_Set; with Event_Analyzer_Set; use Event_Analyzer_Set; use Event_Analyzer_Set.Generic_Event_Analyzer_Set; with Ada.Numerics.Aux; use Ada.Numerics.Aux; with Tasks; use Tasks; with Task_Set; use Task_Set; use Task_Set.Generic_Task_Set; with Caches; use Caches; with Cache_Set; use Cache_Set; with Address_Spaces; use Address_Spaces; with Address_Space_Set; use Address_Space_Set; use Address_Space_Set.Generic_Address_Space_Set; with Buffers; use Buffers; use Buffers.Buffer_Roles_Package; with Buffer_Set; use Buffer_Set; use Buffer_Set.Generic_Buffer_Set; with Processors; use Processors; with Queueing_Systems; use Queueing_Systems; with Time_Unit_Events; use Time_Unit_Events; use Time_Unit_Events.Time_Unit_Package; with Scheduling_Analysis; use Scheduling_Analysis; with Scheduler_Interface; use Scheduler_Interface; with Task_Dependencies; use Task_Dependencies; with Network_Set; use Network_Set; with Ada.Strings.Maps; use Ada.Strings.Maps; with Networks; use Networks; with xml_architecture_io; use xml_architecture_io; with Multiprocessor_Services; use Multiprocessor_Services; with Framework_Config; use Framework_Config; package body Xml_generic_Parsers.event_table is tue1 : Time_Unit_Event_io; sched1 : Scheduling_Result_io; -- Variable to store indexes of indexed_table entities -- Index_value : Natural; New_Table : Scheduling_Result_Ptr; New_Event : Time_Unit_Event_Ptr; A_Buffer : Buffer_Ptr; A_Message : Generic_Message_Ptr; A_Task : Generic_Task_Ptr; A_Cache : Generic_Cache_Ptr; A_Resource : Generic_Resource_Ptr; A_processor : Generic_Processor_Ptr; function Get_Parsed_Event_Table (Handler : in Xml_Event_Table_Parser) return Scheduling_Table_Ptr is begin return Handler.Parsed_Event_Table; end Get_Parsed_Event_Table; procedure Set_Scheduled_System (Handler : in out Xml_Event_Table_Parser; Scheduled_System : in System) is begin Handler.Scheduled_System := Scheduled_System; end Set_Scheduled_System; procedure Initialize_Event_Table_Parser (Handler : in out Xml_Event_Table_Parser) is begin Initialize (tue1); Initialize (sched1); Handler.Current_Parameter := 1; end Initialize_Event_Table_Parser; procedure Start_Document (Handler : in out Xml_Event_Table_Parser) is begin Initialize_Event_Table_Parser (Handler); Handler.Parsed_Event_Table := new Scheduling_Table; end Start_Document; procedure Start_Element (Handler : in out Xml_Event_Table_Parser; Namespace_Uri : Unicode.CES.Byte_Sequence := ""; Local_Name : Unicode.CES.Byte_Sequence := ""; Qname : Unicode.CES.Byte_Sequence := ""; Atts : Sax.Attributes.Attributes'Class) is begin Handler.Current_Parameter := 1; Start_Element (Xml_Generic_Parser (Handler), tue1, Namespace_Uri, Local_Name, Qname, Atts); Start_Element (Xml_Generic_Parser (Handler), sched1, Namespace_Uri, Local_Name, Qname, Atts); -- Start to parse a scheduling sequence -- if Qname = "scheduling_result" then New_Table := new Scheduling_Result; New_Table.has_error := False; New_Table.scheduling_msg := empty_string; New_Table.error_msg := empty_string; New_Table.result := new Scheduling_Sequence; add (Handler.Parsed_Event_Table.all, A_processor, New_Table.all); end if; end Start_Element; procedure End_Element (Handler : in out Xml_Event_Table_Parser; Namespace_Uri : Unicode.CES.Byte_Sequence := ""; Local_Name : Unicode.CES.Byte_Sequence := ""; Qname : Unicode.CES.Byte_Sequence := "") is begin End_Element (Xml_Generic_Parser (Handler), Index_value, Namespace_Uri, Local_Name, Qname); End_Element (Xml_Generic_Parser (Handler), tue1, Namespace_Uri, Local_Name, Qname); End_Element (Xml_Generic_Parser (Handler), sched1, Namespace_Uri, Local_Name, Qname); -- Name of the processor related to the scheduling sequence -- if Qname = "name" then a_processor:=search_processor(Handler.Scheduled_System.processors, handler.Parameter_List (1)); end if; if Qname = "scheduling_result" then Initialize_Event_Table_Parser (Handler); end if; if Qname = "time_unit_event" then case tue1.type_of_event is when Start_Of_Task_Capacity => A_Task := Search_Task_by_id (Handler.Scheduled_System.Tasks, tue1.start_task); New_Event := new Time_Unit_Event (Start_Of_Task_Capacity); New_Event.start_task := A_Task; add (New_Table.result.all, Index_value, New_Event); when End_Of_Task_Capacity => A_Task := Search_Task_by_id (Handler.Scheduled_System.Tasks, tue1.end_task); New_Event := new Time_Unit_Event (End_Of_Task_Capacity); New_Event.end_task := A_Task; add (New_Table.result.all, Index_value, New_Event); when Write_To_Buffer => A_Task := Search_Task_by_id(Handler.Scheduled_System.Tasks, tue1.write_task); A_Buffer := Search_Buffer_by_id (Handler.Scheduled_System.Buffers, tue1.write_buffer); New_Event := new Time_Unit_Event (Write_To_Buffer); New_Event.write_buffer := A_Buffer; New_Event.write_task := A_Task; New_Event.write_size := tue1.write_size; New_Event.write_buffer_current_data_size := tue1.write_buffer_current_data_size; add (New_Table.result.all, Index_value, New_Event); when Read_From_Buffer => A_Task := Search_Task_by_id (Handler.Scheduled_System.Tasks, tue1.read_task); A_Buffer := Search_Buffer_by_id (Handler.Scheduled_System.Buffers, tue1.read_buffer); New_Event := new Time_Unit_Event (Read_From_Buffer); New_Event.read_buffer := A_Buffer; New_Event.read_task := A_Task; New_Event.read_size := tue1.read_size; New_Event.read_buffer_current_data_size := tue1.read_buffer_current_data_size; add (New_Table.result.all, Index_value, New_Event); when Buffer_Overflow => null; when Buffer_Underflow => null; when Context_Switch_Overhead => A_Task := Search_Task_by_id (Handler.Scheduled_System.Tasks, tue1.switched_task); New_Event := new Time_Unit_Event (Context_Switch_Overhead); New_Event.switched_task := A_Task; add (New_Table.result.all, Index_value, New_Event); when Running_Task => A_Task := Search_Task_by_id (Handler.Scheduled_System.Tasks, tue1.running_task); New_Event := new Time_Unit_Event (Running_Task); New_Event.running_task := A_Task; New_Event.running_core := tue1.running_core; New_Event.current_priority := Priority_Range (tue1.current_priority); New_Event.remaining_crpd := tue1.remaining_crpd; add (New_Table.result.all, Index_value, New_Event); when Task_activation => A_Task := Search_Task_by_id (Handler.Scheduled_System.Tasks, tue1.activation_task); New_Event := new Time_Unit_Event (Task_activation); New_Event.activation_task := A_Task; add (New_Table.result.all, Index_value, New_Event); when Allocate_Resource => A_Resource := Search_Resource_by_id (Handler.Scheduled_System.Resources, tue1.allocate_resource); A_Task := Search_Task_by_id (Handler.Scheduled_System.Tasks, tue1.allocate_task); New_Event := new Time_Unit_Event (Allocate_Resource); New_Event.allocate_task := A_Task; New_Event.allocate_resource := A_Resource; add (New_Table.result.all, Index_value, New_Event); when Release_Resource => A_Resource := Search_Resource_by_id (Handler.Scheduled_System.Resources, tue1.release_resource); A_Task := Search_Task_by_id (Handler.Scheduled_System.Tasks, tue1.release_task); New_Event := new Time_Unit_Event (Release_Resource); New_Event.release_task := A_Task; New_Event.release_resource := A_Resource; add (New_Table.result.all, Index_value, New_Event); when Wait_For_Resource => A_Resource := Search_Resource_by_id (Handler.Scheduled_System.Resources, tue1.wait_for_resource); A_Task := Search_Task_by_id (Handler.Scheduled_System.Tasks, tue1.wait_for_resource_task); New_Event := new Time_Unit_Event (Wait_For_Resource); New_Event.wait_for_resource_task := A_Task; New_Event.wait_for_resource := A_Resource; add (New_Table.result.all, Index_value, New_Event); when Send_Message => A_Message := Search_Message_by_id (Handler.Scheduled_System.Messages, tue1.send_message); A_Task := Search_Task_by_id (Handler.Scheduled_System.Tasks, tue1.send_task); New_Event := new Time_Unit_Event (Send_Message); New_Event.send_task := A_Task; New_Event.send_message := A_Message; add (New_Table.result.all, Index_value, New_Event); when Receive_Message => A_Message := Search_Message_by_id (Handler.Scheduled_System.Messages, tue1.receive_message); A_Task := Search_Task_by_id (Handler.Scheduled_System.Tasks, tue1.receive_task); New_Event := new Time_Unit_Event (Receive_Message); New_Event.receive_task := A_Task; New_Event.receive_message := A_Message; add (New_Table.result.all, Index_value, New_Event); when Wait_For_Memory => A_Cache := Search_Cache_by_id (Handler.Scheduled_System.Caches, tue1.wait_for_cache); A_Task := Search_Task_by_id (Handler.Scheduled_System.Tasks, tue1.wait_for_memory_task); New_Event := new Time_Unit_Event (Wait_For_Memory); New_Event.wait_for_memory_task := A_Task; New_Event.wait_for_cache := A_Cache; add (New_Table.result.all, Index_value, New_Event); when Address_Space_Activation => New_Event := new Time_Unit_Event (Address_Space_Activation); New_Event.activation_address_space := tue1.activation_address_space; New_Event.duration := tue1.duration; add (New_Table.result.all, Index_value, New_Event); when Preemption => New_Event := new Time_Unit_Event (Preemption); A_Task := Search_Task_by_id (Handler.Scheduled_System.Tasks, tue1.preempted_task); New_Event.preempted_task := A_Task; A_Task := Search_Task_by_id (Handler.Scheduled_System.Tasks, tue1.preempting_task); New_Event.preempting_task := A_Task; --TODO: FIX THIS New_Event.evicted_ucbs := 0; add (New_Table.result.all, Index_value, New_Event); end case; Initialize_Event_Table_Parser (Handler); end if; end End_Element; end Xml_generic_Parsers.event_table;