Simon Oberthür

Dynamic online reconfiguration for customizable and self-optimizing operating systems

When applications adapt their behavior to the requirements of the environment, their resource usage can change dramatically. The resource usage implies the services that the applications require from the operating system. Thus, the operating system must either provide all services that are totally required over time or reconfigure itself. Reconfiguration of the operating system means to support on demand services or the possibility to degrade services. We present an approach where we extend our offline customizable operating system in order to be dynamically reconfigurable during run-time. Additionally, we describe the procedure how the operating system is aware of the current required services. We claim that the resource usage between the applications and the operating system is optimized. Thus, we derive a self-optimizing real-time operating system (SO-RTOS). This work concentrates on the integration of the configurator, which models the design space and controles the low-level reconfiguration, and the resource manager, which is responsible for the timeliness and optimality. An optimization case study realized on a prototype validates our approach.

Model-based Runtime Verification Framework for Self-optimizing Systems

This paper describes a novel on-line model checking approach offered as service of a real-time operating system (RTOS). The verification system is intended especially for self-optimizing component-based real-time systems where self-optimization is performed by dynamically exchanging components. The verification is performed at the level of (RT-UML) models. The properties to be checked are expressed by RT-OCL terms where the underlying temporal logic is restricted to either time-annotated ACTL or LTL formulae. The on-line model checking runs interleaved with the execution of the component to be checked in a pipelined manner. The technique applied is based on on-the-fly model checking. More specifically for ACTL formulae this means on-the-fly solution of the NHORNSAT problem while in the case of LTL the emptiness checking method is applied.

Making mechatronic agents resource-aware in order to enable safe dynamic resource allocation

Mechatronic systems are embedded software systems with hard real-time requirements. Predictability is of paramount importance for these systems. Thus, their design has to take the worst-case into account and the maximal required resources are usually allocated upfront by each process. This is safe, but usually results in a rather poor resource utilization. If in contrast resource-aware agents, which are able to allocate and free resources in a controllable safe manner, instead of thumb processes are present, then a resource manager will coordinate their safe dynamic resource allocation at run time. But given such a resource manager, how can we transform thumb processes into smart resource-aware agents? Starting with mechatronic components that describe their reconfiguration by means of statecharts, we present how to automatically synthesize the additional information and code, which enables a process to become a resource-aware agent.

Architecture for adaptive resource assignment to virtualized mixed-criticality real-time systems

System virtualization is a powerful approach for the creation of integrated systems, which meet the high functionality and reliability requirements of complex embedded applications. It is in particular well-suited for mixed-criticality systems, since the often applied pessimistic manner of critical system engineering leads to heavily under-utilized resources. Existing static resource management approaches for virtualized systems are inappropriate for the dynamically varying resource requirements of upcoming adaptive systems. In this paper, we propose a dynamic resource management protocol for system virtualization that factors criticality levels in and allows the addition of subsystems at runtime. The two-level architecture offers flexibility across virtual machine borders and has the potential to improve the resource utilization. In addition, it provides the capability to adapt at runtime according to defects or changes of the environment.

Schedulability Criteria and Analysis for Dynamic and Flexible Resource Management

The Flexible Resource Manager (FRM) is a dynamic resource management approach that allows a better utilization of the available resources. However, it necessitates an atomic reconfiguration process that must not violate hard timing constraints. This paper exploits the deadline assignment rule of the Total Bandwidth Server (TBS) to schedule reconfiguration, and it formally shows that there exists a minimum task period for which atomicity and schedulability can be guaranteed. With this solution, real-time system engineers have the tools at hand to design their tasks to exploit the benefits of the FRM with hard real-time constraints.

Algorithmic skeletons for the design of partially reconfigurable systems

Designing reconfigurable systems that beneficially exploit the spatial and temporal domain is a cumbersome task hardly supported by current design methods. In particular, if we aim to bridge the gap between application and reconfigurable substrate, we require concrete concepts that allow for utilizing the inherent parallelism and adaptiveness of re- configurable devices. We propose algorithmic skeletons as sophisticated technique therefore. Algorithmic skeletons are programming templates for the parallel computing domain and therefore separate the structure of a computation from the computation itself. Hence, they offer a seminal means to extract temporal and spatial characteristics of an application, which can be used to make reconfigurability explicit. In this work, we show the conceptual background as well as a concrete implementation means of the method.

Acute stress response for self-optimizing mechatronic systems

Self-optimizing mechatronic systems have the ability to adjust their goals and behavior according to changes of the environment or system by means of complex real-time coordination and reconfiguration in the underlying software and hardware. In this paper we sketch a generic software architecture for mechatronic systems with self-optimization and outline which analogies between this architecture and the information processing in natural organisms exist. The architecture at first exploits the ability of its subsystems to adapt their resource requirements to optimize its performance with respect to the usage of available computational resources. Secondly, the architecture achieves, inspired by the acute stress response of a natural being, that in the case of an emergency it makes all recources available to address a given threat in a self-coordinated manner.

Comprehensive verification framework for dependability of self-optimizing systems

By integrating formal specification and formal verification into the design phase of a system development process, the correctness of the system can be ensured to a great extent. However, it is not sufficient for a self-optimizing system that needs to exchange its components safely and consistently over time. Therefore, this paper presents a comprehensive verification framework to guarantee the dependability of such a self-optimizing system at the design phase (off-line verification) as well as at the runtime phase (on-line verification). The proposed verification framework adopts AsmL as intermediate representation for the system specification and on-the-fly model checking technique for alleviating the state space explosion problem. The off and the on -line verifications are performed at (RT-UML) model level. The properties to be checked are expressed by RT-OCL where the underlying temporal logic is restricted to time-annotated ACTL/LTL formulae. In particular, the on-line verification is achieved by running the on-the-fly model checking interleaved with the execution of the checked system in a pipelined manner.

Increasing dependability by means of model-based acceptance test inside RTOS

Component-based self-optimizing systems can adjust themselves over time to dynamic environments by means of exchanging components. In case that such systems are safety-critical, the dependability issue becomes paramountly significant. This paper presents a novel model-based runtime verification to increase dependability for the self-optimizing systems of this kind. The proposed verification approach plays a role of an alternative acceptance test transparently integrated in RTOS, named model-based acceptance test. The verification is performed at the level of (RT-UML) models representing the systems under consideration. The properties to be checked are expressed by RT-OCL where the underlying temporal logic is restricted to either time-annotated ACTL or LTL formulae. The applied technique is based on the on-the-fly model checking, which runs interleaved with the execution of the checked system in a pipelined manner. More specifically, for ACTL formulae this means an on-the-fly solution to the NHORNSAT problem, while in the case of LTL formulae, the emptiness checking method is applied.

COMPONENT CASE STUDY OF A SELF-OPTIMIZING RCOS/RTOS SYSTEM

In highly dynamic scenarios a real-time communication/real-time operating system (RCOS/RTOS), which can fulfill all upcoming demands of the application, is normally very extensive. These RCOS/RTOS systems are heavy-weighted and produce much overhead. System resources for an application or a system service are often reserved for worst-case scenarios and are not usable for other applications. We present a self-optimizing RCOS/RTOS with an integrated flexible resource management. Our RCOS/RTOS adapts its services to the application demands and redistributes temporarily unused resources to other applications under hard real-time conditions. The benefit of our system is shown by means of a self-optimizing communication service. The main building block of this communication service is a reconfigurable dual-port Ethernet switch. Using dynamically reconfigurable hardware to implement the switch enables an adaption of the switch to changing requirements during run-time.