Synergy Project Home Page

Using the Stateless parallel programming principle, Synergy allows automatic formation of SIMD, MIMD and pipelined parallelisms for any given task.  

Programming using Synergy uses implicit parallelism. This means that the user composes parallel programs that are to communicate using a given set of primitives but NOT concerned with the number of possible processors.

It is only at runtime, the user needs to define the desired number of processors. The Synergy runtime environment automatically configures the multiple processors for the given task and arranges the most suitable SIMD, MIMD and piplelined processor formations for the given task.

Synergy unifies tuple space, message passing parallel programming styles and parallel file access using a Passive Object-Flow Programming (POFP) method. The object passiveness allows dynamic mapping of application programs onto any set of networked computers while keeping the IPC graph constant. POFP also allows a simple API that blends well into the sequential programming and object oriented programming styles. More interestingly, POFP allows parallel programming of parallel programs using Linda, PVM and Express. In other words, it subsumes the existing technologies.

Synergy V3.0 supports three passive data objects for program-to-program communication and synchronization:

A passive data object is an object permitting only passive operations. An operation is considered passive if the object creating semantics is absent. All commonly known large data objects, such as databases, knowledge bases, hashed files, and ISAM files, can be passive objects provided the object creating operators are absent. The use of passive objects results in a static IPC graph for any parallel application. This is the basis for dynamic customization.

The use of passive objects also eases the parallel programming difficulties due to the lack of runtime program and data management tasks.  

In practice, POFP is very similar to conventional programming styles using a simple open-manipulate-close sequence for each passive object. Using POFP, an one-dimensional Coarse-To-Fine (CTF) decomposition method (see Adaptable Parallel Application Development section for details) can produce designs of modular parallel programs. The global view of the connected programs exhibits application dependent coarse grain SIMD, MIMD and pipeline potentials. The parallel programs can be developed and compiled independently.

Synergy’s API is largely static with deterministic parallel operations (if only blocking operations are used). Parallel binaries are hostless (as if they were sequential codes). This leaves rooms for both beginners and experienced parallel programmers to fully exploit the dynamically changing distributed resources.

Since POFP objects are intimately related to an application's specific partial-dataflows, the object service requirements are significantly reduced and simplified. For example, object memory requirements are reduced due to distributed deployment. Object content migration is automated -- data automatically moves to where it is needed. This "RISC" analogous feature enhances service efficiency as well as application's scalability.

Synergy V3.0 kernel includes the following elements:

The most immediate Synergy interface with a parallel programmer is the language injection library (LIL). It contains all passive operations that each program must use for communication and synchronization. LIL is linked to programs at compilation time to generate hostless binaries.

After making the parallel binaries and configuration specification, commands prun and pcheck are for running and monitoring multiple parallel applications. The prun command calls the parallel program configuration processor (CONF) to complete the program/object-to-processor binding according to a static host file and host availability at the time. It then activates DAC (Distributed Application Controller) which in turn launches necessary object daemons and then the entire parallel application. 

Pcheck can be considered as a parallel "ps" command in Unix. It monitors all parallel applications and keeps track of parallel processes of each application. Pcheck also allows a minimal set of management tasks such as killing running processes or applications.

There are two light weight service daemons for making remote processors available for personalized parallel processing:

Cid provides automatic remote command execution functions for each user id. Thus, it is only to be run on those computers where the user has accounts.  Cid only "understands" a very limited set of commands for program activation and simple management functions. Pmd provides a "yellow page" service for locating local cid’s and objects. It should runs on every participating computer.

Using pmd and cid, Synergy V3.0 requires no root priviledged processes at all. Dependency on remote execution utilities, such as rsh and ssh, is limited only to daemon management tasks. All parallel programs run under the given login's credential imposing no security threat to the existing systems.

The object daemons are for passive object types. For the three supported types: tuple space, pipe and files, we saved the pipe daemon by implementing it directly in LIL. Thus, Synergy V3.0 has only two object daemons:

The object daemons are potentially resource hungry but they only "live" on the computers where they are needed and permitted. These daemons will disappear in the newer version of the stateless machine implementation.