SCHEMA Objects;
	USE FROM Basic_Types;

	TYPE Objects_Type = ENUMERATION
		OF ( Buffer_Object_Type,
			 Processor_Object_Type,
			 Cache_Object_Type,
			 Task_Object_Type,
			 Resource_Object_Type,
			 Address_Space_Object_Type,
			 Message_Object_Type,
			 State_Object_Type,
			 Transition_Object_Type,
			 Statement_Object_Type,
			 Expression_Object_Type,
			 Synchronization_Object_Type,
			 Section_Object_Type,
			 Network_Object_Type,
			 Connexion_Object_Type,
			 Core_Object_Type,
			 Event_Analyzer_Type,
			 Deployment_Type,
			 Task_Group_Object_Type );
	END_TYPE;

	ENTITY Generic_Object 
		ABSTRACT SUPERTYPE;
		object_type : Objects_Type;
	END_ENTITY;

	ENTITY Named_Object 
		ABSTRACT SUPERTYPE 
		SUBTYPE OF ( Generic_Object );
		name : STRING;
	UNIQUE
		name;
	END_ENTITY;

	TYPE Generic_Objects_Range = Range;
	END_TYPE;

	TYPE Generic_Objects_Set = LIST OF Generic_Object;
	END_TYPE;

	ENTITY Generic_Object_Set_Package;
		element_range : Generic_Objects_Range;
		set_ : Generic_Objects_Set;
	END_ENTITY;

	FUNCTION object_from_name ( objects_list : SET OF Generic_Object;
			 name : STRING ) : Generic_Object;
		RETURN ( QUERY ( t <* objects_list | t.name = name ) [ 1 ] );
	END_FUNCTION;
END_SCHEMA;

SCHEMA Offsets;
	USE FROM Basic_Types;

	TYPE Offsets_Range = Range;
	END_TYPE;

	TYPE Offsets_Table = LIST OF Offset_Type;
	END_TYPE;

	ENTITY Offset_Type;
		offset_value : INTEGER;
		activation : INTEGER;
	END_ENTITY;

	ENTITY Offsets_Table_Package;
		table_range : Offsets_Range;
		table : Offsets_Table;
	END_ENTITY;
END_SCHEMA;

SCHEMA Caches;
	USE FROM Basic_Types;
	USE FROM Framework_Config;
	USE FROM Objects;

	TYPE Cache_Addressing_Type = ENUMERATION
		OF ( Virtual, Physical );
	END_TYPE;

	TYPE Cache_Type = ENUMERATION
		OF ( Data_Cache_Type, Instruction_Cache_Type, Data_Instruction_Cache_Type );
	END_TYPE;

	TYPE Cache_Coherence_Protocol_Type = ENUMERATION
		OF ( Private_Cache_Protocol,
			 Shared_Cache_Protocol,
			 Private_Invalid_Cache_Protocol,
			 Private_MSI_Cache_Protocol,
			 Private_MESI_Cache_Protocol );
	END_TYPE;

	TYPE Cache_Replacement_Type = ENUMERATION
		OF ( Random, LRU, LRR, FIFO );
	END_TYPE;

	TYPE Write_Policy_Type = ENUMERATION
		OF ( Copy_Back, Write_Through_with_Allocation, Write_Through_without_Allocation );
	END_TYPE;

	TYPE Caches_Range = Range;
	END_TYPE;

	TYPE Caches_Table = LIST OF Generic_Cache;
	END_TYPE;

	ENTITY Generic_Cache 
		SUBTYPE OF ( Named_Object );
		number_of_block : Natural;
		block_size : Natural;
		associativity : Natural;
		cache_replacement : Cache_Replacement_Type;
		hit_time : REAL;
		miss_time : REAL;
		miss_rate : Natural;
		cache_coherence_protocol : Cache_Coherence_Protocol_Type;
		cache_category : Cache_Type;
	WHERE
		wrc1 : miss_rate <= 100;
	END_ENTITY;

	ENTITY Data_Cache 
		SUBTYPE OF ( Generic_Cache );
		write_policy : Write_Policy_Type;
	DERIVE
		SELF\Generic_Cache.cache_category : Cache_Type := Data_Cache_Type;
	END_ENTITY;

	ENTITY Instruction_Cache 
		SUBTYPE OF ( Generic_Cache );
	DERIVE
		SELF\Generic_Cache.cache_category : Cache_Type := Instruction_Cache_Type;
	WHERE
		wrc2 : ( cache_coherence_protocol = Private_Cache_Protocol ) OR
		 ( cache_coherence_protocol = Shared_Cache_Protocol );
	END_ENTITY;

	ENTITY Data_Instruction_Cache 
		SUBTYPE OF ( Generic_Cache );
		write_policy : Write_Policy_Type;
	DERIVE
		SELF\Generic_Cache.cache_category : Cache_Type := Data_Instruction_Cache_Type;
	END_ENTITY;

	ENTITY Caches_Table_Package;
		table_range : Caches_Range;
		table : Caches_Table;
	END_ENTITY;

	ENTITY Cache_System 
		SUBTYPE OF ( Named_Object );
		caches : Caches_Table;
	END_ENTITY;
END_SCHEMA;

SCHEMA Processors;
	USE FROM Framework_Config;
	USE FROM Objects;
	USE FROM Scheduler;
	USE FROM Caches;
	USE FROM Basic_Types;
	USE FROM processor_interface;
	USE FROM Scheduler_Interface;

	TYPE Core_Units_Range = Range;
	END_TYPE;

	TYPE Core_Units_Table = LIST OF Core_Unit;
	END_TYPE;

	ENTITY Core_Unit 
		SUBTYPE OF ( Named_Object );
		scheduling : Scheduling_Parameters;
		speed : REAL;
		l1_cache_system_name : STRING;
	DERIVE
		SELF\Generic_Object.object_type : Objects_Type := Core_Object_Type;
	END_ENTITY;

	ENTITY Generic_Processor 
		SUBTYPE OF ( Named_Object );
		network : STRING;
		processor_type : Processors_type;
		migration_type : migrations_type;
	DERIVE
		SELF\Generic_Object.object_type : Objects_Type := Processor_Object_Type;
	END_ENTITY;

	ENTITY Mono_Core_Processor 
		SUBTYPE OF ( Generic_Processor );
		core : core_unit;
	END_ENTITY;

	ENTITY Core_Units_Table_Package;
		table_range : Core_Units_Range;
		table : Core_Units_Table;
	END_ENTITY;

	ENTITY Multi_Cores_Processor 
		SUBTYPE OF ( Generic_Processor );
		cores : Core_Units_Table;
		l2_cache_system_name : STRING;
	END_ENTITY;
END_SCHEMA;

SCHEMA Buffers;
	USE FROM Framework_Config;
	USE FROM Objects;
	USE FROM Tasks;
	USE FROM Basic_Types;
	USE FROM Queueing_Systems;

	TYPE Buffer_Role_Type = ENUMERATION
		OF ( No_Role, Queuing_Producer, Queuing_Consumer, Sampling_Writer, Sampling_Reader );
	END_TYPE;

	TYPE Buffer_Roles_Range = Range;
	END_TYPE;

	TYPE Buffer_Roles_Table = LIST OF Buffer_Role;
	END_TYPE;

	ENTITY Buffer_Role;
		the_role : Buffer_Role_Type;
		size : Natural;
		time : Natural;
		timeout : Natural;
	END_ENTITY;

	ENTITY Buffer_Roles_Package;
		indexed_table : Buffer_Roles_Table;
		indexed_table_range : Buffer_Roles_Range;
	END_ENTITY;

	ENTITY Buffer 
		SUBTYPE OF ( Named_Object );
		cpu_name : STRING;
		address_space_name : STRING;
		queueing_system_type : Queueing_Systems_Type;
		size : Natural;
		roles : Buffer_Roles_Table;
	DERIVE
		SELF\Generic_Object.object_type : Objects_Type := Buffer_Object_Type;
	END_ENTITY;
END_SCHEMA;

SCHEMA Resources;
	USE FROM Framework_Config;
	USE FROM Basic_Types;
	USE FROM objects;
	USE FROM Tasks;

	TYPE Resources_Type = ENUMERATION
		OF ( No_Protocol,
			 Priority_Ceiling_Protocol,
			 Priority_Inheritance_Protocol,
			 Immediate_Priority_Ceiling_Protocol );
	END_TYPE;

	TYPE Resource_Accesses_Range = Range;
	END_TYPE;

	TYPE Resource_Accesses_Table = LIST [ 0 : Max_Tasks_For_A_Resource] OF Critical_Section;
	END_TYPE;

	TYPE Start_End_Table = LIST OF Critical_Section;
	END_TYPE;

	ENTITY Critical_Section;
		task_begin : Natural;
		task_end : Natural;
	END_ENTITY;

	ENTITY Resource_Accesses;
		indexed_table_range : Resource_Accesses_Range;
		indexed_table : Resource_Accesses_Table;
	END_ENTITY;

	ENTITY Generic_Resource 
		ABSTRACT SUPERTYPE 
		SUBTYPE OF ( Named_Object );
		state : INTEGER;
		size : INTEGER;
		address : INTEGER;
		protocol : Resources_Type;
		critical_sections : Resource_Accesses_Table;
		cpu_name : STRING;
		address_space_name : STRING;
	DERIVE
		SELF\Generic_Object.object_type : Objects_Type := Resource_Object_Type;
	END_ENTITY;

	ENTITY Np_Resource 
		SUBTYPE OF ( Generic_Resource );
	END_ENTITY;

	ENTITY Priority_Constrained_Resource 
		SUBTYPE OF ( Generic_Resource );
		ceiling_priority : priority_range;
	END_ENTITY;

	ENTITY Pip_Resource 
		SUBTYPE OF ( Generic_Resource );
	DERIVE
		SELF\Generic_Resource.protocol : Resources_Type := Priority_Inheritance_Protocol;
	END_ENTITY;

	ENTITY Pcp_Resource 
		SUBTYPE OF ( Priority_Constrained_Resource );
	DERIVE
		SELF\Generic_Resource.protocol : Resources_Type := Priority_Ceiling_Protocol;
	END_ENTITY;

	ENTITY IPcp_Resource 
		SUBTYPE OF ( Priority_Constrained_Resource );
	DERIVE
		SELF\Generic_Resource.protocol : Resources_Type := Immediate_Priority_Ceiling_Protocol;
	END_ENTITY;
END_SCHEMA;

SCHEMA Tasks;
	USE FROM Framework_Config;
	USE FROM Objects;
	USE FROM Parameters;
	USE FROM Offsets;
	USE FROM Basic_Types;

	TYPE Tasks_Type = ENUMERATION
		OF ( Periodic_Type,
			 Aperiodic_Type,
			 Sporadic_Type,
			 Poisson_Type,
			 Parametric_Type,
			 Scheduling_Task_Type,
			 Frame_Task_Type );
	END_TYPE;

	TYPE Policies = ENUMERATION
		OF ( Sched_Fifo, Sched_Rr, Sched_Others );
	END_TYPE;

	ENTITY Generic_Task 
		ABSTRACT SUPERTYPE 
		SUBTYPE OF ( Named_Object );
		task_type : Tasks_Type;
		cpu_name : STRING;
		address_space_name : STRING;
		capacity : Natural;
		deadline : Natural;
		start_time : Natural;
		priority : priority_range;
		blocking_time : Natural;
		policy : Policies;
		offsets : Offsets_Table;
		text_memory_size : Natural;
		stack_memory_size : Natural;
		parameters : User_Defined_Parameters_Table;
		criticality : Natural;
		context_switch_overhead : Natural;
	DERIVE
		SELF\Generic_Object.object_type : Objects_Type := Task_Object_Type;
	END_ENTITY;

	TYPE Generic_Task_Iterator = Iterator;
	END_TYPE;

	TYPE Generic_Task_List = LIST OF Generic_Task;
	END_TYPE;

	ENTITY Generic_Task_List_Package;
		iterator : Generic_Task_Iterator;
		List_ : Generic_Task_List;
	END_ENTITY;

	ENTITY Periodic_Task 
		SUBTYPE OF ( Generic_Task );
		period : Natural;
		jitter : Natural;
	DERIVE
		SELF\Generic_Task.task_type : Tasks_Type := Periodic_Type;
	WHERE
		wr1 : Period > 0;
	END_ENTITY;

	ENTITY Aperiodic_Task 
		SUBTYPE OF ( Generic_Task );
	DERIVE
		SELF\Generic_Task.task_type : Tasks_Type := Aperiodic_Type;
	END_ENTITY;

	ENTITY Poisson_Task 
		SUBTYPE OF ( Periodic_Task );
		seed : INTEGER;
		predictable : BOOLEAN;
	DERIVE
		SELF\Periodic_Task.task_type : Tasks_Type := Poisson_Type;
	END_ENTITY;

	ENTITY Sporadic_Task 
		SUBTYPE OF ( Poisson_Task );
	DERIVE
		SELF\Poisson_Task.task_type : Tasks_Type := Sporadic_Type;
	END_ENTITY;

	ENTITY Parametric_Task 
		SUBTYPE OF ( Poisson_Task );
		activation_rule : STRING;
	DERIVE
		SELF\Poisson_Task.task_type : Tasks_Type := Parametric_Type;
	END_ENTITY;

	ENTITY Scheduling_Task 
		SUBTYPE OF ( Poisson_Task );
	DERIVE
		SELF\Poisson_Task.task_type : Tasks_Type := Scheduling_Task_type;
	END_ENTITY;

	ENTITY Frame_Task 
		SUBTYPE OF ( Periodic_Task );
		interarrival : INTEGER;
	DERIVE
		SELF\Poisson_Task.task_type : Tasks_Type := Frame_Task_type;
	END_ENTITY;
END_SCHEMA;

SCHEMA Task_Groups;
	USE FROM Framework_Config;
	USE FROM Objects;
	USE FROM Tasks;
	USE FROM Offsets;
	USE FROM Basic_Types;
	USE FROM Parameters;

	TYPE Task_Groups_type = ENUMERATION
		OF ( Transaction_Type, Multiframe_Type );
	END_TYPE;

	ENTITY Generic_Task_Group 
		ABSTRACT SUPERTYPE 
		SUBTYPE OF ( Named_Object );
		task_list : Generic_Task_List;
		task_group_type : Task_Groups_Type;
		cpu_name : STRING;
		address_space_name : STRING;
		capacity : Natural;
		deadline : Natural;
		start_time : Natural;
		priority : priority_range;
		blocking_time : Natural;
		policy : Policies;
		offsets : Offsets_Table;
		text_memory_size : Natural;
		stack_memory_size : Natural;
		parameters : User_Defined_Parameters_Table;
		criticality : Natural;
		context_switch_overhead : Natural;
		seed : INTEGER;
		predictable : BOOLEAN;
		period : Natural;
		jitter : Natural;
		activation_rule : STRING;
	DERIVE
		SELF\Generic_Object.object_type : Objects_Type := Task_Group_Object_Type;
	END_ENTITY;

	ENTITY Transaction_Task_Group 
		SUBTYPE OF ( Generic_Task_Group );
	DERIVE
		SELF\Generic_Task_Group.task_group_type : Task_Groups_type := Transaction_Type;
	WHERE
		contains_only_periodic_tasks : SIZEOF ( QUERY ( t <* task_list |
				 NOT ( 'Tasks.Periodic_Task' IN TYPEOF ( t ) ) ) ) = 0;
	END_ENTITY;

	ENTITY Multiframe_Task_Group 
		SUBTYPE OF ( Generic_Task_Group );
	DERIVE
		SELF\Generic_Task_Group.task_group_type : Task_Groups_type := Multiframe_Type;
	WHERE
		contains_only_frame_tasks : SIZEOF ( QUERY ( t <* task_list |
				 NOT ( 'Tasks.Frame_Task' IN TYPEOF ( t ) ) ) ) = 0;
	END_ENTITY;
END_SCHEMA;

SCHEMA Messages;
	USE FROM Objects;
	USE FROM Parameters;
	USE FROM Basic_Types;

	TYPE Messages_Type = ENUMERATION
		OF ( Periodic_Type, Aperiodic_Type, Generic_Type );
	END_TYPE;

	ENTITY Generic_Message 
		ABSTRACT SUPERTYPE 
		SUBTYPE OF ( Named_Object );
		message_type : Messages_Type;
		parameters : User_Defined_Parameters_Table;
		deadline : Natural;
		size : Natural;
		response_time : Natural;
		communication_time : Natural;
	DERIVE
		SELF\Generic_Object.object_type : Objects_Type := Message_Object_Type;
	END_ENTITY;

	ENTITY Periodic_Message 
		SUBTYPE OF ( Generic_Message );
		period : Natural;
		jitter : Natural;
	DERIVE
		SELF\Generic_Message.message_type : Messages_Type := Periodic_Type;
	END_ENTITY;

	ENTITY Aperiodic_Message 
		SUBTYPE OF ( Generic_Message );
	DERIVE
		SELF\Generic_Message.message_type : Messages_Type := Aperiodic_Type;
	END_ENTITY;
END_SCHEMA;

SCHEMA Dependencies;
	USE FROM Basic_Types;
	USE FROM Messages;
	USE FROM Tasks;
	USE FROM Buffers;
	USE FROM Resources;

	TYPE Dependency_Type = ENUMERATION
		OF ( Precedence_Dependency,
			 Queuing_Buffer_Dependency,
			 Communication_Dependency,
			 Time_Triggered_Communication_Dependency,
			 Resource_Dependency,
			 Black_Board_Buffer_Dependency );
	END_TYPE;

	TYPE Time_Triggered_Communication_Timing_Property_Type = ENUMERATION
		OF ( Sampled_Timing, Immediate_Timing, Delayed_Timing );
	END_TYPE;

	TYPE Orientation_Dependency_Type = ENUMERATION
		OF ( From_Object_To_Task, From_Task_To_Object );
	END_TYPE;

	ENTITY Time_Triggered_Communication_Dependency_Type;
		time_triggered_communication_sink : Generic_Task;
		time_triggered_communication_source : Generic_Task;
		timing_property : Time_Triggered_Communication_Timing_Property_Type;
	END_ENTITY;

	ENTITY Precedence_Dependency_Type;
		precedence_sink : Generic_Task;
		precedence_source : Generic_Task;
	END_ENTITY;

	ENTITY Queuing_Buffer_Dependency_Type;
		buffer_dependent_task : Generic_Task;
		buffer_orientation : Orientation_Dependency_Type;
		buffer_dependency_object : Buffer;
	END_ENTITY;

	ENTITY Black_board_Buffer_Dependency_Type;
		black_board_dependent_task : Generic_Task;
		black_board_orientation : Orientation_Dependency_Type;
		black_board_dependency_object : Buffer;
	END_ENTITY;

	ENTITY Resource_Dependency_Type;
		resource_dependency_resource : Generic_Resource;
		resource_dependency_task : Generic_Task;
	END_ENTITY;

	ENTITY Communication_Dependency_Type;
		communication_dependent_task : Generic_Task;
		communication_orientation : Orientation_Dependency_Type;
		communication_dependency_object : Generic_Message;
	END_ENTITY;

	ENTITY Dependency_Union;
		precedence_dependency : Precedence_Dependency_Type;
		queuing_buffer_dependency : Queuing_Buffer_Dependency_Type;
		communication_dependency : Communication_Dependency_Type;
		time_triggered_communication_dependency : Time_Triggered_Communication_Dependency_Type;
		resource_dependency : Resource_Dependency_Type;
		black_board_Buffer_dependency : Black_Board_Buffer_Dependency_Type;
	END_ENTITY;

	ENTITY Dependency;
		type_of_dependency : Dependency_Type;
		union : Dependency_Union;
	END_ENTITY;
END_SCHEMA;

SCHEMA Address_Spaces;
	USE FROM Basic_Types;
	USE FROM Objects;
	USE FROM Processors;
	USE FROM Scheduler_Interface;

	ENTITY Address_Space 
		SUBTYPE OF ( Named_Object );
		cpu_name : STRING;
		text_memory_size : Natural;
		stack_memory_size : Natural;
		data_memory_size : Natural;
		heap_memory_size : Natural;
		scheduling : Scheduling_Parameters;
	DERIVE
		SELF\Generic_Object.object_type : Objects_Type := Address_Space_Object_Type;
	END_ENTITY;
END_SCHEMA;

SCHEMA Laws;

	TYPE Laws_Type = ENUMERATION
		OF ( Uniform_Law_Type, Laplace_Gauss_Law_Type, Exponential_Law_Type );
	END_TYPE;
END_SCHEMA;

SCHEMA Networks;
	USE FROM Objects;

	TYPE Networks_Type = ENUMERATION
		OF ( Bounded_Delay, Jitter_Delay, Parametric_Delay );
	END_TYPE;

	ENTITY Network 
		SUBTYPE OF ( Named_Object );
		network_type : Networks_Type;
	DERIVE
		SELF\Generic_Object.object_type : Objects_Type := Network_Object_Type;
	END_ENTITY;
END_SCHEMA;

SCHEMA Time_Unit_Events;
	USE FROM Basic_Types;
	USE FROM Framework_Config;
	USE FROM Resources;
	USE FROM Tasks;
	USE FROM Messages;
	USE FROM Buffers;
	USE FROM Caches;

	TYPE Time_Unit_Event_Type = ENUMERATION
		OF ( Start_Of_Task_Capacity,
			 End_Of_Task_Capacity,
			 Write_To_Buffer,
			 Read_From_Buffer,
			 Context_Switch_Overhead,
			 Running_Task,
			 Task_activation,
			 Allocate_Resource,
			 Release_Resource,
			 Wait_For_Resource,
			 Send_Message,
			 Receive_Message,
			 Wait_For_Memory,
			 Address_Space_Activation );
	END_TYPE;

	TYPE Time_Unit_Event_Type_Boolean_Table = LIST OF AdaBoolean;
	END_TYPE;

	TYPE Time_Unit_Range = Range;
	END_TYPE;

	TYPE Time_Unit_Table = LIST OF Association;
	END_TYPE;

	ENTITY Address_Space_Activation_Type;
		activation_address_space : STRING;
		duration : Natural;
	END_ENTITY;

	ENTITY Start_Of_Task_Capacity_Type;
		start_task : Generic_Task;
	END_ENTITY;

	ENTITY End_Of_Task_Capacity_Type;
		end_task : Generic_Task;
	END_ENTITY;

	ENTITY Write_To_Buffer_Type;
		write_buffer : Buffer;
		write_task : Generic_Task;
		write_size : Natural;
	END_ENTITY;

	ENTITY Read_From_Buffer_Type;
		read_buffer : Buffer;
		read_task : Generic_Task;
		read_size : Natural;
	END_ENTITY;

	ENTITY Context_Switch_Overhead_Type;
		switched_task : Generic_Task;
	END_ENTITY;

	ENTITY Running_Task_Type;
		running_core : STRING;
		running_task : Generic_Task;
		current_priority : priority_range;
	END_ENTITY;

	ENTITY Task_activation_Type;
		activation_task : Generic_Task;
	END_ENTITY;

	ENTITY Allocate_Resource_Type;
		allocate_task : Generic_Task;
		allocate_resource : Generic_Resource;
	END_ENTITY;

	ENTITY Release_Resource_Type;
		release_task : Generic_Task;
		release_resource : Generic_Resource;
	END_ENTITY;

	ENTITY Wait_For_Resource_Type;
		wait_for_resource_task : Generic_Task;
		wait_for_resource : Generic_Resource;
	END_ENTITY;

	ENTITY Send_Message_Type;
		send_task : Generic_Task;
		send_message : Generic_Message;
	END_ENTITY;

	ENTITY Receive_Message_Type;
		receive_task : Generic_Task;
		receive_message : Generic_Message;
	END_ENTITY;

	ENTITY Wait_For_Memory_Type;
		wait_for_memory_task : Generic_Task;
		wait_for_cache : Generic_Cache;
	END_ENTITY;

	ENTITY Time_Unit_Event_Union;
		start_of_task_capacity : Start_Of_Task_Capacity_Type;
		end_of_task_capacity : End_Of_Task_Capacity_Type;
		write_to_buffer : Write_To_Buffer_Type;
		read_from_buffer : Read_From_Buffer_Type;
		context_switch_overhead : Context_Switch_Overhead_Type;
		running_task : Running_Task_Type;
		task_activation : Task_activation_Type;
		allocate_resource : Allocate_Resource_Type;
		release_resource : Release_Resource_Type;
		wait_for_resource : Wait_For_Resource_Type;
		send_message : Send_Message_Type;
		receive_message : Receive_Message_Type;
		wait_for_memory : Wait_For_Memory_Type;
		address_space_activation : Address_Space_Activation_Type;
	END_ENTITY;

	ENTITY Time_Unit_Event;
		type_of_event : Time_Unit_Event_Type;
		union : Time_Unit_Event_Union;
	END_ENTITY;

	ENTITY Time_Unit_Package;
		indexed_table_range : Time_Unit_Range;
		indexed_table : Time_Unit_Table;
	END_ENTITY;

	ENTITY Time_Unit_Lists_Package;
	END_ENTITY;
END_SCHEMA;

SCHEMA Scheduler;
	USE FROM Basic_Types;
	USE FROM Objects;
	USE FROM Scheduler_Interface;

	ENTITY Generic_Scheduler 
		SUBTYPE OF ( Generic_Object );
		parameters : Scheduling_Parameters;
	END_ENTITY;

	ENTITY Aperiodic_Task_Server_Protocol 
		SUBTYPE OF ( Generic_Scheduler );
	END_ENTITY;

	ENTITY Polling_Server_Protocol 
		SUBTYPE OF ( Aperiodic_Task_Server_Protocol );
	END_ENTITY;

	ENTITY Deferred_Server_Protocol 
		SUBTYPE OF ( Aperiodic_Task_Server_Protocol );
	END_ENTITY;

	ENTITY Sporadic_Server_Protocol 
		SUBTYPE OF ( Aperiodic_Task_Server_Protocol );
	END_ENTITY;

	ENTITY Hierarchical_Protocol 
		SUBTYPE OF ( Generic_Scheduler );
	END_ENTITY;

	ENTITY Compiled_User_Defined_Protocol 
		SUBTYPE OF ( User_Defined_Protocol );
	END_ENTITY;

	ENTITY Automata_User_Defined_Protocol 
		SUBTYPE OF ( User_Defined_Protocol );
	END_ENTITY;

	ENTITY Pipeline_User_Defined_Protocol 
		SUBTYPE OF ( User_Defined_Protocol );
	END_ENTITY;

	ENTITY User_Defined_Protocol 
		SUBTYPE OF ( Generic_Scheduler );
	END_ENTITY;

	ENTITY Earliest_Deadline_First_Protocol 
		SUBTYPE OF ( Dynamic_Priority_Protocol );
	END_ENTITY;

	ENTITY Least_Laxity_First_Protocol 
		SUBTYPE OF ( Dynamic_Priority_Protocol );
	END_ENTITY;

	ENTITY Rate_Monotonic_Protocol 
		SUBTYPE OF ( Fixed_Priority_Protocol );
	END_ENTITY;

	ENTITY Deadline_Monotonic_Protocol 
		SUBTYPE OF ( Fixed_Priority_Protocol );
	END_ENTITY;

	ENTITY Round_Robin_Protocol 
		SUBTYPE OF ( Generic_Scheduler );
	END_ENTITY;

	ENTITY Time_Sharing_Based_On_Wait_Time_Protocol 
		SUBTYPE OF ( Generic_Scheduler );
	END_ENTITY;

	ENTITY Posix_1003_Highest_Priority_First_Protocol 
		SUBTYPE OF ( Fixed_Priority_Protocol );
	END_ENTITY;

	ENTITY D_Over_Protocol 
		SUBTYPE OF ( Dynamic_Priority_Protocol );
	END_ENTITY;

	ENTITY Maximum_Urgency_First_Based_On_Laxity_Protocol 
		SUBTYPE OF ( Generic_Scheduler );
	END_ENTITY;

	ENTITY Maximum_Urgency_First_Based_On_Deadline_Protocol 
		SUBTYPE OF ( Generic_Scheduler );
	END_ENTITY;

	ENTITY Time_Sharing_Based_On_Cpu_Usage_Protocol 
		SUBTYPE OF ( Generic_Scheduler );
	END_ENTITY;

	ENTITY No_Scheduling_Protocol 
		SUBTYPE OF ( Generic_Scheduler );
	END_ENTITY;

	ENTITY Hierarchical_Cyclic_Protocol 
		SUBTYPE OF ( Hierarchical_Protocol );
	END_ENTITY;

	ENTITY Hierarchical_Round_Robin_Protocol 
		SUBTYPE OF ( Hierarchical_Protocol );
	END_ENTITY;

	ENTITY Hierarchical_Fixed_Priority_Protocol 
		SUBTYPE OF ( Hierarchical_Protocol );
	END_ENTITY;

	ENTITY Hierarchical_Offline_Protocol 
		SUBTYPE OF ( Hierarchical_Protocol );
	END_ENTITY;

	ENTITY Fixed_Priority_Protocol 
		SUBTYPE OF ( Generic_Scheduler );
	END_ENTITY;

	ENTITY Dynamic_Priority_Protocol 
		SUBTYPE OF ( Generic_Scheduler );
	END_ENTITY;
END_SCHEMA;

SCHEMA Scheduler_Interface;
	USE FROM basic_types;
	USE FROM Framework_Config;
	USE FROM Tasks;

	TYPE Preemptives_Type = ENUMERATION
		OF ( preemptive, not_preemptive );
	END_TYPE;

	TYPE Schedulers_Type = ENUMERATION
		OF ( Compiled_User_Defined_Protocol,
			 Automata_User_Defined_Protocol,
			 Pipeline_User_Defined_Protocol,
			 User_Defined_Protocol,
			 Earliest_Deadline_First_Protocol,
			 Least_Laxity_First_Protocol,
			 Rate_Monotonic_Protocol,
			 Deadline_Monotonic_Protocol,
			 Round_Robin_Protocol,
			 Time_Sharing_Based_On_Wait_Time_Protocol,
			 Posix_1003_Highest_Priority_First_Protocol,
			 D_Over_Protocol,
			 Maximum_Urgency_First_Based_On_Laxity_Protocol,
			 Maximum_Urgency_First_Based_On_Deadline_Protocol,
			 Time_Sharing_Based_On_Cpu_Usage_Protocol,
			 No_Scheduling_Protocol,
			 Hierarchical_Cyclic_Protocol,
			 Hierarchical_Round_Robin_Protocol,
			 Hierarchical_Fixed_Priority_Protocol,
			 Hierarchical_Polling_Aperiodic_Server_Protocol,
			 Hierarchical_Priority_Exchange_Aperiodic_Server_Protocol,
			 Hierarchical_Sporadic_Aperiodic_Server_Protocol,
			 Hierarchical_Deferrable_Aperiodic_Server_Protocol,
			 Proportionate_Fair_PF_Protocol,
			 Proportionate_Fair_PD_Protocol,
			 Proportionate_Fair_PD2_Protocol,
			 Hierarchical_offline_Protocol );
	END_TYPE;

	ENTITY Scheduling_Parameters;
		scheduler_type : Schedulers_Type;
		quantum : Natural;
		preemptive_type : Preemptives_Type;
		automaton_name : STRING;
		capacity : Natural;
		period : Natural;
		priority : priority_range;
		user_defined_scheduler_source : STRING;
		user_defined_scheduler_source_file_name : STRING;
		start_time : Natural;
	END_ENTITY;
END_SCHEMA;

SCHEMA Parameters;
	USE FROM Basic_Types;
	USE FROM Framework_Config;

	TYPE Parameter_Type = ENUMERATION
		OF ( Boolean_Parameter, Integer_Parameter, Double_Parameter, String_Parameter );
	END_TYPE;

	TYPE User_Defined_Parameters_Range = Range;
	END_TYPE;

	TYPE User_Defined_Parameters_Table = LIST OF Parameter;
	END_TYPE;

	TYPE Framework_Parameters_Table = LIST OF Parameter;
	END_TYPE;

	TYPE Framework_Parameters_Range = Range;
	END_TYPE;

	ENTITY Boolean_Parameter_Type;
		boolean_value : BOOLEAN;
	END_ENTITY;

	ENTITY Integer_Parameter_Type;
		integer_value : INTEGER;
	END_ENTITY;

	ENTITY Double_Parameter_Type;
		double_value : REAL;
	END_ENTITY;

	ENTITY String_Parameter_Type;
		string_value : STRING;
	END_ENTITY;

	ENTITY Parameter_Union;
		boolean_parameter : Boolean_Parameter_Type;
		integer_parameter : Integer_Parameter_Type;
		double_parameter : Double_Parameter_Type;
		string_parameter : String_Parameter_Type;
	END_ENTITY;

	ENTITY Parameter;
		type_of_parameter : Parameter_Type;
		union : Parameter_Union;
		parameter_name : STRING;
	END_ENTITY;

	ENTITY User_Defined_Parameters_Table_Package;
		table_range : User_Defined_Parameters_Range;
		table : User_Defined_Parameters_Table;
	END_ENTITY;

	ENTITY Framework_Parameters_Table_Package;
		table_range : Framework_Parameters_Range;
		table : Framework_Parameters_Table;
	END_ENTITY;
END_SCHEMA;

SCHEMA Queueing_Systems;

	TYPE Queueing_Systems_Type = ENUMERATION
		OF ( Qs_Pp1,
			 Qs_Mm1,
			 Qs_Md1,
			 Qs_Mp1,
			 Qs_Mg1,
			 Qs_Mms,
			 Qs_Mds,
			 Qs_Mps,
			 Qs_Mgs,
			 Qs_Mm1n,
			 Qs_Md1n,
			 Qs_Mp1n,
			 Qs_Mg1n,
			 Qs_Mmsn,
			 Qs_Mdsn,
			 Qs_Mpsn,
			 Qs_Mgsn );
	END_TYPE;
END_SCHEMA;

SCHEMA processor_interface;

	TYPE Processors_type = ENUMERATION
		OF ( Monocore_type,
			 Identical_Multicores_Type,
			 Uniform_Multicores_Type,
			 Unrelated_Multicores_Types );
	END_TYPE;

	TYPE migrations_type = ENUMERATION
		OF ( No_Migration_Type, Job_Level_Migration_Type, Time_Unit_Migration_Type );
	END_TYPE;
END_SCHEMA;

SCHEMA Event_Analyzers;
	USE FROM Basic_Types;
	USE FROM Objects;

	ENTITY Event_Analyzer 
		SUBTYPE OF ( Named_Object );
		event_analyzer_source_file_name : STRING;
	DERIVE
		SELF\Generic_Object.object_type : Objects_Type := Event_Analyzer_Type;
	END_ENTITY;
END_SCHEMA;

SCHEMA Deployments;
	USE FROM Basic_Types;
	USE FROM Objects;
	USE FROM SCheduling_Analysis;
	USE FROM Scheduler_Interface;

	ENTITY Generic_Deployment 
		SUBTYPE OF ( Named_Object );
		consumer_entities : Generic_Objects_Set;
		resource_entities : Generic_Objects_Set;
	DERIVE
		SELF\Generic_Object.object_type : Objects_Type := Deployment_Type;
	END_ENTITY;

	ENTITY Static_Deployment 
		SUBTYPE OF ( Generic_Deployment );
		(* The table bellow defines how the resources are statically allocated by the 
		   resource consumers.
		   This table may be a off-line scheduling of task or a set of adresses statically
		   defined for each software component inside an address space)  *)
		allocation : STRING;
	END_ENTITY;

	ENTITY Dynamic_Deployment 
		SUBTYPE OF ( Generic_Deployment );
		(* The algorithm bellow defines how the resources are dynamically allocated by the 
		   resource consumers.
		   This algorithm may be an on-line scheduler of tasks or a malloc algorithm for a set of software
		   components inside an adress space)  *)
		allocation : Scheduling_Parameters;
	END_ENTITY;
END_SCHEMA;