🚀 go-pugleaf

In article <1992Apr13.151051.1324@pictel.com>, henryc@pictel.com (Claudia Henry) writes:
|> Howdy,
|> 
|> At ICASSP recently, there was an impressive demo of a block-diagram DSP
|> programming environment called Ptolemy.  The system was developed at
|> UCBerkeley, and it was presented by Edward Lee.
|> 
|> They handed out business cards for someone at UCBerkeley who could arrange
|> for people to get free copies of the software over the Internet.
|> Unfortunately, I can't find the business card they gave me!
|> 
|> Does somebody out there have the e-mail address of this UCBerkeley
|> contact person?

Mail to ptolemy-request@ohm.berkeley.edu.  You can get Ptolemy for
free, but for political/bureaucratic reasons, you can't just grab
it by anonymous FTP; we have to have a signed license agreement from
everyone who wants Ptolemy.

Here's the procedure for FTP users:

1.  FTP to forney.berkeley.edu, user "anonymous", use your e-mail
address as password.

2.  Retrieve the file ptolemy-license.shar.  This is a shar archive
containing the license agreement with all the stuff our bureaucrats
want.  Sign it and mail it in.

3.  Our fearless Ptolemy staff person/project coordinator, Alan Kamas,
will tell you the secret word that will allow you to FTP Ptolemy.

If you can't FTP, mail to the above address and find out how to order
a tape, or maybe something else can be set up.

Here's the overview:
----------------------------------------------------------------------


                    PTOLEMY 0.3.1 OVERVIEW

Copyright 1989, 1990, 1991 The Regents of the University of
California.  All rights reserved.

Ptolemy is a very flexible foundation upon which to build simulation
environments, where a key objective is the ability to combine these
environments into multi-paradigm simulations as necessary.  To
effectively use existing simulation and synthesis tools and
methodologies, different models of computation must be used for
different parts of the overall design.  Large systems often mix
hardware, software, and communication subsystems.  They may also
combine hardware targets, including custom logic, processors with
varying degrees of programmability, systolic arrays, and other
multiprocessor subsystems.  Tools supporting each of these components
are different, using for instance dataflow principles, regular
iterative algorithms, communicating sequential processes,
control/dataflow hybrids, functional languages, and discrete-event
system theory and simulation.

Ptolemy is a third-generation software environment that supports
heterogeneous system specification, simulation, and design.  It is an
object-oriented framework within which diverse models of computation
can co-exist and interact.  In addition to the usual use of hierarchy
to manage complexity, Ptolemy uses hierarchy to mix heterogeneous
models of computation.  The result is a unified software environment
that extends the philosophy of mixed-mode circuit simulation up to the
design and simulation of complex systems.

This work is an outgrowth of two previous generations of design
environments, Blosim and Gabriel, that were aimed at digital signal
processing applications.  Both environments used a block-diagram
data-flow paradigm for the description of the algorithms.  To broaden
the applicability beyond DSP, we see the need for other computational
models, such as discrete-event scheduling, mixed compile-time and
run-time scheduling, or computational models based on shared data
structures.  These are not supported very gracefully by Blosim or
Gabriel.  Most importantly, we see the need for a flexible simulation
environment which is extensible to new computational models without
re-implementation of the system.

Ptolemy uses an object-oriented programming methodology to support
heterogeneity, and is programmed in C++.  Data abstraction and
polymorphism, two tenets of object-oriented programming, allow models
of computation to be abstracted so that their differences are not
visible from other domains.  Our goal is to make the system
non-dogmatic, in the sense that the environment itself does not impose
any particular computational model, and it is extensible to new models
by simply adding to the system and not modifying what is already
there.  Further goals are to incorporate features that have been
successful in Blosim or Gabriel, such as achieving modularity and
reusability of user-programmed software modules, friendly graphical
window interfaces, and code generation for targeting concurrent
architectures rather than just simulation.

Each model of computation in Ptolemy is called a Domain.  The system
currently has a synchronous data-flow (SDF) domain (like Gabriel), a
dynamic dataflow (DDF) domain (like Blosim), a discrete-event (DE)
domain, and some others that are either more specialized or still
under development.  The system is thus already capable of simulating
combinations of signal processing and communication networks (such as
in packet speech and packet video) and combinations of behavioral and
hardware simulation.

The same graphical interface used by Gabriel, based on Vem, can be
used with at least some domains in Ptolemy.  Oct serves as the design
database for the system, just as with Gabriel, enabling future
assimilation of many Berkeley design tools.



-- 
Joe Buck	jbuck@ohm.berkeley.edu