Linda implementation of barrier synchronization

	Barrier synch construct			Linda construct (Process j)
1. Initialization:
	ProcGroup G;				each process must know group
	for (i=0;i<N;i++)			name and size of group
	    AddProc(G, P[i])			

2. Reach barrier and wait			
	B_synch(G);				for (i=0;i<N;i++)
						    out("G", "B_synch", i, j)
						for (i=0;i<N;i++)
						    in("G", "B_synch", j, i)

Note:
Care must be taken that a speedy process does not go through the barrier
twice while some other process is trying to get through the barrier the 
first time.  This is why there are both i and j in the tuples - only process
j can use a tuple that names j as the third field.
Every process that reaches the barrier will output a tuple for each other
process in G, while no process may procede until it inputs a tuple from
each other process, which will only happen after the other process reaches
the barrier.
A fast process may reach the barrier, but then it will have to wait until
each other process puts a tuple for it in tuple space.  Once it has these
tuples (removed from TS by the in operation), it may proceed (which is OK
since all other processes must have started executing the barrier statement
to have placed the tuple in the TS).  If it reaches another call to the
barrier synch, it must again wait, since it removed all the tuples meant
for it on the previous call.  A slow process that has not yet returned
from its first barrier synch call cannot have placed a second tuple for
the fast process in the TS, and will not place one there until it again
calls the barrier synch.
.