Balachandran Natarajan

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.

Skoll: distributed continuous quality assurance

Quality assurance (QA) tasks, such as testing, profiling, and performance evaluation, have historically been done in-house on developer-generated workloads and regression suites. Since this approach is inadequate for many systems, tools and processes are being developed to improve software quality by increasing user participation in the QA process. A limitation of these approaches is that they focus on isolated mechanisms, not on the coordination and control policies and tools needed to make the global QA process efficient, effective, and scalable. To address these issues, we have initiated the Skoll project, which is developing and validating novel software QA processes and tools that leverage the extensive computing resources of worldwide user communities in a distributed, continuous manner to significantly and rapidly improve software quality. This paper provides several contributions to the study of distributed continuous QA. First, it illustrates the structure and functionality of a generic around-the-world, around-the-clock QA process and describes several sophisticated tools that support this process. Second, it describes several QA scenarios built using these tools and process. Finally, it presents a feasibility study applying these scenarios to a 1MLOC+ software package called ACE+TAO. While much work remains to be done, the study suggests that the Skoll process and tools effectively manage and control distributed, continuous QA processes. Using Skoll we rapidly identified problems that had taken the ACE+TAO developers substantially longer to find and several of which had previously not been found. Moreover, automatic analysis of QA task results often provided developers information that quickly led them to the root cause of the problems.

An approach for supporting aspect-oriented domain modeling

This paper describes a technique for improving separation of concerns at the level of domain modeling. A contribution of this new approach is the construction of support tools that facilitate the elevation of crosscutting modeling concerns to first-class constructs in a type-system. The key idea is the application of a variant of the OMG Object Constraint Language to models that are stored persistently in XML. With this approach, weavers are generated from domain-specific descriptions to assist a modeler in exploring various alternative modeling scenarios. The paper examines several facets of Aspect-Oriented Domain Modeling (AODM), including: domain-specific model weavers, a language to support the concern separation, an overview of code generation issues within a meta-weaver framework, and a comparison between AODM and AOP. An example of the approach is provided, as well as a description of several future concepts for extending the flexibility within AODM.

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.

Hybrid supervisory utilization control of real-time systems

Feedback control real-time scheduling (FCS) aims at satisfying performance specifications of real-time systems based on adaptive resource management. Existing FCS algorithms often rely on the existence of continuous control variables in real-time systems. A number of real-time systems, however, support only a finite set of discrete configurations that limit the adaptation mechanisms. This paper presents hybrid supervisory utilization control (HySUCON) for scheduling such real-time systems. HySUCON enforces processor utilization bounds by managing the switchings between the discrete configurations. Our approach is based on a best-first-search algorithm that is invoked only if reconfiguration is necessary. Theoretical analysis and simulations demonstrate that the approach leads to robust utilization bounds for varying execution times. Experimental results demonstrate the algorithm performance for a representative application scenario.

Towards Real-Time Fault-Tolerant CORBA Middleware

An increasing number of applications are being developed using Distributed Object Computing (DOC) middleware, such as CORBA. Many of these applications require the underlying middleware, operating systems, and networks to provide dependable end-to-end Quality of Service (QoS) support to enhance their efficiency, predictability, scalability, and reliability. The Object Management Group (OMG), which standardizes CORBA, has addressed many of these application requirements individually in the Real-Time CORBA (RT-CORBA) and Fault-Tolerant CORBA (FT-CORBA) specifications. Though the implementations of RT-CORBA are suitable for mission-critical commercial or military distributed Real-Time and Embedded (DRE) systems, the usage of FT-CORBA with RT-CORBA implementations are not yet suitable for systems that have stringent simultaneous dependability and predictability requirements.This paper provides three contributions to the study and evaluation of dependable CORBA middleware for performance-sensitive DRE systems. First, we provide an overview of FT-CORBA and illustrate the sources of unpredictability associated with conventional FT-CORBA implementations. Second, we discuss the QoS requirements of an important class of mission-critical DRE systems to show how these requirements are not well served by FT-CORBA today. Finally, we empirically evaluate new dependability strategies for FT-CORBA that can help make the use of DOC middleware for mission-critical DRE systems a reality.

Model-Driven Configuration and Deployment of Component Middleware Publish/Subscribe Services

Quality of service (QoS)-enabled publish/subscribe services are available in component middleware platforms, such as the CORBA Component Model (CCM). Today, however, these platforms lack a simple and intuitive way to integrate publish/subscribe service configurations and deployments. This paper illustrates how generative model-driven techniques and tools can automate many service configuration and deployment tasks associated with integrating publish/subscribe services into QoS-enabled component-based systems. We evaluatethese techniques in the context of a real-time avionics mission computing problem involving a system with over 50 components. Our evaluation finds that an automated model-driven configuration of a reusable component middleware framework not only significantly reduces handwritten code and but also simultaneously achieves high reusability and composability of CCM components.

Addressing the middleware configuration challenges using model-based techniques

Component middleware, such as J2EE, .Net and CORBA Component Model (CCM) have been increasingly used to develop and deploy large-scale distributed systems in different domains, including defense, enterprise, avionics and industrial process control. The different applications in each of these domains require different levels and types of quality of service (QoS) guarantees from their underlying component middleware. In an effort to support a large number of applications, therefore, component middleware developers provide enormous flexibility in the way the middleware can be configured and fine-tuned for the target application. Application developers, however, resort to ad hoc techniques to configure the middleware, which are tedious and errorprone.This paper describes a novel scheme we are using based on model-based systems engineering to address the concerns of complex middleware configuration. We present a modeling paradigm called Options Configuration Modeling Language (OCML) we have used in the context of conflguring a QoS-enabled CORBA component middleware.

Applying Patterns to Improve the Performance of Fault Tolerant CORBA

An increasing number of mission-critical systems are being developed using distributed object computing middleware, such as CORBA. Applications for these systems often require the underlying middleware, operating systems, and networks to provide end-to-end quality of service (QoS) support to enhance their efficiency, predictability, scalability, and fault tolerance. The Object Management Group (OMG), which standardizes CORBA, has addressed many of these QoS requirements the recent Real-time CORBA and Fault Tolerant CORBA (FTCORBA) specifications. This paper describes the patterns we are incorporating into a FT-CORBA service called DOORS to eliminate performance bottlenecks caused by common implementation pitfalls.

Leveraging Application Frameworks

In today’s competitive, fast-paced computing industry, successful software must increasingly be: (1) extensible to support successions of quick updates and additions to address new requirements and take advantage of emerging markets; (2) flexible to support a growing range of multimedia data types, traffic flows, and end-to-end QoS (quality of service) requirements; (3) portable to reduce the effort required to support applications on heterogeneous operating-system platforms and compilers; (4) reliable to ensure that applications are robust and tolerant to faults; (5) scalable to enable applications to handle larger numbers of clients simultaneously; and (6) affordable to ensure that the total ownership costs of software acquisition and evolution are not prohibitively high.