ode-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Paul R Brown <paulrbr...@gmail.com>
Subject Re: PXE implementation basis
Date Wed, 12 Apr 2006 08:27:29 GMT

Hi, All --

JaCOb is Maciej's invention, so I'm hoping that he'll jump in here at  
some point and add a layer of detail.

The articles that Matt pointed to can make some interesting reading  
(I like the Sangiori and Weaver book (ISBN 0521781779) and Gul Agha's  
thesis (linked from my bookmarks -- http://del.icio.us/prb/actors)).   
**BUT** PXE is a *PRACTICAL* design, you don't need any of the heavy  
machinery to appreciate how PXE works.

Getting back to the sieve example with JaCOb, here's the basic idea:

The Sieve of Erasthones (http://en.wikipedia.org/wiki/ 
Sieve_of_Eratosthenes) provides a way to enumerate prime numbers.  In  
terms of the example, you have three process terms that work together:

1) You've got a counter term that sends integers one after the other.
2) You've got a head term that works like a factory for primality  
checkers.
3) You've got a printer.

We start off with an arrangement like this:

Counter -1-> Head -2-> Print

Counter sends 2 to Head on -1->, and Head creates a prime checker and  
a new Head.  The new Head still talks to Print on -2->.  The prime  
checker listens on -1-> and checks for relatively primeness to 2; if  
it succeeds, it tells the new Head (on -3->).  So we have:

Counter -1-> P2 -3-> Head -2-> Print

Note that the P2 above is really the term PrimeFilter(2,-1->,-3->),  
Head is really Head(-3->,-2->), and Counter is really Counter(3,-1->).

When Counter sends 3, P2 passes it along, and Head again spawns a  
checker for relatively primeness to 3 and a new Head:

Counter -1-> P2 -3-> P3 -4-> Head -2-> Print

Counter is really Counter(4,-1->), and this time, PrimeFilter(2,-1- 
 >,-3->) just absorbs it.  Counter is now Counter(5,-1->), 5 will  
flow from P2 to P3 to Head, which spawns a mod 5 checker and a new  
Head, etc.

This is what the Sieve example does, and JaCOb ("[Ja]va [C]oncurrent  
[Ob]jects") is a relatively thin layer to translate between notation  
like the above and Java.  The translation between process notation  
like the above and JaCOb notation takes a little getting used to, but  
this little snippet is relatively close to the underlying notation:

   Process:
     ( v x )
   JaCOb:
     NaturalNumberStreamChannel x = newChannel 
(NaturalNumberStreamChannel.class);

   Process:
     PrimeFilter(n,_in,x)
   JaCOb:
     instance(new PrimeFilter(n, _in, x));

   Process:
     Head(x,_primes)
   JaCOb:
     instance(new Head(x, _primes));

And this is the "spawning" phenomenon within a Head(...) term.   
(Parallelism is implicit in JaCOb, so no "|" is needed.)  This is  
covered in the JavaDoc for the instance method on Abstraction --  
"instance(new Term(args))" in JaCOb Java notation is equivalent to  
"Term(args)" in process notation.  In the same vein, "self" is a  
reduction of the represented term.

Does this make some sense so far?

	-- Paul


On Apr 6, 2006, at 3:15 PM, Alex Boisvert wrote:

>
> Yes, the sieve example can be found at:
>
> $PXE_SVN/jacob/src/java/com/fs/jacob/examples/eratosthenes/Sieve.java
>
> alex
>
>
> Paul R Brown wrote:
>
>>
>> Hi, Bill --
>>
>>> We are trying to understand the PXE contribution.  Is this the
>>> implementation basis for PXE?
>>> http://www.labri.fr/perso/grange/documents/fmppta.pdf
>>
>>
>> Funny -- that's a *different* Jacob but with a few ideas in common.
>> (Or at least that's the way it looks after I skimmed the paper.)
>>
>> Did the prime sieve example make it into the submission?  If so, I
>> can walk through that as an explanation.
>>
>> Best,
>>
>> -- Paul
>
>


Mime
View raw message