7.1 Systems
A system represents an assembly of interacting application software, execution platform, and system components. Systems can have multiple modes, each representing a possibly different configuration of components and their connectivity contained in the system. Systems may require access to data and bus components declared outside the system and may provide access to data and bus components declared within.  Systems may be hierarchically nested. This provides for modeling of large-scale runtime architectures.
Legality Rules
Category
Type
Implementation
system
Features:
    • server  subprogram
    • port
    • port group
    • provides data access
    • provides bus access
    • requires data access
    • requires bus access
Flow specifications: yes
Properties: yes
Subcomponents:
    • data
    • process
    • processor
    • memory
    • bus
    • device
    • system
Subprogram calls: no
Connections: yes
Flows: yes
Modes: yes
Properties: yes

A system component type can contain provided and required data and bus access declarations, port, port group, and server subprogram declarations.  It can also contain flow specifications as well as property associations.
A system component implementation can contain data, process, and system subcomponent declarations as well as execution platform components, i.e., processor, memory, bus, and device.
A system implementation can contain a modes subclause, a connections subclause, a flows subclause, and property associations. 
Standard Properties
-- Properties related to source text
Source_Text: inherit list of aadlstring
Source_Language: Supported_Source_Languages
-- Process property that can be specified at the system level as well
-- Runtime enforcement of address space boundaries
Scheduling_Protocol: list of Supported_Scheduling_Protocols
-- Inhertable thread properties
Synchronized_Component: inherit aadlboolean => true
Active_Thread_Handling_Protocol:
   inherit Supported_Active_Thread_Handling_Protocols
         => value(Default_Active_Thread_Handling_Protocol)
Period: inherit Time
Deadline: Time => inherit value(Period)
-- Properties related binding of software component source text in
-- systems to processors and memory
Allowed_Processor_Binding_Class:
   inherit list of classifier (processor, system)
Allowed_Processor_Binding: inherit list of reference (processor, system)
Actual_Processor_Binding: inherit reference (processor)
Allowed_Memory_Binding_Class:
   inherit list of classifier (memory, system, processor)
Allowed_Memory_Binding: inherit list of reference (memory, system, processor)
Not_Collocated: list of reference (data, thread, process, system, connections)
Actual_Memory_Binding: inherit reference (memory)
Allowed_Connection_Binding_Class:
   inherit list of classifier(processor, bus, device)
Allowed_Connection_Binding: inherit list of reference (bus, processor, device)
Actual_Connection_Binding: inherit reference (bus, processor, device)
-- Properties related systems as execution platforms
Available_Processor_Binding: inherit list of reference (processor, system)
Available_Memory_Binding: inherit list of reference (memory, system)
Hardware_Source_Language: Supported_Hardware_Source_Languages
-- Properties related to startup of processor contained in a system
Startup_Deadline: inherit Time
-- Properties related to system load times
Load_Time: Time_Range
Load_Deadline: Time
-- Properties related to the hardware clock
Clock_Jitter: Time
Clock_Period: Time
Clock_Period_Range: Time_Range
Semantics
A system component represents an assembly of software and execution platform components.  All subcomponents of a system are considered to be contained in that system.
System components can represent application software components and connections that must be bound to execution platform components, i.e., processors, memories, and buses in order to be executable.  Those software components and connections may be bound to execution platform components within the system, or they must be bound to execution platform components outside the system. 
Some system components consist of purely software components all of which must be bound to execution platform components outside the system itself. An example is an application software system. 
Some system components consist purely of execution platform components. They represent aggregations of execution platform components that act as the execution platform.
Some system components are self-contained in that all software components and connections are bound to execution platform components contained within the system.  Such self-contained systems may have external connectivity in the form of logical connection points represented by ports and physical connection points in the form of required or provided bus access.  Examples, of such systems are database servers, GPS receivers, and digital cameras.  Such self-contained systems with an external interface can also be modeled as devices. The device representation takes a black-box perspective, while the system representation takes a white-box perspective.
A system component can contain a modes subclause.  Each mode can represent an alternative system configuration of contained subcomponents and their connections.  The transition between modes is determined by the mode transition declarations of the system and is triggered by the arrival of events.  A system can have mode-specific property associations.