The Coordination Language Manifold
by Farhad Arbab
The proper functioning of many of today’s applications depends
on the mutual cooperation and interaction of (one or more) computers
and human users. Special coordination languages have been designed,
in which one can specify, analyze and control the cooperation
between the various system components. An important application
of such languages is in the parallelization of computation intensive
sequential programs. Experimental research on coordination started
at CWI in 1990. The major result of these efforts so far has been
the development of the coordination language MANIFOLD, based on
a novel model for control-oriented coordination (IWIM). The language
has found several licensees in Europe as well as the USA.
Computers nowadays do much more than mere computing. They also
act as facilitators, mediators, and coordinators enabling the
collaboration of other computers (or computer programs), sensors
and actuators that involve their real world environment, or human
beings. This requires computers to interact with these agents,
as expressed in the concept of Interaction Machine, proposed by
P. Wegner in 1995. An Interaction Machine is an extension of a
Turing Machine that can interact with its environment with new
input and output primitive actions. Interaction Machines can represent
the behaviour of many interesting real systems.
The goal of coordination is to manage the interaction among concurrent
programs. Analogous to the way in which topology abstracts away
the metric details of geometry and focuses on the invariant properties
of (seemingly very different) shapes, coordination abstracts away
the details of computation in Interaction Machines, and focuses
on the invariant properties of (seemingly very different) programs.
As such, coordination focuses on program patterns that specifically
deal with interaction.
Coordination is relevant in the design, development, debugging,
maintenance, and reuse of all concurrent systems. The primary
concern in the design of a concurrent application must be how
its various active entities are to cooperate with each other.
A number of software platforms and libraries are presently popular
for easing the development of concurrent applications. Such systems,
eg, PVM, MPI, CORBA, etc., are sometimes called middleware. Coordination
languages can be thought of as their linguistic counterpart.
The coordination language MANIFOLD, developed at CWI during the
1990s, is a control-oriented language, directed to aspects such
as processing or the flow of control, rather than large-scale
data handling, and is suited to, eg, applications involving work-flow
in organizations, or multi-phase applications where the content,
format, and/or modality of information substantially changes from
one phase to the next. Its primitives support coordination of
entities from without, so that the coordination modules are separated
from the computation modules and, hence, can be reused in other
applications. For example, the same MANIFOLD coordinator program
that was developed for a parallel/distributed bucket sort algorithm,
was used at CWI in a quite different research field to perform
function evaluation and numerical optimization using domain decomposition.
MANIFOLD manages complex, dynamically changing inter-connections
among sets of independent, concurrent, cooperating processes.
Whereas computation processes can be written in any conventional
programming language, coordinator processes are written in the
MANIFOLD language. The language is based on the IWIM model (Idealized
Worker Idealized Manager), which is a generic, abstract communication
model that separates computation (worker) from communication and
cooperation (manager) modules.
MANIFOLD is a strongly-typed, block-structured, event-driven language,
in which, semantically, there is no need for ‘computational’ entities
or constructs like integers, floats, strings, arithmetic expressions,
sequential composition, conditional statements, loops, etc. MANIFOLD
only recognizes processes, ports, events, and streams (which are
asynchronous channels), and its only control structure is an event-driven
state transition mechanism. Programming in MANIFOLD is a game
of dynamically creating process instances and (re)connecting the
ports of some processes via streams, in reaction to observed event
occurrences. Any coordinator process can also be used as a meta-coordinator,
to build a sophisticated hierarchy of coordination protocols.
Such higher-level coordinators are not possible in most other
coordination languages and models.
MANIFOLD’s coordination modules construct and maintain a dynamic
data-flow graph where each node is a process. These modules only
change the graph topology, by changing the connections among various
processes in the application. The computation modules cannot possibly
change the graph topology. This separation makes both sets of
modules easier to verify and more reusable.
The MANIFOLD system runs on multiple platforms and consists of
a compiler, a run-time system library, a number of utility programs,
and libraries of built-in and predefined processes of general
interest. Presently, it runs on IBM RS6000 AIX, IBM SP1/2, Solaris,
Linux, Cray, and SGI IRIX. A MANIFOLD application consists of
a (potentially very large) number of processes running on a network
of heterogeneous hosts, some of which may be parallel systems.
Processes in the same application may be written in different
programming languages and some of them may not know anything about
MANIFOLD, nor the fact that they are cooperating with other processes
through MANIFOLD in a concurrent application.
MANIFOLD has been successfully used at CWI to implement parallel
and distributed versions of a semi-coarsened multi-grid Euler
solver algorithm. This represents a real-life heavy-duty Computational
Fluid Dynamics application where MANIFOLD enabled restructuring
of existing sequential Fortran code using pure coordination protocols
that allow it to run on parallel and distributed platforms. The
results of this work are very favourable: no modification to the
computational Fortran 77 code, simple, small, reusable MANIFOLD
coordination modules, and linear speed-up of total execution time
with respect to the number of processors (eg, from almost 9 to
over 2 hours). Other applications of MANIFOLD include its use
in modelling cooperative information systems, coordination of
loosely-coupled genetic algorithms on parallel and distributed
platforms, coordination of multiple solvers in a concurrent constraint
programming system, and a distributed propositional theorem checker.
Information on the web at:
Please contact:
Farhad Arbab - CWI
Tel: +31 20 592 4056
E-mail: Farhad.Arbab@cwi.nl
