Newsgroups: comp.os.parix
From: jcar@pandora.uc.pt (joao carreira)
Subject: ANNOUNCING !! Linda-like library for PARIX
Organization: lis-ftmps
Date: Fri, 14 Oct 1994 04:42:04
Message-ID: <jcar.110.0004B34A@pandora.uc.pt>



Hi Parix users.

Linda is a good alternative to using the low-level message passing primitives 
of Parix to write parallel applications.

We've developed a Linda-like library for PARIX and it is now available under 
the GNU Library public License.

There are two versions available, one for T800 based machines and other for 
PowerPC running PARIX.

Try it..

Joao

-------------------------------------------------------------------------------

			ANNOUNCING !!!!



             PARLIN: A LINDA-LIKE PARALLEL PROGRAMMING
                       LIBRARY FOR PARIX 


Authors:
	Joao Carreira 		jcar@pandora.uc.pt
	Francisco Moreira 	fmoreira@pandora.uc.pt
	Department of Informatics Engineering
	University of Coimbra Portugal


ftp site: 	lisbbs.uc.pt
www:      	http://lisbbs.uc.pt
dir:		pub/parallel/ParLin
bugs:		jcar@pandora.uc.pt


Platforms:
	T800 based machines (Parix 1.2)
	PowerPC based machines (Parix 1.2)



What's Parlin ?
****************

The PARLIN library provides a Linda-like coordination language to the
Parix [Parsytec 93] operating system and the C programming language.
Unlike the original Linda there is no pre-processor involved.
The Linda primitives are implemented as C functions and are supported
by a run-time library. The main consequence of this fact is the loss
of associative search. In PARLIN, as in Brenda [Branner 90] and TsLib
[Silva 93a], tuples are seen as arbitrary arrays of bytes along with
an integer tag. The integer tag should be specified when adding,
removing or reading a tuple from the TS and is the only value used for
matching. The programmer can use tuples containing a C structure with
several fields, but the PARLIN routines will not recognize its
individual elements.
This simple matching strategy has the clear advantage of strongly
simplifying the TS search procedure. Additionally, it may be the key
for an efficient hash-based distribution of the TS, because the search
field is always the same.
Despite the clear performance advantage, this simplification could be
unacceptable if it imposed significant difficulties to the programmer.
But, from our experience, this is not the case. Most of our programs
were easily constructed using only this simple integer tag.


What's Linda ?
**************
You can find a good introduction on Carriero's book
"How to Write Parallel Programs"
The paper and TR about ParLin also have lots
of references.


ParLin Library Overview
************************

Centralised Tuple Space
	The Tuple space is stored in only one processor, freely chosen
	by the programmer. The default processor is number zero.

Six Tuple Space operations
	In spite of some differences to the original Linda, described
	later, the following operations are available:
		EVAL, OUT, IN, RD, RDP, INP

Flexible Linda Termination
	The programmer can choose one of several ways to terminate his
	Linda program. He can for instance specify that the program
	should end when all the workers are blocked on IN/RD operations.
	This mechanism is also usefull for Deadlock run time detection.
	If all workers are blocked they can be in deadlock situation,
	instead of  normal  termination. Of course it only detects total
	deadlock, partial ones, involving a subset of workers will remain
	undetected, but it can provide a good feedback to the programmer
	in several situations.

Minimum of 2 processors required
	One processor is dedicated to store the Tuple space, to manage
	thread creation and optionally to run the user master program,
	that is usually not very time consuming. At least one second
	processor is needed to run workers started by the master or
	another worker.

Several workers running per node
	This feature can be very usefull as the programmer can design his
	algorithm, without having to consider how much processors are
	available to run workers, and can concentrate solely in expressing
	the parallelism.

Tuple Space operations latency hidding
	By having as many workers as he wants running simultaneously per
	processor, the programmer is able to hide the latency of Tuple
	Space operations. This happens because when user threads (workers)
	are blocked in an In() or Rd() operation, another worker can be
	using the CPU; the waiting time of the first thread is used by another.

----------------------------------------------------------------------------
Joao Carreira                        
LIS Lab.de Informatica e Sistemas    tel: 351.39.701791  
Universidade de Coimbra              fax: 351.39.701266
Urb. da Boavista, lote 1,1           email:jcar@pandora.uc.pt  
3000 COIMBRA - PORTUGAL              WWW: http://pandora.uc.pt/jcar.html 
                                     Labs WWW home-page http://lisbbs.uc.pt
----------------------------------------------------------------------------



