David L. Levine

The design of the TAO real-time object request broker

Many real-time application domains can benefit from flexible and open distributed architectures, such as those defined by the CORBA specification. CORBA is an architecture for distributed object computing being standardized by the OMG. Although CORBA is well-suited for conventional request/response applications, CORBA implementations are not yet suited for real-time applications due to the lack of key quality of service (QoS) features and performance optimizations. This paper makes three contributions to the design of real-time CORBA systems. First, the paper describes the design of TAO, which is our high-performance, real-time CORBA 2.0-compliant implementation that runs on a range of OS platforms with real-time features including VxWorks, Chorus, Solaris 2.x, and Windows NT. Second, it presents TAOs real-time scheduling service that can provide QoS guarantees for deterministic real-time CORBA applications. Finally, the paper presents performance measurements that demonstrate the effects of priority inversion and non-determinism in conventional CORBA implementations and how these hazards are avoided in TAO.

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.

The Design and Performance of a Real-Time CORBA SchedulingService

There is increasing demandto extend CORBA middleware to support applications with stringentquality of service (QoS) requirements. However, conventionalCORBA middleware does not define standard features to dynamicallyschedule operations for applications that possess deterministicreal-time requirements. This paper presents three contributionsto the study of real-time CORBA operation scheduling strategies.First, we document our evolution from static to dynamic schedulingfor applications with deterministic real-time requirements. Second,we describe the flexible scheduling service framework in ourreal-time CORBA implementation, TAO, which supports core schedulingstrategies efficiently. Third, we present results from empiricalbenchmarks that quantify the behavior of these scheduling strategiesand assess the overhead of dynamic scheduling in TAO. Our empiricalresults using TAO show that dynamic scheduling of CORBA operationscan be deterministic and can achieve acceptable latency for operations,even with moderate levels of queueing.

The design and performance of a real-time I/O subsystem

The paper describes the design and performance of a real time I/O (RIO) subsystem that supports real time applications running on off-the-shelf hardware and software. The paper provides two contributions to the study of real time I/O subsystems. First it describes how RIO supports end-to-end, prioritized traffic to bound the I/O utilization of each priority class and eliminates the key sources of priority inversion in I/O subsystems. Second, it illustrates how a real time I/O subsystem can reduce latency bounds on end-to-end communication between high-priority clients without unduly penalizing low priority and best-effort clients.

Dynamic scheduling strategies for avionics mission computing

Avionics mission computing systems have traditionally been scheduled statically. Static scheduling provides assurance of schedulability prior to run-time and can be implemented with low renting overhead. However static scheduling handles non-periodic processing inefficiently, and treats invocation-to-invocation variations in resource requirements inflexibly. As a consequence, processing resources am underutilized and the resulting systems are hard to adapt to meet worst-case processing requirements. Dynamic scheduling has the potential to offer relief from some of the restrictions imposed by strict static scheduling approaches. Potential benefits of dynamic scheduling include better tolerance for variations in activities, more flexible prioritization, and better CPU utilization in the presence of non-periodic activities. However the cost of these benefits is expected to be higher run-time scheduling overhead and additional application development complexity. This report reviews the implications of these tradeoffs for avionics mission computing systems and presents experimental results obtained using the Maximum Urgency First dynamic scheduling algorithm.

Applying a scalable CORBA event service to large-scale distributed interactive simulations

Next-generation distributed interactive simulations (DISs) will have stringent quality of service (QoS) requirements for throughput, latency and scalability, as well as requirements for a flexible communication infrastructure to reduce software lifecycle costs. The CORBA event service provides a flexible model for asynchronous communication among distributed and collocated objects. However, the standard CORBA event service specification lacks important features and QoS optimizations required by DIS systems. This paper makes five contributions to the design, implementation and performance measurement of DIS systems. First, it describes how the CORBA event service can be implemented to support key QoS features. Second, it illustrates how to extend the CORBA event service so that it is better suited for DISs. Third, it describes how to develop efficient event dispatching and scheduling mechanisms that can sustain high throughput. Fourth, it describes how to use multicast protocols to reduce network traffic transparently and to improve system scalability. Finally, it illustrates how an event service framework can be strategized to support configurations that facilitate high throughput, predictable bounded latency, or some combination of each.

Evaluating policies and mechanisms for supporting embedded, real-time applications with CORBA 3.0

To be an effective platform for performance-sensitive real time systems, commercial-off-the-shelf (COTS) distributed object computing (DOC) middleware must support application quality of service (QoS) requirements end-to-end. However, conventional DOC middleware does not provide this support, which makes it unsuited for applications with stringent latency, determinism, and priority preservation requirements. It is essential, therefore, to develop standards based, COTS DOC middleware that permits the specification, allocation, and enforcement of application QoS requirements end-to-end. The Real-time CORBA and Messaging specifications in the forthcoming CORBA 3.0 standard are important steps towards defining standards based COTS DOC middleware that can deliver end-to-end QoS support at multiple levels in distributed and embedded real time systems. However these specifications still lack sufficient detail to portably configure and control processor, communication, and memory resources for applications with stringent QoS requirements. The paper provides four contributions to research on real time DOC middleware. First, we show how the CORBA 3.0 Real-time and Messaging specifications provide a starting point for addressing the needs of an important class of applications with stringent real time requirements. Second, we show how the CORBA 3.0 specifications are not sufficient to solve all the issues within this application domain. Third, we describe how we have implemented portions of these specifications, as well as several enhancements, using TAO, which is our open-source real time CORBA ORB. Finally, we empirically evaluate the performance of TAO to illustrate how its features address the QoS requirements of certain types of real time applications.

Evaluating policies and mechanisms to support distributed real‐time applications with CORBA

To be an effective platform for performance‐sensitive real‐time systems, commodity‐off‐the‐shelf (COTS) distributed object computing (DOC) middleware must support application quality of service (QoS) requirements end‐to‐end. However, conventional COTS DOC middleware does not provide this support, which makes it unsuited for applications with stringent latency, determinism, and priority preservation requirements. It is essential, therefore, to develop standards‐based, COTS DOC middleware that permits the specification, allocation, and enforcement of application QoS requirements end‐to‐end.

Architectures and Patterns for Developing High-performance, Real-time ORB Endsystems

Abstract Many types of applications can benefit from flexible and open middleware. CORBA is an emerging middleware standard for Object Request Brokers (ORBs) that simplifies the development of distributed applications and services. Experience with CORBA demonstrates that it is suitable for traditional RPC-style applications. However, the lack of performance optimizations and quality of service (QoS) features in conventional CORBA implementations make them unsuited for high-performance and real-time applications. This paper makes four contributions to the design of CORBA ORBs for applications with high-performance and real-time requirements. First, it describes the design of TAO, which is our high-performance, real-time CORBA-compliant ORB. Second, it presents TAO’s real-time scheduling service, which provides QoS guarantees for deterministic real-time CORBA applications. Third, it empirically evaluates the effects of priority inversion and non-determinism in conventional ORBs and shows how these hazards are avoided in TAO. Fourth, it presents a case study of key patterns used to develop TAO and quantifies the impact of applying patterns to reduce the complexity of common ORB tasks.

Supporting high-performance I/O in QoS-enabled ORB middleware

To be an effective platform for high‐performance distributed applications, off-the-shelf Object Request Broker (ORB) middleware, such as CORBA, must preserve communication-layer quality of service (QoS) properties both vertically (i.e., network interface ↔ application layer) and horizontally (i.e., end-to-end). However, conventional network interfaces, I/O subsystems, and middleware interoperability protocols are not well-suited for applications that possess stringent throughput, latency, and jitter requirements. It is essential, therefore, to develop vertically and horizontally integrated ORB endsystems that can be (1) configured flexibly to support high-performance network interfaces and I/O subsystems and (2) used transparently by performance-sensitive applications. This paper provides three contributions to research on high-performance I/O support for QoS-enabled ORB middleware. First, we outline the key research challenges faced by high-performance ORB endsystem developers. Second, we describe how our real-time I/O (RIO) subsystem and pluggable protocol framework enables ORB endsystems to preserve high-performance network interface QoS up to applications running on off-the-shelf hardware and software. Third, we illustrate empirically how highly optimized ORB middleware can be integrated with real-time I/O subsystem to reduce latency bounds on communication between high-priority clients without unduly penalizing low-priority and best-effort clients. Our results demonstrate how it is possible to develop ORB endsystems that are both highly flexible and highly efficient.