Josef Templ

Transparent distribution of real-time components based on logical execution time

This paper introduces the notion of transparent distribution of real time software components. Transparent distribution means that (1) the functional and temporal behavior of a system is the same no matter where a component is executed, (2) the developer does not have to care about the differences of local versus distributed execution of components, and (3) the components can be developed independently. We present the design and implementation of a component model for real time systems that is well suited for transparent distribution. The component model is based on logical execution time, which abstracts from physical execution time and thereby from both the execution platform and the communication topology.

Modeling with the Timing Definition Language (TDL)

This paper describes the model-based development process of hard real-time software with the Timing Definition Language (TDL): modeling and simulation of TDL components in Matlab®/Simulink®, their mapping to a specific platform and finally the code generation.

A systematic approach to multiple inheritance implementation

Multiple inheritance is commonly believed to increase the expressive power of a programming language, but to slow down efficiency of message sends even in case of single inheritance. This paper shows that none of these arguments hold. First, a technique to express the effect of multiple inheritance in terms of single inheritance is described. Based on this technique an efficient implementation of multiple inheritance is constructed. The resulting implementation does not slow down single inheritance and, in case of multiple inheritance, is more efficient than widely used implementations.

Model-Driven Development of FlexRay-Based Systems with the Timing Definition Language (TDL)

This paper argues that a logical specification of the timing behavior, which represents the core abstraction of the Timing Definition Language (TDL), is the key to significantly reduce the development, maintenance and integration costs of FlexRay-based systems. We measured a productivity gain by a factor of 20 and more with TDL compared to state-of-the-art FlexRay development methods and tools (see Section 1). We illustrate how TDL allows the platform-independent modeling of the timing and functional behavior, and how we accomplish the automatic platform mapping. An outlook sketches future research activities.

Bus scheduling for TDL components

This paper describes a solution for bus scheduling of distributed multi-mode TDL (Timing Definition Language) components. The TDL compo-nent model is based on the concept of Logical Execution Time (LET), which abstracts from physical execution time and thereby from both the execution platform and the communication topology. The TDL component model allows the decomposition of hard real-time applications into modules (= components) that are executed in parallel. A TDL module runs in one particular mode at a time and may switch to another mode independently from other modules. This is in contrast with global modes as introduced by other available hard real-time systems and introduces new challenges for bus scheduling.

Simulink Integration of Giotto/TDL

The paper first presents the integration options of what we call the Timing Description Language (TDL) with MathWorks’ Matlab/Simulink tools. Based on the paradigm of logical execution time (LET) as introduced by Giotto [2], TDL enhances Giotto towards a component architecture for real-time control applications [9]. The challenge is to provide appropriate visual and interactive modeling capabilities so that the developer can come up with the TDL timing model in the context of Simulink which has established itself as defacto modeling standard for control applications. The paper illustrates by means of a simple case study how we envision an adequate integration of both the TDL and the Simulink modeling approaches.

Simulation of LET models in simulink and ptolemy

This paper describes two different approaches of simulating embedded control software whose real-time requirements are explicitly specified by means of the Logical Execution Time (LET) abstraction introduced in the Giotto project. As simulation environments we chose the black-box MATLAB/Simulink product and the open-source project Ptolemy II. The paper first sketches the modeling of LET-based components with the Timing Definition Language (TDL). As the LET abstraction allows the platform-independent modeling of the timing behavior of embedded software, a correct simulation of TDL components is equivalent to the behavior on a specific platform. We integrated TDL with both MATLAB/Simulink and Ptolemy and highlight the differences and similarities of the particular TDL simulation.

Lock-Free Synchronization of Data Flow between Time-Triggered and Event-Triggered Activities in a Dependable Real-Time System

Time-triggered execution of periodic tasks provides the cornerstone of dependable real-time systems. In addition, there is often a need for executing event-triggered activities while the system would be otherwise idle. If time-triggered and event-triggered activities exchange information among each other, the data flow must be synchronized such that reading unfinished output data is avoided. We present a lock-free solution for these synchronization issues that is based exclusively on memory load and store operations and can be implemented efficiently on embedded systems without any operating system support. We also discuss the implications of our synchronization approach for the semantics of combined time-triggered and event-triggered execution in a dependable real-time system.

Real-time component integration based on transparent distribution

This paper introduces a real-time component model that offers a separation of concerns which allows a straight-forward integration of independently developed components. So-called transparent distribution forms the backbone of the integration process. Transparent distribution means that (1) the functional and temporal behavior of a system is the same no matter on which node of a distributed system a component is executed and (2) the developer does not have to care about the differences of local versus distributed execution of a component. We first present the concepts of a component model for real time systems that is well suited for transparent distribution. The component model is based on logical execution time, which abstracts from physical execution time and thereby from both the execution platform and the communication topology. Then we discuss the resulting tool chain and integration process. A case study rounds out the paper.

Towards a Component Architecture for Hard Real Time Control Applications

This paper describes a new approach towards a component architecture for hard real time control applications as found, for example, in the automotive domain. Based on the paradigm of Logical Execution Time (LET) as introduced by Giotto [1], we adapt the high-level language construct module which allows us to organize and parallelize real time code in the large. Our module construct serves multiple purposes: (1) it introduces a namespace for program entities and supports information hiding, (2) it represents a partitioning of the set of actuators and control logic available in a system, (3) it acts as a static specification of components and dependencies, (4) it may serve as the unit of dynamic loading of system extensions and (5) it may serve as the unit of distribution of functionality over a network of electronic control units. We describe the individual usage cases of modules, introduce the syntax required to specify our needs and discuss various implementation aspects.