Ptolemy II 7.0.1 is available for download from

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
* 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.


                       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).


   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 might return
       elements in a different order.

     * 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


     * 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


   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.


     * 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


   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

  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,
     * 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.


     * 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


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]

Reply via email to