Reusability of coordination programs

Isolating computation and communication concerns into separate pure computation and pure coordination modules enhances modularity, understandability, and reusability of parallel and/or distributed software. This can be achieved by moving communication primitives (such as SendMessage and ReceiveMessage), which are now commonly scattered in application codes, into separate modules written in a language dedicated to the coordination of processes and the flow of information among them. MANIFOLD is a pure coordination language that encourages the separation of communication and computation concerns, We use real, concrete, running MANIFOLD programs to demonstrate the concept of pure coordination modules and the advantage of their reuse in applications of different nature

Coordination of distributed/parallel multiple-grid domain decomposition

A workable approach for the solution of many (numerical and non-numerical) problems is domain decomposition. If a problem can be divided into a number of sub-problems that can be solved in a distributed/parallel fashion, the overall performance can significantly improve. In this paper, we discuss one of our experiments using the new coordination language MANIFOLD to solve an instance of the classical optimization problem by domain decomposition. We demonstrate the applicability of MANIFOLD in expressing the solutions to domain decomposition problems in a generic way and its utility in producing executable code that can carry out such solutions in both distributed and parallel environments. The multiple-grid domain decomposition method used in this paper is based on adaptive partitioning of the domain and results in highly irregular grids as shown in the examples. The implementation of the distributed/parallel approach presented in this paper looks very promising and its coordinator modules are generally applicable

Coordinating Components in the Multimedia System Sercices Architecture

The purpose of this work is to examine and exploit the potential of the coordination paradigm to act as the main communication and synchronization mechanism between components forming a distributed multimedia environment and exhibiting real-time properties. Towards this purpose, we have developed a mechanism for coordinating the distributed execution of components, as these are defined by the Multimedia System Services Architecture (MSSA). Our coordination environment uses the control-driven approach to coordination, namely the model IWIM and the associated language Manifold. In the process we show how Manifold can be used to realize object communication and synchronization of MSSA components and we present a methodology of combining a software architecture such as MSSA with a coordination language such as Manifold. We illustrate our approach by means of a suitable example

Coordination of a heterogeneous coastal hydrodynamics application in manifold

In this paper we show how the coordination language Manifold can be used to control the interactions of multiple heterogeneous application programs. We use a concrete example from Delft Hydaulics, a consulting and research company which develops models of natural hydraulic systems (e.g., river flows, tidal currents, wave penetrations in harbours, etc.). These simulation programs accurately model water flow phenomena and are used for many places in the world. Often, however, a number of these programs need to be used in conjunction with each other to address more comprehensive problems. For example, the water level in the Rotterdam harbour is determined both by the behaviour of the North Sea and by the discharge of the rivers Rhine and Meuse. Instead of creating Unix shell scripts for each particular configuration of application programs, an executive program has been developed and implemented in Manifold that reads a configuration file and subsequently starts, interconnects and controls all relevant component programs

Distributed splitting of constraint satisfaction problems

Constraint propagation aims to reduce a constraint satisfaction problem into an equivalent but simpler one. However, constraint propagation must be interleaved with a splitting mechanism in order to compose a complete solver. In~cite{monfroy:sac2000 a framework for constraint propagation based on a control-driven coordination model was presented. In this paper we extend this framework in order to integrate a distributed splitting mechanism. This technique has three main advantages: 1),in a single distributed and generic framework, propagation and splitting can be interleaved in order to realize complete distributed solvers, 2), by changing only one agent, we can perform different kinds of search, and 3), splitting of variables can be dynamically triggered before the fixed point of a propagation is reached

Parallel, distributed-memory implementation of a sparse-grid method for time-dependent advection-diffusion problems

A workable approach for modernizing existing software into parallel/distributed applications is through coarse-grain restructuring. If, for instance, entire subroutines of legacy code can be plugged into a new structure, the investment required for the re-discovery of the d

Coordination of a parallel proposition solver

In this paper we describe an experiment in which {sc Manifold is used to coordinate the interprocess communication in a parallelized proposition solver. {sc Manifold is very well suited for applications involving dynamic process creation and dynamically changing (ir)regular communication patterns among sets of independent concurrent cooperating processes. The idea in this case study is simple. The proposition solver consists of a fixed numbers of separate processing units which communicate with each other such that the output of one serves as the input for the other. Because one of the processing units performs a computation intensive job, we introduce a master/worker protocol to divide its computations. We show that this protocol implemented in {sc Manifold adds another hierarchic layer to the application but leaves the previous layers intact. This modularity of {sc Manifold offers the possibility to introduce concurrency step by step. We also verify the implementation of the proposition solver using a simple family of assertions and give some performance results

Coordination and P2P computing

Peer-to-Peer (P2P) refers to a class of systems and/or applications that use distributed resources in a decentralized and autonomous manner to achieve a goal. A number of successful applications, like BitTorrent (for file and content sharing) and SETI@Home (for distributed computing) have demonstrated the feasibility of this approach. As a new form of distributed computing, P2P computing has the same coordination problems as other forms of distributed computing. Coordination has been considered an important issue in distributed computing for a long time and many coordination models and languages have been developed. This research focuses on how to solve coordination problems in P2P computing. In particular, it is to provide a seamless P2P computing environment so that the migration of computation components is transparent. This research extends Manifold, an event-driven coordination model, to meet P2P computing requirements and integrates the P2P-Manifold model into an existing platform. The integration hides the complexity of the coordination model and makes the model easy to use