SCHEMA Objects;
	USE FROM Basic_Types;
 
	TYPE Objects_Type = ENUMERATION
		OF ( Buffer_Object_Type,
			 Processor_Object_Type,
			 Cache_Block_Object_Type,
			 Cache_Object_Type,
			 Memory_Object_Type,
			 Battery_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,
			 Task_Group_Object_Type,
			 CFG_Node_Object_Type,
			 CFG_Edge_Object_Type,
			 CFG_Object_Type,
			 Cache_Access_Profile_Object_Type,
			 Scheduling_Error_Object_Type,
             		 NoC_Type,
             		 Execution_Unit_Object_Type,
             		 Data_Access_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 Scheduling_Errors;
    USE FROM Basic_Types;
    USE FROM Framework_Config;
    USE FROM Objects;

    TYPE Error_Type_Type = ENUMERATION
        OF (Early_Service_Start,
            Late_Service_Termination,
            Core_Failure,
            Cache_Failure);
    END_TYPE;

    TYPE Error_Action_Type = ENUMERATION
        OF (Reschedule,
            Stop_Schedule,
            User_Defined);
    END_TYPE;

    ENTITY Scheduling_Error
        SUBTYPE OF ( Named_Object );
        error_type : Error_Type_Type;
        time : Natural;
        error_action : Error_Action_Type;
        user_defined_action : STRING;
    DERIVE
        SELF\Generic_Object.object_type : Objects_Type := Scheduling_Error_Object_Type;
    END_ENTITY;

    TYPE Scheduling_Errors_Range = Range;
    END_TYPE;

    TYPE Scheduling_Errors_Table = LIST OF Scheduling_Error;
    END_TYPE;

    ENTITY Scheduling_Errors_Table_Package;
        table_range : Scheduling_Errors_Range;
        table : Scheduling_Errors_Table;
    END_ENTITY;

    ENTITY Scheduling_Error_Record;
        error_type : Error_Type_Type;
        time : Natural;
        error_action : Error_Action_Type;
        user_defined_action : STRING;
    END_ENTITY;

END_SCHEMA;

SCHEMA Memories;
	USE FROM Framework_Config;
	USE FROM Objects;
	USE FROM Basic_Types;

	TYPE Memory_Type = ENUMERATION
		OF ( Generic_Memory_Type,
             DRAM_Type,
			 Kalray_Type );
	END_TYPE;

	ENTITY Generic_Memory
		SUBTYPE OF ( Named_Object );
		size : INTEGER;
		access_latency : INTEGER;
        memory_category : Memory_Type;
	DERIVE
		SELF\Generic_Object.object_type : Objects_Type := Memory_Object_Type;
	END_ENTITY;

    TYPE Memories_Range = Range;
    END_TYPE;

    TYPE Memories_Table = LIST OF Generic_Memory;
    END_TYPE;

    ENTITY Memories_Table_Package;
        table_range : Memories_Range;
        table : Memories_Table;
    END_ENTITY;

    TYPE Generic_Memory_Iterator = Iterator;
    END_TYPE;

    TYPE Generic_Memory_List = LIST OF Generic_Memory;
    END_TYPE;

    ENTITY Generic_Memory_List_Package;
        iterator : Generic_Memory_Iterator;
        list_ : Generic_Memory_List;
    END_ENTITY;

	ENTITY DRAM_Memory 
		SUBTYPE OF ( Generic_Memory );
		shared_access_latency : INTEGER;
		private_access_latency : INTEGER;
        (* data_bus_turn_around_and_rank_to_bank_switch_delay : Natural; also l_rw_inter  in the Kim paper *)
        (* inter_bank_row_activate_timing_constraints : Natural; also l_act_inter  in the Kim paper *)
        (* command_bus_scheduling_time : Natural; also l_pre_inter  in the Kim paper *)
        (* maximum_number_of_row_hits : Natural; also n_reorder  in the Kim paper *)
        (* consecutive_row_hit_requests : Natural; also l_conhit  in the Kim paper *)
        (* row_conflict_service_time : Natural; also l_conf in the Kim paper *)
        l_rw_inter : Natural;
        l_act_inter: Natural;
        l_pre_inter : Natural;
        n_reorder : Natural;
        l_conhit : Natural;
        l_conf : Natural;
	DERIVE
		SELF\Generic_Memory.memory_category : Memory_Type := DRAM_Type;
	END_ENTITY;

    ENTITY Kalray_Memory 
		SUBTYPE OF ( Generic_Memory );
		nb_bank : Natural;
        partition_mode : BOOLEAN;
	DERIVE
		SELF\Generic_Memory.memory_category : Memory_Type := Kalray_Type;
	END_ENTITY;

    ENTITY Memory_Record;
        size : INTEGER;
		access_latency : INTEGER;
        memory_category : Memory_Type;
        shared_access_latency : INTEGER;
		private_access_latency : INTEGER;
        l_rw_inter : Natural;
        l_act_inter: Natural;
        l_pre_inter : Natural;
        n_reorder : Natural;
        l_conhit : Natural;
        l_conf : Natural;
        nb_bank : Natural;
        partition_mode : BOOLEAN;
    END_ENTITY;

END_SCHEMA;

SCHEMA Core_Units;
	USE FROM Framework_Config;
	USE FROM Objects;
	USE FROM Basic_Types;
	USE FROM Scheduler_Interface;
	USE FROM Memories;
	USE FROM Caches;

	TYPE Isa_Type = ENUMERATION
		OF ( i386, powerpc, risc5, sparc1, sparc2, sparc3,
			sparc4, sparc5, sparc6, sparc7, sparc8 );
	END_TYPE;

	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 : INTEGER;
		l1_cache_system_name : STRING;
 		worstcase_perequest_intrabank_memory_interference : natural;
 		worstcase_perequest_interbank_memory_interference : natural;
		memory_partitions : Memories_Table;
		isa : Isa_Type;
	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 );
		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;

        TYPE Generic_Processor_Iterator = Iterator;
        END_TYPE;

        TYPE Generic_Processor_List = LIST OF Generic_Processor;
        END_TYPE;

        ENTITY Generic_Processor_List_Package;
                iterator : Generic_Processor_Iterator;
                list_ : Generic_Processor_List;
        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, UCSDF_Producer, UCSDF_Consumer);
	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;
		amplitude_function : STRING;
	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;
		buffer_initial_data_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,
			 Pool_Based_Priority_Ceiling_Protocol,
			 Priority_Inheritance_Protocol,
			 Immediate_Priority_Ceiling_Protocol );
	END_TYPE;

	TYPE Resources_Synchronization_Type = ENUMERATION
		OF (Mutex, Wait, Post);
	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_synchronization : Resources_Synchronization_Type;
		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 PPcp_Resource 
		SUBTYPE OF ( Generic_Resource );
	DERIVE
		SELF\Generic_Resource.protocol : Resources_Type := Pool_Based_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 Batteries;
	USE FROM Framework_Config;
	USE FROM Objects;
	USE FROM Basic_Types;

	ENTITY Battery  
		SUBTYPE OF ( Named_Object );
		
		capacity : natural;
        	rechargeable_power : natural;
                cpu_name : STRING;
                e_max : natural;
                e_min : natural;
                initial_energy : natural; 
	DERIVE
		SELF\Generic_Object.object_type : Objects_Type := Battery_Object_Type;
	END_ENTITY;

END_SCHEMA;

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

	TYPE Tasks_Type = ENUMERATION
		OF ( Periodic_Type,
			 Aperiodic_Type,
			 Sporadic_Type,
			 Poisson_Type,
                         Timed_Type,
			 Parametric_Type,
			 Scheduling_Task_Type,
			 Frame_Task_Type,
                         Sporadic_Inner_Periodic_Type,
                         Periodic_Inner_Periodic_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;
		core_name : STRING;
		capacity_model : Execution_Unit_Model_Type;
		capacity : Natural;
		capacities : Execution_Units_Table;
		qualities : Execution_Units_Table;
		energy_consumption : Natural;
		deadline : Natural;
		start_time : Natural;
		priority : Priority_Range;
		blocking_time : Natural;
		policy : Policies;
		offsets : Offsets_Table;
		text_memory_size : Natural;
                text_memory_start_address : INTEGER;
		stack_memory_size : Natural;
		parameters : User_Defined_Parameters_Table;
		criticality : Natural;
		context_switch_overhead : Natural;
		cfg_name : STRING;        
                cfg_relocatable : BOOLEAN;
		cache_access_profile_name : STRING;
		mils_confidentiality_level : MILS_Confidentiality_Level_Type;
		mils_integrity_level : MILS_Integrity_Level_Type;
		mils_component : MILS_Component_Type;
		mils_task      : MILS_Task_Type;
		mils_compliant : BOOLEAN;	
		access_memory_number : INTEGER;
                maximum_number_of_memory_request_per_job : natural;        
		seed : INTEGER;
		predictable : BOOLEAN;
	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;
		completion_time : 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 );
	DERIVE
		SELF\Periodic_Task.task_type : Tasks_Type := Poisson_Type;
	END_ENTITY;

	ENTITY Timed_Task 
		SUBTYPE OF ( Periodic_Task );
	DERIVE
		SELF\Periodic_Task.task_type : Tasks_Type := Timed_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\Periodic_Task.task_type : Tasks_Type := Frame_Task_type;
	END_ENTITY;

	ENTITY Sporadic_Inner_Periodic_Task 
		SUBTYPE OF ( Parametric_Task );
		outer_period : INTEGER;
		outer_duration : INTEGER;
	END_ENTITY;
                      
	ENTITY Periodic_Inner_Periodic_Task 
		SUBTYPE OF ( Sporadic_Inner_Periodic_Task );
	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;
	USE FROM Scheduler_Interface;
	USE FROM MILS_Security;

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

	ENTITY Generic_Message 
		ABSTRACT SUPERTYPE 
		SUBTYPE OF ( Named_Object );
		message_type : Messages_Type;
		preemptive_type : Preemptives_Type;
		parameters : User_Defined_Parameters_Table;
		deadline : Natural;
		size : Natural;
		response_time : Natural;
		communication_time : Natural;
		mils_confidentiality_level : MILS_Confidentiality_Level_Type;
		mils_integrity_level : MILS_Integrity_Level_Type;
	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,
                         Remote_Procedure_Call_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;

    TYPE Asynchronous_Communication_Protocol_Property_Type = ENUMERATION 
		OF ( First_Message, All_Messages );
    END_TYPE;

    ENTITY Asynchronous_Communication_Dependency_Type;
		asynchronous_communication_dependent_task : Generic_Task;
		asynchronous_communication_orientation : Orientation_Dependency_Type;
		asynchronous_communication_dependency_object : Generic_Message;
		asynchronous_communication_protocol_property : Asynchronous_Communication_Protocol_Property_Type;
    END_ENTITY;


	ENTITY Time_Triggered_Communication_Dependency_Type;
		time_triggered_communication_sink : Generic_Task;
		time_triggered_communication_source : Generic_Task;
		time_triggered_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 Remote_Procedure_Call_Dependency_Type;
		remote_procedure_call_client : Generic_Task;
		remote_procedure_call_server : 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 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;
	    remote_procedure_call_dependency        : Remote_Procedure_Call_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;
	USE FROM MILS_Security;

	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;
		mils_confidentiality_level : MILS_Confidentiality_Level_Type;
		mils_integrity_level : MILS_Integrity_Level_Type;
		mils_component : MILS_Component_Type;
		mils_partition : MILS_Partition_Type;
		mils_compliant : BOOLEAN;
	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 Basic_Types;
    USE FROM Objects;
    USE FROM Processors;
    USE FROM Memories;
    USE FROM Framework_Config;

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

    (* A link connects only two stations *)
    (* Shared_Bus, Star and Noc may connect 2 or more stations *)
    TYPE Networks_Architecture_Type = ENUMERATION
            OF (Shared_Bus, Star, Point_To_Point_Link , Crossbar, NoC, Spacewire);
    END_TYPE;

    TYPE Topology_Type = ENUMERATION
            OF (Mesh_Topology, Torus_Topology);
    END_TYPE;

    TYPE Arbitration_Type = ENUMERATION
            OF (TDMA, Fixed_Priority_Based, Non_Conservative_Round_Robin, Conservative_Round_Robin, Round_Robin_Bandwidth_Reservation);
    END_TYPE;

    ENTITY Generic_Network
            SUBTYPE OF ( Named_Object );
            network_delay : Networks_Delay_Type;
            network_architecture_type : Networks_Architecture_Type;
            network_arbitration : Arbitration_Type;
    DERIVE
            SELF\Generic_Object.object_type : Objects_Type := Network_Object_Type;
    END_ENTITY;

    TYPE Routing_Type = ENUMERATION
            OF (XY, YX, XYX, Programmable_Routing);
    END_TYPE;

    TYPE NoC_Preemption_Level_Type = ENUMERATION
            OF (Flit, Packet);
    END_TYPE;

    TYPE Switching_Type = ENUMERATION
            OF (Wormwole, Store_And_Forward, Virtual_Cut_Through);
    END_TYPE;

    TYPE Data_Memorisation_Type = ENUMERATION
            OF (Virtual_Channel, Input_Port_Buffer, Output_Port_Buffer);
    END_TYPE;

    ENTITY Position;
            X : Natural;
            Y : Natural;
    END_ENTITY;

    TYPE Positions_Range = Range;
    END_TYPE;

    TYPE Positions_Table = LIST [ 0 : Max_Positions] OF Position;
    END_TYPE;

    ENTITY Positions_Table_Package;
            indexed_table_range : Positions_Range;
            indexed_table : Positions_Table;
    END_ENTITY;

    ENTITY NOC_Network
            SUBTYPE OF ( Generic_Network );
            topology : Topology_Type;
            number_of_processor : Natural;
	    link_delay : Natural;
            dimension : Natural;
            number_of_virtual_channel : Natural;
            routing_protocol : Routing_Type;
            switching_protocol : Switching_Type;
            processor_positions : Positions_Table;
    DERIVE
            SELF\Generic_Network.network_architecture_type : Networks_Architecture_Type := NOC;
    END_ENTITY;

    ENTITY Spacewire_Network
            SUBTYPE OF (Generic_Network);
            number_of_processor : Natural;
            link_delay : Natural;
            Xdimension : Natural;
            Ydimension : Natural;
            routing_protocol : Routing_Type;
            TDMA_synchronization_frame : STRING;
            processor_positions : Positions_Table;
    END_ENTITY;

    ENTITY Bus_Network
            SUBTYPE OF ( Generic_Network );
            processor_list : Generic_Processor_List;
            memory_list : Generic_Memory_List;
            memory_word_access_time : Natural;
            maximum_interbank_interferences_memory_delay : natural;
    DERIVE
            SELF\Generic_Network.network_architecture_type : Networks_Architecture_Type := Shared_Bus;
    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 Least_Runtime_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 ( No_Scheduling_Protocol,
			 Rate_Monotonic_Protocol,
			 Deadline_Monotonic_Protocol,
			 Posix_1003_Highest_Priority_First_Protocol,
			 Earliest_Deadline_First_Protocol,
			 Least_Laxity_First_Protocol,
             		 Least_Runtime_Laxity_First_Protocol,
			 D_Over_Protocol,
			 Maximum_Urgency_First_Based_On_Laxity_Protocol,
			 Maximum_Urgency_First_Based_On_Deadline_Protocol,
			 Earliest_Deadline_First_Energy_Harvesting_Protocol,
			 Earliest_Deadline_First_Energy_To_Time_Protocol,
			 Round_Robin_Protocol,
			 Time_Sharing_Based_On_Cpu_Usage_Protocol,
			 Time_Sharing_Based_On_Wait_Time_Protocol,			 
			 Compiled_User_Defined_Protocol,
			 Automata_User_Defined_Protocol,
			 Pipeline_User_Defined_Protocol,
			 User_Defined_Protocol,
			 Mixed_Criticality_SMC_Protocol,
			 Mixed_Criticality_AMC_Protocol,
			 Mixed_Criticality_Anytime_AMC_Protocol,
			 Mixed_Criticality_Recurrent_Anytime_AMC_Protocol,
			 Mixed_Criticality_EDF_VD_Protocol,
			 DAG_highest_level_first_estimated_times_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,
			 Largest_Local_Remaining_Execution_First_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;
		threshold  : Natural;
		priority : Priority_Range;
		user_defined_scheduler_source : STRING;
		user_defined_scheduler_source_file_name : STRING;
		user_defined_scheduler_protocol_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_Type);
	END_TYPE;

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

	TYPE Multiprocessors_Type = ENUMERATION
		OF ( Identical, Homogeneous, Heterogeneous );
	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 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;
		number_of_memory_access : INTEGER;
		execution_time : 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;

SCHEMA MILS_Security;
	USE FROM Basic_Types;
	USE FROM Framework_Config;

	TYPE MILS_Confidentiality_Level_Type = ENUMERATION
		OF (UnClassified, Classified, Secret, Top_Secret);
	END_TYPE;

	TYPE MILS_Integrity_Level_Type = ENUMERATION
		OF (Low, Medium, High);
	END_TYPE;

	TYPE MILS_Component_Type = ENUMERATION
		OF (SLS, MSLS, MLS);
	END_TYPE;

	TYPE MILS_Partition_Type = ENUMERATION
		OF (Device, Application);
	END_TYPE;

	TYPE MILS_Task_Type = ENUMERATION
		OF (Application, MMR, Guard, Collator, Downgrader, Upgrader);
	END_TYPE;
	
END_SCHEMA;

SCHEMA Execution_Units;
    USE FROM Basic_Types;
    USE FROM Framework_Config;
    USE FROM Objects;

    TYPE Execution_Unit_Model_Type = ENUMERATION
        OF (LiuLayland_Execution_Unit,
            AADL_Execution_Unit,
            MixedCriticality_Execution_Unit
            );
    END_TYPE;

    TYPE Execution_Unit_Type = ENUMERATION
        OF (
            Execute_phase,
	    Compatible_phase,
            Memory_phase,
	    Read_Phase,
            Write_Phase);             
    END_TYPE;

    ENTITY Execution_Unit
        SUBTYPE OF ( Named_Object );
        Type_eu : Execution_Unit_Type;
        values_eu : Natural;
    DERIVE
        SELF\Generic_Object.object_type : Objects_Type := Execution_Unit_Object_Type;
    END_ENTITY;

    TYPE Execution_Units_Range = Range;
    END_TYPE;

    TYPE Execution_Units_Table = LIST OF Execution_Unit;
    END_TYPE;

        ENTITY Execution_Units_Table_Package;
                table_range : Execution_Units_Range;
                table : Execution_Units_Table;
        END_ENTITY;


END_SCHEMA;

SCHEMA Data_Accesses;
    USE FROM Basic_Types;
    USE FROM Framework_Config;
    USE FROM Objects;

    TYPE Data_Access_Type = ENUMERATION
        OF (Read_Data,
            Write_Data);
    END_TYPE;


    ENTITY Data_Access
        SUBTYPE OF ( Named_Object );
        Access_Type : Data_Access_Type;
        Memory_Address : INTEGER;
        Time_Constraint_Name : STRING;
        Size : INTEGER;
        
    DERIVE
        SELF\Generic_Object.object_type : Objects_Type := Data_Access_Object_Type;
    END_ENTITY;

    TYPE Data_Accesses_Range = Range;
    END_TYPE;

    TYPE Data_Accesses_Table = LIST OF Data_Access;
    END_TYPE;

    ENTITY Data_Accesses_Table_Package;
        table_range : Data_Accesses_Range;
        table : Data_Accesses_Table;
    END_ENTITY;

    ENTITY Data_Access_Record;
        Access_Type : Data_Access_Type;
        Memory_Address : INTEGER;
        Time_Constraint_Name : STRING;
        Size : INTEGER;
    END_ENTITY;

END_SCHEMA;