# ode-dev mailing list archives

##### Site index · List index
Message view
Top
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 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->),

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

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:
JaCOb:

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