8     Features and Shared Access

(1)   A feature is a part of a component type definition that specifies how that component interfaces with other components in the system. 

(2)   Feature groups represent groups of component features.  Feature groups can contain feature groups. Feature groups can be used anywhere features can be used.  Within a component, the features of a feature group can be connected to individually.  Outside a component, feature groups can be connected as a single unit.  Feature groups can be partially defined without specifying the elements to play the role of an abstract feature.  It can later be refined into a group of one or more features.

(3)   Port features represent a communication interface for the exchange of data and events between components.  Ports are classified into data ports, event ports, and event data ports. 

(4)   Subprogram access features represent access to a subprogram to be called from other components, and the need for a component to call a subprogram instance locally, i.e., a subprogram that is declared in the containing process or one of its subcomponents, or to call a subprogram remotely, i.e., a subprogram instance in another process.  When used in data components subprogram access features represent subprograms (methods) through which the data component is manipulated.  When used in subprogram groups subprogram access features represent the subprograms of a subprogram library.

(5)   Subprogram group access features represent sharing and required access to a subprogram library.

(6)   Parameter features represent data values that can be passed into and out of subprograms.  Parameters are typed with a data classifier reference.

(7)   Data access represents communication via shared access to data components.  A data component declared inside a component implementation is specified to be accessible to components outside using a provides access feature declaration.  A component may indicate that it requires access to a data subcomponent declared outside utilizing a requires access feature declaration.

(8)   Bus access represents physical connectivity of processors, memory, devices, and buses through buses.  A bus component declared inside a component implementation is specified to be accessible to components outside using a provides access feature declaration.  A component may indicate that it requires access to a bus utilizing a requires access feature declaration.

(9)   Features can be declared as one-dimensional feature arrays.  Such feature arrays complement component arrays and allow for connection patterns that connect a feature of each of the component array elements to a feature array element of one component. An example use is redundant replicas of a component passing their output to a voting component or a routing component.

Syntax

feature ::=

    ( abstract_feature_spec |
      port_spec | 
      feature_group_spec |
      subcomponent_access_spec |
     parameter_spec )
    [ array_dimension ]
    [ { { feature_contained_property_association }+ } ] ;
 
subcomponent_access_spec ::= 
    subprogram_access_spec | subprogram_group_access_spec 
    | data_access_spec | bus_access_spec
 
feature_refinement ::= 
    abstract_feature_refinement
    port_refinement | 
    feature_group_refinement |
    subcomponent_access_refinement |
    parameter_refinement
    [ array_dimension ]
    [ { { feature_contained_property_association }+ } ] ;
 
subcomponent_access_refinement ::= 
    subprogram_access_refinement | subprogram_group_access_refinement 
    | data_access_refinement | bus_access_refinement

 

Naming Rules

(N1)     The defining identifier of a feature must be unique within the namespace of the associated component type. 

(N2)     Thread features may not be declared using the predeclared ports names Complete or Error.

(N3)     Each refining feature identifier that appears in a feature refinement declaration must also appear in a feature declaration of a component type being extended. 

(N4)     A feature is referenced in one of two ways.  Within the component implementations for a component type, a feature declared in the type is named in the implementations by its identifier.  Within component implementations that contain subcomponents with features, a subcomponent feature is named by the subcomponent identifier and the feature identifier separated by a “.” (dot).

(N5)     The path of a contained property association for a feature must refer to an element of a feature group.

Legality Rules

(L1)      Each feature can be refined at most once in the same type extension.

(L2)      A feature refinement declaration of a feature and the original feature must both be declared as port, parameter, access feature, or feature group, or the original feature must be declared as abstract feature.

(L3)      Feature arrays must only be declared for threads, devices, and processors.

(L4)      If the feature refinement specifies an array dimension, then the feature being refined must have an array dimension. 

(L5)      If the refinement specifies an array dimension size, then the feature being refined must not have an array dimension size.

(L6)      A contained property association must only be used when the feature is a feature group.

(L7)      In the case of a feature with a classifier reference, the classifier of the refined feature declaration in a component type extension must adhere to the classifier refinement rules as indicated by the Classifier_Substitution_Rule property (see Section 4.5).   By default, the Classifier_Match rule applies, i.e., an incomplete classifier reference can be completed.

Standard Properties

Acceptable_Array_Size: list of Size_Range 
Required_Connection_Quality_Of_Service : inherit list of Supported_Connection_QoS
Required_Virtual_Bus_Class : inherit list of classifier (virtual bus)

 

Semantics

(10)  A feature declaration specifies an interaction point with other components.  Features can be connected to features of other components external to the component, and they can also be connected to subcomponents within component implementations associated with the component type with the feature declaration.

(11)  A refined feature declaration may complete an incomplete component classifier reference and declare feature property associations.  A feature refinement may replace a classifier reference according to the Classifier_Substitution_Rule property.

(12)  Features can be declared with an array dimension, if the component is a thread, device, or processor.  In this case, each element of the feature array is connected to a different element of an ultimate source or destination component array.  Feature refinement declarations can complete the array dimension with a size specification, but it cannot change the size. The array dimension and size is inherited by the refined feature, if it is not explicitly declared.

(13)  For example, we may have a voting component that takes input from multiple instances of the same processing component, as shown in Figure 11.  We can declare the processing component as an array of subcomponents, and the single instance of the voting component with a port array.  We can then declare a connection from the outgoing port of the processing subcomponent to the port of the voting component declared with array dimensions.  The connection can have a Connection_Pattern property of One_To_One (see Section 9.2.3) to indicate that each processing component output is connected to a separate port of the voting component.  This is illustrated in the example below.

Figure 11 Port Array in a Voting Pattern

(14)  A feature may specify desired quality of service or a particular protocol to be used for connections through the feature.  This property must be consistent with the same property associated with the connection.