Thorsten Kramp

An Open Framework for Real-Time Scheduling Simulation

Real-time systems seek to guarantee predictable run-time be-ha viour to ensure that tasks will meet their deadlines. Optimal scheduling decisions, however, easily impose unacceptable run-time costs for many but the most basic scheduling problems, specifically in the context of multiprocessors and distributed systems. Deriving suitable heuristics then usually requires extensive simulations to gain confidence in the chosen approach. In this paper we therefore present Fortissimo, an open framework that facilitates the development of taylor-made real-time scheduling simulators for multiprocessor systems.

The Design of a Flexible Communications Framework for Next-Generation Middleware

The success of middleware platforms is leading to a number of challenges as the motivation grows to deploy middleware in ever more demanding application domains. This paper therefore introduces a flexible, object-oriented communications framework, called BOSSA NOVA, which can be integrated into middleware platforms to better support domains such as soft real-time, multimedia, and adaptive mobile systems. In particular, BOSSA NOVA aims at providing flexibility in terms of protocol structure and composition, protocol granularity, and concurrency/multiplexing structure. The use of reflective interfaces explicitly facilitates management and dynamic reconfiguration as well as QoS specification and negotiation together with associated resource management in protocol graphs. QoS-negotiation protocols and resource-management policies, however, in common with most areas of the framework, are open and non-prescribed, although basic protocols and reusable base functionality are readily provided. For ease of use, BOSSA NOVA relies on only a small set of simple and consistently used abstractions, which allow for efficient implementations.

Loadable Smart Proxies and Native-Code Shipping for CORBA

Middleware platforms such as CORBA are widely considered as a promising technology path towards a universal service market. For now, however, no mechanisms are offered for dynamically integrating service-specific code (so-called smart proxies) at the client which is a major prerequisite for the development of generic clients that may connect to different service implementations offering different quality-of-service guarantees. In this paper, we therefore demonstrate how support for smart proxies can be integrated within CORBA by means of a native-code shipping service that only relies on the recent objects-by-value extension and portable-interceptors proposal. The feasibility of this approach is shown by a smart-proxy supported video service.

Flexible event-based threading for QoS-supporting middleware

Distributed computing platforms have made their way out of the research lab nowadays, yet support for some key application areas such as real time in general and multimedia in particular is still found lacking. Since a single platform is unlikely to be able to satisfy the widely diverse requirements of such QoS-sensitive application domains, we propose a low-level foundation called Cool Jazz instead, which is designed for easy customisation and on which more specific middleware platforms for distributed heterogeneous environments with QoS-requirements can be built. Cool Jazz combines support for concurrency, communication, and signal handling within a unified event-based processing model inspired by SDL. In this paper we outline the overall architecture of Cool Jazz and present the concurrency mechanisms in detail.

Using message-based threading for multimedia applications

Components of a complex multimedia application typically work reactively processing events such as notifications from other threads, signals, and network packets. To better support these applications we have built a message-based threading platform providing more flexibilty than event handling with one thread and easier synchronisation than conventional multithreading approaches. Reuse and reconfiguration are facilitated by using a uniform message interface for all types of events. Moreover, scheduling can be based on timing constraints attached to messages rather than to threads. The reimplementation of a multi-stream video player shows the benefits of this approach.

Multithreading platform for multimedia applications

Complex multimedia applications have diverse resource and timing requirements. A platform for building such programs therefore should supply the developer with mechanisms for managing concurrency, communication, and real-time constraints but should remain flexible with regard to scheduling policies and interaction models. We have developed such a platform consisting of a user-level threads package and operating system extensions. The threads package offers a message-based threading model uniformly integrating synchronous and asynchronous communication, inter-thread synchronization, and signal handling as well as real-time functionality and application-specific scheduling. To support this user-space flexibility an upcall mechanism links the user-level scheduler to the kernel.

Structuring QoS-supporting services with smart proxies

While middleware platforms have been established in best-effort environments nowadays, support for QoS-sensitive services is still found lacking. More specifically, due to the high diversity of QoS requirements, the abstractions provided for QoS-unaware services cannot be maintained and the developer has to face the difficulties of low-level networking in heterogeneous environments again. In this paper, we therefore propose the notion of smart proxies as an effective means for making the use of QoS-sensitive services for the client-application developer as comfortable as the use of QoS-unaware services. This is achieved without imposing restrictions on the internal mechanisms and protocols used by an QoS-sensitive service to guarantee an agreed on level of QoS. Basically, smart proxies encapsulate service-specific code which is downloaded dynamically to the client during binding establishment. The benefits of this model are discussed in general and exemplified in a case study.

Descriptive-procedural configuration of communication bindings

Although declarative configurability still predominates in the context of communication bindings, the hidden policies involved make it an unlikely candidate to cope with the ever increasing variety of demands imposed by forthcoming application domains such as real time multimedia. We therefore propose a policy-free descriptive-procedural alternative for the configuration of communication bindings which provides a more fine-grained control of procedural configurability without being tied to component-specified interfaces.

Real-Time Support on Top of Ethernet

Ethernet is a widely used low-cost networking technology. It however lacks the determinism and resource management features needed to meet real-time requirements of multimedia applications, for instance. This paper presents the B E A T communication service that adds basic real-time mechanisms on top of Ethernet to the Linux operating system while supporting the use of conventional applications and protocols such as TCP and UDP.