Package Common Control Interfaces

2.3.4Package Common Control Interfaces

2.3.4.1Overview

1. 
   sequential behavior, in which a single flow of control at a time may pass an interface;
   
2. 
   concurrent behavior, in which multiple flows of control can pass an interface concurrently.
   

1. 
   Multiple flows of control are frequently implemented by in-process threads but can also be provided by interrupt handlers or other operating system features. In this Recommended Practice, the term ‘thread’ is used in a broader sense referring to any kind of flow of control.
   
2. 
   The terms ‘sequential’ and ‘concurrent’ have been adopted from the characteristics defined in UML for operations. However, the meaning of ‘sequential’ is slightly more restrictive and the term ‘concurrent’ as used in this Recommended Practice maps to ‘concurrent or guarded’ in UML.
   

A component providing a specific behavior for its interfaces exports an associated control interface to start and terminate processing of the component. These control interfaces are defined by the package Common Control Interfaces. The interface ISLE_Sequential is supported by components providing sequential behavior and the interface ISLE_Concurrent is supported by components providing concurrent behavior.

For the sequential interface behavior, this Recommended Practice also defines interfaces by which the client offers means for components to wait for external events and to handle timers. Components providing concurrent behavior are expected to handle external events and timers internally.

In addition, this package defines an interface to start and stop diagnostic traces, which is implemented by all components providing that option.

2.3.4.2Sequential Behavior

2.3.4.2.1Definitions

Because of these restrictions, components providing sequential interface behavior cannot wait for external events or timers without blocking the client. Therefore the client provides specific interfaces for monitoring of events and handling of timers on behalf of the component.

The application or API components using interfaces of lower layer API components with sequential behavior ensure that methods of these interfaces are invoked sequentially. Use of multiple threads by clients is not excluded, but access to the interface must be strictly serialized.

2.3.4.2.2Sequential Control Interface

2.3.4.2.2.1General

The component class ‘Controlled Component’ is actually a placeholder for a component class that provides the interface ISLE_Sequential. This can be the component class API Proxy or the component class API Service Element. Processing of the methods to start and terminate operation is described in the packages API Proxy and API Service Element.

Figure 2 99: Sequential Control Interface Component Class Controlled Component

2.3.4.2.2.2Exported Interfaces

2.3.4.2.2.3Dependencies

2.3.4.2.3Component Class Event Monitor

2.3.4.2.3.1General

2.3.4.2.3.2Exported Interfaces

2.3.4.2.3.3Dependencies

2.3.4.2.4Component Class Event Processor

2.3.4.2.4.1General

2.3.4.2.4.2Exported Interfaces

2.3.4.2.5Component Class Timer Handler

2.3.4.2.5.1General

2.3.4.2.5.2Exported Interfaces

2.3.4.2.5.3Dependencies

2.3.4.2.6Component Class Timeout Processor

2.3.4.2.6.1General

2.3.4.2.6.2Exported Interfaces

2.3.4.3Concurrent Behavior

2.3.4.3.1Definitions

NOTE – When multiple threads access object data or global data within the component, at least access to these data must be serialized using some kind of guard.

It is expected that components providing concurrent interface behavior use multiple threads of control internally. Therefore they are able to wait for external events and timers without affecting their clients.

Clients of an interface with concurrent behavior must expect that the methods of the complementary interface are called by concurrent flows of control.

When SLE protocol data units are passed across an interface with concurrent characteristics, sequence preservation is not guaranteed when PDUs are passed in one direction by more than one thread. Therefore this Recommended Practice foresees sequence counts that allow the receiver to re-sequence PDUs. Although the actual need for sequence counting depends on the implementation of a multi-threaded component, this Recommended Practice requires that sequence counts be always used on an interface with concurrent behavior.

2.3.4.3.2Concurrent Control Interface

The component class ‘Controlled Component’ in figure 2 -10 is actually a placeholder for a component class that provides the interface ISLE_Concurrent. This can be the component class API Proxy or the component class API Service Element. Processing of the methods to start and terminate operation is described in the packages API Proxy and API Service Element.

Figure 2 1010: Concurrent Control Interface

2.3.4.4Trace Control Interface

2.3.4.5Interfaces Defined by the Package

2.3.5Package SLE Application

2.3.5.1Overview

The obligations of the application and the interfaces it provides are described in this model by a set of classes that are assumed present in the application program. These classes are pure modeling constructs and do not prescribe the design and implementation of the application in any way.

Figure 2 -11 shows the classes provided for actual service provisioning. The model assumes that every service instance is handled by an instance of the class API Application Instance. This class defines the functionality that is independent of the user or provider role and the specific SLE transfer service type. Specific derived classes are assumed for every service type and role. These are represented by the classes User Application and Provider Application in the figure.

Figure 2 1111: Structure of the Package SLE Application

Interfaces that must be provided by the application for logging, for notification of events, and for diagnostic traces, are shown in figure 2 -12. The model assumes a class that accepts log records and notifications (Reporter) and a class that accepts trace records (Trace). The model does not make any assumptions about the number of objects an application uses.

Figure 2 1212: Reporting and Tracing Interfaces Provided by the Application

Finally, applications have the option of supplying an external time source to the API components. To use this option, applications must provide an implementation for the interface ISLE_TimeSource (Component Class Time Source) and pass it to the creator function of the component SLE Utilities (see 2.3.7). If the interface is supplied by the application, the component uses the interface to retrieve current time. Otherwise, it uses system time.

In addition to the tasks discussed in this section, the application is responsible for configuration, initialization and shutdown of API components. These tasks are discussed in more detail in annex A.1.65.1.1.1.1.1.

2.3.5.2Component Class SLE Application Instance

2.3.5.2.1General

The application instance creates the service instance in the service element using the interface ISLE_SIFactory and configures the service instance using the interface ISLE_SIAdmin. For invocations of SLE operations, the class uses the interface ISLE_SIOpFactory to create the required operation objects.

2.3.5.2.2Exported Interfaces

2.3.5.2.3Dependencies

2.3.5.3 Internal Class User Application