Ptolemy II 7.0.1 is available for download from
http://ptolemy.eecs.berkeley.edu/ptolemyII/ptII7.0
Changes between 7.0.beta and 7.0.1:
* Backtrack and Graph Transformation facilities were updated
* Design document updated
* Fixed problem with shorts in Expression language: ceil(1s) was
failing
* Wireless Triangulation actor needed updating
* Don't prompt for a save when the model name has spaces
The primary new features in Ptolemy II 7.0.1:
SDF Code Generation - further enhancements such as embedding C code in models.
Ptalon - language for parameterizing components with other components.
Backtracking - a facility that enables the system to restore its old state.
The Continuous domain - a redesign of the CT domain.
Below is a portion of the release notes.
--start--
Ptolemy II 7.0.1 Release Notes
Ptolemy II is a set of Java packages supporting heterogeneous,
concurrent modeling and design. Its kernel package supports clustered
hierarchical graphs, which are collections of entities and relations
between those entities. Its actor package extends the kernel so that
entities have functionality and can communicate via the relations. Its
domains extend the actor package by imposing models of computation on
the interaction between entities. Examples of models of computation
include discrete-event systems, dataflow, process networks,
synchronous/reactive systems, and communicating sequential processes.
Ptolemy II includes a number of support packages, such as
data, providing a type system, data encapsulation and an expression
parser, plot, providing visual display of data,
math, providing matrix and vector math and signal processing
functions, and graph, providing graph-theoretic manipulations.
The three volumes of the Ptolemy II Design Document describes the
Ptolemy II design and the implementation of the Java classes.
* Volume 1: Introduction to Ptolemy II (Local PDF)
* Volume 2: Ptolemy II Software Architecture (Local PDF)
* Volume 3: Ptolemy II Domains (Local PDF)
The "Using Vergil" describes how to use Vergil.
Complete List of Domains in Ptolemy II
* CI: component interaction (experimental),
* CSP: communicating sequential processes,
* CT: continuous-time modeling,
* Continuos: continuous-time modeling (experimental),
* DE: discrete-event modeling,
* DDE: distributed discrete events (experimental),
* DDF: dynamic dataflow
* DT: discrete time,
* FSM: finite state machines,
* Giotto: periodic time-driven (experimental),
* GR: 3-D graphics (experimental),
* HDF: heterochronous dataflow
* PN: process networks,
* PSDF: parameterized synchronous dataflow (experimental),
* Rendezvous: rendezvous (experimental),
* SDF: synchronous dataflow,
* SR: synchronous/reactive,
* TM: timed multitasking (experimental), and
* Wireless: wireless (experimental).
Platforms
The core of Ptolemy II 7.0.1 is 100% Java, so it should work on any
platform that has JDK 1.5 or later.
We developed Ptolemy II 7.0.1 under Solaris 10 and Windows XP and
with JDK1.5.0.0_15
Ptolemy II 7.0 will not compile under Java 1.3 because we use the
java.lang.URI class, which is present only in Java 1.4 and later. JDK
1.5 or later is required so that these packages can use generics:
backtrack, ptalon and others.
Ptolemy II has been compiled and run under IBM JDK 1.6.0. There are
the following limitations under IBM JDK 1.6.0
The Copernicus code generator does not work.
Caltrop does not work.
The IBM JDK seems to return directory contents in a different order
than the Sun JDK. Thus actor.lib.io.DirectoryListing might return
elements in a different order.
Contents:
* Highlights
* New demonstrations
* Other Key New Capabilities
* New and Enhanced Actor Libraries
* Additional features
* Bug fixes
Ptolemy II 7.0.1 Highlights
SDF Code Generation
The SDF Template based C code generator (Codegen) generates code for
hierarchical Synchronous Dataflow (SDF), Finite State Machine (FSM)
and Heterochronous Dataflow Domain (HDF) models.
Codegen has the following new features:
* EmbeddedCActor - Allows arbitrary C code to be embedded in a
Java model. The entire Java model can then be converted to C code
and the code within the EmbeddedCActor will be used.
* Enhanced polymorphic type system
* Support for invoking the Java plotter from a C version of a model
* and many more
Code Generator Documentation
References
* G. Zhou, M.-K. Leung, and E. A. Lee, "A Code Generation
Framework for Actor-Oriented Models with Partial Evaluation,"
Proceedings of International Conference on Embedded Software and
Systems 2007, LNCS Vol. 4523, Daegu, South Korea, May 14-16, 2007,
pp. 786-799.
Codegen Demonstrations
Some of the code generation demos might not work under Web Start
because Web Start uses a JRE, not a JDK.
Primary Codegen Developers: Gang Zhou, Man-kit Leung.
Codegen Contributors: Christopher Brooks, Teale Fristoe, Edward A.
Lee, Ye Zhou
Ptalon
Actor-oriented design is a common design strategy in embedded system
design, where actors are concurrent components which communicate
through ports by sending signals to one another. Such systems are
frequently modeled with block diagrams, where the blocks represent
systems and lines or arrows between blocks represent signals. Examples
include Simulink, LabView, and VHDL/Verilog.
A common problem in such environments is managing complexity,
particularly when the designs become large. Most actor-oriented design
environments allow hierarchy, or systems (blocks) which are composed
of other systems (blocks). To take this a step further, we are
developing the Ptalon programming language, which allows users to
parameterize components with other components.
We have developed a preliminary interpreter for the Ptalon language in
the context of Ptolemy II, a general-purpose design environment for
actor-oriented systems. We have also developed a mathematical
framework for such languages, to help aid our understanding . We are
currently investigating the resource management issues inherent in
supporting large block-diagram models.
References
* E. A. Lee, "Model-driven Development--From Object-Oriented
Design to Actor-Oriented Design," Workshop on Software Engineering
for Embedded Systems: From Requirements to Implementation (a.k.a.
The Monterey Workshop), Chicago, IL, 2003.
* A. Cataldo, E. Cheong, T. H. Feng, E. A. Lee, and A. Mihal, "A
Formalism for Higher-Order Composition Languages that Satisfies
the Church-Rosser Property," UC Berkeley EECS Technical Report No.
UCB/EECS-2006-48, 2006.
* J. A. Cataldo, "The Power of Higher-Order Composition
Languages in System Design," EECS Department, UC Berkeley,
Technical Report No. UCB/EECS-2006-189, December 18, 2006.
* E. Cheong, "Actor-Oriented Programming for Wireless Sensor
Networks," EECS Department, University of California, Berkeley
Technical Report No. UCB/EECS-2007-112, August 30, 2007
Ptalon Demonstrations
* CruiseControl
* EightChannelFFT
* GameOfLife
* MapReduce
* Unicycle
* ParameterSweep-SmallWorld-fsm
* ParameterSweep-SmallWorld-sdf
* SmallWorld-MultiInstanceComposite
* SmallWorld-PtalonActor
Backtracking
A backtracking facility enables the system to restore its old state. It
has many applications in practice, and is especially important to
high-performance distributed computation.
In developing this sub-project, we highlight the following
(increasing) list of criteria:
* Performance. The highest priority is awarded to the performance of
the resulting system (the Ptolemy II system with backtracking
support built in), as compared to the original system. Novel
approaches are employed mainly to improve performance, with
moderate complexity added.
* Automatic transformation. Transformation from the original system
to the backtracking-enabled system must be automated as much as
possible. Due to the size of the existing system, it is not
realistic to require a manual recoding in most of its sources.
Moreover, coding the backtracking sub-system by hand makes it hard
to debug and evolve over time./li>
* Clean interface to other parts. The backtracking sub-system must
reveal a small but powerful interface to the other parts in the
system. It provides the users with functions such as creating
checkpoints, undoing multiple language-level operations by
backtracking to a previous checkpoint, and even redoing those
operations to achieve some form of laziness.
Primary Developer: Thomas Huining Feng
Backtracking Demonstrations
* Prime Test
* Ramp Rollback
* Trial Module
SDF Code Generation
The SDF Template based C code generator (Codegen) generates code for
hierarchical Synchronous Dataflow (SDF), Finite State Machine (FSM)
and Heterochronous Dataflow Domain (HDF) models.
Codegen has the following new features:
* EmbeddedCActor - Allows arbitrary C code to be embedded in a
Java model. The entire Java model can then be converted to C code
and the code within the EmbeddedCActor will be used.
* Enhanced polymorphic type system
* Support for invoking the Java plotter from a C version of a model
* and many more
Codegen will not work in applets, it requires gcc and access to the
local file system
Codegen chapter from the User Guide
Primary Developers: Gang Zhou, Man-kit Leung.
Contributors: Christopher Brooks, Teale Fristoe, Edward A. Lee, Ye
Zhou
The Continuous domain
The Continuous Domain is a redesign of the Continuous Time (CT) domain
with a rigorous semantics documented in the following papers:
* Edward A. Lee, Haiyang Zheng, "Leveraging Synchronous Language
Principles for Heterogeneous Modeling and Design of Embedded
Systems," EMSOFT, September 30 - October 2, 2007, Salzburg,
Austria.
* Haiyang Zheng, "Operational Semantics of Hybrid Systems,"
Ph.D. Dissertation, EECS Department, University of California,
Berkeley, Technical Report No. UCB/EECS-2007-68, May 18, 2007.
* Edward A. Lee and Haiyang Zheng, "Operational Semantics of
Hybrid Systems," Invited paper in Proceedings of Hybrid Systems:
Computation and Control (HSCC) LNCS 3414, Zurich, Switzerland,
March 9-11, 2005, pp.25-53.
The continuous domain models systems with continuous dynamics,
including for example analog circuits and mechanical systems, but also
cleanly supports discrete events, modal behaviors, and signals that
mix continuous-time behaviors with discrete events. Models for
continuous dynamics are equivalent to linear or nonlinear integral
equations. A sophisticated numerical solver for these equations is
integrated with the director. The clean semantics of the Continuous
domain enables its integration in hierarchical heterogeneous models
that use the Synchronous/Reactive (SR) and Discrete Event (DE)
domains. Arbitrary hierarchical mixtures of these domains are
supported, although if SR is at the top level, then the period
parameter of the director must be used so that time advances. Domain
interactions are documented in the following paper:
* A. Goderis, C. Brooks, I. Altintas, E. A. Lee, and C. Goble,
"Heterogeneous Composition of Models of Computation," EECS
Department, University of California, Berkeley, Tech. Rep.
UCB/EECS-2007-139, Nov. 2007.
Primary Developers: Haiyang Zheng, Edward A. Lee
Graph Transformation
The graph transformation facility provides a framework for the analysis and
transformation of actor models using graph transformation techniques.
The design of large-scale models poses a number of challenges. As the size of
the models increases to thousands of actors or hundreds of thousands of
actors, analysis and consistent modification on the models become extremely
hard. Furthermore, to maximize component reuse, a systematic approach is
needed for the specification and maintenance of common patterns in the models
and the transformation of those patterns.
The model transformation framework to be developed in this project aims to
support the flexible specification of patterns and replacements by means of
rules in graph grammar. An intuitive graphical user interface will be built.
For novice users, a set of common transformations will be included in a
library to facilitate their common tasks.
The transformations are models in their own right. They can be embedded in
larger models hierarchically. Heterogeneous models of computation can be used
to control the application of individual "atomic" transformations. This makes
it easy to create sophisticated transformations by composing simple ones in a
manageable and disciplined way. The sophisticated transformations will also
take advantage of the concurrency inherent in those models of computation.
Model transformation can be applied as an optimization of modal models. These
are hierarchical state machines with refinements in their states, which are
sub-models to be executed when those states are active. The current
implementation includes the complete description of each refinement in the
model description, even though refinements of the states in a state machine
tend to have large commonality. With the transformation technique, only one
refinement needs to be stored completely. The others are obtained by
transformations performed on the stored refinement. This eliminates
redundancy and eases the job of modifying multiple refinements consistently.
Other applications of the model transformation technique include recognizing
common design patterns in the models in a static analysis, replacing exiting
design patterns with more efficient ones, and reusing design patterns by
incorporating them into new models.
References
* Thomas Huining Feng, Miriam Zia, and Hans Vangheluwe,
"Multi-Formalism Modelling and Model Transformation for the
Design of Reactive Systems," In 2007 Summer Computer
Simulation Conference (SCSC 2007), San Diego, CA, USA, Jul. 2007.
Graph Transformation Demonstrations
The Graph Transformation facility requires WebStart or a full
installation, it will not work in an applet
Primary Graph Transformation Developer: Thomas Huining Feng
New demonstrations
Continuous Time (CT)
* Starmac
Discrete Event (DE)
* Real Time Composite
Process Network (PN)
* Nondeterministic Merge with Feedback
Synchronous Dataflow (SDF)
* Gravitation
* ModelDisplay
Synchronous/Reactive (SR)
* GuardedCountTimed
* TrafficLight
* WirelessDeployment
User Interface Demonstrations
* Curriculum
Other Key New Capabilities
* Initializable
* TokenGotEvent
* TokenGotListener
New and Enhanced Actor Libraries
* ArrayElementAsMatrix
* ArraySum
* CodegenActor
* LimitedFiringSource
* MovingAverage
* PublisherNonStrictTest
* PublisherTest
* SingleTokenCommutator
* SubMatrix
* ArrayPlotterXY
* LEDMatrix
* ModelDisplay
* MirrorComposite
* RealTimeComposite
* ClipPlayer
* SoundActor
* SoundPlayer
New Continuous Time (CT) actors:
* DiscreteClock
New Synchronous Dataflow (SDF) actors:
* MatrixJoin
* MatrixSplit
Additional Features
* doc/tutorial - Tutorials for creating directors and using the GUI.
* ActorFiringListener
* FiringsRecordable
* TokenGotEvent
* TokenGotListener
* TypedCompositeActorWithCoSimulation
* AbstractPlaceableActor
* DependencyHighlighter
* FloatToken
* ShortToken
* UnsizedArrayToken
* NameParameter
* UndefinedConstantOrIdentifierException
* MissingClassException
* MoMLVariableChecker
* StringBufferExec
* ContextMenuFactoryCreator
* KeplerDocumentationAttribute
* OffsetMoMLChangeRequest
New Code Generation Actors
* ArrayElementAsMatrix
* ArrayPeakSearch
* CodegenActor
* CurrentTime
* Lattice
* MovingAverage
* Publisher
* PublisherTest
* RecursiveLattice
* SetVariable
* Subscriber
* SubscriptionAggregator
* VectorAssembler
* VectorDisassembler
* WallClockTime
* CartesianToComplex
* ComplexToCartesian
* LEDMatrix
* MultiInstanceComposite
* BitsToInt
* Chop
* DownSample
* IntToBits
* LMSAdaptive
* RaisedCosine
* UpSample
* VariableFIR
* VariableLattice
* CCodegenUtilities
--end--
_Christopher
Christopher Brooks (cxh at eecs berkeley edu) University of California
Chess Executive Director US Mail: 337 Cory Hall #1774
Programmer/Analyst Chess/Ptolemy/Trust Berkeley, CA 94720-1774
ph: 510.643.9841 fax:510.642.2718 (office: 400A Cory)
home: (F-Tu) 707.665.0131 (W-F) 510.655.5480
----------------------------------------------------------------------------
Posted to the ptolemy-hackers mailing list. Please send administrative
mail for this list to: [EMAIL PROTECTED]
