Kristian Sandström

Handling interrupts with static scheduling in an automotive vehicle control system

The requirements of industrial applications only rarely permit the exclusive use of single paradigms in the development of real-time systems. Product cost, reuse of existing solutions, and efficiency require diverse, or even opposing methods to coexist or to be integrated. In this paper, we deal with one problem encountered during the development of a real-time system for motion control in automotive vehicles, the integration of static scheduling and interrupts. The user mandates pre run-time scheduling for a number of reasons, e.g., predictability, testability and low run-time overhead. However, the interrupt overhead cannot be ignored in a safety critical system, and therefore has to be accounted for when creating a static schedule. We propose a method that combines static scheduling and run-time interrupts by applying standard static scheduling techniques and exact analysis. The appropriateness of this method is underlined by successful industrial deployment.

Frame packing in real-time communication

A common computational model in distributed embedded systems is that the nodes exchange signals via a network. Most often, a signal represents the state of some physical device and has a signal size ranging from a single bit up to a few bytes. Furthermore, each signal typically has a deadline requirement. The communication networks used are often based on a broadcast bus where fixed or variable sized frames are transmitted. The amount of data that can be transmitted in each frame is almost always bigger than the size of a signal. Thus, from a resource perspective it would be desirable if each frame could transport several signals. The authors investigate how to assign signals to periodic frames with the objective function to minimise the network bandwidth requirement while not violating specified deadlines. This problem is NP-hard, but can for most typical applications be solved efficiently by using simple heuristics. The effectiveness of our algorithm is demonstrated by applying it to signal sets derived from automotive applications for a CAN based system and for the newly developed, low cost and low speed, Local Interconnect Network (LIN). The results can be of great use in cost sensitive embedded systems such as car control systems, where the used hardware, communication networks and nodes (typically microcontrollers), have to be highly utilised to keep the production cost at a minimum level.

Introducing a Component Technology for Safety Critical Embedded Real-Time Systems

Safety critical embedded real-time systems represent a class of systems that has attracted relatively little attention in research addressing component based software engineering. Hence, the most widely spread component technologies are not used for resource constrained safety critical real-time systems. They are simply to resource demanding, to complex and to unpredictable. In this paper we show how to use component based software engineering for low footprint systems with very high demands on safe and reliable behaviour. The key concept is to provide expressive design time models and yet resource effective run-time models by statically resolve resource usage and timing by powerful compile time techniques. This results in a component technology for resource effective and temporally verified mapping of a component model to a commercial real-time operating system.

Optimizing resource usage in component-based real-time systems

The embedded systems domain represents a class of systems that have high requirements on cost efficiency as well as run-time properties such as timeliness and dependability. The research on component-based systems has produced component technologies for guaranteeing real-time properties. However, the issue of saving resources by allocating several components to real-time tasks has gained little focus. Trade-offs when allocating components to tasks are, e.g., CPU-overhead, footprint and integrity. In this paper we present a general approach for allocating components to real-time tasks, while utilizing existing real-time analysis to ensure a feasible allocation. We demonstrate that CPU-overhead and memory consumption can be reduced by as much as 48% and 32% respectively for industrially representative systems.

Real world influences on software architecture - interviews with industrial system experts

Industrial systems are examples of complex and often long-lived systems in which software is playing an increasingly important role. Their architectures play a crucial role in maintaining the properties of such systems during their entire life cycle. In this paper, we present the results of a case study based on a series of interviews and a workshop with key personnel from research and development groups of successful international companies in their Swedish locations. The main goal of the investigation was to find the significant factors which influence system and software architectures and to find similarities and differences between the architecture-determining decisions and the architectures of these systems. The role of the architect was an important subject of the investigation. Our findings result in recommendations relating to the design and evolution of system architectures and suggestions regarding areas in which future research would be beneficial.

Virtualization technologies in embedded real-time systems

Virtualization is a promising solution to develop complex embedded systems with real-time requirements. This paper discusses the current state-of-the-art in virtualization technologies, with a particular focus on solutions for embedded real-time systems. Several such solutions have been developed over the past decade, and in this paper we give an overview of the more well known technologies and we provide a comparative assessment of key virtualization techniques available in these solutions. Gaps and lacking pieces are identified and further development and research is suggested.

Managing complex temporal requirements in real-time control systems

Design and implementation of motion control applications includes the transition from control design to real-time system implementation. To make this transition smooth, the specification model for the real-time system should allow also for temporal requirements other than deadlines, e.g., deviation from nominal period time of an activity, end-to-end timing constraints, temporal correlation between different sampling tasks and constraints on temporal variations in output. Many real-time systems in industry today are based on pre-emptive priority based run-time systems, and hence, the temporal requirements should be fulfilled by correctly assigning attributes such as priorities and offsets to the tasks executing in such systems. Assigning priorities and offsets in order to fulfill complex temporal requirements originating from control design and computer system design is a hard task that should be supported by powerful methods and tools. In this paper we propose a method which, by assigning priorities and offsets to tasks, guarantees that complex timing constraints can be met. In addition to the complex timing constraints, the method supports sporadic tasks, shared resources, and varying execution times of tasks. We present the idea and implementation, which is based on a genetic algorithm, and illustrate the method by an example.Design and implementation of motion control applications includes the transition from control design to real-time system implementation. To make this transition smooth, the specification model for the real-time system should allow also for temporal requirements other than deadlines, e.g., deviation from nominal period time of an activity, end-to-end timing constraints, temporal correlation between different sampling tasks and constraints on temporal variations in output. Many real-time systems in industry today are based on pre-emptive priority based run-time systems, and hence, the temporal requirements should be fulfilled by correctly assigning attributes such as priorities and offsets to the tasks executing in such systems. Assigning priorities and offsets in order to fulfill complex temporal requirements originating from control design and computer system design is a hard task that should be supported by powerful methods and tools. In this paper we propose a method which, by assigning priorities and offsets to tasks, guarantees that complex timing constraints can be met. In addition to the complex timing constraints, the method supports sporadic tasks, shared resources, and varying execution times of tasks. We present the idea and implementation, which is based on a genetic algorithm, and illustrate the method by an example.

Model level worst-case execution time analysis for IEC 61499

The IEC 61499 standard provides a possibility to develop industrial embedded systems in a component-based manner. Besides alleviating the efforts of system design, the component-based approach also allows analysis of various system characteristics using system models even before the actual deployment. One of the crucial characteristics in the domain of safety-critical and real-time systems is timing: a failure to execute a specific task on time can have severe consequences. This paper presents a method for compositional model-level analysis of worst-case execution time of IEC 61499 software models. The analysis is performed on one hierarchical level of composition at a time, and the results can be stored together with the software artefact to be used when analysis is performed on the higher hierarchical level, or when the unit is reused in another system. The analysis has been implemented as a plug-in for the 4DIAC tool.

An Overview of RealTimeTalk, a Design Framework for Real-Time Systems

RealTimeTalk (RTT) is a design framework for developing distributed real-time applications with both hard and soft requirements. The framework supports design via hierarchical decomposition. We believe that object-orientation is the best way to go about structuring a problem, hence the RTT language is based on Smalltalk with an analysis frontend to infer type information for run-time safety, and to yield more precise estimations of execution times. Unlike most real-time systems, RTT does not force the designer to embed constructs for timing requirements, communication, and synchronization in the code. Rather, such information is specified on a higher level of abstraction using graphical tools. This not only keeps the code “clean” but also simplifies timing analysis and resource allocation. A comparison with other real-time systems concludes the paper.

An efficient scheduling of AUTOSAR runnables to minimize communication cost in multi-core systems

The AUTOSAR consortium has developed as the worldwide standard for automotive embedded software systems. From a processor perspective, AUTOSAR was originally developed for single-core processor platforms. Recent trends have raised the desire for using multi-core processors to run AUTOSAR software. However, there are several challenges in reaching a highly efficient and predictable design of AUTOSAR-based embedded software on multi-core processors. In this paper a solution framework comprising both the mapping of runnables onto a set of tasks and the scheduling of the generated task set on a multi-core processor is suggested. The goal of the work presented in this paper is to minimize the overall inter-runnable communication cost besides meeting all corresponding timing and precedence constraints. The proposed solution framework is evaluated and compared with an exhaustive method to demonstrate the convergence to an optimal solution. Since the exhaustive method is not applicable for large size instances of the problem, the proposed framework is also compared with a well-known meta-heuristic algorithm to substantiate the capability of the frameworks to scale up. The experimental results clearly demonstrate high efficiency of the solution in terms of both communication cost and average processor utilization.