![]() ![]() |
||||
|
||||
Informative
Definitions of terms used from other standards, such
as the IEEE Standard Glossary of Software
Engineering Terminology [IEEE Std. 610.12-1990], ISO/IEC 9945-1:1996 [IEEE/ANSI Std 1003.1,
1996 Edition], Information Technology Portable Operating System Interface (POSIX), Unified
Modeling Language Specification [UML 2004, version 1.4.2], or the IFIP WG10.4 Dependability:
Basic Concepts and Terminology [IFIP WG10.4-1992] are so marked. Terms not defined in this
standard are to be interpreted according to the Webster's Third New International Dictionary of the
English Language.
Aggregate Data Port: [AADL] An aggregate data
port is an extension of the port group feature. An
aggregate data port makes a collection of data from multiple thread out data available in a time-
consistent manner.
Ancestor: [AADL] An ancestor in the component
extension hierarchy is a component type or
component implementation that (directly or indirectly) has been extended to the given component
type or implementation.
Annex: [AADL] An approved extension to the core
AADL standard.
Annex Subclause: [AADL] An annex-specific subclause
expressed in an annex-specific notation or
sublanguage. Annex subclauses can be declared in component types and component
implementations.
Annex Library: [AADL] A reusable declaration in
an annex-specific notation or sublanguage. Annex
libraries can be declared in packages.
Anomaly: [IFIP, AADL] An anomaly occurs
when a component is in an erroneous or failed state
that does not result in a standard exception.
Application: [IEEE, AADL] Software designed to
fulfill specific needs of a user.
Architecture: [IEEE, AADL] An architecture
represents the organizational structure of a system or
component.
Binding-dependent Implementation: [AADL] A binding-dependent
implementation of a
subcomponent is determined after the binding to an execution platform component is fixed.
Behavior: [AADL] A behavior is a description
of sequencing of various kinds that may occur in a
component. Examples are execution sequences of subprograms, end-to-end sequencing of data
and event flow, the interaction between components, or a specification of mode transitions.
Behaviors describe how various fault events cause a component to transition between various error
states. Behaviors are nameable objects in specifications and have properties.
Binding: [AADL] A binding establishes a
many-to-one hosted/allocated relationship between
components using resources and those representing resources. In particular, it maps application
components to execution platform components.
Bus: [AADL] A bus is a category
of component used to model a communication channel, typically
hardware together with communication protocols that can exchange control and data between
memories, processors, and devices. Depending on the properties of the bus, a bus may be used
to access a memory or device. A bus may be used to send data messages between processors.
Connections may be bound to buses.
Component: [AADL] A component is a hardware,
software, or system unit used as a part of some
system. A component belongs to a component category. Each component has a name (also
called its defining identifier) and has categoryspecific properties that can be
assigned values. A
fully defined component is an instance of a component type and has an implementation.
Component Category: [AADL] A component category
is either the name of a kind of execution
platform component (e.g. processor), a software component (e.g. process), or a composite
component (e.g. system). The AADL defines several categories for software components: process,
thread group, thread, subprogram, data. Several categories are also defined
for execution platform
components: processor, memory, bus, and device. The composite category
only defines the
system component category.
Component Classifier: [AADL] A component classifier
is a language element that defines one or
more components regarded as forming a group by reason of the same structure and behavior.
The
classifier is a reusable description of the structure and behavior used to define one or more
components. There are two kinds of classifiers: component type and component
implementation.
A component classifier belongs to a particular component category.
Component Classifier Reference: [AADL] A component
classifier reference is a uniquely named
reference to a component type or to a component type and implementation pair.
Component Extension: [AADL] A component extension
allows a component classifier to be defined
in terms of an existing component classifier through addition of features, subcomponents, property
associations, connections, and behaviors, while inheriting the elements of the component being
extended.
Component Implementation: [AADL] A component
implementation is a component classifier that
describes an internal structure (subcomponents, features, connections), properties, and behaviors
of a component. A component type can have several implementations.
Component Instance: [AADL] Another name for component.
Component Type: [AADL] A component type
is a kind of component classifier that describes a
components visible functional and behavioral interface. The component type describes
the
provided features and accessible components of an instance of the type that other components
may use. The component type also specifies the features and components required to create
each
instance of itself.
Configuration: [IEEE] The arrangement of a computer
system or component as defined by the
number, nature, and interconnections of its constituent parts. [AADL] The set of components and
connections that are active in the current mode.
Connection: [AADL] A connection is a link
between the features of two components over which
data, events, or subprogram calls can be exchanged.
Connections are directional.
Data: [IEEE] A representation of facts, concepts,
or instructions in a manner suitable for
communication, interpretation, or processing by humans or automatic means.
Data Port: [AADL] A data port is a port
through which data is transferred in unqueued form. It
represents a variable declared in source text.
Data Subprogram: [AADL] A subprogram that
provides an interface to a data component.
Data Type: [IEEE] A class of data, characterized
by the members of the class and the operations
that can be applied to them.
Declaration: [IEEE] A non-executable language
statement that affects the assemblers or
compilers interpretation of other statements. [AADL] A language statement that introduces a
component classifier, component instance, feature, connection, or property.
Delayed Connection: [AADL] A connection between
two data ports, where the data is transferred at
the deadline of the originating thread. This results in deterministic communication of state data
and receipt of data in a phase-delayed manner.
Descendent: [AADL] A descendent in the
component extension hierarchy is a component type or
component implementation that (directly or indirectly) extends the given component type or
implementation.
Deterministic: [IEEE] Pertaining to a process,
model, or variable whose outcome, result, or value
does not depend on chance.
Deterministic Communication: [AADL] Communication
of state data between periodic threads in
predictable order.
Device: [AADL] A device models components
that interface with an external environment, i.e.,
exhibit complex behaviors that require a nontrivial interface to application software systems.
A
device cannot directly store and execute binary images associated with software process
specifications. Software components can communicate with devices via ports. Examples of
devices are sensors and actuators that interface with the external physical world, or standalone
systems such as a GPS that can interface with an application system.
Dispatch Point: [AADL] For periodic threads: any
non-negative integral multiple of the period
following the transition out of the loaded
process state. For sporadic and aperiodic threads:
the
arrival of an event or event data at an event or event data port of the thread, or the arrival of a
remote
subprogram call at a server subprogram feature of the thread following the transition out of the
loaded process
state.
Error: [IFIP, AADL] An error in a physical
component occurs when an existing fault causes the
internal state of the component to deviate from its nominal or desired operation. For example,
a
component error may occur when an add instruction produces an incorrect result because a
transistor in the adding circuitry is faulty.
Error Latency: [AADL] The period of time a component
may persist in an erroneous state before a
failure occurs.
Error Model: [AADL] An error model is a
behavior that describes responses to faults and errors
(which occur in components and state transitions) in a probabilistic manner.
Error Propagation: [AADL] Error propagation
occurs when a failed component causes the
containing system or another dependent component to become erroneous.
Event: [Webster] An outcome or occurrence.
Event Port: [AADL] Port through which events are
passed between components. Events may be
queued at the receiving end.
Event Data Port: [AADL] Port through which data
is passed between components, whose transfer
implies the passing of an event. Event data may be queued at the receiving end.
Exception: [IFIP, AADL] An exception represents
an error condition that changes the behavior of a
component. An exception may occur for an erroneous or failed component when that error or failure
is detected, either by the component itself or by another component with which it interfaces.
Execution Platform: [AADL] A combination of hardware
and software that supports the execution of
application software through its ability to schedule threads, store source text code and data, and
perform communication modeled by connections. This combination would typically include runtime
support (O/S or language runtime environment) and the specific hardware.
Execution Platform Component: [AADL] A component
of the execution platform.
Failure: [IFIP, AADL] A failure in a physical
component occurs when an error manifests itself at the
component interface. A component fails when it does not perform its nominal function for the other
parts of the system that depend on that component for their nominal operation.
Fault: [IFIP, AADL] A fault is defined
to be an anomalous undesired change in thread execution
behavior, possibly resulting from an anomalous undesired change in data being accessed by that
thread or from violation of a compute time or deadline constraint. A fault in a physical
component
is a root cause that may eventually lead to a component error or failure. A fault is often a specific
event such as a transistor burning out or a programmer making a coding mistake.
Fault Latency: [AADL] The period of time before
a component may persist in a faulty state before
an error occurs.
Feature: [AADL] A feature models a characteristic
or a component that is externally visible as part
of the component type. A feature is used to establish interaction with other components. Features
include: ports and port groups to support flow of data and control, access to data components and
bus components to support coordination of access to shared data components, subprograms to
represent entry points, and parameters to represent the data values that can be passed into and
out of subprograms.
Immediate Connection: [AADL] A connection
between two data ports, where the execution of the
receiving thread is delayed until the sending thread completes execution and data is transferred at
that time. This results in deterministic communication of state data and receipt of data in mid-
frame, i.e., within the same dispatch of both the sending and receiving thread.
Implementation: [IEEE] The result of translating
a design, i.e., architecture, components,
interfaces, and other characteristics of a system or component, into hardware components,
software components, or both.
Instance: [AADL] An individual object of a class
that is indicated by a component classifier.
Instantiation: [IEEE] The process of substituting
specific data, instructions, or both into a generic
program unit to make it usable in a computer program.
Interface: [IEEE] 1) A shared boundary across
which information is passed; 2) A hardware or
software component that connects two or more other components for the purpose of passing
information from one to the other; 3) To connect two or more components for the purpose of
passing information from one to the other; 4) To serve as a connecting or connected component as
in (2). [UML] A named set of operations that characterize the behavior of an element.
Memory: [AADL] A memory is a category of
component used to model randomly addressable
physical storage or logical storage. A memory component may be contained in a platform, or may
be accessible from a platform via a bus.
Mode: [AADL] A mode models an operational
mode in the form of an alternative set of active
threads and connections and alternative execution behavior within threads. A mode behavior
models dynamic mode changes by declaring runtime transitions between operational modes as the
result of events. Mode specifications can be hierarchical; sub-moding and concurrent
reconfiguration of different subsystems can be specified.
Model: [UML] An abstraction of a physical system,
with a certain purpose.
Noncompliance: [IFIP, AADL] Noncompliance
of a component with its specification is a kind of
design fault. This may be handled by run-time fault-tolerance in an implemented physical system.
A developer is permitted to classify such components as anomalous rather than noncompliant.
Package: [AADL] A package defines a namespace
for component type and component
implementation declarations and allows them to be logically organized into a hierarchy. Packages
can control visibility of declarations by declaring them public or private.
Physical System: [UML] 1) Subject of a model;
2) A collection of connected physical units, which
can include software, hardware, and people, that are organized to accomplish a specific purpose.
[AADL] The system being modeled by an AADL specification. This includes software components,
execution platform components, including interfaces to the external environment, and system
components.
Port: [AADL] Ports are connection points
between components that are used for directional transfer
of data, events, or both. Data transferred through ports is typed.
Port Connection: [AADL] Port connections
represent directional transfer of data and control
between data, event, and event data ports of components. The endpoints of such a connection are
threads, devices, or processors.
Port Group: [AADL] A grouping of ports
or port groups. Outside a component a port group is
treated as a single unit. Inside a component the ports of a port group can be accessed individually.
Port groups allow collections of ports to be connected with a single connection.
Predictable: [Webster] Determinable in advance.
Private: [AADL] Declarations contained
in a package that can only be referenced from within the
package.
Process: [IEEE] An executable unit managed by
an operating system scheduler; [POSIX] a
conceptual object with an address space, one or more threads of control executing within that
address space, a collection of system resources required for execution, and possibly other
attributes. [AADL]: A process represents a space partition in terms of virtual address spaces
containing source text that forms complete programs. A process contains threads as concurrent
units of execution scheduled to execute on processors.
Processor: [AADL] A processor is an abstraction
of hardware and software that is responsible for
scheduling and executing threads. Processors may contain memory and may access memory and
devices via buses.
Program: [AADL] A program is a body of source
text written in a standard programming language
that can be compiled, linked and loaded as an executable image. A program has a self-contained
namespace (no source names appear that are not declared within that program or are part of the
language standard). The complete set of source files associated with a process must form a legal
program as defined by the applicable programming language standard.
Property: [AADL] A property is a named
value associated with an AADL component, connection,
flow, or feature. Every property has a name and can be assigned a value of a specific type in
a
specification. There is a standard set of properties for each category of component, connection,
flow or feature, e.g. thread components have a Period property that can be assigned a time value.
Implementations, components, features, connections, and behaviors have properties. Non-
standard property names may be defined and used in a specification, this is the primary means
available to create non-standard extensions to the language.
Property Set: [AADL] A new set of properties and
property types as extension to existing
categories of components, features, behaviors, and connections.
Property Type: [AADL] The type of values that
can be associated with a property.
Property Value Association: [AADL] A property
value association is a statement in the language
that associates a value with a named property. In some cases a property value may be overridden.
Public: [AADL] Declarations contained
in a package that can be referenced from within another
package or component.
Qualified Name: [AADL] A qualified name uniquely
identifies the component classifier identifier with
a package name separated by a double colon (::). Only the public package namespace
is used
to resolve these references.
Reconfiguration [AADL] Transition from one mode
to another resulting in a change from one
component and connection configuration to another.
Server Subprogram: [AADL] A subprogram
that executes in its own thread and can be called
remotely.
Shared Component: [AADL] A component that is directly
accessible to two or more components.
Software Component: [AADL] A software component
is a component that represents software, i.e.,
source text describing a program or procedure in an implementation language, and represents the
units of concurrency of an application in terms of its threads and processes.
Source Text: [AADL] Refers to a body of text written
in a conventional programming language such
as Ada 95 or C, written in a domain-specific modeling language such as MatLab®/Simulink®,
or
written in a hardware description language such as VHDL.
Specification: [AADL] An AADL source file
that specifies, in a complete or legally partial manner, a
set of requirements, design, behavior, or other characteristics of a system or component.
Subcomponent: [AADL] A component declared inside
a component implementation that represents
the application system or the execution platform. A subcomponent that belongs to the system
category is also known as a subsystem.
Subprogram: [AADL] A subprogram is a category
of component used to model source text and
images that have a single entry point that can be called by a thread. Subprograms have no
statically allocated variables. A data subprogram can be declared as a feature of a data
component. A server subprogram may be declared as a feature of a thread, thread group, process,
processor or system.
System: [AADL] A system is an integrated
composite that consists of one or more hardware,
software, or system components. System is the name of a component category.
Task: [IEEE] 1) A sequence of instructions treated
as a basic unit of work by the supervisory
program of an operating system; 2) A software component that can operate in parallel with other
software components.
Thread: [AADL] A thread is used to model
a physical thread of execution. A thread communicates
with other threads through ports. Threads can have different dispatch protocols such as periodic,
aperiodic, sporadic, and background.
Type: [IEEE] A class characterized by the individual
members of the class and the operations that
can be applied to them. [Webster] Qualities common to a number of individuals that distinguish
them as an identifiable class. [AADL] In this standard the term type is used to characterize
three
classes: component type, property type, data type. |
||||