Chapter 8. Composite and Generic Components
In this section, we discuss the system and abstract component categories that provide a framework for specifying composite components and generic components. Systems are used to define the composite components of a system recursively in terms of system subcomponents as well as specific software, computer hardware, and physical system components. Abstract components can be used to represent a component hierarchy as composites and individual components that are generic. Abstract components can be refined later in the design process to declare explicitly the runtime category of the components that comprise the runtime architecture. Components contained in a system component or abstract component can only interact with external components through the features that make up the interface of a system or abstract component.
8.1. System
The system abstraction represents a composite that can include software, execution platform, or system components. It can be used to represent composites of computer hardware components (e.g., a processor board or cabinet), a collection of application software processes (e.g., a flight navigation system), a combination of software and hardware components (e.g., an air data computer), collections of physical system components (e.g., a cockpit consisting of various panels, displays, flight sticks, and other controls), or a composite of subsystems or a system of systems (e.g., an aircraft system). In addition, models consisting of only system components can be used as a generic representation of a component-based conceptual view of a system architecture.
8.1.1. Representations
A system can consist of various combinations of software, execution platform, and system components. For example, a system may consist only of software (processes, subprograms, subprogram groups, or data—threads or thread groups must be contained in processes) or only of computer system components (processor, bus, memory, and systems of these), components of the external environment (devices, buses, and their composites in form of systems), as well as combinations of such systems.
Listing 8-1 provides textual and graphical representations of an implementation of the system type integrated_control. Subcomponent declarations are shown in the implementation. However, the requisite classifier declarations are not shown (e.g., the process type declaration for the process type controller). In the graphical portrayal, the subcomponents of integrated_control.PBA are shown.
Listing 8-1. A Sample System Specification: Textual and Graphical Representation
system integrated_control
end integrated_control;
--
system implementation integrated_control.PBA
subcomponents
control_process: process controller.speed_control;
set_point_data: data set_points;
navigation_system: system core_system.navigation;
real_time_processor: processor rt_fast.rt_processor;
hs_memory: memory rt_memory.high_speed;
high_speed_bus: bus network_bus.HSbus;
end integrated_control.PBA;
8.1.2. Properties
Many standard properties that can be attached to system components are properties that are shared with contained components as inherited properties. Some properties are not inherited and apply to the system component itself, such as Startup_Execution_Time and Startup_Deadline. It is common for you to introduce additional properties for characteristics that are relevant at the system level, such as weight, reliability, or security.
8.1.3. Constraints
Table 8-1 summarizes the legal elements within system type and implementation declarations as well as the permitted components that may contain a system. Notice that a system cannot contain a thread or thread group directly; they must be contained in a process.
Table 8-1. Summary of Constraints on System Classifier Declarations
8.2. Abstract
The abstract component category is a generic category that allows you to declare component types and implementations without choosing their runtime category. With this category, you can develop
• Conceptual component-based views of a system architecture
• Generic component-based reference architectures
• Architecture templates or patterns that can be instantiated and applied to an architecture (e.g., a redundancy pattern that is applied as an aspect)
As needed, you can refine these generic declarations into a thread, thread group, process, system, data, subprogram, processor, virtual processor, memory, bus, virtual bus, or device. This technique is especially useful in the early phases of development by providing alternatives for architectural trade-off studies and representations for analysis (e.g., system-wide latency analyses can be conducted without having to define the runtime nature of the components involved).
8.2.1. Representations
The basic forms for abstract component type and implementation declarations are the same as for the runtime-specific component categories. An example is shown in Listing 8-2 that is similar to the system declaration shown in Listing 8-1 but, in addition, includes an abstract subcomponent error_response. The graphical representation associated with the specification is presented in the middle section of the listing. In the lower portion, the declarations are shown that extend the abstract component implementation to the system category. The result is an equivalent description of the system component presented in Listing 8-1.
Listing 8-2. A Sample Abstract Specification: Textual and Graphical Representation
abstract integrated_control
end integrated_control;
--
abstract implementation integrated_control.PBA
subcomponents
control_process: process controller.speed_control;
set_point_data: data set_points;
navigation_system: system core_system.navigation;
real_time_processor: processor rt_fast.rt_processor;
hs_memory: memory rt_memory.high_speed;
high_speed_bus: bus network_bus.HSbus;
error_response: abstract error_manager.real_time;
end integrated_control.PBA;
system integrated_control_sys
extends integrated_control
end integrated_control_sys;
system implementation integrated_control_sys.PBA
extends integrated_control.PBA
end integrated_control_sys.PBA;
8.2.2. Properties
All of the properties available to the other categories apply to an abstract component. However, when an abstract component is refined to a non-abstract category, only those properties that apply to the non-abstract category are valid.
8.2.3. Constraints
Table 8-2 summarizes the legal elements within abstract type and implementation declarations as well as the permitted components that may contain an abstract component.
Table 8-2. Summary of Constraints on Abstract Classifier Declarations
