Michael J. Lewis

A Component Architecture for High-Performance Scientific Computing

The Common Component Architecture (CCA) provides a means for software developers to manage the complexity of large-scale scientific simulations and to move toward a plug-and-play environment for high-performance coputing. In the scientific computing context, component models also promote collaboration using independently developed software, thereby allowing particular individals or groups to focus on the aspects of greatest interest to them. The CCA supports parallel and distributed coputing as well as local high-performance connections between components in a language-independent manner. The design places minimal requirements on components and thus facilitates the integration of existing code into the CCA environment. The CCA model imposes minimal ovehead to minimize the impact on application performance. The focus on high performance distinguishes the CCA from most other component models. The CCA is being applied within an increasing range of disciplines, including cobustion research, global climate simulation, and computtional chemistry.

Differential Deserialization for Optimized SOAP Performance

SOAP, a simple, robust, and extensible protocol for the exchange of messages, is the most widely used communication protocol in the Web services model. SOAP’s XML-based message format hinders its performance, thus making it unsuitable in high-performance scientific applications. The deserialization of SOAP messages, which includes processing of XML data and conversion of strings to in-memory data types, is the major performance bottleneck in a SOAP message exchange. This paper presents and evaluates a new optimization technique for removing this bottleneck. This technique, called differential deserialization (DDS), exploits the similarities between incoming messages to reduce deserialization time. Differential deserialization is fully SOAPcompliant and requires no changes to a SOAP client. A performance study demonstrates that DDS can result in a significant performance improvement for some Web services.

A Benchmark Suite for SOAP-based Communication in Grid Web Services

The convergence of Web services and grid computing has promoted SOAP, a widely used Web services protocol, into a prominent protocol for a wide variety of grid applications. These applications differ widely in the characteristics of their respective SOAP messages, and also in their performance requirements. To make the right decisions, an application developer must thus understand the complex dependencies between the SOAP implementation and the application. We propose a standard benchmark suite for quantifying, comparing, and contrasting the performance of SOAP implementations under a wide range of representative use cases. The benchmarks are defined by a set of WSDL documents. To demonstrate the utility of the benchmarks and to provide a snapshot of the current SOAP implementation landscape, we report the performance of many different SOAP implementations (gSOAP, AxisJava, XSUL and bSOAP) on the benchmarks, and draw conclusions about their current performance characteristics.

Toward characterizing the performance of SOAP toolkits

The SOAP protocol underpins Web services as the standard mechanism for exchanging information in a distributed environment. The XML-based protocol offers advantages including extensibility, interoperability, and robustness. The merger of Web services and grid computing promotes SOAP into a standard protocol for the large-scale scientific applications that computational grids promise to support, further elevating the protocols importance and requiring high-performance implementations. Various SOAP implementations differ in their implementation language, invocation model and API, and supported performance optimizations. In this paper we compare and contrast the performance of widely used SOAP toolkits and draw conclusions about their current performance characteristics. We also provide insights into various design features that can lead to optimized SOAP implementations. The SOAP implementations included in our study are gSOAP 2.4, AxisC++ CVS May 28, AxisJava 1.2, .NET 1.1.4322 and XS0AP4/XSUL 1.1.

Non-uniform information dissemination for dynamic grid resource discovery

Effective use of computational grids requires up-to-date information about widely-distributed resources within it - a challenging problem given the scale of the grid, and the continuously changing state of the resources. We propose nonuniform information dissemination protocols to efficiently propagate information to distributed repositories, without requiring flooding or centralized approaches. Capitalizing on the observation that grid resources are of more interest to nearby users, we disseminate resource information with a frequency and resolution inversely proportional to the distance from the resource. Results indicate a significant reduction in the overhead compared to uniform dissemination to all repositories.

An Adaptive Algorithm for Information Dissemination in Self-Organizing Grids

Effective scheduling in large-scale computational grids is challenging because it requires tracking the dynamic state of the large number of distributed resources that comprise the grid. Classical distributed information dissemination approaches such as push, pull, and their combinations, are not well suited to the problem of resource tracking, where resources are redundant and full information about all resources everywhere is neither necessary nor desirable. Aggregated, partial, or probabilistic forwarding protocols result in more efficient (but incomplete) dissemination, while maintaining sufficient information to enable effective scheduling. However, a static approach to dissemination in which all information is treated identically, is ineffective in the presence of spatial and temporal non-uniformity of resources and demands. For example, a single forwarding probability for gossipping-based dissemination may result in unnecessarily high overhead in some areas of the grid. Moreover, the right forwarding probability values can change over time, with changes in offered load and node utilization. Adaptive protocols can adjust the aggressiveness with which information is disseminated, based on current grid conditions, and can in turn increase query satisfaction rates, reduce overhead, or both. This paper explores the characteristics and behavior of adaptive probabilistic and change-sensitive information forwarding protocols, identifying and addressing several issues and problems, and introducing dissemination protocols that are better able to reduce overhead and increase query satisfaction rates for a variety of grid conditions.

Lightweight Checkpointing for Faster SOAP Deserialization

Differential deserialization (DDS) is an optimization technique that exploits similarities between incoming SOAP messages to reduce deserialization time. DDS works by checkpointing the state of the SOAP deserializer at various points while deserializing a message, and using those checkpoints to avoid full deserialization of similar messages. DDS can improve performance in many cases, but its benefit is limited by the potentially significant memory and processing overhead associated with its checkpointing mechanism. Differential checkpointing (DCP) substantially reduces memory use, but still requires significant processing overhead. In this paper, we introduce lightweight checkpointing (LCP), a checkpointing approach that significantly reduces the cost of both DDS and DCP, in terms of both memory use and processing time. LCP statically determines locations in the incoming message where it would be most efficient to create checkpoints. LCP creates checkpoints much faster than both our original DDS checkpointing mechanism and our DCP approach. LCP also has significantly smaller memory requirements. For example, in some of our test cases, LCP requires only 10% of the memory that DCP requires, and only 3% of the memory that our original approach required. In terms of processing time, deserialization with LCP is approximately 50% to 60% faster than without differential deserialization, when approximately half the message is unchanged from the previous message

Uniform Dynamic Deployment of Web and Grid Services

The Web services resource framework (WSRF) has redefined grid computing standards, making Web services more suitable for grid applications by adding persistent state management. However, it is still difficult to build, deploy, and evolve such services, since different Web and grid services containers require that the services they host be written in specific languages, to target particular internal interfaces for state management. Therefore, services must be built and deployed differently for each hosting environment. This paper describes uniform dynamic service code deployment on three Web services containers (namely, Tomcat, ASP.NET and a gSOAP based C++ container), and two grid services containers (namely, GT4 and WSRF.NET). Containers receive the code in an XML-based standard intermediate form, and then generate container-specific native code in different languages, without exposing these details to applications and grid services programmers. The dynamically deployed code can access state managed by the hosting container, can utilize functionalities exposed by statically deployed services, and can communicate with other dynamically deployed modules, running either in the same container or in different containers. A performance study shows that the newly deployed mobile code can run nearly as efficiently as it would if it had been deployed statically, through container-specific mechanisms.

Performance Analysis of Adapting a MapReduce Framework to Dynamically Accommodate Heterogeneity

When data centers employ the common and economical practice of upgrading subsets of nodes incrementally, rather than replacing or upgrading all nodes at once, they end up with clusters whose nodes have non-uniform processing capability, which we also call performance-heterogeneity. Popular frameworks supporting the effective MapReduce programming model for Big Data applications do not flexibly adapt to these environments. Instead, existing MapReduce frameworks, including Hadoop, typically divide data evenly among worker nodes, thereby inducing the well-known problem of stragglers on slower nodes. Our alternative MapReduce framework, called MARLA, divides each worker’s labor into sub-tasks, delays the binding of data to worker processes, and thereby enables applications to run faster in performance-heterogeneous environments. This approach does introduce overhead, however. We explore and characterize the opportunity for performance gains, and identify when the benefits outweigh the costs. Our results suggest that frameworks should support finer grained sub-tasking and dynamic data partitioning when running on some performance-heterogeneous clusters. Blindly taking this approach in homogeneous clusters can slow applications down. Our study further suggests the opportunity for cluster managers to build performance-heterogeneous clusters by design, if they also run MapReduce frameworks that can exploit them.

Design and implementation issues for distributed CCA framework interoperability

Component frameworks, including those that support the Common Component Architecture (CCA), represent a promising approach to addressing the challenge of building and deploying high‐performance scientific applications in Grid environments, one that is being realized, for example, in our LegionCCA and XCAT‐C++ frameworks. The next step beyond building independent individual frameworks is making them interoperate. Component‐based applications should be able to transparently span multiple disjoint component frameworks with low overhead as compared with the same applications running within a single framework. Interoperable frameworks enable applications to take advantage of more resources, and to better match constituent parts to the underlying resources that best support them. The CCA specification does not prescribe a wire format for inter‐component calls in distributed frameworks, thereby promoting considerable flexibility and customization for the framework developer. This approach thus requires an additional specific strategy outside of the CCA to support interoperability between distributed frameworks. Mandating one common wire format, however, risks choosing the wrong format. We discuss in detail five underlying component framework interoperability requirements, and three general approaches to addressing them. We then discuss how the approaches can be applied to meet the requirements, and address the advantages, issues, and implications of doing so. This effectively defines a design space for framework interoperability approaches. We then address the communication interoperability in detail via a single multi‐protocol communication library called Proteus, and discuss how we have incorporated it into two distinct distributed framework implementations of the CCA specification: LegionCCA and XCAT‐C++. Copyright