Many distributed real-time and embedded (DRE) applications require a scalable event-driven communication model that decouples suppliers from consumers and simultaneously supports advanced quality of service (QoS) properties and event filtering mechanisms. The CORBA notification service provides publisher/subscriber capabilities designed to support scalable event-driven communication by routing events efficiently between suppliers and consumers, enforcing QoS properties (such as reliability, priority, ordering, and timeliness), and filtering events at multiple points in a distributed system. The standard CORBA notification service is insufficient, however, to enforce predictable communication needed by DRE applications and does not leverage real-time CORBA capabilities, such as end-to-end priority assignment or scheduling services. We make three contributions to the study of scalable real-time notification services for DRE applications. First, we describe the requirements of the OMG request for proposals (RFP) on real-time notification, which seeks solutions to the problem of enforcing real-time properties by enhancing the standard CORBA notification service. Second, we explain how we have addressed key design challenges faced when implementing a real-time notification service for TAO, which is our CORBA-compliant real-time object request broker (ORB). We discuss how we integrate real-time CORBA features (such as thread pools, thread lanes, and priority models) to provide real-time event communication. Finally, we analyze the results of empirical benchmarks of the performance and predictability of TAO's real-time notification service. These results show that the static real-time assurances provided by real-time CORBA are maintained within the more flexible context of TAO's real-time notification service.

In an emerging class of open distributed real-time and embedded (DRE) systems with stringent but dynamic QoS requirements, there is a need to propagate QoS parameters and enforce task QoS requirements across multiple endsystems in a way that is simultaneously efficient and adaptable. The object management group's (OMG) real-time CORBA 2.0 specification (RTC2) defines a dynamic scheduling framework for propagating and enforcing QoS parameters dynamically in standard CORBA middleware. We make two contributions to research on middleware for open DRE systems. First, it describes the design and capabilities of the RTC2 dynamic scheduling framework provided by TAO, which is our open-source CORBA standards-based object request broker (ORB). Second, it describes and summarize the results of empirical studies we have conducted to validate our RTC2 framework in the context of open DRE systems. The results of those experiments show that a range of policies for adaptive scheduling and management of distributable threads can be enforced efficiently in standard middleware for open DRE systems.

End-to-end predictability of remote operations is essential for many fixed-priority distributed real-time and embedded (DRE) applications, such as command and control systems, manufacturing process control systems, large-scale distributed interactive simulations, and testbeam data acquisition systems. To enhance predictability, the Real-time CORBA specification defines standard middleware features that allow applications to allocate, schedule, and control key CPU, memory, and networking resources necessary to ensure end-to-end quality of service support. This paper provides two contributions to the study of Real-time CORBA middleware for DRE applications. First, we identify potential problems with ensuring predictable behavior in conventional middleware by examining the end-to-end critical code path of a remote invocation and identifying sources of unbounded priority inversions. Experimental results then illustrate how the problems we identify can yield unpredictable behavior in conventional middleware platforms. Second, we present design techniques for ensuring real-time quality of service in middleware. We show how middleware can be redesigned to use nonmultiplexed resources to eliminate sources of unbounded priority inversion. The empirical results in this paper are conducted using TAO, which is widely used and open-source DRE middleware compliant with the Real-time CORBA specification.

Abstract 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. The real‐time CORBA and messaging specifications in the CORBA 2.4 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. These specifications still lack sufficient detail, however, to portably configure and control processor, communication, and memory resources for applications with stringent QoS requirements. This paper provides four contributions to research on real‐time DOC middleware. First, we illustrate how the CORBA 2.4 real‐time and messaging specifications provide a starting point to address the needs of an important class of applications with stringent real‐time requirements. Second, we illustrate how the CORBA 2.4 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 evaluate the performance of TAO empirically to illustrate how its features address the QoS requirements for certain classes of real‐time applications. Copyright © 2001 John Wiley & Sons, Ltd.

In many application domains, the distributed object computing (DOC) middleware is responsible for dispatching upcalls to one or more application objects when events or requests arrive from clients. Implementing efficient, predictable, and scalable middleware dispatching mechanisms is hard and implementing them for multi-threaded systems is even harder. In particular dispatching mechanisms must be prepared to dispatch upcalls to multiple objects, to handle recursive requests originated from application-provided upcalls, and must often collaborate with the application to control object life-cycle. In our DOC middleware research we have implemented many dispatching mechanisms that repeatedly apply common solutions to solve the challenges outlined above. Moreover, we have discovered that the forces constraining dispatching mechanisms often differ slightly thereby requiring alternative solutions. This paper presents two contributions to the design and implementation of efficient, predictable, scalable and flexible DOC middleware and applications. First, it shows how patterns can be applied to the object-oriented systems to capture key design and performance characteristics of proven dispatching mechanisms. Second it presents a pattern language that describes successful solutions that are appropriate for key dispatching challenges that arise in various real-time DOC middleware and applications.