Dietmar Schreiner

Explicit Connectors in Component Based Software Engineering for Distributed Embedded Systems

The increasing complexity of todays embedded systems applications imposes the requirements and constraints of distributed, heterogeneous subsystem interaction to software engineers. These requirements are well met by the component based software engineering paradigm: complex software is decomposed into coherent, interacting units of execution, the so called components. Connectors are a commonly used abstraction to model the interaction between them. We consequently contribute with the application of explicit connectors for distributed embedded systems software. Explicit connectors encapsulate the logic of distributed interaction, hence they provide well defined contracts regarding properties of inter-component communication. Our approach allows model level validation of component composition and interaction incorporating communication related constraints beyond simple interface matching. In addition, by using explicit connectors, the complexity of application components is reduced without the need for any heavy weight middleware. In fact, the set of all deployed explicit connectors forms the smallest possible, custom tailored middleware.

Refactoring an Automotive Embedded Software Stack using the Component-Based Paradigm

The number of electronic systems in cars is continuously growing. Electronic systems, consisting of so-called electronic control units (ECUs) interconnected by a communication network, account for up to 30% of a modern cars worth. Consequently, software plays an ever more important role, both for the implementation of functions and the infrastructure. In order to benefit from the reuse of software modules, the major automotive companies have standardized a large number of these modules in the context of the AUTOSAR consortium. In this paper we propose the refactoring of the AUTOSAR stack of system software modules by applying the component-based paradigm in order to increase the scalability of the software stack according to the particular requirements of the application. We demonstrate the feasibility of this approach by performing the refactoring of the modules FlexRay Driver and FlexRay Interface as an example and by deploying the resulting refactored components in a sample automotive application. Finally, we measure the execution time as well as the memory consumption of the refactored components and compare these measures to the measures obtained from the corresponding ordinary AUTOSAR modules.

Practical experiences of applying source-level WCET flow analysis on industrial code

Code-level timing analysis, such as Worst-Case Execution Time (WCET) analysis, takes place at the binary level. However, much information that is important for the analysis, such as constraints on possible program flows, are easier to derive at the source code level since this code contains much more information. Therefore, different source-level analyses can provide valuable support for timing analysis. However, source-level analysis is not always smoothly applicable in industrial projects. In this paper we report on the experiences of applying source-level analysis to industrial code in the ALL-TIMES FP7 project: the promises, the pitfalls, and the workarounds that were developed. We also discuss various approaches to how the difficulties that were encountered can be tackled.

Practical experiences of applying source-level WCET flow analysis to industrial code

Code-level timing analysis, such as worst-case execution time (WCET) analysis, usually takes place at the binary level. However, many program properties that are important for the analysis, such as constraints on possible program flows, are easier to derive at the source code level since this code contains much more information. Therefore, various source-level analyses can provide valuable support for timing analysis. However, source-level analysis is not always smoothly applicable in industrial settings. In this paper, we report on the experiences of applying source-level analysis to industrial code in the ALL-TIMES project: the promises, the pitfalls, and the workarounds that were developed. We also discuss various approaches to how the difficulties that were encountered can be tackled.

Adding Timing-Awareness to AUTOSAR Basic-Software -- A Component Based Approach

AUTOSAR as specified in its current version fosters timing-constraints at application level to support the development of real-time automotive applications. However, the standards actual specification does not consider any timing information for its Basic Software. In consequence, the over-all timing-behavior of software running at a specific system node can not be calculated and thus validated at development-time. Even worse, any exchange or modification of Basic Software modules induces unpredictable alteration in system timing, and may even lead to a severe miss of execution deadlines. Within this paper we solve this issue by using a component based Basic Software architecture, as much as timing-aware software composition for Basic Software components. We therefore introduce timing contracts as enhancement for existing interface contracts, specify a timing annotation language on a conceptual level, and demonstrate how to capitalize on our approach by calculating timings within composed Basic Software architectures at development time.

Source Code Based Component Recognition in Software Stacks for Embedded Systems

Current trends in embedded systems software aim at an increase of reusability, exchangeability and maintainability and thus at a significant reduction of time- and costs-to-market. One way to reach these goals is the adaption of Component Based Software Engineering (CBSE) for the embedded systems domain. Unfortunately most existing embedded systems applications are realized as coarse-grained layered or even monolithic software that can hardly be reused. This paper demonstrates how to recognize reusable and exchangeable components within existing typically monolithic or stacked embedded systems software via a semi-automatic analysis of the systems source code. The complexity of the proposed analysis is kept linear to code size by utilizing expert-knowledge on the application-domain, and deployment specific configuration data. To prove our approach, a functional decomposition for an existing automotive middleware stack is calculated and is finally compared to a human designed one.

A Unified Benchmarking Process for Components in Automotive Embedded Systems Software

During the last years, component based software development has become a well accepted software engineering paradigm within the automotive industry. This fact is not only reflected by upcoming development tools but also by newly arising automotive software standards. In component based software engineering, applications are built by assembling small reusable building blocks, the components. Typically more than one component implementation meets the application developers requirements, so proper selection of the assembled components becomes a key element of the whole procurement and engineering process. This papers contribution is twofold: First, a basic set of performance and dependability metrics and measures for automotive components is identified. Second, a unified benchmarking process is proposed, that allows an unambiguous comparison of distinct component implementations of a given component class.

Component Based Middleware-Synthesis for AUTOSAR Basic Software

Distributed real-time automotive embedded systems have to be highly dependable as well as cost-efficient due to the large number of manufactured units. To close the gap between raising complexity and cutting costs, upcoming software standards like AUTOSAR introduce a clear separation of concerns into their system architecture. An AUTOSAR application is built from components that deal with business logic only whereas infrastructural services are provided by standardized middleware. Unfortunately, this middleware tends to be heavy-weight due to its coarse-grained layered design. By applying a component based design to AUTOSARs middleware, a custom-tailored version for each specific application and system node can be built to overcome this problem. This paper demonstrates how to automatically synthesize component based middleware via the Connector Transformation: Component connectors in platform independent application models are utilized to automatically assemble platform- and application specific middleware. As a result, AUTOSAR middleware becomes custom-tailored and hence light-weight and flexible. In addition, the described synthesis algorithm is capable of incorporating timing annotations via interface contracts at model level, and thus reflects upcoming ambitions to cover real-time constraints at middleware level within AUTOSAR. To prove our approach we successfully synthesized middleware for a demonstrator application and compared it to its conventional counterpart.

Modeling component based embedded systems applications with explicit connectors in UML 2.0

When building a system by connecting components, the connection itself, the connector, becomes a hot-spot of abstraction for any interaction. In contrary to most existing component models, we introduce explicit connectors as first class architectural entities. They materialize detailed contracts regarding composition, deployment and interaction and hence provide fine granular information on composed structures. Using explicit connectors results in customtailored and consequently light-weight middleware, as any interaction logic is contained within them. Modeling component architectures with explicit connectors allows the usage of off-the-shelf connector libraries. Thereby, developing a distributed component based application becomes less complex and more competitive due to reduced costs and increased reliability. We contribute by adopting a model driven development process for the use of explicit connectors by extending the syntax of UML 2.0 and defining a set of required model transformations.

Building Component Based Software Connectors for Communication Middleware in Distributed Embedded Systems

Interaction in distributed component based software-architectures can become a rather complex and error prone issue. As it is good practice to keep application concerns separated from infrastructural ones, component based applications typically rely on communication middleware to cope with matters of distribution and heterogeneity. Unfortunately, generic middleware tends to be monolithic, heavyweight software, which is unacceptable in resource constrained embedded systems. Communication middleware for distributed embedded systems has to be custom tailored to the application’s interaction needs and therefore shall be as lightweight as possible. By applying the component paradigm to the communication middleware, a practical methodology can be defined, that allows the middleware’s automatic generation from the application’s architectural models and structural designs of explicit component connectors with a well defined set of prefabricated basic building blocks—so called communication primitives. This paper contributes by specifying the most common structural designs for explicit connectors within the automotive domain and thereby, in addition identifies a set of classes of automotive communication primitives. Thus this paper provides the sound foundation for automatic, model driven middleware synthesis by specifying all necessary basic modules.Copyright