Martin Gergeleit

An adaptive approach to object-oriented real-time computing

Real time computing is becoming an enabling technology for many important distributed applications such as flexible manufacturing, multimedia, robotics and process control. Traditionally, real time systems have been realized as isolated embedded systems. Unfortunately, this approach no longer suffices for future complex systems in the application scenarios mentioned above. In this situation, the use of an object oriented design paradigm greatly reduces the complexity of the system while improving reusability and manageability. Furthermore, the surrounding IT infrastructure is more and more accessible through object oriented interfaces (e.g. CORBA). In addition, object oriented modeling allows reflection of the dynamic characteristics of the applications mentioned above by instantiating objects dynamically. In order to meet the real time requirements in such an environment, static scheduling is not sufficient since many non predictable resource conflicts influence execution times. Therefore, the most distinguishing requirement of these complex heterogeneous systems is the need of the computing system to dynamically adapt to dynamically changing conditions. Little work has been done on integrating object oriented system design with resource allocation algorithms that are flexible enough to cope with this new requirement. The paper presents an approach for an adaptive object oriented system with integrated monitoring, dynamic execution time prediction and scheduling. It explains how this approach is applied to CORBA and C++.

Checking timing constraints in distributed object-oriented programs

In real-time systems design-assumptions can be divided into functional and temporal assumptions. While checks for functional correctness are already addressed by some modern programming languages (e.g. Eiffels pre- and postconditions), checks for temporal correctness are usually out of the scope of the existing programming or runtime systems. Our work in the DIRECT [GKS94] project tries to fill this gap. A methodology for specifying and checking timing constraints in an object-oriented environment is presented. The approach extends previous work on RTL[JM86] (Real-Time Logic) based monitors towards an object-oriented responsive system. The paper focuses on how object-orientation can be utilized to simplify the specification and the checking of timing constraints and how this can be integrated into an existing programming language like C++.

An integrated environment for the complete development cycle of an object-oriented distributed real-time system

This paper describes a powerful integrated development environment that covers all steps of the development of an object-oriented real-time application from initial design to the final evaluation. The system consists of a set of integrated tools for modeling, simulation, implementation, instrumentation, monitoring, and visualization that all work on the same OO system model. As all steps of creating a running implementation with visualized monitoring output from the design model are automatic, the environment encourages an iterative approach to the design of complex real-time control applications. This complete environment has been accomplished by integrating the SIMOO-RT modeling, simulation and implementation environment, developed at the Federal University of Rio Grande do Sul, with the Jewel++ object-oriented instrumentation and monitoring tool from GMD, St. Augustin, Germany. The work has been done in the context of the ADOORATA project (A Distributed Object-Oriented Architecture for Real-Time Automation), a Brazilian-German cooperation.

Robust scheduling in team-robotics

Mobile robots interact with a dynamically changing, physical environment. All tasks controlling such interactions must be performed reliably and in real-time. Information from the local sensors often is incomplete or inconsistent. Distributed sensor fusion is a technique that enables a team to get a more complete view of the world with a better quality of the provided information. In this paper we address the problem of scheduling the local processing tasks that are part of the overall fusion process. The particular problem to be addressed lies in the unpredictable execution times of these tasks, which do not allow for scheduling using worst-case execution times. The Time-Aware Fault-Tolerant (TAFT) scheduler allows working with expected-case execution times instead, and still achieves a predictable timing behavior. The paper details an efficient scheduling strategy for TAFT based on Earliest Deadline algorithms, formalizing the adopted task model and the underlying scheduling mechanism. Results are presented showing the achieved real-time behavior with an increased acceptance rate, a higher throughput, and a graceful degradation in transient overload situations compared to standard schedulers. Additionally, it describes the implementation of TAFT in the real-time platform that is embedded in our robot team.

TaskPair-scheduling with optimistic case execution times-an example for an adaptive real-time system

The paper first describes a model for an adaptive real time system, that consists of four components: the real time application, a monitor that observes the behaviour of the application, a dynamic resource manager that controls the execution of the application based on the data collected by the monitor, and finally an adaptation manager that uses the input from the monitor to implement long term adaptation strategies. In the second part of the paper, a concrete adaptation mechanism is introduced. This mechanism extends TaskPair scheduling (H. Streich, 1995), an online, fault tolerant scheduling method developed at GMD within the context of the DIRECT project (M. Gergeleit et al., 1994). TaskPair scheduling is extended with the notion of optimistic case execution time (OCET), that describes the time that a task needs in most of the cases for successful completion. As this time may depend on the system state and the environment, the system observes the actual resource consumption during execution and adapts future resource requests accordingly.

Monitoring distributed real-time activities in DCOM

Object-oriented frameworks have become a key element in the design of distribution systems. They make the existence of the physical and operating system level resources transparent to the designer and provide the abstract view of the distributed systems as a set of objects that interact by invoking well-defined interfaces of each other. Easy reuse of existing components, location transparency and implementation hiding are the main ingredients of such frameworks that simplify the task of designing distributed systems drastically. It is desirable to take advantage of these benefits when designing distributed real-time systems, too. However, this goal conflicts with the essential need to consider the allocation of system resources when real-time requirements must be met. Here, system level resource issues such as execution times on CPUs, thread switches, occurrence of interrupts, and message delays are of primary interest. Our approach to solve this dilemma is to allow and support the designer of distributed real-time object-oriented applications to become aware of system level resources. We present a monitoring tool JewelDC that allows monitoring of distribution activities (i.e. nested sequences of object invocations) in a distributed object-oriented framework. Distributed activities are visualized at the abstract object level while simultaneously revealing their use of system level resources. The tool has been implemented for DCOM on Microsoft Windows NT 4.0.

Cooperative concurrency control on the Web

Sharing of data in collaborative environments requires mechanisms that ensure the consistency of data in spite of concurrency and failures. This is traditionally handled by transactions or extended transaction mechanisms. The World Wide Web, although originally designed as an information storage and retrieval system, is being extended to serve as a vehicle for collaboration. However, the proposed extensions mainly address the basic issues such as file formats and up- and downloading of files. We are developing a configurable set of services for handling concurrency, recovery and collaboration that can be integrated into different system environments. We show an approach to use them for supporting cooperative work on the Web. In particular, the design and implementation of a cooperative concurrency control mechanism for the Web is presented.

Integrating time-aware CORBA objects into O-O real-time computations

Future real time applications are often closely integrated with the surrounding IT infrastructure and often they have to interact with external services that have CORBA interfaces. In such a scenario, static run time prediction for scheduling and static guarantees of timing assertions is impossible since many nonpredictable interaction elements influence execution times. To include CORBA objects in the real time system, the system must be aware of their timing behavior. Monitoring run time behavior is essential for future real time applications that exhibit dynamic behavior since it can be used to dynamically generate estimates of execution times and remaining execution times. However, the accuracy of the generated estimates is crucial for the success of such an approach. Achieving sufficient accuracy is difficult if the variance of the monitored execution times is high. One main source of high variances in execution times are data dependencies in the programs code. We present an object oriented, adaptable approach to monitoring execution times in object oriented systems which reduces the influence of data dependencies. It includes monitoring and mathematical analysis concepts to continuously predict remaining execution times in order to detect executions that will exceed their timing estimate. Furthermore, it allows us to dynamically adjust the monitoring granularity and the depth of the mathematical analysis on a per object base, in order to achieve higher accuracy if necessary, thus trading monitoring overhead against accuracy.

Guaranteeing Real-Time Behaviour in Adaptive Distributed Systems

Abstract Traditionally, real-time systems have been realized as isolated, embedded systems. Unfortunately, this approach does not longer suffice for future complex systems in application scenarios like flexible manufacturing, multimedia, robotics and process control. Often, there is a need to integrate external services through non real-time, object-oriented interfaces (e.g. CORBA).The most distinguishing requirement for these complex real-time systems is the need to adapt to dynamically changing conditions. Little work has been done on (operating) system mechanisms and algorithms that are flexible enough to cope with this new requirement. This paper presents an approach for an adaptive object-oriented system with integrated monitoring, dynamic execution time prediction and scheduling. Its applicability in a CORBA-like environment is exhibited.

A lightweight awareness service for industrial environments [distributed software]

Presents the design and implementation of a lightweight awareness service and its application to example scenarios of distributed software environments. Due to the complexity of distributed systems, the behavior of software for distributed systems is hard to predict. Even examining the behavior of existing software is difficult, due to the lack of central control and state. Awareness denotes the ability of a (distributed) system to report about and to assess its own status and behavior. Awareness is helpful for important steps of the distributed software engineering process, e.g. for gathering state information, for online observation, for debugging and for performance management of each development cycle. The basic purpose of the lightweight awareness service is to visualize online information in powerful, flexible presentation views. To be useful for industrial environments, the awareness service is designed to be easy-to-use: it is a fully distribution-transparent client/server architecture which does not require manual configuration. This is achieved by the introduction two new concepts: (1) a view request broker that is responsible for launching, locating and binding views to clients, and (2) the concept of auto-configuring views, i.e. views that adapt their outline automatically to the data being presented. Both concepts can be accessed as ready-to-use components via a simple object-based procedural client interface.