Research on Real-time CORBA

The following papers describe our research on real-time CORBA ORBs and related services based on results from the TAO project. If you have trouble obtaining or printing these files see my troubleshooting tips. These are also available electronically in postscript for via anonymous ftp from wuarchive.wustl.edu or in PDF format. The CORBA benchmarking suite that was used to generate these results is available for downloading as part of the TAO release.

  1. Chris Gill, Jeanna M. Gossett, David Corman, Joseph P. Loyall, Richard E. Schantz, Michael Atighetchi, and Douglas C. Schmidt, Integrated Adaptive QoS Management in Middleware: An Empirical Case Study, Submitted to the 10th Real-time Technology and Application Symposium, May 25-28, 2004, Toronto, CA.

    Distributed real-time and embedded (DRE) systems in which application requirements and environmental conditions may not be known a priori or may vary at run-time, mandate an adaptive approach to management of quality-of-service (QoS) to meet key constraints such as end-to-end timeliness. Furthermore, coordinated management of multiple QoS capabilities across layers of applications and their supporting middleware may be required to achieve necessary assurances of meeting these constraints. This paper offers two primary contributions to the state of the art in distributed computing systems: (1) a case study of our integration of multiple middleware QoS management technologies to manage quality and timeliness of imagery adaptively within a representative distributed avionics system and (2) empirical results and analysis of the impact of that integration on fundamental trade-offs between timeliness and image quality in that system.

  2. Arvind Krishna, Douglas C. Schmidt, and Raymond Klefstad, Enhancing Real-Time CORBA via Real-Time Java, Proceedings of the 24th IEEE International Conference on Distributed Computing Systems (ICDCS), May 23-26, 2004, Tokyo, Japan.

    Ensuring end-to-end middleware predictability is essential to support quality of service (QoS) capabilities needed by distributed real-time and embedded (DRE) applications. Real-time CORBA is a middleware standard that allows DRE applications to allocate, schedule, and control the QoS of CPU, memory, and networking resources. Existing implementations of Real-time CORBA are implemented in C++, which is widely considered to be more complicated and error-prone to program than Java and the Real-time Specification for Java (RTSJ). Although Real-time CORBA does not currently leverage key RTSJ features, such as scoped memory and real-time threads, integration of Real-Time CORBA and RTSJ is essential to ensure predictability required for Java-based DRE applications. This paper provides the following contributions to the study of middleware for DRE applications. First, we discuss the optimization strategies applied in the Real-time CORBA Portable Object Adapter (POA) layer. Second, we identify sources for applying RTSJ features within ZEN, which is our implementation of Real-time CORBA that runs atop multiple RTSJ implementations. Third, we qualitatively and quantitatively analyze predictability enhancements arising from applying RTSJ features to the Real-time CORBA POA layer. Our results show that combining optimizations with RTSJ features can considerably improve the performance and predictability of DRE applications written using Real-time CORBA and Java.

  3. Arvind Krishna, Douglas C. Schmidt, Krishna Raman, and Raymond Klefstad, Optimizing the ORB Core to Enhance Real-time CORBA Predictability and Performance, Proceedings of the Submitted to the 5th International Symposium on Distributed Objects and Applications (DOA), Catania, Sicily, November 2003.

    Distributed real-time and embedded (DRE) applications possess stringent quality of service (QoS) requirements, such as low latency, bounded jitter, and high throughput. An increasing number of DRE applications are developed using QoS-enabled middleware, such as Real-time CORBA and the Real-time Specification for Java (RTSJ), to ensure predictable end-to-end QoS. Real-time CORBA is an open middleware standard that allows DRE applications to allocate, schedule, and control the QoS of CPU, memory, and networking resources. The RTSJ provides extensions to Java that enable it to be used as the basis for Real-time CORBA middleware and applications.

    This paper provides the following contributions to the study of QoS-enabled middleware for DRE applications. First, we outline key Real-time CORBA implementation challenges within the ORB Core, focusing on efficient buffer allocation and collocation strategies. Second, we describe how these challenges have been addressed in ZEN, which is an implementation of Real-time CORBA that runs atop RTSJ platforms. Third, we describe how RTSJ features, such as scoped memory and no-heap real-time threads, can be applied in a real-time ORB Core to enhance the predictability of DRE applications using Real-time CORBA and the RTSJ. Our results show that carefully applied optimization strategies can enable RTSJ-based Real-time CORBA ORBs to achieve effective QoS support for a range of DRE applications.

  4. Arvind Krishna, Douglas C. Schmidt, Raymond Klefstad, and Angelo Corsaro, Towards Predictable Real-time Java Object Request Brokers, Proceedings of the 9th IEEE Real-time/Embedded Technology and Applications Symposium (RTAS), Toronto, Canada, May 2003.

    Distributed real-time and embedded (DRE) applications often possess stringent quality of service (QoS) requirements. Designing middleware for DRE applications poses several challenges to object request broker (ORB) developers. This paper provides the following contributions to the study of middleware for DRE applications. First, we outline the challenges present in one of the principal ORB components -- the portable object adapter (POA) -- focusing on predictable and scalable demultiplexing. Second, we describe how these challenges are addressed in ZEN, which is an implementation of Real-time CORBA that runs atop jRate, an ahead-of-time compiler that implements most of the Real-time Specification for Java (RTSJ). Third, we qualitatively and quantitatively compare ZEN's demultiplexing strategies with those of other popular Java ORBs, including JacORB, Sun JDK ORB, and ORBacus. Our results show that ZEN and jRate incorporate the strategies necessary to enable predictability using standards-based middleware and also provide a baseline for what can be achieved by combining Real-time CORBA and RTSJ.

  5. Richard E. Schantz, Joseph P. Loyall, Douglas C. Schmidt, Craig Rodrigues, Yamuna Krishnamurthy, and Irfan Pyarali, Flexible and Adaptive QoS Control for Distributed Real-time and Embedded Middleware, Proceedings of Middleware 2003, 4th IFIP/ACM/USENIX International Conference on Distributed Systems Platforms, June 16-20, 2003, Rio de Janeiro, Brazil.

  6. Irfan Pyarali, Douglas C. Schmidt, and Ron Cytron, Techniques for Enhancing Real-time CORBA Quality of Service, IEEE Proceedings, May 2003.

    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 providing real-time QoS guarantees in middleware. We show how middleware can be redesigned to use non-multiplexed resources to eliminate sources of unbounded priority inversion.

  7. Chris Gill, Fred Kuhns, Douglas C. Schmidt, and Ron Cytron, Empirical Differences Between COTS Middleware Scheduling Paradigms, Proceedings of the Distributed Objects and Applications (DOA) conference, Irvine, CA, October/November, 2002.

    The proportion of complex distributed real-time embedded (DRE) systems made up of commercial-off-the-shelf (COTS) hardware and software is increasing significantly in response to the difficulty and expense of building DRE systems entirely from scratch. In previous work, we showed how applying different scheduling strategies in middleware can allow COTS-based solutions to provide both assurance and optimization of real-time constraints for important classes of mission-critical DRE systems. There are few empirical studies, however, that help developers of COTS-based DRE systems to make crucial distinctions between strategies that appear similar in policy, but whose run-time effects may differ in practice.

    This paper provides two contributions to the study of real-time quality of service (QoS) assurance and performance in COTS-based DRE systems. First, we examine in detail two hybrid static/dynamic scheduling strategies that should behave similarly according to policy alone, but that in fact produce different results under the same conditions, both in utilization and in meeting real-time assurances. Second, we offer recommendations based on these results for developers of mission-critical DRE systems, such as the Boeing Bold Stroke platform used in the Adaptive Software Flight Demonstration (ASFD) program under which our experiments were conducted. These contributions address and highlight the importance of the following issues to real-time scheduling in COTS environments: (1) careful mapping of scheduling policies into implementation mechanisms and (2) benchmarking and analysis of actual systems in representative operational environments.

  8. Mayur Deshpande, Douglas C. Schmidt, Carlos O'Ryan, Darrell Brunsch, The Design and Performance of Asynchronous Method Handling for CORBA, Proceedings of the Distributed Objects and Applications (DOA) conference, Irvine, CA, October/November, 2002.

    This paper describes the design and performance of a new asynchronous method handling (AMH) mechanism that allows CORBA servers to process client requests asynchronously. AMH decouples the association of an incoming request from the run-time stack that received the request, without incurring the context-switching, synchronization, and data movement overhead of conventional CORBA multi-threading models. A servant upcall can therefore return quickly, while the actual work performed by the servant can run asynchronously with respect to other client requests.

    This paper provides two contributions to the study of asynchrony for CORBA servers. First, it describes the design and implementation of AMH in The ACE ORB (TAO), which is a widely-used, high-performance, open-source implementation of CORBA. The syntax and semantics of AMH are defined using the CORBA Interface Definition Language (IDL), the forces that guided the design of AMH are described, and the patterns and C++ idioms used to resolve these forces to implement AMH in TAO are presented. Second, we empirically compare a middle-tier server implemented using AMH against other CORBA server concurrency models, such as thread pool, thread-per-connection, and thread-per-request. The benchmarks show that AMH delivers better throughput and scalability for heavily loaded servers, though it lags a bit in performance for lightly loaded servers. Analysis and optimization techniques to improve the performance of AMH are then described.

  9. Douglas C. Schmidt, Aniruddha Gokhale, and Christopher D. Gill, Patterns and Performance of Real-time and Data Parallel CORBA for High-Performance Embedded Computing Applications, Proceedings of the 6th Annual Workshop on High Performance Embedded Computing, Boston, MA, September 24--26, 2002.

    High performance embedded computing (HPEC) systems are widely used for sensor-driven, signal and image processing (SIP) applications with stringent simultaneous quality of service (QoS) requirements, such as predictability, scalability, high performance, and reliability. Several emerging technologies are driving R&D efforts to integrate the power of standards-based component middleware and Model-Integrated Computing (MIC) tools to address the needs of HPEC applications:

    The confluence of these technologies is making it possible to model the interfaces and semantics of various HPEC application and system components via standard middleware, rather than language-, OS, or hardware-specific features or proprietary APIs. This abstract describes how we are applying MDA/MIC to synthesize, assemble, and deploy HPEC applications based on the RT-CORBA and DP-CORBA component middleware.

  10. Douglas C. Schmidt and Carlos O'Ryan, Patterns and Performance of Distributed Real-time and Embedded Publisher/Subscriber Architectures,'' Journal of Systems and Software, Special Issue on Software Architecture -- Engineering Quality Attributes, edited by Jan Bosch and Lars Lundberg, 2002.

    This paper makes four contributions to the design and evaluation of publisher/subscriber architectures for distributed real-time and embedded (DRE) applications. First, it illustrates how a flexible publisher/subscriber architecture can be implemented using standard CORBA middleware. Second, it shows how to extend the standard CORBA publisher/subscriber architecture so it is suitable for DRE applications that require low latency and jitter, periodic rate-based event processing, and event filtering and correlation. Third, it explains how to address key performance-related design challenges faced when implementing a publisher/subscriber architecture suitable for DRE applications. Finally, the paper presents benchmarks that empirically demonstrate the predictability, latency, and utilization of a widely used Real-time CORBA publisher/subscriber architecture. Our results demonstrate that it is possible to strike an effective balance between architectural flexibility and real-time quality of service for important classes of DRE applications.

  11. Angelo Corsaro and Douglas C. Schmidt, Evaluating Real-Time Java Features and Performance for Real-time Embedded Systems, Proceedings of the 8th IEEE Real-Time Technology and Applications Symposium, San Jose, CA, September 2002.

    Over 90 percent of all microprocessors are now used for real-time and embedded applications, and the behavior of many of these applications is constrained by the physical world. Higher-level programming languages and middleware are needed to robustly and productively design, implement, compose, integrate, validate, and enforce real-time constraints along with conventional functional requirements and reusable components.

    This paper provides two contributions to the study of programming languages and middleware for real-time and embedded applications. First, we present the empirical results from applying the RTJPerf benchmarking suite to evaluate the efficiency and predictability of several implementations of the Real-time Specification for Java (RTSJ). Second, we describe the techniques used to develop jRate, which is an open-source ahead-of-time-compiled implementation of RTSJ we are developing. Our results indicate that RTSJ implementations are maturing to the point where they can be applied to a variety of real-time embedded applications.

  12. Irfan Pyarali, Douglas C. Schmidt, and Ron Cytron, Achieving End-to-End Predictability of the TAO Real-time CORBA ORB, Proceedings of the 8th IEEE Real-Time Technology and Applications Symposium, San Jose, CA, September 2002.

    End-to-end predictability of 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 facilitate this common requirement, 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 presents the results of empirical studies that illustrate how a Real-time CORBA ORB can provide end-to-end QoS guarantees in middleware. The results in this paper are based on TAO, which is widely-used, open-source, Real-time CORBA-compliant DRE middleware. TAO uses non-multiplexed resources to eliminate sources of unbounded priority inversion.

  13. Chris Gill, Fred Kuhns, Douglas C. Schmidt, and Ron Cytron, Empirical Differences Between COTS Middleware Scheduling Paradigms, Proceedings of the 8th IEEE Real-Time Technology and Applications Symposium, San Jose, CA, September 2002.

    The proportion of complex distributed real-time embedded (DRE) systems made up of commercial-off-the-shelf (COTS) hardware and software is increasing significantly in response to the difficulty and expense of building DRE systems entirely from scratch. In previous work, we showed how applying different scheduling strategies in middleware can allow COTS-based solutions to provide both assurance and optimization of real-time constraints for important classes of mission-critical DRE systems. There are few empirical studies, however, that help developers of COTS-based DRE systems make crucial distinctions between strategies that appear similar in policy, but whose run-time effects may differ in practice.

    This paper provides two contributions to the study of real-time quality of service (QoS) assurance and performance in COTS-based DRE systems. First, we examine in detail two hybrid static/dynamic scheduling strategies that should behave similarly according to policy alone, but that in fact produce different results under the same conditions, both in utilization and in meeting real-time assurances. Second, we offer recommendations based on these results for developers of mission-critical DRE systems, such as the Boeing Bold Stroke platform used in the Adaptive Software Flight Demonstration (ASFD) program under which our experiments were conducted. These contributions address and highlight the importance of the following issues to real-time scheduling in COTS environments: (1) careful mapping of scheduling policies into implementation mechanisms and (2) benchmarking and analysis of actual systems in representative operational environments.

  14. Christopher D. Gill, Douglas C. Schmidt, and Ron Cytron, Multi-Paradigm Scheduling for Distributed Real-Time Embedded Computing, IEEE Proceedings Special Issue on Modeling and Design of Embedded Systems, Volume 91, Number 1, January 2003.

    Increasingly complex requirements, coupled with with tighter economic and organizational constraints, are making it hard to build complex distributed real-time embedded (DRE) systems entirely from scratch. The proportion of DRE systems made up of commercial-off-the-shelf (COTS) hardware and software is therefore increasing significantly. There are relatively few systematic empirical studies, however, that illustrate how suitable COTS-based hardware and software have become for mission-critical DRE systems.

    This paper provides the following contributions to the study of real-time quality of service (QoS) assurance and performance in COTS-based DRE systems: (1) it presents evidence that flexible configuration of COTS middleware mechanisms, and the operating system settings they use, allows DRE systems to meet critical QoS requirements over a wider range of load and jitter conditions than statically configured systems, (2) it shows that in addition to making critical QoS assurances, non-critical QoS performance can be improved through flexible support for alternative scheduling strategies, and (3) it presents an empirical study of three canonical scheduling strategies---specifically the conditions that predict success of a strategy for a production-quality DRE avionics mission computing system. Our results show that applying a flexible scheduling framework to COTS hardware, operating systems, and middleware improves real-time QoS assurance and performance for mission-critical DRE systems.

  15. Christopher D. Gill, Ron Cytron, and Douglas C. Schmidt, Middleware Scheduling Optimization Techniques for Distributed Real-Time and Embedded Systems, the 7th IEEE Workshop on Object-oriented Real-time Dependable Systems, San Diego, CA, January, 2002.

    Developers of mission-critical distributed real-time and embedded (DRE) systems face a fundamental tension between (1) the performance gains achievable with hand-crafted optimizations to systems built largely from scratch and (2) the development cost and cycle-time reductions offered by common off-the-shelf (COTS) middleware.

    This paper describes how the Kokyu portable middleware scheduling framework, which is built using standards-based COTS middleware and OS primitives, can be used both to (1) maintain the flexibility and reuse offered by COTS middleware and (2) provide opportunities for domain-specific optimizations that are needed to meet stringent real-time performance requirements.

  16. Douglas C. Schmidt and Mayur Deshpande and Carlos O'Ryan, Operating System Performance in Support of Real-time Middleware, Proceedings of the 7th IEEE Workshop on Object-oriented Real-time Dependable Systems, San Diego, CA, January, 2002.

    Commercial-off-the-shelf (COTS) hardware and software is being evaluated and/or used in an increasing range of mission-critical distributed real-time and embedded (DRE) systems. Due to substantial R&D investment over the past decade, COTS middleware has recently matured to the point where it is no longer the dominant factor in the overhead, non-determinism, and priority inversion incurred by DRE systems. As a result, the focus has shifted to the COTS operating systems and networks, which are once again responsible for the majority of end-to-end latency and jitter.

    This paper compares and evaluates the suitability of popular COTS operating systems for real-time COTS middleware, such as Real-time CORBA. We examine real-time operating systems (VxWorks and QNX), general-purpose operating systems with real-time thread scheduling classes (Windows NT, Windows 2K, and Linux), and a hybrid real-time/general-purpose operating system (Linux/RT). While holding the hardware and ORB constant, we vary these operating systems systematically to measure platform-specific variations in context switch overhead, throughput of the ORB in terms of two-way operations per-second and memory footprint of the ORB libraries. We also measure how the latency and jitter of high-priority operations are affected as the number of low-priority operations increase.

    Our results indicate that real-time operating systems remain the platforms of choice to deliver predictable, efficient, and scalable performance for DRE middleware and applications. However, the emergence of hybrid general-purpose/real-time operating systems, such as Linux/RT, are a promising direction for future DRE systems. Although Linux/RT is not yet as deterministic as traditional real-time operating systems, such as QNX and VxWorks, it does provide more predictable and scalable behavior compared to mainstream operating systems, such as Windows NT/2K. Since traditional real-time operating systems tend to be expensive and tedious to configure/program, the maturation of Linux/RT will be a welcome advance for DRE system developers.

  17. Carlos O'Ryan and Douglas C. Schmidt and J. Russell Noseworthy, Patterns and Performance of a CORBA Event Service for Large-scale Distributed Interactive Simulations International Journal of Computer Systems Science and Engineering, CRL Publishing, 2001.

    Next-generation distributed interactive simulations 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 distributed interactive simulation systems.

    This paper makes five contributions to the design, implementation, and performance measurement of distributed interactive simulation 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 distributed interactive simulations. 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.

  18. Angelo Corsaro, Douglas C. Schmidt, Chris Gill, and Ron Cytron, Formalizing Meta-Programming Techniques to Reconcile Heterogeneous Scheduling Policies in Open Distributed Real-Time Systems, Proceedings of the 3rd International Symposium on Distributed Objects and Applications, September 8-10, 2001, Rome, Italy.

    In open distributed real-time and embedded (DRE) systems, different ORB endsystems may use different scheduling policies. To ensure appropriate end-to-end application behavior in an open architecture, however, DRE systems must enforce an ordering on activities originating in an endsystem and activities that migrate there, based on the relative importance of these activities. This paper describes the meta-programming techniques applied in Juno, which is an extension to Real-time CORBA that enhances the openness of DRE systems with respect to their scheduling policies by enabling dynamic ordering of priority equivalence classes. We use the forthcoming OMG Dynamic Scheduling Real-time Specification of CORBA (DSRT-CORBA) as a case study to illustrate our techniques.

  19. Darrell Brunsch, Carlos O'Ryan, and Douglas C. Schmidt, Designing an Efficient and Scalable Server-side Asynchrony Model for CORBA, Proceedings of the ACM SIGPLAN Workshop on Optimization of Middleware and Distributed Systems (OM 2001), Snowbird, Utah, June 18, 2001.

    When the Asynchronous Method Invocation (AMI) model was introduced into the CORBA specification, client applications benefited from the ability to invoke non-blocking two-way requests. In particular, AMI improved the scalability of clients by removing the restrictions associated with Synchronous Method Invocations (SMI). Server request handling remained synchronous, however, which minimized the benefits of AMI for middle-tier servers, such as firewall gateways and front-end database servers.

    This paper describes our strategy for implementing a scalable server-side asynchrony model for CORBA. We first outline the key design challenges faced when developing an Asynchronous Method Handling (AMH) model for CORBA and then describe how we are resolving these challenges in TAO, our high-performance, real-time CORBA ORB. In general, AMH-based CORBA servers provide more scalability than existing concurrency models, with only a moderate increase in programming complexity. Although targeted for CORBA, similar techniques can also be used in other method-oriented middleware, such as COM+ and Java RMI.

  20. David A. Karr, Craig Rodrigues, Yamuna Krishnamurthy, Irfan Pyarali, and Douglas C. Schmidt Application of the QuO Quality-of-Service Framework to a Distributed Video Application, Proceedings of the 3rd International Symposium on Distributed Objects and Applications, September 8-10, 2001, Rome, Italy.

    Adaptation of distributed software to maintain the best possible application performance in the face of changes in available resources is an increasingly important and complex problem. We discuss the application of the QuO adaptive middleware framework and the CORBA A/V Streaming Service to the development of real-time embedded applications. We demonstrate a standards-based middleware platform for developing adaptive applications that are better architected an easier to modify and that can adapt to changes in resource availability to meet QoS requirements. These are presented in the context of a video distribution application. The application is developed using QuO and the A/V Streaming Service, and uses adaptive behavior to meet timeliness requirements in the face of restrictions in processing power and network bandwidth. We present experimental results we have gathered for this application.

  21. Yamuna Krishnamurthy, Vishal Kachroo, David A. Karr, Craig Rodrigues, Joseph P. Loyall, Richard Schantz, and Douglas C. Schmidt, Integration of QoS-enabled Distributed Object Computing Middleware for Developing Next-generation Distributed Applications, Proceedings of the ACM SIGPLAN Workshop on Optimization of Middleware and Distributed Systems (OM 2001), Snowbird, Utah, June 18, 2001.

    This paper describes the integration of QoS-enabled distributed object computing (DOC) middleware for developing next-generation distributed applications. QoS-enabled DOC middleware, facilitates ease of development and deployment of applications that can leverage the underlying networking technology or end-system QoS architecture. This paper also describes the development of a demonstration application utilizing QoS-enabled middleware to control the dissemination of Unmanned Air Vehicle (UAV) data throughout a ship.

  22. Irfan Pyarali, Marina Spivak, Douglas C. Schmidt, and Ron Cytron, Optimizing Thread-Pool Strategies for Real-Time CORBA, Proceedings of the ACM SIGPLAN Workshop on Optimization of Middleware and Distributed Systems (OM 2001), Snowbird, Utah, June 18, 2001.

    Strict control over the scheduling and execution of processor resources is essential for many fixed-priority real-time applications. To facilitate this common requirement, the Real-Time CORBA (RT-CORBA) specification defines standard middleware features that support end-to-end predictability for operations in fixed-priority CORBA applications. One of the most important features in RT-CORBA is thread pools, which allow application developers and end-users to configure and control processor resources.

    This paper provides two contributions to the evaluation of techniques for improving the quality of service (QoS) of RT-CORBA thread pools. First, we describe the key patterns underlying common strategies for implementing RT-CORBA thread pools. Second, we evaluate each thread pool strategy in terms of its consequences on (1) feature support, such as request buffering and thread borrowing, (2) scalability in terms of endpoints and event demultiplexers required, (3) efficiency in terms of data movement, context switches, memory allocations, and synchronizations required, (4) optimizations in terms of stack and thread specific storage memory allocations, and (5) bounded and unbounded priority inversion incurred in each implementation. This paper also provide results that illustrate empirically how different thread pool implementation strategies perform in different ORB configurations.

  23. J. Loyall, J. Gossett, C. Gill, R. Schantz, J. Zinky, P. Pal, R. Shapiro, C. Rodrigues, M. Atighetchi, and D. Karr Comparing and Contrasting Adaptive Middleware Support in Wide-Area and Embedded Distributed Object Applications, 21st International Conference on Distributed Computing Systems (ICDCS-21), Phoenix, Arizona, USA April 16-19, 2001.

    The Quality Objects (QuO) middleware is a set of extensions to standard distributed object computing middleware that is used to control and adapt quality of service in a number of distributed application environments, from wide-area to embedded distributed applications. This paper compares and contrasts the characteristics of key use cases and the variations in QuO implementations that have emerged to support them. We pres-ent these variations in the context of several actual applications being developed using the QuO middleware.

  24. Carlos O'Ryan, Douglas C. Schmidt, Fred Kuhns, Marina Spivak, Jeff Parsons Irfan Pyarali, and David L. Levine, Evaluating Policies and Mechanisms to Support Distributed Real-Time Applications with CORBA, Evaluating Policies and Mechanisms to Support Distributed Real-time Applications with CORBA (Special Issue on Distributed Objects and Applications), Wiley and Sons, Vol. 13, No. 2, February, 2001.

    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.

  25. Sumedh Mungee, Nagarajan Surendran, Yamuna Krishnamurthy, and Douglas C. Schmidt The Design and Performance of a CORBA Audio/Video Streaming Service, A chapter in the book Design and Management of Multimedia Information Systems: Opportunities and Challenges, edited by Mahbubur Syed and to be published by Idea Group Publishing, Hershey, USA, in 2000.

    This paper presents an overview of the key architectural components in the CORBA A/V Streaming Service and then summarizes the key design challenges faced when developing TAO's CORBA A/V Streaming Service and outline how we applied patterns to resolve these challenges. In addition, it describes the design and performance of the pluggable A/V protocol framework integrated into TAO's A/V Streaming Service.

  26. Carlos O'Ryan, Douglas C. Schmidt, Fred Kuhns, Marina Spivak, Jeff Parsons Irfan Pyarali, and David L. Levine, Evaluating Policies and Mechanisms for Supporting Embedded, Real-Time Applications with CORBA 3.0, Proceedings to the Sixth IEEE Real-Time Technology and Applications Symposium (RTAS'00), Washington D.C., USA, May 31-June 2, 2000.

    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 lack sufficient detail 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 characterize the QoS requirements of an important class of applications with stringent real-time requirements and illustrate how the CORBA 3.0 Real-time and Messaging specifications provide a starting point for addressing these requirements. Second, we illustrate 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.

  27. Douglas C. Schmidt and Fred Kuhns, An Overview of the Real-time CORBA Specification, IEEE Computer special issue on Object-Oriented Real-time Distributed Computing, edited by Eltefaat Shokri and Philip Sheu, June 2000.

    To be an effective platform for performance-sensitive real-time systems, distributed object computing middleware must support application quality of service (QoS) requirements end-to-end. This article describes how the OMG's Real-time CORBA specification defines standard policies and mechanisms that permit the specification and enforcement of end-to-end QoS.

  28. Nanbor Wang, Douglas C. Schmidt, and David Levine, Optimizing the CORBA Component Model for High-performance and Real-time Applications, Work-in-progress paper for the IFIP/ACM Middleware 2000 Conference, Pallisades, New York, April 3-7, 2000.

    With the recent adoption of the CORBA component model (CCM), application programmers now have a standard way to implement, manage, configure, and deploy components that implement and integrate CORBA services. The CCM standard not only enables greater software reuse for servers, it also provides greater flexibility for dynamic configuration of CORBA applications. Thus, CCM appears to be well-suited for general-purpose client/server applications.

    Due to the complexity of the standard and relative immaturity of implementations, however, CCM is not yet appropriate for mission-critical applications with high-performance and real-time quality-of-server (QoS) requirements. Therefore, we have begun a project to identify, prototype, benchmark, optimize, and deploy the key patterns and framework components necessary to mature the CCM standard so it can be applied successfully to mission-critical applications with stringent QoS requirements.

    There are two contributions of our research project. First, we are identifying the performance bottlenecks and other obstacles that impede the use of CCM for high-performance and real-time applications. Second, we are demonstrating the effectiveness of our methodology of applying optimization principle patterns to alleviate these obstacles.

  29. Christopher D. Gill, Fred Kuhns, David Levine, Douglas C. Schmidt, Bryan S. Doerr, Richard E. Schantz, and Alia K. Atlas, Applying Adaptive Real-time Middleware to Address Grand Challenges of COTS-based Mission-Critical Real-Time Systems, Proceedings of the 1st International Workshop on Real-Time Mission-Critical Systems: Grand Challenge Problems, IEEE, Phoenix, Arizona, November 30, 1999.

    Commercial-off-the-shelf (COTS) middleware addresses many design forces for developing mission-critical distributed systems, including reducing development cost and cycle-time. However, meeting additional requirements for real-time quality of service (QoS) in these systems is currently beyond the state-of-the-art in available COTS middleware solutions. In this paper, we discuss key research challenges associated with determining the policies, mechanisms, and patterns required to create a new generation of QoS-enabled COTS middleware for real-time mission-critical systems.

  30. Carlos O'Ryan, Fred Kuhns, Douglas C. Schmidt, Ossama Othman, and Jeff Parsons, The Design and Performance of a Pluggable Protocols Framework for Real-time Distributed Object Computing Middleware, (updated October 14) IFIP/ACM Middleware 2000 Conference, Pallisades, New York, April 3-7, 2000

    To be an effective platform for performance-sensitive real-time and embedded applications, off-the-shelf CORBA middleware must preserve the communication-layer quality of service (QoS) properties of applications end-to-end. However, the standard CORBA GIOP/IIOP interoperability protocols are not well suited for applications that cannot tolerate the message footprint size, latency, and jitter associated with general-purpose messaging and transport protocols. It is essential, therefore, to develop standard pluggable protocols frameworks that allow custom messaging and transport protocols to be configured flexibly and used transparently by applications.

    This paper provides three contributions to research on pluggable protocols frameworks for performance-sensitive distributed object computing (DOC) middleware. First, we outline the key design challenges faced by pluggable protocols developers. Second, we describe how we resolved these challenges by developing a pluggable protocols framework for TAO, which is our high-performance, real-time CORBA-compliant ORB. Third, we present the results of benchmarks that pinpoint the impact of TAO's pluggable protocols framework on its end-to-end efficiency and predictability.

    Our results demonstrate how the application of optimizations and patterns to DOC middleware can yield both highly flexible/reusable designs and highly efficient/predictable implementations. In particular, the overall roundtrip latency of a TAO two-way method invocation using the standard inter-ORB protocol and using a commercial, off-the-self Pentium II Xeon 400 MHz workstation running in loopback mode is ~189 usecs. The ORB middleware accounts for approximately 48% or ~90 usecs of the total roundtrip latency. Using the specialized POSIX local IPC protocol reduces roundtrip latency to ~125 usecs. These results illustrate that (1) DOC middleware performance is largely an implementation detail and (2) the next-generation of optimized, standards-based CORBA middleware can replace ad hoc and proprietary solutions.

  31. Bryan S. Doerr, Thomas Venturella, Rakesh Jha, Christopher D. Gill, and Douglas C. Schmidt, Adaptive Scheduling for Real-time, Embedded Information Systems, Proceedings of the 18th IEEE/AIAA Digital Avionics Systems Conference (DASC), St. Louis, Missouri, October 24-29, 1999.

    One way to increase software system adaptability is to allocate resources dynamically at run-time rather than statically at design time. For example, fine-grained run-time allocation of processor utilization and network bandwidth creates an opportunity to execute multi-modal operations. This allocation strategy enhances adaptability by combining deterministic and non-deterministic functionality. In general, adaptability is essential to improve versatility and decrease lifecycle maintenance costs for embedded real-time systems.

    Consider the following dynamic resource allocation example: as the pilot of an aircraft nears a weapon release point, he must maneuver the aircraft based on information computed by an embedded mission computer. It is also important, however, to simultaneously monitor for and react to possible air threats, using the same mission computer. In legacy mission computing systems, which were designed according to static resource allocation techniques, the pilot must allocate processing resources manually by switching between different mission computer operating modes to perform both of these functions.

    Underlying the design of these legacy systems are resource allocation strategies that optimize resource utilization for each mode. These strategies suffer, however, from embedding allocation decisions within application components, which complicates reuse. Likewise extensive system testing must be conducted whenever these strategies change.

    Dynamic resource allocation has the potential to provide pilots more operational capability with less manual intervention. In the prior example, for instance, the use of dynamic allocation could simultaneously provide the pilot continuously varying qualities of air threat data and release point information, as measured by target count, accuracy, etc. While implementing this capability within a specific solution would be straightforward, it is more challenging to support operator configured generic adaptation, using information known only at mission time. It is even more challenging to perform generic run-time adaptation while still ensuring correct overall system operation. It is this type of adaptation, however, that allows mission computing system developers to produce application components that are more stable in the presence of resource variability.

    The example above is just one instance of the general evolution of embedded systems from pre-configured "point-solutions" (with strictly controlled inputs and outputs) to operator-configurable systems capable of operating in less deterministic situations. In general, real-time information systems, such as those within fighter aircraft, multimedia applications, and manufacturing plants, are becoming increasingly interconnected with other real-time and non-real-time systems. Due to the desire to react to information derived from this increased data sharing, real-time information systems are evolving to be more supportive of functional customization later in their deployment lifecycles. This evolution motivates our research into adaptive software systems.

    In summary, adaptability can be defined as an aggregate measure of key software characteristics that support customization of software functionality after initial development. High adaptability occurs when the application provides numerous, significant customization options based on user or system input. While many examples of solution-specific adaptability exist in prior work, our goal is to make adaptive characteristics an integral part of real-time, embedded system software architectures.

    Many software architectural precepts are mechanized within a software framework that supports application development. A software framework is "a set of cooperating classes that make up a reusable design for a family of related software applications." Our resulting framework will enable developers to produce adaptive components, even for functionality that does not have initial requirements for adaptability. Our hypothesis is that the resulting applications will be more extensible to future requirements, thereby lowering costs for maintenance and enhancement over the lifecycle of the software.

  32. Christopher D. Gill, David L. Levine, Carlos O'Ryan, and Douglas C. Schmidt, Distributed Object Visualization for Sensor-Driven Systems, Proceedings of the 18th IEEE/AIAA Digital Avionics Systems Conference (DASC), St. Louis, Missouri, October 24-29, 1999.

    Many sensor-driven systems, such as those for avionics mission computing and for manufacturing process control, have stringent timing requirements for processing sensor data. Furthermore, many of these systems must manage multiple sources of sensor data simultaneously. Our previous work has shown that sensor-driven systems can be implemented efficiently and predictably using a real-time CORBA Event Service. This approach allows designers of real-time systems to leverage the benefits of flexible and open distributed computing architectures, such as those defined in the CORBA specification, while still meeting real-time requirements for efficiency, scalability, and predictability. To build and manage these types of systems, application developers and test engineers must be able to monitor and visualize the systems' real-time behavior.

    This paper describes how we have extended our distributed object visualization environment (DOVE) framework to monitor the timing behavior of a real-time application that generates and processes two separate streams of simulated sensor data events. The principal contributions of this paper are: 1) applying the DOVE framework to a simulated sensor-driven application, 2) extending the DOVE framework to support new application requirements, and 3) demonstrating and visualizing quality of service (QoS) control for multiple event streams within a real-time CORBA Event Service.

  33. Fred Kuhns, Douglas C. Schmidt, and David L. Levine, The Performance of a Real-time I/O Subsystem for QoS-enabled ORB Middleware, Proceedings of the International Symposium on Distributed Objects and Applications (DOA '99), OMG, Edinburgh, Scotland, September 1999.

    There is increasing demand to extend Object Request Broker (ORB) middleware to support applications with stringent quality of service (QoS) requirements. However, conventional ORBs do not define standard features for specifying or enforcing end-to-end QoS for applications with deterministic real-time requirements. This paper describes the design and performance of a real-time I/O (RIO) subsystem optimized for QoS-enabled ORB endsystems that support high-performance and real-time applications running on off-the-shelf hardware and software. The paper illustrates how integrating a real-time ORB with 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.

  34. Fred Kuhns, Carlos O'Ryan, Douglas C. Schmidt, Ossama Othman, and Jeff Parsons, The Design and Performance of a Pluggable Protocols Framework for Object Request Broker Middleware, Proceedings of the IFIP Sixth International Workshop on Protocols For High-Speed Networks (PfHSN '99), Salem, MA, August 25--27, 1999.

    To be an effective platform for performance-sensitive real-time and embedded applications, off-the-shelf CORBA middleware must preserve communication-layer quality of service (QoS) properties to applications end-to-end. However, the standard CORBA's GIOP/IIOP interoperability protocols are not well suited for applications that cannot tolerate the message footprint size, latency, and jitter associated with general-purpose messaging and transport protocols. It is essential, therefore, to develop standard pluggable protocols frameworks that allow custom messaging and transport protocols to be configured flexibly and used transparently by applications.

    This paper provides three contributions to research on pluggable protocols frameworks for performance-sensitive middleware applications. First, we outline the key design challenges faced by pluggable protocols developers. Second, we describe how TAO, our high-performance, real-time CORBA-compliant ORB, addresses these challenges in its pluggable protocols framework. Third, we present the results of benchmarks that pinpoint the impact of TAO's OO design on its end-to-end efficiency, predictability, and scalability.

    Our results demonstrate how applying optimizations to CORBA middleware can yield highly flexible/reusable designs and highly efficient/predictable implementations. In particular, the overall round-trip latency of a TAO two-way method invocation using the standard inter-ORB protocol and using a commercial, off-the-self Pentium II Xeon 400 MHz workstation running in loopback mode is ~125 usecs. The ORB middleware accounts for approximately 48% or ~60 usecs of the total round-trip latency. These results illustrate that (1) CORBA middleware performance is largely an implementation detail and (2) the next-generation of optimized, standards-based CORBA middleware can replace ad hoc and proprietary solutions.

  35. Applying Optimization Patterns to Real-time ORBs, Proceedings of the 5th USENIX Conference on Object-Oriented Technologies and Systems, May 3-7, 1999, San Diego, CA and subsequently in IEEE Concurrency, edited by Murthy Devarakonda, to appear 2000. (with Irfan Pyarali, Carlos O'Ryan, Vishal Kachroo, Andy Gokhale, and Nanbor Wang).

    First-generation CORBA middleware was reasonably successful at meeting the demands of request/response applications with best-effort quality of service (QoS) requirements. Supporting applications with more stringent QoS requirements poses new challenges for next-generation real-time CORBA middleware, however. This paper provides three contributions to the design and optimization of real-time CORBA middleware. First, we outline the challenges faced by real-time ORBs implementers, focusing on requirements for efficient, predictable, and scalable concurrency, demultiplexing, and protocol processing in CORBA's ORB Core and Object Adapter components. Second, we describe how TAO, our real-time CORBA implementation, addresses these challenges by applying key ORB optimization principle patterns. Third, we present the results of empirical benchmarks that compare the impact of TAO's patterns and design strategies on ORB efficiency, predictability, and scalability.

    Our results indicate that it is possible to develop highly configurable and adaptable ORBs that can meet the QoS requirements of many real-time applications. A key contribution of our work is to demonstrate that the ability of CORBA ORBs to support real-time systems is largely an implementation detail. In particular, relatively few changes are required to the standard CORBA reference model and programming API to support real-time applications.

  36. An Empirical Evaluation of OS Support for Real-time CORBA Object Request Brokers, Proceedings of the Multimedia Computing and Networking 2000 (MMCN00) conference, ACM, San Jose, CA, January 25-27 2000. (with David Levine and Sergio Flores-Gaitan)

    There is increasing demand to extend Object Request Broker (ORB) middleware to support distributed applications with stringent real-time requirements. However, lack of proper OS support can yield substantial inefficiency and unpredictability for ORB middleware. This paper provides two contributions to the study of OS support for real-time ORBs.

    First, we empirically compare and evaluate the suitability of real-time operating systems, VxWorks and LynxOS, and general-purpose operating systems with real-time extensions, Windows NT, Solaris, and Linux, for real-time ORB middleware. While holding the hardware and ORB constant, we vary these operating systems and measure platform-specific variations, such as context switching, priority inversions, deterministism, and ORB/OS CPU processing overhead. Second, we describe key areas where these operating systems must improve to support predictable, efficient, and scalable ORBs.

    Our findings illustrate that general-purpose operating systems like Windows NT and Solaris are not yet suited to meet the demands of applications with stringent QoS requirements. However, LynxOS does enable predictable and efficient ORB performance, thereby making it a compelling OS platform for real-time CORBA applications. Linux provides good raw performance, though it is not a real-time operating system. Surprisingly, VxWorks does not scale robustly. In general, our results underscore the need for a measure-driven methodology to pinpoint sources of priority inversion and non-determinism in real-time ORB endsystems.

  37. Measuring OS Support for Real-time CORBA ORBs, Proceedings of the Fourth IEEE International Workshop on Object-oriented Real-time Dependable Systems (WORDS'99), Santa Barbara, California, January 27-29, 1999. (with David Levine and Sergio Flores-Gaitan)

    There is increasing demand to extend Object Request Broker (ORB) middleware to support distributed applications with stringent real-time requirements. However, lack of proper OS support can yield substantial inefficiency and unpredictability for ORB middleware. This paper provides empirical contributions to the study of OS support for real-time ORBs.

    We compare and evaluate the suitability of real-time operating systems, VxWorks and LynxOS, and general-purpose operating systems with real-time extensions, Windows NT, Solaris, and Linux, for real-time ORB middleware. While holding the hardware and ORB constant, we vary these operating systems and measure platform-specific variations in context switching overhead and priority inversions.

    Our findings illustrate that general-purpose operating systems like Windows NT, Solaris, and Linux are not yet suited to meet the demands of applications with stringent QoS requirements. Although Linux provides good raw performance, its high jitter makes it unsuitable for real-time applications. Both LynxOS and VxWorks do enable predictable and efficient ORB performance, however, thereby making them suitable as OS platforms for real-time CORBA applications. In general, our results underscore the need for a measure-driven methodology to pinpoint sources of overhead and priority inversion in real-time ORB endsystems.

  38. The Design and Performance of RIO -- a Real-time I/O Subsystem for ORB Endsystems , Proceedings of the 5th IEEE Real-Time Technology and Applications Symposium (RTAS99), Vancouver, British Columbia, Canada, June 2-4, 1999. (with Fred Kuhns and David Levine).

    There is increasing demand to extend Object Request Broker (ORB) middleware to support applications with stringent quality of service (QoS) requirements. However, conventional ORBs do not define standard features for specifying or enforcing end-to-end QoS for applications with deterministic real-time requirements. This paper provides two contributions to the study of real-time ORB middleware. This paper describes the design and performance of a real-time I/O (RIO) subsystem optimized for ORB endsystems that support real-time applications running on ``off-the-shelf'' hardware and software.

  39. Douglas C. Schmidt, David L. Levine, and Chris Cleeland, Architectures and Patterns for High-performance, Real-time CORBA Object Request Brokers, Advances in Computers, Academic Press, Ed., Marvin Zelkowitz, to appear.

    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 currently 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 presents performance measurements that demonstrate the effects of priority inversion and non-determinism in conventional ORBs and how these hazards are avoided in TAO. Fourth, it presents a case study of key patterns used to develop extensible real-time ORBs and quantifies the impact of applying patterns to reduce the complexity and improve the maintainability of common ORB tasks.

  40. Andy Gokhale and Douglas C. Schmidt, Techniques for Optimizing CORBA Middleware for Distributed Embedded Systems, (updated August 9th), Proceedings of INFOCOM '99, March 21-25th, New York, New York.

    The distributed embedded systems industry is poised to leverage emerging real-time operating systems, such as Inferno, Windows CE 2.0, and Palm OS, to support mobile communication applications. Advances in off-the-shelf real-time operating systems provides an enabling framework for a wide range of mobile communication applications, such as such as electronic mail, Internet browsing, and network management. Ideally, these applications can be developed using standard middleware components like CORBA to improve their quality and reduce their cost and cycle time. However, stringent constraints on the available memory in embedded systems imposes a severe limit on the footprint of CORBA middleware.

    This paper provides three contributions to the study and design of small footprint, real-time CORBA middleware. First, we describe the optimizations used to develop the protocol engine and CORBA IDL compiler provided by TAO, which is our real-time CORBA implementation. TAO's IDL compiler produces stubs that can use either compiled and/or interpretive marshaling. Second, we compare the performance and footprint of TAO IDL compiler-generated stubs and skeletons that use compiled and/or interpretive marshaling for a wide range of IDL data types. Third, we illustrate the benefits of the small footprint and efficiency of TAO IDL compiler-generated stubs and skeletons for a range of standard CORBA services implemented using TAO.

    Our results comparing the performance of the compiled and interpretive stubs and skeletons indicate that the interpretive stubs and skeletons perform between 75-100% of the compiled stubs and skeletons for a wide range of data types. On the other hand, the code sizes for the interpreted stubs and skeletons were between 26-45% and 50-80% of the compiled stubs and skeletons, respectively. These results indicate a positive step towards implementing high performance, small footprint middleware for distributed embedded systems.

  41. The Design and Performance of a Real-Time CORBA Scheduling Service, International Journal of Time-Critical Computing Systems, special issue on Real-Time Middleware, guest editor Wei Zhao (with Chris Gill and David Levine).

    There is increasing demand to extend CORBA middleware to support applications with stringent quality of service (QoS) requirements. However, conventional CORBA middleware does not define standard features to dynamically schedule operations for applications that possess deterministic real-time requirements. This paper presents three contributions to the study of real-time CORBA operation scheduling strategies.

    First, we document our evolution from static to dynamic scheduling for applications with deterministic real-time requirements. Second, we describe the flexible scheduling service framework in our real-time CORBA implementation, TAO, which supports core scheduling strategies efficiently. Third, we present results from empirical benchmarks that quantify the behavior of these scheduling strategies and assess the overhead of dynamic scheduling in TAO. Our empirical results using TAO show that dynamic scheduling of CORBA operations can be deterministic and can achieve acceptable latency for operations, even with moderate levels of queueing.

  42. Dynamic Scheduling for Avionics Applications, (updated August 7th), Proceedings of the 17th IEEE/AIAA Digital Avionics System Conference, 31 October - 6 November 1998. (with Chris Gill and David Levine).

    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 run-time overhead. However, static scheduling handles non-periodic processing inefficiently, and treats invocation-to-invocation variations in resource requirements inflexibly. As a consequence, processing resources are 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.

  43. Alleviating Priority Inversion and Non-determinism in Real-time CORBA ORB Core Architectures, Proceedings of the Fourth IEEE Real-Time Technology and Applications Symposium (RTAS), Denver, Colorado, June 3-5, 1998. (with Sumedh Mungee, Sergio Flores-Gaitan and Andy Gokhale).

    There is increasing demand to extend CORBA to support applications with stringent real-time requirements. However, conventional CORBA Object Request Brokers (ORBs) exhibit substantial priority inversion and non-determinism, which makes them unsuitable for applications with deterministic real-time requirements. This paper focuses on software architectures that help to alleviate priority inversion and non-determinism in real-time CORBA ORBs. It also illustrates empirically why conventional ORBs do not yet provide real-time QoS support.

  44. The Design and Performance of Real-Time Object Request Brokers (Updated August 14th), Computer Communications, Volume 21, No. 4, April, 1998 (with David Levine and Sumedh Mungee).

    Many real-time application domains can benefit from flexible and open distributed architectures, such as those defined by the CORBA specification. CORBA is an emerging architecture for distributed object computing being standardized by the OMG. Although it is well-suited for conventional request/response applications, CORBA is not yet suited for real-time applications due to the lack of key quality of service (QoS) features and optimizations.

    This paper makes three contributions to the design of real-time CORBA systems. First, it illustrates how to extend the CORBA specification and optimize CORBA implementations, so that CORBA it is suitable for real-time systems. Second, it describes how to develop a real-time scheduling service for CORBA that can provide QoS guarantees for deterministic real-time applications. Finally, the paper presents performance measurements that demonstrate common sources of priority inversion and non-determinism in CORBA implementations.

  45. Evaluating the Performance of Demultiplexing Strategies for Real-time CORBA, (updated March 18th), Proceedings of the GLOBECOM '97 conference, Phoenix, AZ, November, 1997. (with Andy Gokhale)

    Efficient and predictable demultiplexing is necessary to provide real-time support for distributed object computing applications developed with CORBA. This paper presents two contributions to the study of demultiplexing for real-time CORBA endsystems. First, we present an empirical study of three demultiplexing strategies used by a real-time Object Adapter based on SunSoft IIOP. These strategies compare the performance of (1) linear search, (2) perfect hashing, and (3) active demultiplexing for a wide range of target objects and operations. Second, we describe how we are using the perfect hashing and active demultiplexing strategies to develop a high-performance, real-time ORB called TAO.

  46. The Design and Performance of a Real-time CORBA Object Event Service, (updated April 24th, 1997), Proceedings of OOPSLA '97, Atlanta, Georgia, October, 1997. (with David Levine and Tim Harrison)

    The CORBA Event Service provides a flexible model for asynchronous communication among objects. However, the standard CORBA Event Service specification lacks important features that are required by hard real-time applications. In particular, hard real-time applications (such as operational flight programs for fighter aircraft) have complex periodic processing requirements. This paper describes the design and performance of a real-time, object-oriented implementation of TAO's real-time CORBA Event Service that meets these requirements.

    This research 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 hard 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 hard real-time guarantees. Finally, the paper presents benchmarks that demonstrate the performance tradeoffs of several real-time concurrency mechanisms implemented in our real-time Event Service.

  47. A High-performance Endsystem Architecture for Real-time CORBA. (updated January 7th, 1996). To appear in the IEEE Communications Magazine feature topic issue on Distributed Object Computing, February 1997. (with Andy Gokhale, Tim Harrison, and Guru Parulkar).

    Many application domains (such as avionics, telecommunications, and multimedia) require real-time guarantees from the underlying networks, operating systems, and middleware components to achieve their quality of service (QoS) requirements. In addition to providing end-to-end QoS guarantees, applications in these domains must be flexible and reusable. Requirements for flexibility and reusability motivate the use of object-oriented middleware like the Common Object Request Broker Architecture (CORBA). However, the performance of current CORBA implementations is not yet suited for hard real-time systems (e.g., avionics) and constrained latency systems (e.g., teleconferencing).

    This paper describes the architectural features and optimizations required to develop real-time ORB endsystems that can deliver end-to-end QoS guarantees to applications. While some operating systems, networks, and protocols now support real-time scheduling, they do not provide integrated solutions. The main thrust of this paper is that advances in real-time distributed object computing can be achieved only by systematically pinpointing performance bottlenecks; optimizing the performance of networks, ORB endsystems, common services, and applications; and simultaneously integrating techniques and tools that simplify application development.


Back to my CORBA Research page.

Last modified 11:34:34 CDT 28 September 2006