Ossama Othman

Evaluating the performance of middleware load balancing strategies

This work presents three contributions to research on middleware load balancing. First, it describes the design of Cygnus, which is an extensible open-source middleware framework developed to support adaptive and nonadaptive load balancing strategies. Key features of Cygnus are its ability to make load balancing decisions based on application-defined load metrics, dynamically (re)configure load balancing strategies at run-time, and transparently add load balancing support to client and server applications. Second, it describes the design of LBPerf, an open-source middleware load balancing benchmarking toolkit developed to evaluate load balancing strategies at the middleware level. Third, it presents the results of experiments that systematically evaluate the performance of adaptive load balancing strategies implemented using the Cygnus middleware framework using workloads generated by LBPerf. The workloads used in our experiments are based on models of CPU-bound requests that are representative of a broad range of distributed applications. Our experiments with LBPerf illustrate the need for evaluating different adaptive and nonadaptive load balancing strategies under different workload conditions. In addition to assisting in choosing a suitable load balancing strategy for a particular class of distributed applications, our empirical results help configure run-time parameters properly and analyze their behavior in the presence of different workloads. Our results also indicate that integrating Cygnus into distributed applications can improve their scalability, while incurring minimal run-time overhead. As a result, developers can concentrate on their core application behavior, rather than wrestling with complex middleware mechanisms needed to enhance the scalability of their distributed 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.

Issues in the Design of Adaptive Middleware Load Balancing

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 specic 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-specic 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).

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.

The design and performance of a pluggable protocols framework for real-time distributed object computing middleware

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/HOP 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 TAOs 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 µsecs. The ORB middleware accounts for approximately 48% or ~90 µsecs of the total roundtrip latency. Using the specialized POSIX local IPC protocol reduces roundtrip latency to ~125 µsecs. 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.