Wolfgang Haberl

Optimizing Automatic Deployment Using Non-functional Requirement Annotations

Model-driven development has become common practice in design of safety-critical real-time systems. High-level modeling constructs help to reduce the overall system complexity apparent to developers. This abstraction caters for fewer implementation errors in the resulting systems. In order to retain correctness of the model down to the software executed on a concrete platform, human faults during implementation must be avoided. This calls for an automatic, unattended deployment process including allocation, scheduling, and platform configuration.

Model-Level Debugging of Embedded Real-Time Systems

Model-driven development has become the state- of-the-art approach for designing embedded real-time systems. Due to their high level of abstraction, models are easier to understand and verify, thus leading to less faulty systems. But even when combined with automatic code generation, there is still the risk of unintended behavior. This may, for example, arise from real sensor inputs which differ from the characteristics assumed in the model. Consequently, debugging techniques still play an important role, even in model-driven development processes. However, debugging a system on the embedded target platform is tedious because of the limited user interface. In this paper, we present an approach for capturing runtime data on the target platform and mapping them back to the model. Debugging can then be performed at model-level by visualizing actual input data, like feedback from the target platform’s environment. Using a case study, we demonstrate a realization of our approach.

Automatic generation of systemc models from component-based designs for early design validation and performance analysis

In this paper we present an approach of generating SystemC executable models from software designs captured in a new component-based modeling language, COLA, which follows the paradigm of synchronous dataflow. COLA has rigorous semantics and specification mechanisms. Due to its well-founded semantics, it is possible to establish an integrated development process, the artifacts of which can be formally reasoned about and are dealt with in automated tools such as model checkers and code generators. However, the resulting models remain abstract and cannot be executed immediately. Therefor SystemC offers executable models of a component-based flavor. Establishing an automated translation procedure from COLA to SystemC thus allows for design validation and performance analysis during early design phases. We have validated our approach on a case study taken from the automotive domain.

Model-level simulation for COLA

Model-driven development has become the standard approach for the development of avionic and automotive embedded systems. When a semantically founded modeling language is employed, the implemented systems can be checked and further processed in an automated manner. To this end, the Component Language (COLA) was invented. It allows for the definition of all information needed during system development. For a better understanding, and also debugging, of the systems modeled therewith, simulation at the level of the model is a welcome complement. In this paper we present a model-level simulator for COLA. It follows the languages semantics closely, thus guaranteeing the same behavior as specified in the model and implemented by other tools based on COLA. Furthermore, its modular nature allows for the use of different sources for input data. We will demonstrate the architecture and abilities of our simulator, using parts of a recent case study throughout the paper.

Seamless model-driven development put into practice

Model-driven development (MDD) today is the most promising approach to handle the complexity of software development for distributed embedded systems. Still, no single tool-chain exists that meets all needs of companies employing MDD. Moving back and forth between the tools in todays iterative development processes thus requires manual integration steps, which are error-prone and hamper reuse and refinement of models. A possible workaround is developing adapters for each pair of tools. Despite its large overhead, industry started pursuing this approach because of a lack of better alternatives. A proper solution is a tool-chain building on an integrated modeling language. We have realized this in cooperation with BMW Research and Technology. To increase the degree of automation during development, the modeling language builds upon a core featuring a rigorous semantics. This enables automatic analysis, facilitating an automatic transition from model-based designs to a distributed system running on the target platform.

Reliable operating modes for distributed embedded systems

Hard real-time embedded distributed systems pose huge demands in their implementation which must contain as few faults as possible. Over the past years, model-driven development and automatic code generation have proven to effectively reduce design faults in those systems. Still, models are mainly used for parts of the systems functionality and most solutions do not address the generation of a whole system. In this paper we will showcase an approach for code generation for entire systems. A crucial step is the semantically correct realization of operating modes defined in the model. If they are not changed synchronously, a distributed system will show unpredictable behavior. We will demonstrate how a reliable transition between operating modes, even for a distributed system, can be achieved. Our approach is exemplified using a case study we carried out recently.

Generating Distributed Code From COLA Models

Model driven development (MDD) is well established as a means of tackling the complexity involved in designing such distributed embedded systems. The complexity of the modeled system not only necessitates proper abstractions, but also calls for automation to take a model to an executable object, and later to a functional integrated system. An automated translation reduces errors, guarantees reproducible results, and thus improves overall quality. We focus on automation of the translation steps. Using COLA, we need not handle a multitude of heterogeneous models, but rather benefit from the consistent modeling formalism and start with a single, behavioral, model. It provides a clustering of application components which define the tasks that must be allocated to hardware nodes contained in the platform model. The obtained executables are tailored towards the specific platform and require no further manual intervention before effective installation (flashing) onto the target hardware system.

SysCOLA: a framework for co-development of automotive software and system platform

A modeling language with formal semantics is able to capture a systems functionality unambiguously, without concerning implementation details. Such a formal language is well-suited for a design process that employs formal techniques and supports hardware/software synthesis. On the other hand, SystemC is a widely used system level design language with hardware-oriented modeling features. It provides a desirable simulation framework for system architecture design and exploration. This paper presents a design framework, called SysCOLA, that makes use of the unique advantages of both a new formal modeling language, COLA, and SystemC, and allows for parallel development of application software and system platform. In SysCOLA, function design and architecture exploration are done in the COLA based modeling environment and the SystemC based virtual prototyping environment, respectively. Our concepts of abstract platform and virtual platform abstraction layer facilitate the orthogonalization of functionality and architecture by means of mapping and integration in the respective environments. As SysCOLA is targeted at the automotive domain, the whole design approach is showcased using a case study of designing an automotive system.

Towards a personalized and distributed in-car infotainment experience using the open and web-based webinos middleware

Emerging cloud services provide users the device- and location agnostic access to their applications and personal data. With growing customer demand for personalized in-vehicle infotainment (IVI) the seamless access to personal data will play a crucial role in the success of upcoming IVI-systems. A seamless access, however, is tied to specific consumer electronic (CE)-device ecosystems and requires the storage of personal data in the backend infrastructure of the chosen ecosystem. An open and user-controlled middleware is missing. This paper present the webinos middleware for enabling the execution of applications across heterogeneous devices such as IVI-systems, smartphones, tablets, PCs and home media centers. By avoiding the storage of personal data in the backend infrastructure, users stay in control over their personal data. We evaluate the feasibility of our approach in respect for in-car scenarios with a prototype implementation of a browser-based Point-of-Interests manager on top of the webinos middleware. The application runs on three different device types - pc, smartphone/tablet and IVI-system.

A Simulation Approach for Performance Validation during Embedded Systems Design

Due to the time-to-market pressure, it is highly desirable to design hardware and software of embedded systems in parallel. However, hardware and software are developed mostly using very different methods, so that performance evaluation and validation of the whole system is not an easy task. In this paper, we propose a simulation approach to bridge the gap between model-driven software development and simulation based hardware design, by merging hardware and software models into a SystemC based simulation environment. An automated procedure has been established to generate software simulation models from formal models, while the hardware design is originally modeled in SystemC. As the simulation models are annotated with timing information, performance issues are tackled in the same pass as system functionality, rather than in a dedicated approach.