Object-oriented Real-time Systems Research Articles

Dual ceiling protocol for real-time synchronization under preemption threshold scheduling

The application of object-oriented design methods to real-time embedded systems is seriously hindered by the lack of existing real-time scheduling techniques that can be seamlessly integrated into these methods. Preemption threshold scheduling (PTS) enables a scalable real-time system design and thus has been suggested as a solution to this problem. However, direct adoption of PTS may lead to long priority inversion since object-oriented real-time systems require synchronization considerations in order to maintain consistent object states. In this paper, we propose the dual ceiling protocol (DCP) in order to solve this problem. While DCP exploits both priority ceilings and preemption threshold ceilings, this is not a straightforward integration of existing real-time synchronization protocols for PTS. We present the rationale for the locking conditions of DCP and show that it leads to the least blocking and response times by comparison with other real-time synchronization protocols. We also present its blocking properties and schedulability analyses. We implemented PTS and DCP in a real-time object-oriented CASE tool and present the associated experimental results, which show that the proposed protocol is a viable solution that is superior to other real-time synchronization protocols for PTS.

Abstraction and Completeness for Real-Time Maude

This paper presents criteria that guarantee completeness of Real-Time Maude search and temporal logic model checking analyses, under the maximal time sampling strategy, for a large class of real-time systems. As a special case, we characterize simple conditions for such completeness for object-oriented real-time systems, and show that these conditions can often be easily proved even for large and complex systems, such as advanced wireless sensor network algorithms and active network multicast protocols. Our results provide completeness and decidability of time-bounded search and model checking for a large and useful class of dense-time non-Zeno real-time systems far beyond the class of automaton-based real-time systems for which well known decision procedures exist. For discrete time, our results justify abstractions that can drastically reduce the state space to make search and model checking analyses feasible.

Perfecting preemption threshold scheduling for object-oriented real-time system design

In spite of the proliferation of object-oriented design methodologies in contemporary software development, their application to real-time embedded systems has been limited because of the practitioner's conservative attitude toward handling timing constraints. In fact, this conservative attitude is well-grounded because traditional priority-based scheduling techniques cannot be straightforwardly integrated into them. The automated implementation from the object-oriented real-time designs usually incurs a large number of tasks which, under traditional priority-based scheduling techniques, does not scale well due to excessive preemption overheads. Recently, preemption threshold scheduling was introduced to reduce run-time multi-tasking overhead while improving schedulability by exploiting non-preemptibility as much as possible. Unfortunately, the preemption threshold scheduling cannot be directly adopted into the object-oriented design methods due to the lack of real-time synchronization.In this paper, we present the essential basis of real-time synchronization for preemption threshold scheduling. Specifically, we integrate the priority inheritance protocol, the priority ceiling protocol, and the immediate inheritance protocol into preemption threshold scheduling. We also provide their schedulability analyses. Consequently, the integrated scheme, which minimizes worst-case context switches, is appropriate for the automated implementation of real-time object-oriented design models.

The design and performance of a real-time CORBA event service

The CORBA Event Service provides a flexible model for asynchronous communication among objects. However, the standard CORBA Event Service specification lacks important features required by real-time applications. For instance, operational flight programs for fighter aircraft have complex real-time processing requirements. This paper describes the design and performance of an object-oriented, real-time implementation of the GORBA Event Service that is designed to meet these requirements.This paper makes three contributions to the design and performance measurement of object-oriented real-time systems. First, it illustrates how to extend the CORBA Event Service so that it is suitable for real-time systems. These extensions support periodic rate-based event processing and efficient event filtering and correlation. Second, it describes how to develop object-oriented event dispatching and scheduling mechanisms that can provide real-time guarantees. Finally, the paper presents benchmarks that demonstrate the performance tradeoffs of alternative concurrent dispatching mechanisms for real-time Event Services.

Object-oriented real-time systems using a hybrid distributed model of Ada 95's built-in DSA capability (distributed systems annex-E) and CORBA

This paper reports on the issues in design and development of Object Oriented Real-Time Distributed Systems using Ada 95. The paper is broken into the following parts: First, one of the general distributed real-time problems is introduced as it fits the domain within Boeing. Next, prototype solutions to the distributed capabilities are introduced including the new technologies present in Ada-95 through DSA (Distributed Systems Annex-E)[2] and extended with CORBA (Common Object Request Broker Architecture) capabilities[1]. Many issues are addressed with adoption and use of these technologies especially applicable as they relate to custom fine-tuned solutions used today to solve real-time constraints. As the various distributed solutions provide different strengths, a combination of the capabilities provides an attractive option. A hybrid distributed capability composed of DSA and CORBA has been developed and is discussed as it relates to the seamless introduction with the Ada language. Finally a set of research issues are raised.

Schema evolution of an object-oriented real-time database system for manufacturing automation

Database schemata often experience considerable changes during the development and initial use phases of database systems for advanced applications such as manufacturing automation and computer-aided design. An automated schema evolution system can significantly reduce the amount of effort and potential errors related to schema changes. Although schema evolution for nonreal-time databases was the subject of previous research, its impact on real-time database systems remains unexplored. These advanced applications typically utilize object-oriented data models to handle complex data types. However, there exists no agreed-upon real-time object-oriented data model that can be used as a foundation to define a schema-evolution framework. Therefore, the authors first design a conceptual real-time object-oriented data model, called Real-time Object Model with Performance Polymorphism (ROMPP). It captures the key characteristics of real-time applications-namely, timing constraints and performance polymorphism-by utilizing specialization-dimension and letter-class hierarchy constructs, respectively. They then re-evaluate previous (nonreal-time) schema evolution support in the context of real-time databases. This results in modifications to the semantics of schema changes and to the needs of schema change resolution rules and schema invariants. Furthermore, they expand the schema change framework with new constructs-including new schema change operators, new resolution rules, and new invariants-necessary for handling the real-time characteristics of ROMPP.

Special Issue on Object-Oriented Real-Time Systems: Guest Editors' Introduction

Special Issue on Object-Oriented Real-Time Systems: Guest Editors' Introduction

Metric framework for object-oriented real-time systems specification languages

In this paper, a framework for maintaining control of and analyzing object-oriented system specifications of real-time systems by using a set of metrics covering technical, cognitive, and process-oriented views is presented. The indicators defined can be u nsed for monitoring the evolution of system quality and for effort prediction. The use of metrics for the estimation of reusability, verifiability, and testability is analyzed. The metric framework is integrated in a CASE tool named TOOMS, which is based on TROL, a dual object-oriented language with both descriptive and operational capabilities. TOOMS allows one to describe the system at different levels of structural abstractions and at different levels of specification detail, such as many other languages and models for real-time systems (e.g., OSDL, ObjectTime, ObjectChart). According to this, the metrics proposed are capable of producing estimations at each level of system specification, thus allowing incremental specification/metrication. The metric framework must be regarded as a support for controlling the process of software development in order to guarantee the final quality.

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.

Progress on RTSS simulation-based analysis for real-time systems development at two laboratories

A new object-oriented Real Time System Simulator (RTSS) with the capability for simulation graphics and animation, has been developed and used for modeling the distributed data acquisition and processing systems at JET and ASIPP. Simulation allows estimates of response time, throughput and resource utilization for a variety of configurations to be investigated. Performance measurements, simulation and analysis are used together to calibrate and validate each other.

The object oriented real-time systems (OORTS) workshop

The workshop was held in San Antonio Texas in conjunction with the "7th IEEE Symposium on Parallel and Distributed Processing" (SPDP) on October 27th, 1995. It was organized in cooperation with the Software Engineering Laboratory at NJIT with support from the U.S. Naval Surface Warfare Center and the faculty of Mathematics and Computing Science of the Eindhoven University of Technology.

Guest editor's introduction

Object-orientation is an effective means to improve the software engineering process. It provides a natural approach to system modeling, and yields benefits in all lifecycle phases. While much progress has been made in general-purpose object-oriented methods, considerably less progress has been made in the domain of object-oriented real-time computing. In addition to the typical requirements of functional correctness, efficiency, and information hiding, object-oriented real-time systems must also conform to stringent timing requirements. An additional complicating factor is that real-time control systems are frequently distributed in nature. For researchers and engineers, this has ramifications for requirements, object specification, object composition, implementation, verification, testing, languages and run-time systems.

A metrics-driven approach for utilizing concurrency in object-oriented real-time systems

This paper presents a metrics-driven process and software toolset for the engineering of concurrent, object-oriented, real-time systems. In the engineering of real-time systems, the objective need not be to exploit all potential concurrency, but to exploit only as much concurrency as is needed to enable satisfaction of timing constraints. Thus, the systems engineering process presented in the paper utilizes inter-object concurrency selectively, as a means to meet timelines. To support the selective use of concurrency, this paper describes techniques for computing inter-object concurrency metrics. It is also shown how the concurrency metrics are used to guide the mapping of objects onto processors.

A taxonomy for distributed object-oriented real-time systems

This paper gives a taxonomy for the evaluation of object-oriented design methods and implementation languages for the construction of distributed real-time systems. This taxonomy is aimed at answering the following main questions: (1) how well do current approaches support the design of non-functional system features like concurrency and the specification of allocation, timing and fault tolerance constraints and (2) how can we discern essential properties of such methods and languages in order to point out the strengths and weaknesses of contemporary approaches.

High-level dynamic memory management for object-oriented real-time systems

Dynamic memory management in real-time systems is difficult because most traditional allocation and deallocation algorithms are unpredictable in terms of their worst-case memory utilization and execution times. This paper describes recent work on a new memory management system designed specifically to support hard-real-time allocation, automatic garbage collection, and defragmentation of the free pool. The memory management system consists of special hardware circuits placed between the CPU's level-two caches and its memory subsystem. Benefits include worst-case allocation delays of two microseconds and typical memory utilizations that exceed binary-buddy allocators by over 30%. A commercial implementation of this technology is currently under development.

Object-oriented real-time systems

Object-oriented real-time systems

Object-oriented real-time systems analysis and design issues

Our goal as an investigation group in this area was not to make a check list of hundreds of items but to identify the “high level capabilities” that a real-time object-oriented analysis and design technique should provide. We are well aware that no current methodology provides very much of what we have identified. Nevertheless, we felt it was our task to define meaningful selection criteria regardless of whether they are currently available. These guidelines should provide direction for the developers of real-time object-oriented design and analysis systems as well as for developers of real-time systems.

Object-oriented real-time system analysis and design issues

Object-oriented real-time system analysis and design issues

Object-oriented real-time systems: concepts and examples

The problems associated with developing real-time software systems, including ensuring predictable real-time behavior under both normal and abnormal operating conditions, are outlined. The management of temporal complexity, structuring of dynamic real-time applications, object-oriented models, object-oriented real-time languages, and the requirements for real-time object-oriented models are discussed. Chaos, an object-based language and programming/execution paradigm designed for dynamic real-time applications, is described. >