Rainer Koster

Player for adaptive MPEG video streaming over the Internet

This paper describes the design and implementation of a real-time, streaming, Internet video and audio player. The player has a number of advanced features including dynamic adaptation to changes in available bandwidth, latency and latency variation; a multi-dimensional media scaling capability driven by user-specified quality of service (QoS) requirements; and support for complex content comprising multiple synchronized video and audio streams. The player was developed as part of the QUASAR project at Oregon Graduate Institute, is freely available, and serves as a testbed for research in adaptive resource management and QoS control.

Infopipes for composing distributed information flows

Building applications that process information flows on existing middleware platforms is difficult, because of the variety of QoS requirements, the need for application-specific protocols, and the poor match of the commonly used abstraction of remote invocations to streaming. We propose Infopipes as a high-level abstraction for building blocks that handle information flows. The ability to query individual Infopipe elements as well as composite Infopipes for properties of supported flows enables QoS-aware configuration. Similarly to local protocol frameworks Infopipes provide a flexible infrastructure for configuring communication services from modules, but unlike protocols the abstraction uniformly includes the entire pipeline from source to sink, possibly across process and node boundaries.

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.

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.

Thread transparency in information flow middleware

Applications that process continuous information flows are challenging to write because the application programmer must deal with flow‐specific concurrency and timing requirements, necessitating the explicit management of threads, synchronization, scheduling and timing. We believe that middleware can ease this burden, but many middleware platforms do not match the structure of these applications, because they focus on control‐flow centric interaction models such as remote method invocation. Indeed, they abstract away from the very things that the information‐flow centric programmer must control.