Parallel computing using a system such as PVM may be approached
from three fundamental viewpoints, based on the organization of
the computing tasks. Within each, different
workload allocation strategies are possible and will be discussed
later in this chapter. The first and most common model for PVM
applications can be termed ``crowd'' computing :
a collection
of closely related processes, typically executing the same code,
perform computations on different portions of the workload,
usually involving the periodic exchange of intermediate results.
This paradigm can be further subdivided into two categories:

The master-slave (or host-node)
model in which a
separate ``control'' program
termed the master is responsible for process spawning, initialization,
collection and display of results, and perhaps timing of functions.
The slave programs perform the actual computation involved;
they either are allocated their workloads by the master
(statically or dynamically) or perform the allocations themselves.

The node-only model where multiple instances of a single
program execute, with one process (typically the one initiated
manually) taking over the noncomputational responsibilities
in addition to contributing to the computation itself.

The second model supported by PVM is termed a ``tree''
computation.
In this scenario, processes are spawned (usually dynamically
as the computation progresses) in a tree-like manner, thereby
establishing a tree-like, parent-child relationship (as opposed
to crowd computations where a star-like relationship exists). This
paradigm, although less commonly used, is an extremely natural
fit to applications where the total workload is not known
a priori, for example, in branch-and-bound algorithms, alpha-beta
search, and recursive ``divide-and-conquer'' algorithms.

The third model, which we term ``hybrid,'' can be thought of as
a combination of the tree model and crowd model. Essentially,
this paradigm possesses an arbitrary spawning structure: that is,
at any point during application execution, the process
relationship structure may resemble an arbitrary and changing graph.

We note that these three classifications are
made on the basis of process relationships, though they frequently
also correspond to communication
topologies.
Nevertheless, in all three, it is possible for any process to
interact and synchronize with any other. Further, as may be expected,
the choice of model is application dependent and should be selected
to best match the natural structure of the parallelized program.