Cloud infrastructures increasingly include a heterogeneous mix of components in terms of performance, power, and energy usage. As the size of cloud infrastructures grows, power consumption becomes a significant constraint. We use Apache Mesos and Apache Aurora, which provide massive scalability to Web-scale applications, to demonstrate how a policy driven approach involving bin-packing workloads according to their power profiles, instead of the default allocation by Mesos and Aurora, can effectively reduce the peak-power and energy usage as well as the node utilization, when workloads are co-scheduled. Our experimental results show reductions of 11% in peak power, 86% for total energy usage, and an increase in utilization of 148% for memory and 8% CPU for the different policies.

Volunteer-based grid computing resources are characteristically volatile and frequently become unavailable due to the autonomy that owners maintain over them. This resource volatility has significant influence on the applications the resources host. Availability predictors can forecast unavailability, and can provide schedulers with information about reliability, which helps them make better scheduling decisions when combined with information about speed and load. This paper studies using this prediction information for deciding when to replicate jobs. In particular, our predictors forecast the probability that a job will complete uninterrupted, and our schedulers replicate those jobs that are least likely to do so. Our strategies outperform other comparable replication strategies, as measured by improved make span and fewer redundant operations. We define a new ``replication efficiency" metric, and demonstrate that our availability predictor can provide information that allows our schedulers to be more efficient than the most closely related replication strategy for a variety of loads in a trace-based grid simulation. We demonstrate that under low load conditions, our techniques come within 6% of the makespan improvement of a previously proposed replication technique while creating 76.8% fewer replicas and under higher loads, can improve makespan marginally while creating 72.5% fewer replicas.

Parallel computing on volatile distributed resources requires schedulers that consider job and resource characteristics. We study unconventional computing environments containing devices spread throughout a single large organization. The devices are not necessarily typical general purpose machines; instead, they could be processors dedicated to special purpose tasks (for example printing and document processing), but capable of being leveraged for distributed computations. Harvesting their idle cycles can simultaneously help resources cooperate to perform their primary task and enable additional functionality and services. A new burstiness metric characterizes the volatility of the high-priority native tasks. A burstiness-aware scheduling heuristic opportunistically introduces grid jobs (a lower priority workload class) to avoid the higher-priority native applications, and effectively harvests idle cycles. Simulations based on real workload traces indicate that this approach improves makespan by an average of 18.3% over random scheduling, and comes within 7.6% of the theoretical upper bound.

The frequent and volatile unavailability of volunteer-based grid computing resources challenges grid schedulers to make effective application placements. The manner in which host resources become unavailable will have different effects on different applications, depending on their runtime and their ability to be checkpointed or replicated. A multi-state availability model can help improve scheduling performance by capturing the various ways a resource may be available or unavailable to the grid. This paper uses a multi-state model and describes several prediction techniques to forecast resource transitions into the model's states. We analyze the accuracy of our predictors, which outperform existing approaches. Our approach increases the accuracy of multi-state resource availability prediction, and enables better application placement decisions that reduce the number of operations lost due to resource failure and eviction, decreases application makespan, or both.

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.

Resource scheduling in large-scale, volatile desktop grids is challenging because resource state is both dynamic and eclectic. Matching available resources with requests is not always possible with existing approaches. Partial dissemination protocols, such as gossiping, may provide efficient schedules when resource requesters are located near providers that can meet their needs. However, when requesters are distant from available resources, regular information dissemination techniques can waste communication bandwidth with futile messages. Thus, it may be advantageous to attempt to advertise to select remote regions of the grid, without necessarily also going through all intermediate nodes. This paper proposes dissemination proxies to increase coverage footprints and reduce dissemination overhead. We incorporate selecting and adjusting the amount of proxy nodes into an adaptive dissemination algorithm, and show that dissemination proxies are able to reduce dissemination overhead, and handle available resource distribution scenarios where regular information dissemination approaches may not produce efficient protocols. We also report initial results that indicate that randomly selecting nodes to serve as proxies can perform as well as strategies that select seemingly better-qualified proxies.

Publish/subscribe model has become a prevalent paradigm for building distributed event delivering systems. Content-based publish/subscribe allows high expresses in subscriptions and thus is more appropriate for content dissemination. However, the scalability has remained a challenge in the design of distributed content-based publish/subscribe systems due to the expensive matching and delivering cost of content-based events. In this paper we propose an infrastructure built on top of distributed hash table for efficient content-based data distribution. Based on efficient subscription installation, event publication and event delivery mechanisms, the proposed infrastructure can simultaneously support any numbers of pub/sub schemas with different number of attributes. There are three key features in our design: (1) a locality-preserving hashing mechanism which partitions and maps the content space to nodes. Subscriptions and events are mapped to the corresponding node for efficiently matching; (2) an efficient event delivery algorithm which exploits the embedded trees in the underlying DHT to deliver events to the corresponding subscribers; (3) light-weighted load balancing mechanisms to adjust the load among peers and ensure that no peer is unduly loaded.

Abstract 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 © 2006 John Wiley & Sons, Ltd.

Making effective use of computational grids requires scheduling grid applications onto resources that best match them. Resource-related state (e.g., load, availability, and location), and demand-related state (number and distribution of application resource requests) influences scheduling decision success. The scale of the grid makes collecting and maintaining detailed up-to-date state information for all resources and requests impractical. Thus, concurrent distributed schedulers must make scheduling decisions based on incomplete resource state information. In this paper, we evaluate the effect that the criteria for selecting scheduling matches have on the success of scheduling decisions. We focus on three criteria: information freshness, resource distance from requesters, and past behavior. We evaluate the quality of the schedule for various resource monitoring models, grid load models, and grid overlay topologies. Among our findings is the counter-intuitive result that favoring freshness can sometimes harm overall system performance; a combination of resource distance and past scheduling success performs best. We also evaluate a pure resource state pull model with caching, and discover that pro-actively pushing dynamic state information to schedulers is beneficial.

Computational grids have not scaled effectively due to administrative hurdles to resource and user participation. Most production grids are essentially multi-site supercomputer centers, rather than truly open and heterogeneous sets of resources that can join and leave dynamically, and that can provide support for an equally dynamic set of users. Large-scale grids containing individual resources with more autonomy about when and how they join and leave will require self-organizing grid middleware services that do not require centralized administrative control. This paper considers one such service, namely the dynamic discovery of high-performance variable-size clusters of grid nodes. A brute force approach to the problem of identifying these "ad-hoc clusters" would require excessive overhead in terms of both message exchange and computation. Therefore, we propose a scalable solution that uses a delay-based overlay structure to organize nodes based on their proximity to one another, using a small number of delay experiments. This overlay can then be used to provide a variable-size set of promising candidate nodes than can then be used as a cluster, or tested further to improve the selection. Simulation results show that this approach results in effective clustering with acceptable overhead

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.

The potential of truly large scale grids can only be realized with grid architectures and deployment strategies that lower the need for human administrative intervention, and therefore open the grid to wider participation from resources and users. Self-organizing grids (SOGs) are characterized by services, protocols, and deployment strategies that promote true scalability by eliminating administrative bottlenecks. We describe four enabling mechanisms for SOGs - automatically inferring grid structure, tracking and making available dynamic resource state information, unifying the grid service deployment model, and making effective use of intermittently connected grid hosts via lightweight fault tolerance mechanisms that take advantage of the resource fault characteristics

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

A primary benefit of Web services is that they provide a uniform implementation-independent mechanism for accessing distributed services. Building and deploying such services do not benefit from the same advantages, however. Different Web services containers are implemented in different programming languages, with different constraints and requirements placed on the programmer. Moreover, client side programmers must use the Web service interface specified by the service developer. Therefore, the kinds of applications and uses for a Web service are unnecessarily restrictive, constrained by the granularity of access defined by the interface and by the characteristics of the service functions. This paper describes an approach that addresses both of these drawbacks by enabling Web service containers with the ability to accept new mobile code on the fly, and to run it within the containers, providing direct local access to the containers' other services. The code can be specified in a small simple language (a subset of C), and translated and passed to the container in a common XML-based intermediate language called X#. This approach effectively removes the dependence on any single implementation environment. Our prototype implementation for two different containers demonstrates the feasibility of the approach, which represents a first step toward write-once deploy-anywhere Web services.

Grid information dissemination protocols distribute information about the dynamic state of computational resources throughout interconnected wide area grids. Performance metrics for these protocols include the overhead of information packets, and the accuracy of the information at the time it is used to schedule applications. Our previous work advocated non-uniform protocols to keep dissemination local to the information source, as a method of keeping overhead manageable while achieving adequate freshness and accuracy. This paper considers the problem of providing better control over the dissemination of information and influencing the "coverage footprint" that defines where the information reaches within the grid. The paper describes work that investigates the coverage characteristics of existing protocols and refines and combines them into hybrid protocols that are more controllable. We consider this work to be a necessary step toward adaptive dissemination protocols that would be able to react to the state of grid resources to change dynamically how and where information is disseminated. This in turn increases the effectiveness of grid schedulers under various load levels and distributions

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.

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.

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.

Computational grids have the potential to give programmersaccess to a much larger set and wider range of underlyingcomputing resources than currently possible. To be useful in this capacity, however, grids must address the problems of heterogeneity, multiple disjoint administrative domains, and scale. This paper describes the Legion implementationmodel, which prescribes how active objects are created and managed in the face of these problems. The Legion wide area metasystem maintains object executablesin architecture-specific binary format, and automaticallydownloads and executes the appropriate binary for theplatform on which the object is to run. The implementationmodel relieves the programmer from requiring an individualaccount on all the machines or domains on which herobjects may run, and from explicitly installing programsthroughout the metasystem. Instead, programmers have asingle account, register executables once, with Legion, andcan then potentially utilize all the machines in the system.

This paper describes the design and implementation of CAVERNsoft G2, a toolkit for building collaborative virtual reality applications. G2's special emphasis is on providing the tools to support high-performance computing and data intensive systems that are coupled to collaborative, immersive environments.This paper describes G2's broad range of services, and demonstrates how they are currently being used in a collaborative volume visualization application.

No abstract available.

The Legion project at the University of Virginia is an architecture for designing and building system services that provide the illusion of a single virtual machine to users, a virtual machine that provides secure shared object and shared name spaces, application adjustable fault tolerance, improved response time, and greater throughput. Legion targets wide area assemblies of workstations, supercomputers, and parallel supercomputers. Legion tackles problems not solved by existing workstation based parallel processing tools; the system will enable fault tolerance, wide area parallel processing, interoperability, heterogeneity, a single global name space, protection, security, efficient scheduling, and comprehensive resource management. The paper describes the core Legion object model, which specifies the composition and functionality of Legion's core objects-those objects that cooperate to create, locate, manage, and remove objects in the Legion system. The object model facilitates a flexible extensible implementation, provides a single global name space, grants site autonomy to participating organizations, and scales to millions of sites and trillions of objects.