14.1 Standard AADL Property Set
There is a standard predeclared property set named AADL_Properties.  This property set declaration is a part of every AADL specification. 
NOTES:
In accordance with the naming rules for references to items defined in the predeclared property sets, the declarations in this property set refer to enumeration types and property constants declared in the AADL_Project property set without a qualifying property set name.
property_set AADL_Properties is
Activate_Deadline: Time
   applies to(thread);
Activate_Deadlinespecifies the maximum amount of time allowed for the execution of a thread’s activation sequence.  The numeric value of time must be positive.
The property type is Time.  The standard units are ps (picoseconds), ns (nanoseconds), us(microseconds), ms(milliseconds), sec(seconds), min(minutes) and hr (hours). 
Activate_Execution_Time: Time_Range
   applies to(thread);
Activate_Execution_Time specifies the minimum and maximum execution time, in the absence of runtime errors, that a thread will use to execute its activation sequence, i.e., when a thread becomes active as part of a mode switch.  The specified execution time includes all time required to execute any service calls that are executed by a thread, but excludes any time spent by another thread executing remote procedure calls in response to a remote subprogram call made by this thread.
Activate_Entrypoint: aadlstring
   applies to(thread);
TheActivate_Entrypoint property specifies the name of a source text code sequence that will execute when a thread is activated.  This property may have an unspecified value.
The named code sequence in the source text must be visible in and callable from the outermost program scope, as defined by the scope and visibility rules of the applicable source language.  The source language annex of this standard defines acceptable parameter and result signatures for the entrypoint subprogram.
Active_Thread_Handling_Protocol:
   inheritSupported_Active_Thread_Handling_Protocols
         =>value(Default_Active_Thread_Handling_Protocol)
   applies to (thread, thread group, process, system);
The Active_Thread_Handling_Protocolproperty specifies the protocol to use to handle execution at the time instant of an actual mode switch. The available choices are implementer defined. One of the available choices must be the default value.
This protocol specifies the activation order of threads become active as part of a new mode.
Active_Thread_Queue_Handling_Protocol:
   inherit enumeration (flush, hold) => flush
   applies to (thread, thread group, process, system);
The Active_Thread_Queue_Handling_Protocolproperty specifies the protocol to use to handle the content of any event port or event data port queue of a thread at the time instant of an actual mode switch. The available choices are flushand hold.  Flush empties the queue.Holdkeeps the content in the queue of the thread being deactiveated until it is reactivated.
Actual_Connection_Binding: inheritreference (bus, processor, device)
   applies to (port connections, thread, thread group, process, system);
Connections are bound to the bus, processor, or device specified by the Actual_Connection_Bindingproperty. 
Actual_Latency: Time
   applies to(flow);
The Actual_Latency property specifies the actual latency as determined by the implementation of the end-to-end flow through semantic connections.  Its numeric value must be positive. 
The property type is Time.  The standard units are ns (nanoseconds), us (microseconds),ms(milliseconds), sec (seconds),min (minutes) and hr (hours). 
Actual_Memory_Binding: inheritreference (memory)
   applies to(thread, thread group, process, system, processor,
               data port, event data port, subprogram);
Code and data from source text is bound to the memory specified by the Actual_Memory_Binding property. 
 
 
Actual_Processor_Binding: inheritreference (processor)
   applies to(thread, thread group, process, system);
A thread is bound to the processor specified by the Actual_Processor_Bindingproperty. The process of binding threads to processors determines the value of this property.
Actual_Subprogram_Call: reference (server subprogram)
   applies to(subprogram);
The Actual_Subprogram_Callproperty specifies the server subprogram that is servicing the subprogram call as a remote call. If no value is specified, the subprogram call is a local call.
Actual_Subprogram_Call_Binding: reference(bus, processor, memory)
   applies to(subprogram);
The Actual_Subprogram_Call_Bindingproperty specifies the bus, processor, or memory to which a remote subprogram call is bound. If no value is specified, the subprogram call is a local call.
Actual_Throughput: Data_Volume
   applies to(flow);
The Actual_Throughputproperty specifies the actual throughput as determined by an analysis of the semantic flows representing the end-to-end flow.
Aggregate_Data_Port: aadlboolean =>  false
   applies to (port group);
The Aggregate_Data_Portproperty specifies whether the port group acts as an aggregate data port for ports that contain data.
Allowed_Access_Protocol: list ofenumeration (Memory_Access,
                                              Device_Access)
    applies to(bus);
The Allowed_Access_Protocolproperty specifies the categories of hardware components that can be connected to the processor via the bus.  The Memory_Accessvalue specifies that threads executing on a processor may access portions of their binary image that have been bound to a memory over that bus.  TheDevice_Accessvalue specifies that threads executing on the processor can communicate with devices via that bus.
If a list of allowed connection protocols is not specified for a bus, then the bus may be used to connect both devices and memory to the processor.
Allowed_Connection_Binding: inheritlist of reference (bus, processor, device)
   applies to (port connections, thread group, process, system);
The Allowed_Connection_Bindingproperty specifies the execution platform resources that are to be used to perform a communication.  The property type is a list of component names.  The list must contain an odd number of component names.  The named components must belong to a processor, device or bus category.
The first component named in the list must be either the processor to which the thread containing the ultimate source feature is bound, or else the processor or device containing the ultimate hardware source feature.  The last component named in the list must be either the processor to which the thread containing the ultimate destination feature is bound, or else the processor or device containing the ultimate hardware destination feature.  The intermediate component names must alternate between a bus, and a processor or a device.  Each pair of names for processor or device components that are separated by the name of a bus component must share that bus component. That is, the sequence of processors, devices and buses must form a connected path through the specified hardware architecture.
Allowed_Connection_Binding_Class:
   inherit list ofclassifier(processor, bus, device)
   applies to (port connections, thread, thread group, process, system);
The Allowed_Connection_Binding_Classproperty specifies the hardware resources that are to be used to perform a communication.  The property type is list of component classifier names.  The list must contain an odd number of component names.  The named component classifiers must belong to a processor, device or bus category.
The first component classifier named in the list must be either that of the processor to which the thread containing the ultimate source feature is bound, or else the processor or device containing the ultimate hardware source feature.  The last component classifier named in the list must be either that of the processor to which the thread containing the ultimate destination feature is bound, or else the processor or device containing the ultimate hardware destination feature.  The intermediate component classifier names must alternate between a bus, and a processor or a device.  Each pair of names for processor or device classifiers that are separated by the name of a bus classifier must share that bus component. That is, the sequence of processors, devices, and buses must form a connected path through the specified hardware architecture.
Allowed_Connection_Protocol: list ofenumeration
                                     (Data_Connection,
                                      Event_Connection)
    applies to(bus);
The Allowed_Connection_Protocolproperty specifies the categories of connections a bus supports.  That is, a connection may only be legally bound to a bus if the bus supports that category of connection.  The Data_Connectionvalue means data connections are supported. The Event_Connectionvalue means event connections are supported. 
If a list of allowed connection protocols is not specified for a bus, then any category of connection can be bound to the bus.
Allowed_Dispatch_Protocol: list ofSupported_Dispatch_Protocols
   applies to(processor);
The Allowed_Dispatch_Protocolproperty specifies the thread dispatch protocols are supported by a processor.  That is, a thread may only be legally bound to the processor if the specified thread dispatch protocol of the processor corresponds to the dispatch protocol required by the thread.
If a list of allowed scheduling protocols is not specified for a processor, then a thread with any dispatch protocol can be bound to and executed by the processor.
Allowed_Memory_Binding: inherit listof reference (memory, system, processor)
   applies to(thread, thread group, process, system, device, data port,
               event data port, subprogram, processor);
Code and data produced from source text can be bound to the set of memory components that is specified by the Allowed_Memory_Bindingproperty.  The set is specified by a list of memory and system component names.  System names represent the memories contained in them.  TheAllowed_Memory_Bindingproperty may specify a single memory, thus specifying the exact memory binding. 
The allowed binding may be further constrained by the memory classifier specified in the Allowed_Memory_Binding_Class.
The value of the Allowed_Memory_Bindingproperty may be inherited from the component that contains the component or feature.
If this property has no associated value, then all memory components declared in an AADL specification are acceptable candidates.
Allowed_Memory_Binding_Class:
   inherit list ofclassifier (memory, system, processor)
   applies to(thread, thread group, process, system, device, data port,
               event data port, subprogram, processor);
The Allowed_Memory_Binding_Classproperty specifies a set of memory, device, and system classifiers.  These classifiers constrain the set of memory components in the Allowed_Memory_Bindingproperty to the subset that satisfies the component classifier.
The value of the Allowed_Memory_Bindingproperty may be inherited from the component that contains the component or feature.
If this property has no associated value, then all memory components specified in the Allowed_Memory_Bindingare acceptable candidates.
Allowed_Message_Size: Size_Range
   applies to(bus);
The Allowed_Message_Sizeproperty specifies the allowed range of sizes for a block of data that can be transmitted by the bus hardware in a single transmission (in the absence of packetization).
The expression defines the range of data message sizes, excluding any header or packetization overheads added due to bus protocols, that can be sent in a single transmission over a bus. Messages whose sizes fall below this range will be padded. Messages whose sizes fall above this range must be broken into two or more separately transmitted packets.
Allowed_Period: list ofTime_Range
   applies to(processor, system);
The Allowed_Periodproperty specifies a set of allowed periods for periodic tasks bound to a processor.
The period of every thread bound to the processor must fall within one of the specified ranges.
If an allowed period is not specified for a processor, then there are no restrictions on the periods of threads bound to that processor.
 
Allowed_Processor_Binding: inheritlist of reference (processor, system)
   applies to(thread, thread group, process, system, device);
The Allowed_Processor_Bindingproperty specifies the set of processors that are available for binding.  The set is specified by a list of processor and system component names. System names represent the processors contained in them.
If the property is specified for a thread, the thread can be bound to one of the specified set of processors for execution. If the property is specified for a thread group, process or system, then it applies to all contained threads, i.e., the contained threads inherit the property association unless overridden. If this property is specified for a device, then it the thread associated with the device driver code can be bound to oe of the set of processors for execution.  TheAllowed_Processor_Bindingproperty may specify a single processor, thus specifying the exact processor binding. 
The allowed binding may be further constrained by the processor classifier reference specified in theAllowed_Processor_Binding_Classproperty.
If this property has no associated value, then all processors declared in n AADL specification are acceptable candidates.
Allowed_Processor_Binding_Class:
   inherit list ofclassifier (processor, system)
   applies to(thread, thread group, process, system, device);
The Allowed_Processor_Binding_Classproperty specifies a set of processor and system classifiers.  These component classifiers constrain the set of processors in the Allowed_Processor_Bindingproperty to the subset that satisfies the component classifier.
The default value is inherited from the containing process or system component.
If this property has no associated value, then all processors specified in the Allowed_Processor_Bindingare acceptable candidates.
Allowed_Subprogram_Call: list ofreference (server subprogram)
   applies to(subprogram);
A subprogram call can be bound to any member of  the set of server subprograms specified by the Allowed_Subprogram_Callproperty. If no value is specified, then subprogram call must be a local call.
Allowed_Subprogram_Call_Binding:
   inherit list ofreference (bus, processor, device)
   applies to(subprogram, thread, thread group, process, system);
Server subprogram calls can be bound to the physical connection of an execution platform that is specified by the Allowed_Subprogram_Call_Bindingproperty. If no value is specified, then subprogram call must be a local call.
Assign_Time: Time
   applies to(processor, bus);
The Assign_Timeproperty specifies a time unit value used in a linear estimation of the execution time required to move a block of bytes on a particular processor or bus. The time required is assumed to be the number of bytes times theAssign_Byte_Time plus Assign_Fixed_Time.
Assign_Time = (Number_of_Bytes * Assign_Byte_Time) + Assign_Fixed_Time
The property type is Time.  The standard units are ns (nanoseconds), us (microseconds),ms(milliseconds), sec (seconds),min (minutes) and hr (hours).  The numeric value must be a positive number. 
Assign_Byte_Time: Time
   applies to(processor, bus);
The Assign_Byte_Timeproperty specifies a time unit value which reflects the time required to move a single bytes on a particular processor or bus, not including the Assign_Fixed_Time.
The property type is Time.  The standard units are ns (nanoseconds), us (microseconds),ms(milliseconds), sec (seconds),min (minutes) and hr (hours).  The numeric value must be a  positive number. 
Assign_Fixed_Time: Time
   applies to(processor, bus);
The Assign_Fixed_Timeproperty specifies a time unit value which reflects the fixed or overhead time required for assignment of any number of bytes on a particular processor or bus.
The property type is Time.  The standard units are ns (nanoseconds), us (microseconds),ms(milliseconds), sec (seconds),min (minutes) and hr (hours).  The numeric value must be a positive number. 
Available_Memory_Binding: inherit listof reference (memory, system)
   applies to(system);
The Available_Memory_Bindingproperty specifies the set of contained memory components that are made available for binding outside the system.  The set is specified by a list of memory and system component names.  System names represent the memories contained in them.
Available_Processor_Binding: inheritlist of reference (processor, system)
   applies to(system);
The Available_Processor_Bindingproperty specifies the set of contained processor components that are made available for binding outside the system. The set is specified by a list of processor and system component names.  System names represent the processors contained in them.
Base_Address: access aadlinteger 0 .. value(Max_Base_Address)
   applies to(data);
The Base_Addressproperty specifies the address of the first word in the memory.  The addresses used to access successive words of memory are Base_Address, Base_Address+ Word_Space, …Base_Address+ (Word_Count-1) * Word_Space.
The property expression must be preceded by the reserved word access, in which case the property specifies the address associated with the access to a subcomponent rather than the data component itself.
Client_Subprogram_Execution_Time: Time
   applies to(subprogram);
The Client_Subprogram_Execution_Timeproperty specifies the length of time it takes to execute the client portion of a remote subprogram call.
The property type is Time.  The standard units are ns (nanoseconds), us (microseconds),ms(milliseconds), sec (seconds),min (minutes) and hr (hours).  The numeric value must be a  positive number. 
Clock_Jitter: Time
   applies to(processor, system);
The Clock_Jitterproperty specifies a time unit value that gives the maximum time between the start of clock interrupt handling on any two processors in a multi-processor system.
The property type is Time.  The standard units are ns (nanoseconds), us (microseconds),ms(milliseconds), sec (seconds),min (minutes) and hr (hours).  The numeric value must be a positive number. 
Clock_Period: Time
   applies to(processor, system);
The Clock_Periodproperty specifies a time unit value that gives the time interval between two clock interrupts.
The property type is Time.  The standard units are ns (nanoseconds), us (microseconds),ms(milliseconds), sec (seconds),min (minutes) and hr (hours).  The numeric value must be a positive number. 
Clock_Period_Range: Time_Range
   applies to(processor, system);
The Clock_Period_Rangeproperty specifies a time range value that represents the minimum and maximum value assignable to the Clock_Period property.
Compute_Deadline: Time
   applies to(thread, subprogram, event port, event data port);
The Compute_Deadlinespecifies the maximum amount of time allowed for the execution of a thread’s compute sequence.  If the property is specified for a subprogram, event port, or event data port feature, then this compute execution time applies to the dispatched thread when the corresponding call, event, or event data arrives.   When specified for a server subprogram, the Compute_Deadlineapplies to the thread executing the remote procedure call in response to the server subprogram call.  The Compute_Deadlinespecified for a featuremust not exceed the Compute_Deadlineof the associatedthread. The numeric value of time must be positive. 
The values specified for this property for a thread are bounds on the values specified for specific features.
The Deadlineproperty places a limit onCompute_Deadlineand Recover_Deadline: Compute_Deadline+ Recover_Deadline£Deadline.
The property type is Time.  The standard units are ps (picoseconds), ns (nanoseconds), us (microseconds),ms(milliseconds), sec (seconds),min (minutes) and hr (hours).
Compute_Entrypoint: aadlstring
   applies to(thread, subprogram, event port, event data port);
TheCompute_Entrypoint property specifies the name of a source text code sequence that will execute after a thread has been dispatched.  If the property is specified for a subprogram, event port, or event data port feature, then this entrypoint is chosen when the corresponding call, event, or event data arrives instead of the compute entrypoint specified for the containing thread.
The named code sequence in the source text must be visible in and callable from the outermost program scope, as defined by the scope and visibility rules of the applicable implementation language.  The source language annex of this standard defines acceptable parameter and result signatures for the entry point subprogram.
Compute_Execution_Time: Time_Range
   applies to(thread, device, subprogram, event port, event data port);
TheCompute_Execution_Time property specifies the amount of time that a thread will execute after a thread has been dispatched, before that thread begins waiting for another dispatch. If the property is specified for a subprogram, event port, or event data port feature, then this compute execution time applies to the dispatched thread when the corresponding call, event, or event data.  When specified for a server subprogram, it applies to the thread executing the remote procedure call in response to a server subprogram call. The Compute_Execution_Timespecified for a featuremust not exceed the Compute_Execution_Timeof the associatedthread.
The range expression specifies a minimum and maximum execution time in the absence of runtime errors.  The specified execution time includes all time required to execute any service calls that are executed by a thread, but excludes any time spent by another thread executing remote procedure calls in response to a remote subprogram call made by the thread.
The values specified for this property for a thread are bounds on the values specified for specific features.
Concurrency_Control_Protocol: Supported_Concurrency_Control_Protocols =>          
                                                                 NoneSpecified
      appliesto (data);
The Concurrency_Control_Protocolproperty specifies the concurrency control protocol used to ensure mutually exclusive access, i.e., a critical region, to a shared data component.  The default value isNoneSpecified, i.e., no concurrency control protocol.
Connection_Protocol: Supported_Connection_Protocols
   applies to(connections);
The Connection_Protocolproperty specifies a connection protocols to be used for a connection.  The selected protocol must be supported for connections within the same processor and across processors.
A method used to construct a physical system from a specification is permitted to support only a subset of the standard connection protocols.  A method used to construct a physical system is permitted to support additional non-standard connection protocols.
Data_Volume: type aadlinteger 0 bitsps .. value(Max_Aadlinteger)
                              units ( bitsps, Bps => bitsps * 8,
                                      Kbps => Bps * 1000,
                                      Mbps => Kbps * 1000,
                                      Gbps => Mbps * 1000 );
TheData_Volumeproperty type specifies a property type for the volume of data per time unit. The predeclared unit literals are expressed in terms of seconds as time unit.  The numeric value of the property must be positive.
Deactivate_Deadline: Time
   applies to(thread);
TheDeactivate_Deadlineproperty specifies the maximum amount of time allowed for the execution of a thread’s deactivation sequence.  The numeric value of time must be positive.
The property type is Time.  The standard units are ps (picoseconds), ns (nanoseconds), us (microseconds),ms(milliseconds), sec (seconds),min (minutes) and hr (hours). 
Deactivate_Execution_Time: Time_Range
   applies to(thread);
TheDeactivate_Execution_Time propertyspecifies the amount of time that a thread will execute its deactivation sequence, i.e., when the thread is deactivated as part of a mode switch.
The range expression specifies a minimum and maximum execution time in the absence of runtime errors.  The specified execution time includes all time required to execute any service calls that are executed by a thread, but excludes any time spent by another thread executing remote procedure calls in response to a remote subprogram call made by this thread.
Deactivate_Entrypoint: aadlstring
   applies to(thread);
TheDeactivate_Entrypoint property specifies the name of a source text code sequence that will execute when a thread is deactivated.  This property may have an unspecified value.
The named code sequence in the source text must be visible in and callable from the outermost program scope, as defined by the scope and visibility rules of the applicable implementation language.  The source language annex of this standard defines acceptable parameter and result signatures for the entry point subprogram.
Deadline: Time => inheritvalue(Period)
   applies to(thread, thread group, process, system, device);
TheDeadlineproperty specifies the maximum amount of time allowed between a thread dispatch and the time that thread begins waiting for another dispatch.  Its numeric value must be positive.
The Deadlineproperty places a limit onCompute_Deadlineand Recover_Deadline: Compute_Deadline+ Recover_Deadline£Deadline
The Deadlineproperty may not be specified for threads with background dispatch protocol.
The Deadlinemust not be greater than the specified period for the thread, if any.
Dequeue_Protocol: enumeration ( OneItem, AllItems ) => OneItem
   applies to (event port, event data port);
The Dequeue_Protocolproperty specifies whether one or all queued events or event data will be made available to a thread in its port variable.  If the value is OneItem, the port variable must accommodate the data of a single instance of the event data port’s data type.  If the value is AllItems, the port variable must accommodate the data of the maximum number of event data that can be queued – as determined by the Queue_Sizeproperty of the port.  The sequence of dequeued data instances must be accessible to the source text in the queuing order through an appropriate data structure – as documented by the implementer of an AADL tool.
Device_Dispatch_Protocol: Supported_Dispatch_Protocols => Aperiodic
   applies to(thread, device);
The Device_Dispatch_Protocolproperty specifies the dispatch behaviors for a thread representing the device driver.
Aperiodicrepresents interrupt-driven device drivers, while Periodicrepresents polling device drivers.
Device_Register_Address: aadlinteger
   applies to (port, port group);
The Device_Register_Addressproperty specifies the address of a device register that is represented by a port associated with a device.  This property is optional.  Device ports may be represented by a source text variable as part of the device driver software.
Dispatch_Protocol: Supported_Dispatch_Protocols
   applies to(thread);
The Dispatch_Protocolproperty specifies the dispatch behavior for a thread.
A method used to construct a physical system from a specification is permitted to support only a subset of the standard scheduling protocols.  A method used to construct a physical system is permitted to support additional non-standard scheduling protocols.
Expected_Latency: Time
   applies to(flow);
The Expected_Latency property specifies the expected latency for a flow specification.  Actual latency must not exceed the expected latency. Its numeric value must be positive. 
The property type is Time.  The standard units are ns (nanoseconds), us (microseconds),ms(milliseconds), sec (seconds),min (minutes) and hr (hours).
Expected_Throughput: Data_Volume
   applies to(flow);
The Expected_Throughput property specifies the expected throughput for a flow specification. The actual throughput must not exceed the expected throughput. Its numeric value must be positive. 
Finalize_Deadline: Time
   applies to(thread);
TheFinalize_Deadlineproperty specifies the maximum amount of time allowed for the execution of a thread’s finalization sequence.  The numeric value of time must be positive.
The property type is Time.  The standard units are ps (picoseconds), ns (nanoseconds), us (microseconds),ms(milliseconds), sec (seconds),min (minutes) and hr (hours).
Finalize_Execution_Time: Time_Range
   applies to(thread);
TheFinalize_Execution_Time propertyspecifies the amount of time that a thread will execute its finalization sequence. 
The range expression specifies a minimum and maximum execution time in the absence of runtime errors.  The specified execution time includes all time required to execute any service calls that are executed by a thread, but excludes any time spent by another thread executing remote procedure calls in response to a remote subprogram call made by this thread.
Finalize_Entrypoint: aadlstring
   applies to(thread);
TheFinalize_Entrypoint property specifies the name of a source text code sequence that will execute when a thread is finalized.  This property may have an unspecified value.
The named code sequence in the source text must be visible in and callable from the outermost program scope, as defined by the scope and visibility rules of the applicable implementation language.  The source language annex of this standard defines acceptable parameter and result signatures for the entrypoint subprogram.
Hardware_Description_Source_Text: inheritlist of aadlstring
   applies to (memory, bus, device, processor, system);
The Hardware_Description_Source_Textproperty specifies a list of files that contain source text of a hardware description in a hardware description language. 
Each string is interpreted as a POSIX pathname and must satisfy the syntax and semantics for path names as defined in the POSIX standard. Extensions to the standard POSIX pathname syntax and semantics are permitted.  For example, environment variables and regular expressions are permitted.  Special characters may be used to assist in configuration management and version control.
If the first character of a pathname is .(dot) then the path is relative to the directory in which the file containing the AADL specification text is stored.  Otherwise, the method of processing may define the default directory used to locate the file designated by a pathname.
Hardware_Source_Language: Supported_Hardware_Source_Languages
   applies to (memory, bus, device, processor, system);
The Hardware_Source_Languageproperty specifies an applicable hardware description language.
The hardware description source text associated with a hardware component is written in a hardware description language. 
Initialize_Deadline: Time
   applies to(thread);
The Initialize_Deadlineproperty specifies the maximum amount of time allowed between the time a thread executes its initialization sequence and the time that thread begins waiting for a dispatch.  The numeric value of time must be positive.
The property type is Time.  The standard units are ps (picoseconds), ns (nanoseconds), us (microseconds),ms(milliseconds), sec (seconds),min (minutes) and hr (hours).
Initialize_Execution_Time: Time_Range
   applies to(thread);
The Initialize_Execution_Time propertyspecifies the amount of time that a thread will execute its initialization sequence. 
The range expression specifies a minimum and maximum execution time in the absence of runtime errors.  The specified execution time includes all time required to execute any service calls that are executed by a thread, but excludes any time spent by another thread executing remote procedure calls in response to a remote subprogram call made by this thread.
Initialize_Entrypoint: aadlstring
   applies to(thread);
TheInitialize_Entrypoint property specifies the name of a source text code sequence that will execute when a thread is to be initialized.  This property may have an unspecified value.
The named code sequence in the source text must be visible in and callable from the outermost program scope, as defined by the scope and visibility rules of the applicable implementation language.  The source language annex of this standard defines acceptable parameter and result signatures for the entrypoint subprogram.
Latency: Time
   applies to (flow, connections);
TheLatencyproperty specifies the maximum amount of elapsed time allowed between the time the data or events enter the connection or flow and the time it exits.  Its numeric value must be positive.
The property type is Time.  The standard units are ns (nanoseconds), us (microseconds),ms(milliseconds), sec (seconds),min (minutes) and hr (hours).
Load_Deadline: Time
   applies to(process, system);
TheLoad_Deadlineproperty specifies the maximum amount of elapsed time allowed between the time the process begins and completes loading.  Its numeric value must be positive.
The property type is Time.  The standard units are ns (nanoseconds), us (microseconds),ms(milliseconds), sec (seconds),min (minutes) and hr (hours).
Load_Time: Time_Range
   applies to(process, system);
TheLoad_Timeproperty specifies the amount of execution time that it will take to load the binary image associated with a process.  The numeric value of time must be positive.
When applied to a system, the property specifies the amount of time it takes to load the binary image of data components declared within the system implementation and shared across processes (and their address spaces).
The range expression specifies a minimum and maximum load time in the absence of runtime errors.
Memory_Protocol: enumeration (read_only, write_only, read_write) => read_write
   applies to(memory);
The Memory_Protocol property specifies memory access and storage behaviors and restrictions.  Writeable data produced from software source text may only be bound to memory components that have the write_only or read_write property value.
Not_Collocated: list ofreference (data, thread, process, system, connections)
    applies to(data, thread, process, system, connections);
The Not_Collocatedproperty specifies that hardware resources used by two software components must be distinct.  The component to which this property applies must not be bound to any hardware resources to which any of the named components or connections are also bound.
The value of the Not_Collocatedproperty may be inherited from the component that contains the software component. 
If this property has no associated value, then there are no additional constraints on allowed hardware bindings other than the constraints imposed by the semantics and legality rules of this standard.
Overflow_Handling_Protocol: enumeration(DropOldest, DropNewest, Error)
                                                                 => DropOldest
   applies to (event port, event data port, subprogram);
The Overflow_Handling_Protocolproperty specifies the runtime behavior of a thread when an event arrives and the queue is full. DropOldestremoves the oldest event from the queue and adds the new arrival. DropNewestignores the newly arrived event.Errorcauses the thread’s error recovery to be invoked.
Period: inherit Time
   applies to(thread, thread group, process, system, device);
The Periodproperty specifies the time interval between successive dispatches of a thread whose scheduling protocol is periodic, or the minimum interval between successive dispatches of a thread whose scheduling protocol is sporadic
The property type is Time.  The standard units are ns (nanoseconds), us (microseconds),ms(milliseconds), sec (seconds),min (minutes) and hr (hours).  The numeric value must be a single positive number. 
A Periodproperty association is only allowed if the thread scheduling protocol is either periodicor sporadic.
Process_Swap_Execution_Time: Time_Range
      applies to(processor);
TheProcess_Swap_Execution_Timeproperty specifies the amount of execution time necessary to perform a context swap between two threads contained in different processes.
The range expression specifies a minimum and maximum swap time in the absence of runtime errors.
Propagation_Delay: Time_Range
   applies to(bus);
The Propagation_Delay property specifies the time between the start of a transmission of a message of Nbytes onto a bus and the start of receipt of that message from the bus.  Propagation delay will depend on the physical properties of the transmission media and associated hardware and software and on the spatial distance between sender and receiver.
The range expression specifies a minimum and maximum transmission time in the absence of runtime errors.
Provided_Access : access enumeration(read_only, write_only, read_write,
                                      by_method) => read_write
   applies to(data);
The Provided_Accessproperty specifies the form of access provided by a data component that may be shared by multiple subcomponents.  Provided access to the data component may be limited to access through the subprograms provided with the data type or may be direct. Required_Access property values associated with requires subprogram access references must be satisfied by theProvided_Accessproperty value of the referenced data component.
Queue_Processing_Protocol: Supported_Queue_Processing_Protocols => FIFO
   applies to (event port, event data port, subprogram);
The Queue_Processing_Protocolproperty specifies the protocol for processing elements in the queue.
Queue_Size: aadlinteger 0 .. value(Max_Queue_Size) => 0
   applies to (event port, event data port, subprogram);
The Queue_Sizeproperty specifies the size of the queue for an event or event data port of a thread.
TheQueue_Sizeproperty specifies the size of the queue for a server subprogram feature of a thread.
Read_Time: list ofTime_Range
   applies to(memory);
The Read_Timeproperty specifies the parameters for a linear model for the time required to read a sequence ofNwords from the memory.
The property type is a list containing two number ranges. 
The time required to read a sequence of N words from the memory is Read_Time(1) + N * Read_Time(2), where Read_Time(1)is any number that falls in the first range specified and Read_Time(2)is any number that falls in the second range specified   Using Read_Time_Lower(k)and Read_Time_Upper(k)to be the lower and upper values of the kth range, the minimum time required to read a sequence of N words is Read_Time_Lower(1) + N * Read_Time_Lower(2)and the maximum time required to read a sequence of Nwords is Read_Time_Upper(1) + N * Read_Time_Upper(2).
If this property has no associated value and the Write_Timeproperty has an associated value, then the Write_Timevalues shall be used as the defaultRead_Timevalues.
Recover_Deadline: Time
   applies to (thread, server subprogram);
Recover_Deadlinespecifies the maximum amount of time allowed between the time when a detected error occurs and the time a thread or server subprogram begins waiting for another dispatch.  Its numeric value must be positive.
The Recover_Deadlineproperty may not be specified for threads with backgrounddispatch protocol.
The Recover_Deadline must not be greater than the specified period for the thread, if any.
The Deadlineproperty places a limit onCompute_Deadlineand Recover_Deadline: Compute_Deadline+ Recover_Deadline£Deadline.
The property type is Time.  The standard units are ps (picoseconds), ns (nanoseconds), us (microseconds), ms (milliseconds), sec (seconds), min (minutes) and hr (hours). 
Recover_Execution_Time: Time_Range
   applies to(thread, server subprogram);
TheRecover_Execution_Timeproperty specifies the amount of time that a thread or server subprogram will execute after an error has occurred, before it begins waiting for another dispatch.
The range expression specifies a minimum and maximum execution time in the absence of runtime errors.  The specified execution time includes all time required to execute any service calls that are executed by a thread, but excludes any time spent by another thread executing remote procedure calls in response to a remote subprogram call made by this thread.
aadlstring
   applies to(thread);
TheRecovery_Entrypoint property specifies the name of a source text code sequence that will execute when a thread is recovering from a fault.  This property may have an unspecified value.
The named code sequence in the source text must be visible in and callable from the outermost program scope, as defined by the scope and visibility rules of the applicable implementation language.  The source language annex of this standard defines acceptable parameter and result signatures for the entrypoint subprogram.
Required_Access : access enumeration(read_only, write_only, read_write,
                                      by_method) => read_write 
   applies to (data, bus);
The Required_Accessproperty specifies the form of access a component of a given component type makes to a required subcomponent, i.e., a component that may be shared by multiple subcomponents. This access may be direct through read and write access or indirect through subprograms provided with the data type.
 
Required_Connection : aadlboolean=> true 
   applies to(port);
The Required_Connectionproperty specifies whether the port or subprogram requires a connection.  If the value of this property is false, then it is assumed that the component can function without this port or subprogram feature being connected.
The default value is that a connection is required.
Runtime_Protection : inheritaadlboolean =>true 
   applies to (process, system);
The Runtime_Protectionproperty specifies whether the process requires runtime address space protection. 
The default value is that runtime protection is required.
Scheduling_Protocol: list ofSupported_Scheduling_Protocols
   applies to(processor);
The Scheduling_Protocol property specifies what scheduling protocol the thread scheduler of the processor uses.  The core standard does not prescribe a particular scheduling protocol.
Scheduling protocols may result in schedulers that coordinate scheduling of threads across multiple processors.
Server_Subprogram_Call_Binding: inheritlist of reference (thread, processor)
   applies to(subprogram, thread, thread group, process, system);
The Server_Subprogram_Call_Binding property specifies the sequence of processor, thread and subprogram connections required to complete a remote subprogram server call.
Size: type aadlinteger 0B .. value(Max_Memory_Size) units Size_Units;
Memory size as integers with predefined size units.
Size_Range: type range ofSize;
The Size_Rangeproperty specifies a closed range of memory size values, i.e., a memory size range including the lower and upper bound.
Source_Code_Size: Size
   applies to (data, thread, process, subprogram, processor, device);
The Source_Code_Sizeproperty specifies the size of the static code and read-only data that results when the associated source text is compiled, linked, bound and loaded in the final system. 
The property type is Size.  The standard units are bits, B (bytes), KB (kilobytes), MB (megabytes) and GB (gigabytes). 
Source_Data_Size: Size
   applies to (data, subprogram, thread, process, processor, device);
The Source_Data_Sizeproperty specifies the size of the readable and writeable data that results when the associated source text is compiled, linked, bound and loaded in the final system. In the case of data types, it specifies the maximum size required to hold a value of an instance of the data type.
The property type is Size.  The standard units are bits, B (bytes), KB (kilobytes), MB (megabytes) and GB (gigabytes).
Source_Heap_Size: Size
   applies to (thread, subprogram);
The Source_Heap_Sizeproperty specifies the minimum and maximum heap size requirements of a thread or subprogram.
The property type is Size.  The standard units are bits, B (bytes), KB (kilobytes), MB (megabytes) and GB (gigabytes).
Source_Language: Supported_Source_Languages
   applies to (subprogram, data, thread, process,
               bus, device, processor);
The Source_Languageproperty specifies an applicable programming language.
The property type is enumeration.  The standard enumeration literals are Ada, C, and Simulink®for software categories.  Other enumeration literals are permitted. 
There is no default value for the source language property. 
Where a source language is specified for a component, the source text associated with that component must comply with the applicable programming language standard.  Where a source language is not specified, a method of processing may infer a source language from the syntax of the source text pathname.  A method of processing may establish a default value for the source language property.
Where a source language property is specified for a component, any specified source language and any specified source text for the complete set of software subcomponents of that component must comply with the applicable language standard.
Multiple source languages, and source text written in those languages, are compliant with a specified source language if the applicable language standard permits mixing source text units of those languages within the same program.
A method of processing may accept data produced by processing a source text file, for example an object file produced by compiling source text may be considered compliant with the applicable language standard.  A method of processing may accept non-standard source languages.  A method of processing may restrict itself to specific source languages, either standard or non- standard.
The source text associated with an execution platform component represents software that is necessary to provide the full functionality of the execution platform component.
Source_Name: aadlstring
   applies to (data, port, subprogram, parameter);
The Source_Nameproperty specifies a source declaration or source name within the associated source text that corresponds to a feature defining identifier. 
The default value is defined in the source language annex of this standard.
Source_Stack_Size: Size
   applies to(thread, subprogram, processor, device);
The Source_Stack_Sizeproperty specifies the maximum size of the stack used by a processor executive, a device driver, a thread or a subprogram during execution.
The property type is Size.  The standard units are bits, B (bytes), KB (kilobytes), MB (megabytes) and GB (gigabytes).
Source_Text: inherit list of aadlstring
   applies to (data, port, subprogram, thread, thread group, process, system,
               memory, bus, device, processor, parameter, port group);
The Source_Textproperty specifies a list of files that contain source text. 
Each string is interpreted as a POSIX pathname and must satisfy the syntax and semantics for path names as defined in the POSIX standard.  Extensions to the standard POSIX pathname syntax and semantics are permitted.  For example, environment variables and regular expressions are permitted.  Special characters may be used to assist in configuration management and version control.
If the first character of a pathname is .(dot) then the path is relative to the directory in which the file containing the AADL specification text is stored.  Otherwise, the method of processing may define the default directory used to locate the file designated by a pathname.
There is no standard default value for the source text property.
The combined source text contained in all files named in the associated expression must form one or more separately compileable units as defined in the applicable source language standard.
Startup_Deadline: inheritTime
   applies to (processor, system);
The Startup_Deadlineproperty specifies the deadline for processor initialization. 
The property type is Time.  The standard units are ps (picoseconds), ns (nanoseconds), us (microseconds),ms(milliseconds), sec (seconds),min (minutes) and hr (hours).  The numeric value must be a single positive number. 
Subprogram_Execution_Time: Time_Range
   applies to(subprogram);
The Subprogram_Execution_Timeproperty specifies the length of time it takes to execute a subprogram when called locally.
The range expression specifies a minimum and maximum execution time in the absence of runtime errors.
Supported_Source_Language: list ofSupported_Source_Languages
   applies to (processor, system);
The Supported_Source_Languageproperty specifies the source language(s) supported by a processor. 
The source language of every software component that may be accessed by any thread bound to a processor must appear in the list of allowed source languages for that processor.
If an allowed source language list is not specified, then there are no restrictions on the source.
Synchronized_Component: inheritaadlboolean => true
      applies to(thread, thread group, process, system);
The Synchronized_Componentproperty specifies whether a periodic thread will be synchronized with transitions into and out of a mode.  In other words, the thread affects the hyperperiod for mode switching of the property value is true.  The default value is true.
Thread_Limit: aadlinteger 0 .. value(Max_Thread_Limit)
                                                    => value(Max_Thread_Limit)
   applies to(processor);
TheThread_Limit property specifies the maximum number of threads supported by the processor.
Thread_Swap_Execution_Time: Time_Range
   applies to(processor, system);
TheThread_Swap_Execution_Timeproperty specifies the amount of execution time necessary for performing a context swap between two threads contained in the same process.
The range expression specifies a minimum and maximum swap time in the absence of runtime errors.
Throughput: Data_Volume
   applies to (flow, connections);
TheThroughputproperty specifies the maximum volume of data transferred per time unit.  Its numeric value must be positive.
Time: type aadlinteger 0 ps .. value(Max_Time) units Time_Units;
TheTimeproperty type specifies a property type for time that is expressed as numbers with predefined time units.
Time_Range: type range ofTime;
TheTime_Rangeproperty type specifies a property type for a closed range of time, i.e., a time span including the lower and upper bound.
The property type is Time.  The standard units are ps (picoseconds), ns (nanoseconds), us (microseconds),ms(milliseconds), sec (seconds),min (minutes) and hr (hours).
Transmission_Time: list ofTime_Range
   applies to(bus);
The Transmission_Timeproperty specifies the parameters for a linear model for the time interval between the start and end of a transmission of a sequence of Nbytes onto a bus.  The transmission time is the time between the transmission of the first bit of the message onto the bus and the transmission of the last bit of the message onto the bus.  This time excludes arbitration, queuing, or any other times that are a function of how bus contention and scheduling are performed for a bus.
The associated expressions must evaluate to a list of two ranges of nonnegative numbers.
The time required to transmit a message of Nwords over the bus is Transmission_Time(1) + N * Transmission_Time(2), where Transmission_Time(1)is any number that falls in the first range specified and Transmission_Time(2)is any number that falls in the second range specified. 
Using Transmission_Time_Lower(k)and Transmission_Time_Upper(k)to be the lower and upper values of the kth range, the minimum time required to transmit a sequence of N words is Transmission_Time_Lower(1) + N * Transmission_Time_Lower(2) and the maximum time required to transmit a sequence of N words is Transmission_Time_Upper(1) + N * Transmission_Time_Upper(2).
Type_Source_Name: aadlstring
   applies to (data, port, subprogram);
The Type_Source_Nameproperty specifies a source declaration or source name within the associated source text that corresponds to a feature defining identifier. 
The default value is defined in the source language annex of this standard.
Urgency: aadlinteger 0 .. value(Max_Urgency)
   applies to(port);
The Urgencyproperty specifies the urgency with which an event at an in port is to be serviced relative to other events arriving at or queued at other in ports of the same thread.  A numerically larger number represents higher urgency.
Word_Count: aadlinteger 0 .. value(Max_Word_Count)
   applies to(memory);
The Word_Countproperty specifies the number of words in the memory.
Word_Size: Size => 8 bits
   applies to(memory);
The Word_Sizeproperty specifies the size of the smallest independently readable and writeable unit of storage in the memory.
The property type is Size.  The standard units are bits, B (bytes), KB (kilobytes), MB (megabytes) and GB (gigabytes).
Word_Space: aadlinteger 1 .. value(Max_Word_Space) => 1
   applies to(memory);
The Word_Spacespecifies the interval between successive addresses used for successive words of memory.  A value greater than 1 means the addresses used to access words are not contiguous integers. 
Write_Time: list ofTime_Range
   applies to(memory);
The Write_Timeproperty specifies the parameters for a linear model for the time required to write a sequence ofNwords into the memory.
The property type is a list containing two number ranges. 
The time required to write a sequence of N words into the memory is Write_Time(1) + N *Write_Time(2), where Write_Time(1)is any number that falls in the first range specified and Write_time(2)is any number that falls in the second range specified.  Using Write_Time_Lower(k)and Write_Time_Upper(k)to be the lower and upper values of the kth range, the minimum time required to write a sequence of Nwords is Write_Time_Lower(1) + N * Write_Time_Lower(2)and the maximum time required to write a sequence ofNwords is Write_Time_Upper(1) + N * Write_Time_Upper(2).
If this property has no associated value, but the Read_Timeproperty has an associated value, then the Read_Timevalues shall be used as the defaultWrite_Timevalues.
 
endAADL_Properties;