Learn More
Nearly ten years after its first presentation and five years after its first application to operating systems, the suitability of <i>Aspect-Oriented Programming (AOP)</i> for the development of operating system kernels is still highly in dispute. While the AOP advocacy emphasizes the benefits of AOP towards better configurability and maintainability of(More)
—Traditional operating systems differentiate between threads, which are managed by the kernel scheduler, and interrupt handlers, which are scheduled by the hardware. This approach is not only asymmetrical in its nature, but also introduces problems relevant to real-time systems because low-priority interrupt handlers can interrupt high-priority threads. We(More)
— System software strongly relies on the availability of static as well as dynamic adaptation techniques. With Aspect-Oriented Programming (AOP) it is now possible to adapt even policy-like crosscutting concerns in the implementation of system software. While this is straightforward in the static case, dynamic adaptation of crosscutting concerns requires an(More)
The increasing complexity of embedded systems calls for operating systems that are highly specialized and at the same time are made of a number of reusable building blocks. This brings up a conflict as software specialized in supporting a very dedicated case usually cannot be (easily) reused for a different environment. As described in the paper, supporting(More)
During the development of real-time systems one has either to plump for a time-triggered or an event-triggered architecture. Actually this decision deals with a non-functional property of a real-time system and should therefore be postponed as far as possible. Unfortunately, this property also exhibits functional qualities during the development of(More)
In this paper we present a prototype of the RTSC – the Real-Time System Compiler. The RTSC is a compiler-based tool that leverages the migration from event-triggered to time-triggered real-time systems. For this purpose, it uses an abstraction called Atomic Basic Blocks (ABBs) which is used to capture all relevant dependencies of the event-triggered system(More)
Modern computer systems require an enormous amount of flexibility. This is especially the case in low-level system software, from embedded devices to networking services. From literature and practice, various approaches to modularize and integrate adaptations have been investigated. However, most of this work is implemented with dynamic languages that offer(More)
A common problem in event-triggered real-time systems is caused by low-priority tasks that are implemented as interrupt handlers interrupting and disturbing high-priority tasks that are implemented as threads. This problem is termed rate-monotonic priority inversion, and current software-based solutions are restricted in terms of more sophisticated(More)
Whether a real-time system is implemented as time-triggered or event-triggered system is constituted quite early in the development process of real-time systems. Unfortunately , different task models are associated inseparably with these real-time architectures. This makes it very hard to migrate from time-triggered to event-triggered systems and vice(More)
The reduction of structure sizes in microcontollers, environmental conditions or low supply voltages increase the susceptibility of embedded systems to soft errors. As a result, the employment of fault-detection and fault-tolerance measures is becoming a mandatory task even for moderately critical applications. Accordingly, software-based techniques have(More)