Path: utzoo!utgpu!news-server.csri.toronto.edu!cs.utexas.edu!sdd.hp.com!wuarchive!emory!hubcap!Steven
From: zenith@ensmp.fr (Steven Ericsson-Zenith)
Newsgroups: comp.parallel
Subject: Re: parallel programming model
Message-ID: <12242@hubcap.clemson.edu>
Date: 13 Dec 90 17:43:40 GMT
Sender: fpst@hubcap.clemson.edu
Lines: 99
Approved: parallel@hubcap.clemson.edu


   From: ciancarini-paolo@CS.YALE.EDU (paolo ciancarini)
   Subject: Re: parallel programming model

   In article <12221@hubcap.clemson.edu> hshi@maytag.waterloo.edu writes:
   >A naive question:
   >	We have two parallel programming models: shared memory model via
   >shared variables and distributed memory model via message passing. 
   >Is there any model which is some where between? Will it be more suitable
   >for the persent comptuter architectures?

   A naive answer:
   >From a linguistic point of view, "Infinite systems exist" (Dedekind). :)

   More seriously, I would say that Linda'a Generative communication
   through a Tuple Space is different from both.

I can't agree with you here Paolo. In the Linda model processes interact
via the global associative memory of Tuple Space. In a shared memory
model processes interact via an addressable global space. In message
passing processes interact via shared objects (which in some forms are
dynamically addressable) called "channels" or "mailboxes" or somesuch.
The behavioral characteristics may differ but what we have here are
essentially variants of the same model - the persistent nature of the
intermediary objects being the significant disinquishing characteristic.

Another distinquishing feature of these variants is that in addition to
the synchronization characteristics of the means by which processes
"communicate", processes may interact via some distinct synchronization.
For example, in the message passing model, epitomised by CSP, processes
combined by a parallel sychronize when all the components of the
parallel have terminated. In Linda the programmer must "coordinate" his
programs via interactions with Tuple Space.

It would seem desirable to have all process interactions defined by the
associated "interaction model". As things stand in Linda processes are
able to side-effect each other directly, i.e. outside of the tuple space
model -- at least this is the case for the Yale C-Linda model. The
process model in Linda is vague to say the least, with the semantics of
process creation varying according to implementation.

Linda's distinquishing characteristic is "value associative matching",
which amounts to complex address translation in a global shared memory -
this turns out to be an operation with unpredictable performance
characteristics. For example, in the case of the Linda optimizer, write
a Linda program or Linda-ize an existing C code. You cannot predict the
performance of the program, and you will not know the performance until
the task is complete - any imperical analysis you perform at any point
in the development will likely be invalidated by subsequent changes to
the program since the optimizer will almost certainly change stategy as
you add new tuple types. Ok, so you learn everything there is to know
about the optimizer - now you have subverted portability. Most
"successful" Linda programs are either written within a few feet of the
implementor of the optimizer or are so parallel and have such
granularity that the Linda overhead disappears into insignificance and
in such cases pretty much any model would do (e.g. a decent system of
batch files with native job control language, and "sockets" is likely to
do as well - maybe better - than any network distributed version of
Linda, for as much effort).

   is NEITHER a msg passing model, because agents do not know
   about each other

Well "agents" "know" about Tuple space and also must "know" about data
structure and type. This is directly analogous to a "knowledge" of
communication channels, mail boxes and protocols in message passing.

   and the Tuple Space is Shared and communications are
   associative, NOR a shared memory
   model because agents do not shared variables or a global environment
   (in fact, for Linda exist both shared memory implementations and
   distributed memory implementations, but this is another issue).

Again, Tuple Space epitomises a "global environment" and in current
implementations I've seen at Yale "agents" may indeed share variables ..
I've already indicated that I view side effecting processes as
undesirable.

   >From a semantic point of view, however, it seems to me that 
   we have only two models: the CCS interleaving model and the
   Petri Net distributed model. It is unclear to me if does exist
   a third basic model in the sense that Linda seems to be basically
   different from shared memory and msg passing.

Sorry Paolo, maybe it is your English I'm having trouble with, since you
seem to be contradicting yourself here. I hope my view here is clear.
Linda is a variant of a model I have come to call the "interacting
process model"(nee MIMD), members of this model are distinquished by an
associated "interaction model" which captures the means by which
processes "communicate" and "synchronize" (in this sense Occam, Linda
and indeed Ease are members of the Interacting Process Model).

Steven
--
Steven Ericsson Zenith * email: zenith@ensmp.fr *   fax: (1).64.69.47.09
                       |                        | voice: (1).64.69.48.52
	     Ecole Nationale Superieure des Mines de Paris
	  35 Rue Saint-Honore 77305 Fontainebleau Cedex France
    "All see beauty as beauty only because they see ugliness" LaoTzu