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;
|
|