[kepler-dev] introduction & distributed ptolemy

[Edward A Lee]

At 05:48 PM 6/11/2004 -0700, Tobin Fricke wrote:
>A basic question I have is, is there a defined network transport for
>Ptolemy relations?  I expect that this question isn't really well-formed
>as I still have some reading to do on how relations actually work.
>Nonetheless, there is the question of, if we have different instances of
>Ptolemy talking to each other across the network, how are the data streams
>transmitted?  In our case one option is to use the ORB as the stream
>transport, equipping each sub-model with ORB source and ORB sink
>components; and perhaps this could be done implicitly to automatically
>distribute a model across the network.  But this line of thinking is
>strongly tied to the idea of data streams and may not be appropriate for
>the more general notion of relations in Ptolemy.

We have done quite a bit of experimentation with distributed
Ptolemy II models, but haven't completely settled on any one
approach... Most of the recent work in this area has been
done by Yang Zhao, whom I've cc'd for additional comments...
Here are some notes:

- A model can contain a component that is defined elsewhere
   on the network, referenced at a URL.  There is a demo
   in the quick tour that runs a submodel that sits on our
   web server.

- The Corba library provides a mechanism for transporting
   tokens from one model to another using either push or
   pull style interactions.  The software is in the
   ptolemy.actor.corba package, but there are currently
   no good (easily run) demos, and documentation is sparse.

- The MobileModel actor accepts a model definition on an
   input port and then executes that model.  Yang has used
   this with the Corba actors to build models where one
   model constructs another model and sends it to another
   machine on the network to execute.

- The JXTA library (ptolemy.actor.lib.jxta) uses Sun's
   XML-based P2P mechanism.  Yang has used this to construct
   a distributed chat room application.

- The ptolemy.actor.lib.net has two actors DatagramReader
   and DatagramWriter that provide low-level mechanisms for
   models to communicate over the net.  Three or four years
   ago Win Williams used this to created a distributed model
   where two computers on the net were connected to
   motor controllers and users could "arm wrestle" over
   the network ... when one of the users turned his motor,
   the other motor would turn, and they could fight each
   other, trying to turn the motors in opposite directions.

- Some years ago we also did some experimentation with
   Sun's JINI P2P mechanism, but this has been largely
   supplanted by JXTA.

- The security library (ptolemy.actor.lib.security)
   provides encryption and decryption and authentication
   based on digital signatures.

Most of these mechanisms have not been well packaged,
and we haven't worked out the "lifecycle management" issues
(how to start up a distributed model systematically, how
to manage network failures).

In my view, working out these issues is a top priority...
I would be delighted to work with you or anyone else on this...

Edward





------------
Edward A. Lee, Professor
518 Cory Hall, UC Berkeley, Berkeley, CA 94720
phone: 510-642-0455, fax: 510-642-2739
eal at eecs.Berkeley.EDU, http://ptolemy.eecs.berkeley.edu/~eal