Nanbor Wang

Applying model-integrated computing to component middleware and enterprise applications

Combining the best elements of these two technologies can address the key challenges associated with developing enterprise applications.

Total quality of service provisioning in middleware and applications

Abstract Commercial off-the-shelf (COTS) middleware, such as real-time CORBA, is gaining acceptance in the distributed real-time and embedded (DRE) community. Existing COTS specifications, however, do not effectively separate quality of service (QoS) policy configurations and adaptations from application functionality. DRE application developers therefore often intersperse code that provisions resources for QoS guarantees and program adaptation mechanisms throughout DRE applications, making it hard to configure, validate, modify, and evolve complex DRE applications. This paper illustrates how (1) standard component-based middleware can be enhanced to flexibly compose static QoS provisioning policies with application logic, (2) adaptive middleware capabilities enable developers to abstract and encapsulate reusable dynamic QoS provisioning and adaptive behaviors, and (3) component-based middleware and adaptive middleware capabilities can be integrated to provide a total QoS provisioning solution for DRE applications.

The design and performance of meta-programming mechanisms for object request broker middleware

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 changing existing software drastically. This paper presents three contributions to the study of metaprogramming mechanisms for DOC middleware. First, it illustrates, compares, and contrasts several meta-programming mechanisms from an application developers 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.

Configuring Real-Time Aspects in Component Middleware

This paper makes two contributions to the study of configuring real-time aspects into quality of service (QoS)-enabled component middleware for distributed real-time and embedded (DRE) systems. First, it compares and contrasts the integration of real-time aspects into DRE systems using conventional QoS-enabled distributed object computing (DOC) middleware versus QoS-enabled component middleware. Second, it presents experiments that evaluate real-time aspects configured in The ACE ORB (TAO) versus in the Component-Integrated ACE ORB (CIAO). Our results show that QoS-enabled component middleware can offer real-time performance that is comparable to DOC middleware, while giving greater flexibility to compose and configure key DRE system aspects.

Evaluating meta-programming mechanisms for ORB middleware

Distributed object computing middleware, such as CORBA, COM+, and Java RMI, shields developers from many tedious and error-prone aspects of programming distributed applications. It is hard to evolve distributed applications after they are deployed, however, without adequate middleware support for 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 article examines and compares common meta-programming mechanisms supported by DOC middleware. These mechanisms allow applications to adapt more readily to changes in requirements and runtime environments throughout their lifecycles. Some of these meta-programming mechanisms are relatively new, whereas others have existed for decades. This article provides a systematic evaluation of these mechanisms to help researchers and developers determine which are best suited to their application needs.

Using principle patterns to optimize real-time ORBs

Increasing quality-of-service requirements pose challenges in both design and optimization for real time CORBA middleware. The authors describe TAO (The Ace ORB), an object request broker that provides end-to-end QoS guarantees. In discussing TAO, we focus on object-adapter and ORB-core optimizations in three key dimensions in high performance, real time ORB end system design: server-side concurrency, memory management, and CORBA request demultiplexing.

Applying reflective middleware techniques to optimize a QoS-enabled CORBA component model implementation

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 suboptimal. 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. The 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.

Improving real-time system configuration via a QoS-aware CORBA component model

A fundamental tension exists in systems research and practice between (1) hiding extraneous details to simplify the system programming model, and (2) revealing crucial details to allow better customization to particular application requirements, data characteristics, or other constraints. For many modern systems, such as distributed real-time and embedded (DRE) systems and multimedia applications, this tension is even stronger: the correctness of the system depends not only on functional behavior (e.g., correctness of interfaces and the algorithms behind them) but also on quality of service (QoS) properties such as CPU speeds, frame rates, and end-to-end timeliness requirements. Satisfying both the functional and QoS requirements of modern applications running in various run-time environments requires programming models that can allow selective visibility and reconfigurability of key details in both the application and the services it uses. Although prior research and practice has focused on decoupling system properties from the application logic to facilitate modification at different points in the system life-cycle, some system properties cross-cut both (1) multiple layers (application and supporting infrastructure) and (2) multiple configuration phases in the system lifecycle. To date, there has been little support for configuring such cross-cutting concerns in a systematic and standardized way across different kinds of applications. This has resulted historically in laborious and ad hoc hand-customization of systems to meet real-world constraints, especially for DRE systems. However, the convergence of model-integrated computing with component-oriented middleware in the DRE middleware research community offers a new opportunity for automated coordination of system modifications at different layers and at different points in the system lifecycle, to meet application requirements end-to-end. We are extending the component-integrated ACE ORB (CIAO), to provide a unified system configuration capability that can be leveraged by higher-level modeling tools. This paper provides two main contributions to the state of the art in component middleware for model integrated computing in DRE systems. First, we present an argument based on a representative real-world example from the avionics mission computing domain, that multiple points of coordination in the CORBA component model (CCM), i.e., component packaging, assembly and deployment, are needed to assure feasibility and increase performance at run-time. Second, we summarize key lessons learned for configuring QoS properties such as event dependencies, rates of execution, and feasibility of deadlines, and describe which of the alternative configuration points in CCM are most appropriate in our example under different design considerations.

Toward an adaptive data distribution service for dynamic large-scale network-centric operation and warfare (NCOW) systems

To achieve the goal of information dominance, the DoD has adopted the doctrine of net-centric operations and warfare (NCOW). The global information grid (GIG), future combat system (FCS), C2 constellation, and FORCEnet are examples of net-centric operations where multiple systems-of-systems integrate thousands of platforms, sensors, decision nodes, weapons, and warfighters through heterogeneous wire-line and wireless networks. NCOW provides superior collection, fusion, analysis, and use of information to help the DoD exploit information superiority and achieve strategic and tactical goals. Standard-based publish/subscribe (pub/sub) middleware, such as the object management group (OMG) s data distribution service (DDS), is a key enabling technology to build and evolve large-scale and long-lived distributed real-time and embedded NCOW systems. DDS is particularly relevant since it is the only standards-based pub/sub middleware that can satisfy the stringent quality-of service (QoS) requirements for a wide variety of tactical net-centric applications. The current OMG DDS specification, however, does not define services that (1) enable large-scale applications to execute in highly dynamic wide-area network environments, where information producers and consumers join and leave the information exchange and (2) rigorously maintain the necessary QoS required by NCOW systems. This paper provides three contributions to enabling dynamic NCOW applications to utilize standard-based pub/sub middleware effectively. First, it investigates and surveys key challenges in building dynamic NCOW applications, using DDS as an example. Second, it examines existing DDS standards and DDS implementations and identifies their pros and cons in the context of NCOW. Finally, we propose an adaptive discovery service framework that enables the application of DDS in large-scale and highly dynamic data-critical NCOW systems over diverse operating environments.

The design and performance of component middleware for QoS-enabled deployment and configuration of DRE systems

Quality of Service (QoS)-enabled component middleware can help reduce the complexity of deploying and configuring QoS aspects, such as priorities and rates of invocation. Few empirical studies have been conducted, however, to guide developers of distributed real-time and embedded (DRE) systems in choosing among alternative designs and performance optimizations. Moreover, few empirical studies have been conducted to examine the performance and flexibility trade-offs between standards-based and domain-specific DRE middleware solutions. This paper makes three key contributions to research on QoS-enabled component middleware for DRE systems. First, it describes optimizations applied to an implementation of the OMGs Deployment and Configuration (D&C) of Components specification that enable performance trade-offs between QoS aspects of DRE systems. Second, it compares the performance of several dynamic and static configuration mechanisms to help guide the selection of suitable configuration mechanisms based on specific DRE system requirements. Third, it compares the performance of our static standards-based approach to an avionics domain-specific approach. Our results show that these optimizations (1) provide developers improved control over key trade-offs between flexibility and performance at different stages of the DRE system lifecycle, (2) enhance trustworthiness of component-based DRE systems by supporting greater customization of how they are configured to meet specific requirements of each application, and (3) offer greater flexibility at a reasonable performance cost, compared to a domain-specific approach.