Reflections on an Adaptable Real-Time Metalevel Architecture

Existing reflective object-oriented real-time systems typically provide the programmer with a single mechanism or policy. With the advent of a new generation of application software with demand for (soft) real-time behavior, this limited choice may not be sufficient. We propose a metalevel architecture, where an application can choose from different real-time mechanisms and policies, thereby configuring its real-time behavior dynamically at run-time. This allows the adaptation to requirements that are not anticipated during application development. An example from the field of multimedia systems motivates our approach. We achieve this adaptability by structuring our metalevel into separate entities concerned with the support of different areas such as active object models, scheduling, and synchronization. These entities implement a variety of different real-time mechanisms and policies. This metalevel architecture is implemented using standard reflective mechanisms such as metalevel interceptions and metaobject protocols. Some preliminary performance figures give an impression of the price that has to be paid when our approach is used.

[1]  Lui Sha,et al.  Priority Inheritance Protocols: An Approach to Real-Time Synchronization , 1990, IEEE Trans. Computers.

[2]  Karsten Schwan,et al.  CHAOSarc: kernel support for multiweight objects, invocations, and atomicity in real-time multiprocessor applications , 1993, TOCS.

[3]  Aloysius K. Mok,et al.  Multiprocessor On-Line Scheduling of Hard-Real-Time Tasks , 1989, IEEE Trans. Software Eng..

[4]  Brian N. Bershad,et al.  Extensibility safety and performance in the SPIN operating system , 1995, SOSP.

[5]  Karsten Schwan,et al.  Dynamic adaptation of real-time software , 1991, TOCS.

[6]  Pattie Maes Concepts and experiments in computational reflection , 1987, OOPSLA 1987.

[7]  Bjarne Stroustrup,et al.  The C++ programming language (2nd ed.) , 1991 .

[8]  Vinny Cahill,et al.  It's your choice-on the design and implementation of a flexible metalevel architecture , 1996, Proceedings of International Conference on Configurable Distributed Systems.

[9]  Chris Zimmermann Advances in Object-Oriented Metalevel Architectures and Reflection , 1996 .

[10]  Yasuhiko Yokote,et al.  Adaptive Operating System Design using Reflection , 1995, OBPDC.

[11]  Mario Tokoro,et al.  DROL: an object-oriented programming language for distributed real-time systems , 1992, OOPSLA '92.

[12]  Randall B. Smith,et al.  Self: The power of simplicity , 1987, OOPSLA 1987.

[13]  Emin Gün Sirer,et al.  Protection is a software issue , 1995, Proceedings 5th Workshop on Hot Topics in Operating Systems (HotOS-V).

[14]  Brendan Tangney,et al.  Extensible systems: the tigger approach , 1994, EW 6.

[15]  Chung Laung Liu,et al.  Scheduling Algorithms for Multiprogramming in a Hard-Real-Time Environment , 1989, JACM.

[16]  Vinny Cahill,et al.  Roo: a framework for real-time threads , 1995, Proceedings of Third Workshop on Parallel and Distributed Real-Time Systems.

[17]  Robert Wahbe,et al.  Efficient software-based fault isolation , 1994, SOSP '93.

[18]  Lynn Andrea Stein Delegation is inheritance , 1987, OOPSLA 1987.

[19]  Hideyuki Tokuda,et al.  ARTS: a distributed real-time kernel , 1989, OPSR.

[20]  Yasuhiko Yokote Kerner Structuring of Object-Oriented Operating Systems: The Apertos Approach , 1993, ISOTAS.

[21]  Satoshi Matsuoka,et al.  Object-oriented concurrent reflective languages can be implemented efficiently , 1992, OOPSLA '92.

[22]  T. Bloom,et al.  Communications in the Mercury system , 1988, [1988] Proceedings of the Twenty-First Annual Hawaii International Conference on System Sciences. Volume II: Software track.