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.
Commercial off-the-shelf (COTS) middleware increasingly offers not only functional support for standard interfaces, but also the ability to optimize their resource consumption patterns. For example, a COTS real-time object request broker (ORB) may permit users to configure its server-side thread pooling policies. On one hand, this flexibility makes it possible to use standard functional interfaces in applications where they were not applicable previously. On the other hand, the non-standard nature of the optimization mechanisms - i.e., the "knobs and dials" - acts against the very product-independence that standardized COTS interfaces are intended to provide.
This paper provides two contributions to the study of mechanisms for reducing the life-cycle costs of distributed real-time and embedded (DRE) systems. First, we present a mechanism-called a Quality Connector-that enables applications to specify the qualities of service that they require from their infrastructure, and then manages the operations that optimize the middleware to implement those requirements. Second, we show how Quality Connectors are being applied in practice to allocate communication resources automatically for real-time CORBA event propagation. Although middleware that configures itself in response to quality of service (QoS) requests has been investigated and applied in general-purpose computing contexts, we believe that the present work is among the first to put such capabilities into mission-critical DRE systems with stringent QoS requirements.
Open-source development processes have emerged as an effective approach to reduce cycle-time and decrease design, implementation, and quality assurance costs for certain types of software, particularly systems infrastructure software, such as operating systems, compilers and language processing tools, editors, and distribution middleware. This paper presents two contributions to the study of open-source software engineering. First, we describe the key challenges of open-source software, such as controlling long-term maintenance and evolution costs, ensuring acceptable levels of quality, sustaining end-user confidence and good will, and ensuring the coherency of system-wide software and usability properties. We illustrate how well-organized open-source projects make it easier to address many of these challenges compared with traditional closed-source approaches to building software. Second, we present the goals and methodology of the Skoll project, which focuses on developing and empirically validating novel open-source software quality assurance and optimization techniques to resolve key open-source challenges. We summarize the experimental design of a long-term case study of two widely used open-source middleware projects-ACE and TAO-that we are using in the Skoll project to devise, deploy, and evaluate techniques for improving software quality through continuous distributed testing and profiling. These techniques are designed to leverage common open-source project assets, such as the technological sophistication and extensive computing resources of worldwide user communities, open access to source, and ubiquitous web access, that can improve the quality and performance of open-source software significantly.
Load balancing middleware is used extensively to improve scalability and overall system throughput in distributed systems. Many load balancing middleware services are simplistic, however, since they are geared only for specific use-cases and environments. These limitations make it hard to use the same load balancing service for anything other than the distributed application it was designed for originally. This lack of generality forces continuous re-development of application-specific load balancing services. Not only does re-development increase deployment costs of distributed applications, but it also increases the potential of producing non-optimal load balancing implementations since proven load balancing service optimizations cannot be reused directly.
This paper presents a set of load balancing service features that address many existing middleware load balancing service inadequacies, such as lack of server-side transparency, centralized load balancing, sole support for stateless replication, fixed load monitoring granularities, lack of fault tolerant load balancing, non-extensible load balancing algorithms, and simplistic replica management. All the capabilities described in this paper are currently under development for the next generation of middleware-based load balancing service distributed with our CORBA-compliant ORB (TAO).
CORBA is increasingly popular as distributed object computing middleware for systems with stringent quality of service (QoS) requirements, including scalability and dependability. One way to improve the scalability and dependability of CORBA-based applications is to balance system processing load among multiple server hosts. Load balancing can help improve system scalability by ensuring that client application requests are distributed and processed equitably across a group of servers. Likewise, it can help improve system dependability by adapting dynamically to system configuration changes that arise from hardware or software failures.
This paper presents three contributions to research on CORBA-based load balancing. First, we describe deficiencies with common load-balancing techniques, such as introducing unnecessary overhead or not adapting dynamically to changing load conditions. Second, we present a novel adaptive load balancing service that can be implemented efficiently using standard CORBA features. Finally, we present the results of benchmark experiments that evaluate the pros and cons of different load balancing strategies empirically by measuring the overhead of each strategy and showing how well each strategy balances system load.
As network-centric computing becomes more pervasive and applications become more distributed, the demand for greater scalability and dependability is increasing. Distributed system scalability can degrade significantly, however, when servers become overloaded by the volume of client requests. To alleviate such bottlenecks, load balancing middleware mechanisms can be used to distribute system load equitably across object replicas residing on multiple servers. This paper describes the key design challenges we faced when adding this load balancing service to our CORBA ORB (TAO) and outline how we resolved the challenges by applying patterns.
Distributed object computing (DOC) middleware, such as CORBA, COM+, and Java RMI, shields developers from many tedious and error-prone aspects of programming distributed applications. Without proper middleware support, however, it is hard to evolve distributed applications after they are deployed. Therefore, DOC middleware should also support meta-programming mechanisms, such as smart proxies, interceptors, and pluggable protocols. These mechanisms can help improve the adaptability of distributed applications by allowing their behavior to be modified without changing their existing software designs and implementations significantly.
This papers examines and compares common meta-programming mechanisms supported by DOC middleware that allow applications to adapt more readily to changes in requirements and run-time environments. Some of these meta-programming mechanisms are relatively new, whereas some have existed for decades. Until recently, however, DOC middleware has not provided all of these mechanisms, so researchers and developers may not be familiar with the breadth of meta-programming mechanisms available today. The goal of this paper is to evaluate these mechanisms systematically to help researchers and developers determine which are best suited for their application needs.
Existing CORBA specifications, such as Real-time CORBA and CORBA Messaging, address many quality-of-service (QoS) properties by defining policies that control local and end-to-end priorities, connection multiplexing, queue ordering, and request routing. They do not, however, define strategies for configuring these QoS properties into applications flexibly, transparently, and adaptively. Application developers must therefore make these configuration decisions manually, which is tedious, error-prone, and sub-optimal for complex distributed systems. Although the recently adopted CORBA Component Model (CCM) defines a standard configuration framework for packaging and deploying software components, conventional CCM implementations focus on functionality rather than adaptive quality-of-service, which makes them unsuitable for next-generation applications with demanding QoS requirements.
In this paper, we explore how reflective middleware techniques can be applied to implement a CCM-compliant ORB in which QoS properties of components can be specified and adjusted dynamically. This paper presents three contributions to the study of middleware for QoS-enabled component-based applications. It outlines reflective middleware techniques designed to adaptively (1) select optimal communication mechanisms, (2) manage QoS properties of CORBA components in their containers, and (3) (re)configure selected component executors dynamically. Our ongoing research on CORBA and the CCM indicates that reflective middleware techniques are well-suited to address the QoS demands of next-generation component-based applications.
Distributed object computing (DOC) middleware shields developers from many tedious and error-prone aspects of programming distributed applications. Without proper support from the middleware, however, it can be hard to evolve distributed applications after they are deployed. Therefore, DOC middleware should support meta-programming mechanisms, such as smart proxies and interceptors, that improve the adaptability of distributed applications by allowing their behavior to be modified without drastically changing existing software.
This paper presents three contributions to the study of meta-programming mechanisms for DOC middleware. First, it illustrates, compares, and contrasts several meta-programming mechanisms from an application developer's perspective. Second, it outlines the key design and implementation challenges associated with developing smart proxies and portable interceptors features for CORBA. Third, it presents empirical results that pinpoint the performance impact of smart proxies and interceptors. Our goal is to help researchers and developers determine which meta-programming mechanisms best suit their application requirements.
This paper describes how recent advances in distributed object computing (DOC) middleware are enabling the creation of common quality-of-service (QoS) interfaces that support next-generation distributed applications. DOC middleware helps to simplify and coordinate applications in order to leverage the underlying network and endsystem QoS architectures more effectively. This paper also describes a QoS-enabled middleware framework used to customize the CORBA Audio/Video Streaming Service for applications on multiple operating system platforms.
Although existing CORBA specifications, such as Real-time CORBA and CORBA Messaging, address many end-to-end quality-of-service (QoS) properties, they do not define strategies for configuring these properties into applications flexibly, transparently, and adaptively. Therefore, application developers must make these configuration decisions manually and explicitly, which is tedious, error-prone, and often sub-optimal. Although the recently adopted CORBA Component Model (CCM) does define a standard configuration framework for packaging and deploying software components, conventional CCM implementations focus on functionality rather than adaptive quality-of-service, which makes them unsuitable for next-generation applications with demanding QoS requirements.
This paper presents three contributions to the study of middleware for QoS-enabled component-based applications. It outlines reflective middleware techniques designed to adaptively (1) select optimal communication mechanisms, (2) manage QoS properties of CORBA components in their containers, and (3) (re)configure selected component executors dynamically. Based on our ongoing research on CORBA and the CCM, we believe the application of reflective techniques to component middleware will provide a dynamically adaptive and (re)configurable framework for COTS software that is well-suited for the QoS demands of next-generation applications.
This paper presents an overview of the CORBA Component Model (CCM), focusing on the problems it addresses and the features it provides.
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.
Next-generation distributed systems have growing demands for real-time quality of service (QoS), flexibility, and control over the often unpredictable environments in which they are deployed. These demands have been hard to achieve simultaneously. For instance, systems have historically either been real-time, which meant that they were highly-tuned, special-purpose, and fragile, or they were flexible, thereby incurring performance penalties that made it hard to achieve stringent QoS requirements. Achieving both sets of demands simultaneously requires distributed object computing (DOC) middleware that supports dynamic and layered resource management, automated reconfiguration, dynamic scheduling, and application-level interfaces for control and adaptation.
This paper provides three contributions to the study of adaptive real-time middleware for distributed and embedded systems. First, it describes advances in Object Request Broker (ORB) technology that can support stringent real-time requirements. Second, it describes extensions to the DOC model that support the control and measurement of, and adaptation to, changing QoS requirements and conditions. Finally, the paper describes how combining multiple cross-cutting DOC middleware strategies for real-time scheduling, resource management, flexible control, and adaptation can achieve real-time QoS and flexibility simultaneously.
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 Events Service provides a flexible model for asynchronous communication among distributed and collocated objects. However, the standard CORBA Events 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 Events Service can be implemented to support key QoS features. Second, it illustrates how to extend the CORBA Events 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 improve system scalability. Finally, it illustrates how an Events Service framework can be strategized to support configurations that facilitate high throughput, predictable bounded latency, or some combination of each.
To make informed choices among middleware alternatives, developers of distributed object systems should understand the patterns and components used to implement key features in CORBA ORBs. Recent Object Interconnection columns have explored the features of the CORBA Messaging specification. In this article, we describe key patterns and components used to implement an OMG IDL compiler that supports the Asynchronous Method Invocation (AMI) callback model defined in the CORBA Messaging specification.
Method-oriented middleware, such as SunRPC, DCE, Java RMI, COM, and CORBA, has traditionally provided synchronous method invocation (SMI) models to applications. Although SMI works well for conventional client/server applications, it is not well-suited for high-performance or real-time applications due to its lack of scalability. To address this problem, the OMG has recently standardized an asynchronous method invocation (AMI) model for CORBA.
This paper provides two contributions to research on asynchronous invocation models for method-oriented middleware. First, we outline the key design challenges faced when developing the CORBA AMI model and describe how we resolved these challenges in TAO, which is our high-performance, real-time CORBA-compliant ORB. Second, we present the results of empirical benchmarks that demonstrate the performance benefits of AMI compared with alternative CORBA invocation models. In general, CORBA AMI is more scalable than equivalent SMI designs, with only a moderate increase in programming complexity.
gperf is a ``software-tool generating-tool'' that
automates the generation of perfect hash functions. This paper
describes the features, algorithms, and object-oriented design and
implementation strategies incorporated in
gperf. It also
codesents the results from an empirical comparison between
gperf-generated recognizers and other popular techniques
for reserved word lookup.
gperf is distributed with the
GNU libg++ library and is used to generate the keyword recognizers for
the GNU C/C++ compilers and the TAO IDL compiler.
An Object Adapter is an integral part of the Common Object Request Broker Architecture (CORBA). An Object Adapter assists an Object Request Broker (ORB) in delivering client requests to server object implementations (servants). Services provided by an Object Adapter include: (a) generation and interpretation of object references, (b) operation dispatching, (c) object activation and deactivation, (d) mapping object references to servants, and (e) registration of servants.
This paper provides two contributions to the study of Object Adapters. First, it outlines the CORBA Portable Object Adapter (POA) specification, which is a recent addition to the CORBA standard that greatly simplifies the development of portable and extensible servants and server applications. The design goals, architectural components, and semantics of the POA are explained. Second, the paper describes the design choices made to adapt the POA for the TAO Real-time ORB. Key design issues regarding efficient demultiplexing, upcall and collocation optimizations, ORB and POA concurrency configurations, and predictability are covered.
Recent advances in network bandwidth and processing power of CPUs has led to the emergence of several multimedia streaming frameworks, such as NetShow, Realvideo and Vxtreme. Such frameworks typically rely on proprietary stream establishment and control mechanisms. To facilitate the development of standards-based distributed multimedia streaming applications, the OMG has defined a CORBA-based specification that stipulates the key interfaces and semantics needed to control and manage audio/video streams.
This paper makes two contributions to the study of CORBA-based distributed multimedia streaming frameworks. First, it describes the design and performance of TAO's audio/video (A/V) streaming framework, which is a freely available implementation of the OMG CORBA streams model. Second, it describes the design and performance of a distributed application that uses TAO's A/V streaming framework to establish and control MPEG video streams. Our experience with the A/V streaming framework indicates that it is a flexible and efficient model for developing multimedia streaming applications.
Distributed object computing forms the basis for next-generation application middleware. At the heart of distributed object computing are Object Request Brokers (ORBs), which automate many tedious and error-prone distributed programming tasks. This article presents a case study of key design patterns needed to develop ORBs that can be dynamically configured and evolved for specific application requirements and system characteristics.
Back to my CORBA Research page.
Last modified 19:53:46 CST 06 November 2001