With the recent widespread adoption of service-oriented architecture, the dynamic composition of services is now a crucial issue in the area of distributed computing. The coordination and execution of composite Web services are today typically conducted by heavyweight centralized workflow engines, leading to an increasing probability of processing and communication bottlenecks and failures. In addition, centralization induces higher deployment costs, such as the computing infrastructure to support the workflow engine, which is not affordable for a large number of small businesses and end-users. In a world where platforms are more and more dynamic and elastic as promised by cloud computing, decentralized and dynamic interaction schemes are required. Addressing the characteristics of such platforms, nature-inspired analogies recently regained attention to provide autonomous service coordination on top of dynamic large scale platforms. In this paper, we propose an approach for the decentralized execution of composite Web services based on an unconventional programming paradigm that relies on the chemical metaphor. It provides a high-level execution model that allows executing composite services in a decentralized manner. Composed of services communicating through a persistent shared space containing control and data flows between services, our architecture allows to distribute the composition coordination among nodes. A proof of concept is given, through the deployment of a software prototype implementing these concepts, showing the viability of an autonomic vision of service composition.

SUMMARY Live virtual machine migration is a powerful feature of virtualization technologies. It enables efficient load balancing, reduces energy consumption through dynamic consolidation, and makes infrastructure maintenance transparent to users. Although live migration is available across wide area networks with state of the art systems, it remains expensive to use because of the large amounts of data to transfer, especially when migrating virtual clusters rather than single virtual machine instances. As evidenced by previous research, virtual machines running identical or similar operating systems have significant portions of their memory and storage containing identical data. We propose Shrinker, a live virtual machine migration system leveraging this common data to improve live virtual cluster migration between data centers interconnected by wide area networks. Shrinker detects memory pages and disk blocks duplicated in a virtual cluster to avoid sending the same content multiple times over wide‐area network links. Virtual machine data is retrieved in the destination site with distributed content‐based addressing. We implemented a prototype of Shrinker in the KVM (Kernel‐based Virtual Machine) hypervisor and present a performance evaluation in a distributed environment. Experiments show that it reduces both total data transferred and total migration time. Copyright © 2012 John Wiley & Sons, Ltd.

With the proliferation of Web Services, scientific applications are more and more designed as temporal compositions of services, commonly referred to as, workflows. To address this paradigm shift, different workflow management systems have been proposed. If their efficiency has been established over centralized reliable systems, it is questionable over highly decentralized failure-prone platforms. Scientific applications recently started to be deployed over clouds, leading to new issues, like elasticity, i.e., the possibility to dynamically refine, at runtime, the amount of resources dedicated to an application. This raised a new demand for programming models, able to express autonomic self-coordination of services in a dynamic, elastic platform. Chemistry-inspired computing recently regained momentum in this context, naturally expressing parallelism, distribution, and autonomic behaviors. While its high expressiveness and adequacy for this context has been established, the chemical model severely suffers from a lack of proof of concepts. In this paper, we concretely show how to leverage such models in this context. We focus on the design, the implementation and the experimental validation of a chemistry-inspired scientific workflow management system.

This paper investigates a chemical workflow enactment model that is intended to coordinate workflows of large set of activities on a large number of resources in a self-evolving nature, based on a chemical analogy. The concept of chemical workflow engine is introduced for a concurrent, self-coordinating enactment exploiting as much parallelism as inherently present. The concept is aimed at supporting a generalized workflow language without any restrictions, modeling most workflow patterns, separating data and control flow, supporting dynamic changes by multiple versions and instances. The paper presents the notion and model of the chemical based coordination.

Nowadays, executions of composite Web services are typically conducted by heavyweight centralized engines. A centralized is a potential processing and communication bottleneck as well as a central point of failure, and its cost of deployment is usually too high for a large number of small businesses or end-users. In addition, it presents some weaknesses dealing with privacy issues. These drawbacks, and requirements such as loose coupling, are pushing service infrastructures toward more decentralized and dynamic interaction schemes. In this paper, we propose a decentralized alternative system for the execution of composite Web services based on the chemical analogy. The chemical paradigm provides a high-level execution model that allows executing composite services in a fully decentralized manner. Our architecture is composed by nodes communicating through a shared space containing both control and data flows, allowing to distribute the composition among nodes without the need for any centralized coordination.

This paper introduces the application of an unconventional approach to Grid programming. The proposed programming model is based on the chemical metaphor for expressing coordination of large grain computations. A chemical program can be seen as a set of chemical reactions, representing computations, that transform a set of floating molecules, representing data, within a chemical solution until an inert solution is reached. This model is intrinsically parallel and possesses nice autonomic properties, which are expected for programming Grids. We illustrate this novel programming model with a simple ray-tracing application and describe an implementation in the context of Desktop Grids.

This paper describes work in progress to extend component models to support master-worker applications and to let them to be executed on grid infrastructures. The proposed approach is generic enough to be applied to existing component models such as the OMG CORBA and the ObjectWeb FRACTAL component models. One objective of our research is to relieve grid application designers of managing low level programming and implementation aspects. With the proposed approach, a designer has only to cope with the description of an abstract view of the application architecture in which he has to specify what the master and the workers have to do while leaving the system environment to manage the low level aspects such as communication between the master and the workers.

Workflow execution on large-scale heterogeneous distributed computing systems, such as grids, requires a complex coordination. Activities of complex workflow patterns must be matched with entities of the computing system that possesses highly dynamic properties. We pinpoint the key concept of such workflow coordination as actions according to actual and local conditions-analogously to chemical reactions. Modeling workflow enactment as molecules and reactions, formalized in the nature inspired gamma-calculus, yielded an autonomously evolving, distributed, decentralized coordination model that can adapt to a dynamically changing environment

Executing workflows on large-scale heterogeneous distributed computing systems is a challenging task. Albeit there have been many well elaborated approaches, they are often motivated by a certain class of applications and focus on some implementation specific problems. The work presented in this paper aimed at establishing a highly abstract coordination model for distributed workflow enactment where decentralized control, autonomy, adaptation to high dynamics and partial lack of information are of primary concerns. The model is based on a nature metaphor and envisioned as a chemical reaction where molecules react autonomously according to local and actual conditions. The execution model of such chemical workflow enactment is formalized using the /spl gamma/-calculus. In the /spl gamma/-calculus control, scheduling, dependencies, errors and the state of the computation are all represented in a single uniform declarative formalism that has a mathematically founded clear semantics. The paper shows that the abstract coordination model expressed in /spl gamma/-calculus is able to grasp all aspects of such a chemical enactment, provides a more complex and adaptive framework than most current approaches, and actual realizations may be founded on it.

Summary form only given. This article studies a communication model that aims at extending the scope of computational grids by allowing the execution of parallel and/or distributed applications without imposing any programming constraints or the use of a particular communication layer. Such model leads to the design of a communication framework for grids which allows the use of the appropriate middleware for the application rather than the one dictated by the available resources. Such a framework is able to handle any communication middleware - even several at the same time - on any kind of networking technologies. Our proposed dual-abstraction (parallel and distributed) model is organized into three layers: arbitration, abstraction and personalities which are highlighted. The performance obtained with PadicoTM, our available open source implementation of the proposed framework, show that such functionality can be obtained with still providing very high performance.

Abstract With the availability of Computational Grids, new kinds of applications are emerging. They raise the problem of how to program them on such computing systems. In this paper, we advocate a programming model based on a combination of parallel and distributed programming models. Compared to previous approaches, this work aims at bringing single program multiple data (SPMD) programming into CORBA in a portable way. For example, we want to interconnect two parallel codes by CORBA without modifying either CORBA or the parallel communication API. We show that such an approach does not entail any loss of performance compared to previous approaches that required modification to the CORBA standard. Moreover, using an ORB that is able to exploit high‐performance networks, we show that portable parallel CORBA objects can efficiently make use of such networks. Copyright © 2003 John Wiley & Sons, Ltd.

Computational grids are seen as the future emergent computing infrastructures. Their programming requires the use of several paradigms that are implemented through communication middleware and runtimes. However some of these middleware systems and runtimes are unable to take benefit of the presence of specific networking technologies available in grid infrastructures. In this paper, we describe an open integration framework that allows several communication middleware and runtimes to efficiently share the networking resources available in a computational grid. Such framework encourages grid programmers to use the most suited communication paradigms for their applications independently from the underlying networks. Therefore, there is no obstacle to deploy the applications on a specific grid configuration.

This paper describes a technique that allows an MPI code to be encapsulated into a component. Our technique is based on an extension to the Common Object Request Broker Architecture (CORBA) from the OMG (Object Management Group). The proposed extensions do not modify the CORBA core infrastructure (the Object Request Broker) so that it can fully co-exist with existing CORBA applications. An MPI code is seen as a new kind of CORBA object that hides most of the cumbersome problems when dealing with parallelism. Such technique can be used to connect MPI codes to existing CORBA software infrastructures which are now being developed in the framework of several research and development projects such as JACO3, JULIUS or TENT from DLR. To illustrate the concept of parallel CORBA object, we present a virtual reality application that is made of the coupling of a light simulation application (radiosity) and a visualisation tool using VRML and Java.

To solve a given problem on a distributed memory parallel computer (DMPC), the message passing programming model involves distributing both the data and the computations among the processors. While this can be easily feasible for well structured problems, it can become fairly hard for unstructured ones, like sparse matrix computations, unless you use some runtime support. In this paper, we consider a relatively new approach to implementing the Cholesky factorization on a DMPC, by using a shared virtual memory (SVM). The abstraction of a shared memory on top of a distributed memory allows us to introduce a large-grain factorization algorithm, synchronized with events. Experiments conducted so far show that some scheduling techniques enhance not only the parallelism but the SVM behavior as well, allowing interesting results.

A programming environment for distributed memory parallel computers, consisting of a Fortran 77 compiler enhanced with directives to specify parallelism, is introduced. These directives are used to specify shared data structures and parallel loops. Shared data structures are implemented using the KOAN shared virtual memory that is available on an Intel iPSC/2 computer. Preliminary results obtained with the first prototype of the compiler are presented.

A parallel space tracing algorithm is presented. It subdivides the scene into regions. These latter are distributed among the processors of an iPSC hypercube machine designed by Intel company. Each processor subdivides its own region into cells to accelerate the ray tracing algorithm. Processors communicate by means of messages. The pyramidal shape of the regions allows the deletion of the primary ray messages. A method of performing a roughly uniform load distribution is proposed.

This paper describes a new algorithm of space tracing. Scenes are modeled by a CSG tree. Space is subdivided regularly into 3D regions called boxes. With each box is associated a subtree which is the restriction of the whole scene CSG tree to primitives belonging to this box. A 3D grid is used to access boxes.