SCHEMA Objects;
	USE FROM Basic_Types;

	TYPE Objects_Type = ENUMERATION
		OF ( Buffer_Object_Type,
			 Processor_Object_Type,
			 Cache_Block_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,
			 CFG_Node_Object_Type,
			 CFG_Edge_Object_Type,
			 CFG_Object_Type,
			 Cache_Access_Profile_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;

	(*-------------------------------*)
	ENTITY Cache_Block
		SUBTYPE OF ( Named_Object );
		cache_block_number : Natural;
	DERIVE
		SELF\Generic_Object.object_type : Objects_Type := Cache_Block_Object_Type;
	END_ENTITY;

	TYPE Cache_Blocks_Table = LIST OF Cache_Block;
	END_TYPE;

	TYPE Cache_Blocks_Range = Range;
	END_TYPE;

	ENTITY Cache_Blocks_Table_Package;
		table_range : Cache_Blocks_Range;
		table : Cache_Blocks_Table;
	END_ENTITY;

	(*-------------------------------*)
	ENTITY Cache_Access_Profile 
		SUBTYPE OF ( Named_Object );
		UCBs : Cache_Blocks_Table;
		ECBs : Cache_Blocks_Table;
	DERIVE
		SELF\Generic_Object.object_type : Objects_Type := Cache_Access_Profile_Object_Type;
	END_ENTITY;

	(*-------------------------------*)
	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_Policy_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;

	ENTITY Generic_Cache 
		SUBTYPE OF ( Named_Object );
		cache_size : Natural;
		line_size : Natural;
		associativity : Natural;
		block_reload_time : Natural;
		replacement_policy : Cache_Replacement_Policy_Type;
		coherence_protocol : Cache_Coherence_Protocol_Type;
		cache_category : Cache_Type;
		cache_blocks : Cache_Blocks_Table;
	DERIVE
		SELF\Generic_Object.object_type : Objects_Type := Cache_Object_Type;	
	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 : ( coherence_protocol = Private_Cache_Protocol ) OR
		 ( 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;

	(*-------------------------------*)
	TYPE Caches_Range = Range;
	END_TYPE;

	TYPE Caches_Table = LIST OF Generic_Cache;
	END_TYPE;

	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 Core_Units;
	USE FROM Framework_Config;
	USE FROM Objects;
	USE FROM Basic_Types;
	USE FROM Scheduler_Interface;
	USE FROM Caches;

	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 Core_Units_Table_Package;
		table_range : Core_Units_Range;
		table : Core_Units_Table;
	END_ENTITY;
END_SCHEMA;

SCHEMA Processors;
	USE FROM Framework_Config;
	USE FROM Objects;
	USE FROM processor_interface;
	USE FROM Core_Units;
	USE FROM Caches;
	USE FROM Basic_Types;

	ENTITY Generic_Processor 
		SUBTYPE OF ( Named_Object );
		network_name : 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 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 ( 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;
		buffer_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;

	TYPE Priority_Assignment_Type = ENUMERATION
		OF ( Automatic_Assignment, Manual_Assignment );
	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;
		priority : priority_range;
		priority_assignment : Priority_Assignment_Type;
	DERIVE
		SELF\Generic_Object.object_type : Objects_Type := Resource_Object_Type;
	END_ENTITY;

	ENTITY Np_Resource 
		SUBTYPE OF ( Generic_Resource );
	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 ( Generic_Resource );
	DERIVE
		SELF\Generic_Resource.protocol : Resources_Type := Priority_Ceiling_Protocol;
	END_ENTITY;

	ENTITY IPcp_Resource 
		SUBTYPE OF ( Generic_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;
		cfg_name : STRING;
		cache_access_profile_name : STRING;
	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;
		every : 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;
		deadline : Natural;
		start_time : Natural;
		priority : priority_range;
		criticality : Natural;
		period : Natural;
		jitter : Natural;
	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,
			 Queueing_Buffer_Dependency,
			 Asynchronous_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 Queueing_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 Asynchronous_Communication_Dependency_Type;
		asynchronous_communication_dependent_task : Generic_Task;
		asynchronous_communication_orientation : Orientation_Dependency_Type;
		asynchronous_communication_dependency_object : Generic_Message;
	END_ENTITY;

	ENTITY Dependency_Union;
		precedence_dependency : Precedence_Dependency_Type;
		queueing_buffer_dependency : Queueing_Buffer_Dependency_Type;
		asynchronous_communication_dependency : Asynchronous_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 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 ( Rate_Monotonic_Protocol,
			 Deadline_Monotonic_Protocol,
			 Posix_1003_Highest_Priority_First_Protocol,
			 Earliest_Deadline_First_Protocol,
			 Least_Laxity_First_Protocol,
			 D_Over_Protocol,
			 Maximum_Urgency_First_Based_On_Laxity_Protocol,
			 Maximum_Urgency_First_Based_On_Deadline_Protocol,
			 Round_Robin_Protocol,
			 Time_Sharing_Based_On_Cpu_Usage_Protocol,
			 Time_Sharing_Based_On_Wait_Time_Protocol,
			 No_Scheduling_Protocol,
			 Compiled_User_Defined_Protocol,
			 Automata_User_Defined_Protocol,
			 Pipeline_User_Defined_Protocol,
			 User_Defined_Protocol,
			 Hierarchical_Cyclic_Protocol,
			 Hierarchical_Round_Robin_Protocol,
			 Hierarchical_Fixed_Priority_Protocol,
			 Hierarchical_Offline_Protocol,
			 Hierarchical_Polling_Aperiodic_Server_Protocol,
			 Hierarchical_Priority_Exchange_Aperiodic_Server_Protocol,
			 Hierarchical_Sporadic_Aperiodic_Server_Protocol,
			 Hierarchical_Deferrable_Aperiodic_Server_Protocol,
			 Reduction_To_Uniprocessor_protocol,
			 Earliest_Deadline_Zero_Laxity_protocol,
			 Proportionate_Fair_PF_Protocol,
			 Proportionate_Fair_PD_Protocol,
			 Proportionate_Fair_PD2_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;

	TYPE Deployments_Type = ENUMERATION
		OF ( Static_Deployment_Type, Dynamic_Deployment_Type );
	END_TYPE;

	ENTITY Generic_Deployment 
		SUBTYPE OF ( Named_Object );
		deployment_type : Deployments_Type;
		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_description : 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_parameters : Scheduling_Parameters;
	END_ENTITY;
END_SCHEMA;


SCHEMA CFGs;
	USE FROM Basic_Types;
	USE FROM Framework_Config;
	USE FROM Objects;
	USE FROM CFG_Nodes;
	USE FROM CFG_Edges;

	ENTITY CFG 
		SUBTYPE OF ( Named_Object );
		nodes : CFG_Nodes_Table;
		edges : CFG_Edges_Table;
	DERIVE
		SELF\Generic_Object.object_type : Objects_Type := CFG_Object_Type;
	END_ENTITY;
END_SCHEMA;

SCHEMA CFG_Nodes;
	USE FROM Basic_Types;
	USE FROM Framework_Config;
	USE FROM Objects;

	TYPE CFG_Graph_Type = ENUMERATION
		OF ( CFG_Basic_Block, CFG_Atomic_Operation, DFG_Basic_block );
	END_TYPE;

	TYPE CFG_Node_Type = ENUMERATION
		OF ( Start_Node, Middle_Node, Terminate_Node );
	END_TYPE;

	ENTITY CFG_Node 
		SUBTYPE OF ( Named_Object );
		graph_type : CFG_Graph_Type;
		node_type : CFG_Node_Type;
	DERIVE
		SELF\Generic_Object.object_type : Objects_Type := CFG_Node_Object_Type;
	END_ENTITY;

	TYPE CFG_Nodes_Range = Range;
	END_TYPE;

	TYPE CFG_Nodes_Table = LIST OF CFG_Node;
	END_TYPE;

	ENTITY CFG_Nodes_Table_Package;
		table_range : CFG_Nodes_Range;
		table : CFG_Nodes_Table;
	END_ENTITY;
END_SCHEMA;

SCHEMA CFG_Edges;
	USE FROM Basic_Types;
	USE FROM Framework_Config;
	USE FROM Objects;
	USE FROM CFG_Nodes;
	
	ENTITY CFG_Edge 
		SUBTYPE OF ( Named_Object );
		node : STRING;
		next_node : STRING;
	DERIVE
		SELF\Generic_Object.object_type : Objects_Type := CFG_Edge_Object_Type;
	END_ENTITY;

	TYPE CFG_Edges_Range = Range;
	END_TYPE;

	TYPE CFG_Edges_Table = LIST OF CFG_Edge;
	END_TYPE;

	ENTITY CFG_Edges_Table_Package;
		table_range : CFG_Edges_Range;
		table : CFG_Edges_Table;
	END_ENTITY;
END_SCHEMA;

SCHEMA Basic_Blocks;
	USE FROM Basic_Types;
	USE FROM Framework_Config;
	USE FROM Objects;
	USE FROM CFG_Nodes;

	ENTITY Basic_Block 
		SUBTYPE OF ( CFG_Node );
		instruction_offset : INTEGER;
		instruction_capacity : INTEGER;
		data_offset : INTEGER;
		data_capacity : INTEGER;
		loop_bound : INTEGER;
	DERIVE
		SELF\CFG_Node.graph_type : CFG_Graph_Type := CFG_Basic_Block;
	END_ENTITY;

	TYPE Basic_Blocks_Range = Range;
	END_TYPE;

	TYPE Basic_Blocks_Table = LIST OF Basic_Block;
	END_TYPE;

	ENTITY Basic_Blocks_Table_Package;
		table_range : Basic_Blocks_Range;
		table : Basic_Blocks_Table;
	END_ENTITY;
END_SCHEMA;

SCHEMA Atomic_Operations;
	USE FROM Basic_Types;
	USE FROM Framework_Config;
	USE FROM Objects;
	USE FROM CFG_Nodes;
	USE FROM Processors;
	USE FROM Task_Groups;
	USE FROM CFGs;

	TYPE Processor_Sort_Type = ENUMERATION
		OF ( Processor_Index, Processor_Utilization );
	END_TYPE;

	TYPE Task_Sort_Type = ENUMERATION
		OF ( Task_Period, Task_Deadline );
	END_TYPE;

	TYPE Feasibility_Test_Type = ENUMERATION
		OF ( Condition_IP_Test, Utilization_Test );
	END_TYPE;

	TYPE Loop_Operation_Type = ENUMERATION
		OF ( RMFF_loop, RMBF_loop, RMNF_loop );
	END_TYPE;

	TYPE Atomic_Operations_Range = Range;
	END_TYPE;

	TYPE Atomic_Operations_Table = LIST OF Atomic_Operation;
	END_TYPE;

	ENTITY Atomic_Operation 
		SUBTYPE OF ( CFG_Node );
		task_sorting : Task_Sort_Type;
		processor_sorting : Processor_Sort_Type;
		feasibility_test : Feasibility_Test_Type;
	DERIVE
		SELF\CFG_Node.graph_type : CFG_Graph_Type := CFG_Atomic_Operation;
	END_ENTITY;

	ENTITY Atomic_Operations_Table_Package;
		table_range : Atomic_Operations_Range;
		table : Atomic_Operations_Table;
	END_ENTITY;

	ENTITY Partitioning_Algorithm;
		name : STRING;
		task_set : STRING;
		processor_set : STRING;
		task_sorting : Task_Sort_Type;
		looping : Loop_Operation_Type;
		processor_sorting : Processor_Sort_Type;
		feasibility_test : Feasibility_Test_Type;
	END_ENTITY;

	ENTITY Generic_Algorithm;
		task_set : Transaction_Task_Group;
		proc_set : Multi_Cores_Processor;
		entry_point_node : Atomic_Operation;
		list_of_nodes : Atomic_Operations_Table;
	END_ENTITY;
END_SCHEMA;