Philippe Robin

An architecture for next generation middleware

This paper proposes an approach to the design of configurable and open middleware platforms based on the concept of reflection. More specifically, the paper introduces a language-independent reflective architecture featuring a per-object meta-space, the use of meta-models to structure meta-space, and a consistent use of object graphs for composite components. This is complemented by a component framework supporting the construction of meta-spaces. The paper also reports on experiences of implementing the architecture (with emphasis on experiments with open bindings).

The design of a QoS-controlled ATM-based communications system in Chorus

We describe the design of an application platform able to run distributed real-time and multimedia applications alongside conventional UNIX programs. The platform is embedded in a microkernel/PC environment and supported by an ATM-based, QoS-driven communications stack. In particular, we focus on resource-management aspects of the design and deal with CPU scheduling, network resource-management and memory-management issues. An architecture is presented that guarantees QoS levels of both communications and processing with varying degrees of commitment as specified by user-level QoS parameters. The architecture uses admission tests to determine whether or not new activities can be accepted and includes modules to translate user-level QoS parameters into representations usable by the scheduling, network, and memory-management subsystems. >

Supporting adaptive multimedia applications through open bindings

In order to support multimedia applications in mobile environments, it will be necessary for applications to be aware of the underlying network conditions and also to be able to adapt their behaviour and that of the underlying platform. This paper focuses on the role of middleware in supporting such adaptation. In particular, we investigate the role of open implementation and reflection in the design of middleware platforms such as CORBA. The paper initially extends CORBA with the concept of explicit binding, where path of communication between objects is represented as first class objects. We then introduce the concept of open bindings which support inspection and adaptation of the path of communications. An implementation of open bindings is described, based on the Ensemble protocol suite from Cornell University.

Adaptive middleware for mobile multimedia applications

The traditional approach to developing middleware platforms is to adopt a black box philosophy whereby the platform offers a fixed programming model to applications together with a fixed per-platform implementation. In this paper we describe research which is exploring an open approach to middleware implementation. Our motivation is to accommodate the demanding requirements for quality of service adaptation which are imposed by mobile multimedia applications. We use an extended CORBA computational model which supports the concept of explicit open bindings, which provide an architectural framework for openness and quality of service adaptation. The paper offers examples of the programming style facilitated by our architecture and reports on our implementation experience to date.

Micro-kernel support for continuous media in distributed systems

Abstract Currently, popular operating systems are unable to support the end-to-end real-time requirements of distributed continuous media. Furthermore, the integration of continuous media communications software into such systems poses significant challenges. This paper describes a design for distributed multimedia support in a micro-kernel operating system environment which provides the necessary soft real-time support while simultaneously running conventional applications. Our approach is to extend existing micro-kernel abstractions to include QoS configurability, connection-oriented communications and real-time threads. The design uses the following key concepts: the notion of a flow to represent QoS controlled communication between two application threads, a close integration of communications and thread scheduling and the use of a split-level scheduling architecture with kernel- and user-level threads. Implementation work is not yet completed and therefore performance figures are not available. However, the paper shows how our design qualitatively improves performance over existing micro-kernel facilities by reducing the number of protection-domain crossings and context switches incurred.

Extending the Chorus Micro-Kernel to Support Continuous Media Applications

Currently, popular operating systems are unable to support the end-to-end real-time requirements of distributed continuous media. Furthermore, the integration of continuous media communications software into such systems poses significant challenges. This paper describes a design for distributed multimedia support in the Chorus micro-kernel operating system environment which provides the necessary soft real-time support while simultaneously running conventional applications. Our approach is to extend existing Chorus abstractions to include QoS configurability, connection oriented communications and real-time threads. The design uses the following key concepts: the notion of a flow to represent QoS controlled communication between two application threads, a close integration of communications and thread scheduling and the use of a split level scheduling architecture with kernel and user level threads. The paper shows how our design qualitatively improves performance over existing micro-kernel facilities by reducing the number of protection domain crossings and context switches incurred.

Supporting mobile multimedia applications through adaptive middleware

The traditional approach to developing middleware platforms is to adopt a black box philosophy whereby the platform offers a fixed programming model to applications together with fixed per-platform implementations. In this paper, we describe research which is exploring an open approach to the implementation of middleware platforms. Our motivation is to accommodate the demanding requirements for quality-of-service (QoS) adaptation as imposed by mobile multimedia applications. We use an extended CORBA computational model featuring the concept of explicit open bindings. This provides an architectural framework for openness and QoS adaptation. The paper concludes by considering the more general application of an open systems philosophy; in particular, we introduce the concept of reflective middleware.

Software architecture for adaptive distributed multimedia systems

To support multimedia applications in mobile environments, it will be necessary for applications to be aware of the underlying network conditions and also to be able to adapt their behaviour and that of the underlying platform. This paper focuses on the role of middleware in supporting such adaptation. In particular, we investigate the role of open implementation and reflection in the design of middleware platforms such as CORBA. The paper initially extends CORBA with the concept of explicit binding, where path of communication between objects is represented as first class objects. We then introduce the concept of open bindings which support inspection and adaptation of the path of communications. An implementation of open bindings for adaptive continuous-media interaction is described using the example of adaptive video-on-demand for mobile environments.

Supporting continuous media applications in a micro-kernel environment

Today’s operating systems were not designed to support the end-to-end real-time requirements of distributed continuous media. Furthermore, the integration of continuous media communications software into such systems poses significant challenges. This paper describes a design for distributed multimedia support in the Chorus micro-kernel operating system environment which provides the necessary soft real-time support while simultaneously running conventional applications. Our approach is to extend existing Chorus abstractions to include QoS configurability, connection oriented communications and real-time threads. The paper defines a low level API for distributed real-time programming and describes an implementation which features a close integration of communications and thread scheduling and the use of a split level scheduling architecture with kernel and user level threads.

A programming model and system infrastructure for real-time synchronization in distributed multimedia systems

One of the major requirements of distributed multimedia applications is the need to maintain often complex, real-time synchronization constraints. More specifically, it is necessary to be able to manage arbitrary intra- and inter-media synchronization across activities in the distributed environment. Furthermore, it is important that such developments are integrated into emerging object-oriented standards for distributed computing. This paper presents an object-oriented programming model and associated implementation to meet these requirements. The main concepts behind the proposed approach are, firstly, the use of reactive objects for real-time control and synchronization and, secondly, quality of service controlled bindings for predictable communication between objects. The flexibility of the approach is demonstrated by three contrasting examples of real-time synchronization. The implementation extends the real-time capabilities of the Chorus micro-kernel by introducing the concepts of rtports, rthandlers and quality of service controlled connections. The paper demonstrates how reactive objects and bindings are realized on this infrastructure.