Gsoc

Ptolemy Google Summer of Code (GSoC)

Contents

  • Introduction
    • Ptolemy
  • Google Summer of Code 2009
    • Contact
    • Instructions for Student Applicants
    • Project Ideas

***** 03/25/09: We added two new project ideas. Please scroll down towards the end of the page. *****

Introduction

Ptolemy

The Ptolemy project studies modeling, simulation, and design of concurrent, real-time, embedded systems. The focus is on assembly of concurrent components. The key underlying principle in the project is the use of well-defined models of computation that govern the interaction between components. A major problem area being addressed is the use of heterogeneous mixtures of models of computation. A software system called Ptolemy II is being constructed in Java. Ptolemy II differs from other commonly used graphical block-diagram languages in that they typically support only one model of computation. In addition, Ptolemy II is a more open architecture in that its infrastructure is open source, and the interfaces to the core mechanisms in the software are published and documented.

Google Summer of Code 2009

Contact

A preferred means of communication with us during the application period would be the Ptolemy GSoC 2009 group at Google Groups. That way, everyone can benefit from the discussion.
http://groups.google.com/group/ptolemy-gsoc-2009
If you would like to contact us, but rather not use the group, please send an email to gsoc at chess dot eecs dot berkeley dot edu .
If you are interested in applying for a Google Summer of Code position please do not request membership on this website at this time. Website accounts will be created after applicants have been selected.

Instructions for Student Applicants

We do not use a specific application template for this program. However, this is what we will be looking for in an application:
  • Summary of your previous programming projects (open-source/class/research).
  • Summary of your university-level education.
  • What interests you about our projects? What would you like to learn or improve?
  • What other activities (exams, vacation, etc.) you plan for the summer? How much of your time you think you can devote to project per week, per day?

Project Ideas

Project Ideas 1

- The best code developers are typically users first. Select a discrete-event system or application of your choice and model it in Ptolemy. In discrete-event models, the components interact via signals that consist of time-stamped events. Here are some ideas in Ptolemy: Timing Paradox or Wireless Networks. Start with Ptolemy Tutorial. Think about using Discrete-Event, Modal or Distributed Discrete-Event models of computation.
- Projects for GSoC 2009 could involve modeling of networking protocols in the Ptolemy environment. For instance, TTEthernet, Flexray, or Precision Time Protocol. An interesting approach would be to integrate or port to Ptolemy open source code developed within the OMNET++ project.
- A version of the Ptides model of computation for Real-time and Distributed systems based on the DE model will be available during summer. Build Ptides components that are not yet supported. Start with Ptolemy Design Document(Vol.3, Chap.1,4,7). Some ideas include implementing and testing different event schedulers or modeling standard networking components within Ptides.
  • Further Reading: Real-Time Computing, Ptides
  • Skills: Block-diagram language (e.g. Matlab) or Java [recommended]
  • Level: Beginning - Advanced
  • Benefits to the Student: Model and study properties of a system of interest. Get to know and build upon Ptolemy infrastructure. Learn to use source version control systems.
  • Benefits to the Community: Expand open computational models and open-architecture design frameworks.
  • Comments: More than one student.

Project Ideas 2

In this project we will be working on PtidyOS, a novel lightweight embedded operating system based on PTIDES, a programming model for distributed real-time systems. In PtidyOS, all event processing is done in interrupt service routines, and we only use interrupts to ensure correct mutually exclusive accesses to memory. Our approach combines PTIDES semantics with traditional scheduling methods. The first implementation leverages Earliest-Deadline First scheduling algorithm and guarantees correct event order defined by PTIDES. It is deployed on an ARM based micro-controller.
We would like this project to address the distributed character of PtidyOS. Our implementation testbed will probably consist of micro-controllers synchronized in time using PTPd, an open-source implementation of the Precision Time Protocol. Another idea for this project could be to implement efficient event queue structures or experiment with other scheduling algorithms for real-time processing of events. This project may build on recent open-source real-time projects, such as S.Ha.R.K.: Soft Hard Real-Time Kernel (for dynamic priority schedulers) or OCERA: Open Components for Embedded Real-time Applications (for resource reservation or publish/subscribe middleware mechanisms).
  • Further Reading: PtidyOS, Calendar queues
  • Skills: C [required]
  • Level: Intermediate - Advanced
  • Benefits to the Student: Learn about embedded middleware, discrete-event model semantics and real-time event processing. Learn to use source version control systems.
  • Benefits to the Community: Expand the space of open-source real-time embedded and middleware solutions.
  • Comments: Visit to UC Berkeley recommended.

Project Ideas 3

  • Wikipedia Keywords: Discrete-Event, Code Generation
  • Mentors: Jia Zou / Slobodan Matic
  • Title: C Code Generation for Ptides Models
  • Technical Details:
The Ptolemy group is developing a code generator that uses template files to build C code from Ptolemy models. The current template effort synthesizes C code from certain Ptolemy II models (SDF, FSM and HDF). For more details see Ptolemy Design Document (Vol.2, Chap.7).
A simpler idea for this project would be to implement code generator for Discrete-Event models.
A related but more advanced project would do the same for the PTIDES programming model which targets distributed real-time embedded systems. The current code generator for PTIDES model does not yet support heterogeneous models, meaning no PTIDES actor can yet be refined by any other Ptolemy II models such as SDF, FSM, and HDF. Thus the goal of this project is to integrate PTIDES code generator with other models. Since any model that supports heterogeneity is likely to be big, an efficient implementations is needed to reduce the overhead introduced by high level abstraction of models. To address this we use partial evaluation as an optimized compilation technique for actor-oriented models.
Test the implementation on simple demo models with a limited actor library. The generated code could be targeted for an embedded micro-controller used in the Ptolemy group.
  • Further Reading: Code Generation with Partial Evaluation, Software Synthesis
  • Skills: Java, C [required]
  • Level: Intermediate - Advanced
  • Benefits to the Student: Learn compilation and code generation techniques for graphical block-oriented languages. Learn about discrete-event model semantics and implementation. Learn to use source version control systems.
  • Benefits to the Community: Broaden the space of open-source C code generators from higher level languages.
  • Comments: High importance to us.

Project Ideas 4

Model-based design and languages are gaining traction in industrial practice as evidenced by commercial tools such as Simulink/Real-Time Workshop, LabVIEW or Rhapsody. The development tools are more often designed with support for performance requirements, such as latencies and buffer sizes of components. For instance, models (programs) can be extended with timing, activation and distribution properties of components, and schedulability analysis can be performed to certify that real-time constraints can be met on a certain platform. A more refined analysis would take into account computation and communication times as well as timing properties of the input signals. The goal of this project is not to define new techniques for analyzing real-time and embedded systems, but to integrate already existing ones into the Ptolemy design environment.
A potential GSoC project might apply recent compositional performance analysis techniques, such as open-source Real-Time Calculus or event-flow based SymTA/S. Another approach may be based on techniques developed in the open-source project MAST.
  • Further Reading: Performance Analysis Hard Real-Time Systems
  • Skills: Java [required]
  • Level: Intermediate
  • Benefits to the Student: Learn model-based design tools. Explore certain performance and schedulability analysis techniques. Learn to use source version control systems.
  • Benefits to the Community: Expand the space of open-source performance analysis tools.
  • Comments: Research potential.

Project Ideas 5

The number of distributed event processing applications is increasing. Start with the discussion of related implementation problems for a distributed discrete-event (DDE) example. Ptolemy also comes with the DDE domain. The objective of this project is to build infrastructure for distributed event processing that will subsequently be used in other projects. This approach could build on the code already developed during GSoC 2008.
A student could implement discrete-event simulator distributed over locally connected servers. S/he would program in C or C++ most likely using Red Hat Enterprise Linux. We plan to experiment with the Messaging component of the Red Hat MRG framework that implements open standard protocol AMQP. The other approach in a similar setting could build upon recent open-source projects such as DREAM: Distributed Real-time Embedded Analysis Method. Another interesting idea with research potential would be to build an efficient simulator on a multi-core processor. It could also leverage related enhancements of 2.6 Linux kernels. Test on a simple distributed discrete-event application of interest.
  • Further Reading: Parallel Discrete Event Simulation, Multi-Core and Linux
  • Skills: C or C++ [required]
  • Level: Intermediate - Advanced
  • Benefits to the Student: Learn to program distributed and/or parallel applications. Learn about discrete-event model semantics and implementation. Learn to use source version control systems.
  • Benefits to the Community: Increase the efficiency of open-source parallel discrete-event simulation/execution platforms.
  • Comments: More than one student. Research potential.

Project Ideas 6

There are a lot of open-source discrete-event simulation frameworks. Much less work has been done in adapting these models as an execution platform for embedded software. Such a platform has to take into account real-time interaction with the environment. In this project a student could adapt the current implementation of Ptolemy Discrete-Event or Ptides simulation frameworks. This project will not address the distributed aspects of Ptides models. The student would program in Java and test on Red Hat Enterprise Linux. We plan to experiment with the Realtime component of the Red Hat MRG framework. If standard Java programming model is used, the student will have access to the IBM WebSphere Real Time platform that performs automatic garbage collection. Other approaches could use more difficult programming models according to the Real-Time Specification for Java. Debug using Eclipse based Tuning Fork visualization tool. Test on a simple discrete-event application of interest.
  • Further Reading: MRG Realtime, RTSJ, Ptides (from slide 32)
  • Skills: Java [required], JNI [recommended]
  • Level: Intermediate
  • Benefits to the Student: Learn high-level real-time programming in Java. Learn about discrete-event model semantics and implementation. Learn to use source version control systems.
  • Benefits to the Community: Advance real-time programming under Java and Linux.
  • Comments: Visit to UC Berkeley recommended.

Project Ideas 7

ERG (Event Relationship Graphs) is a formal language for discrete-event simulation. It has a visual syntax similar to FSM (Finite State Machines), but it is much more expressive. Model verification of ERG is a challenging problem because the event queue in a model is potentially unbounded. This project aims to build a prototype for model verification. For a subset of models, it can be statically checked whether the event queue is bounded, and whether one event is causally dependent on another. The task of this project is to identify such a subset, and create a verification tool that can handle it.
  • Further Reading: Simulation modeling with event graphs
  • Skills: Java [required], formal languages and verification [preferred]
  • Level: Intermediate
  • Benefits to the Student: Learn event-oriented modeling. Learn model verification techniques. Learn to contribute on a specific subject in a large project (Ptolemy II). Practice Java programming and algorithm design.
  • Benefits to the Community: A prototype of a model verification tool that can be easily extended to solve general problems.
  • Comments: Visit to UC Berkeley recommended.

Project Ideas 8

The objective of this project is to add features to Ptolemy in order to improve its capability of being used as an educational tool. Two roles would be involved, the instructor (docent, tutor, etc.) and the students. The instructor would pass some challenges to the students, giving some gaming aspect to Ptolemy, that could be in the form of new models creation or modifications of the existing models. The accomplishment of these challenges would be conditioned to some prerequisites, like time to complete a model, simulation time, number and types of actors on model, configuration of same parameters, set of output data generated by some actors and so on. It is also important the possibility to follow the students progress. Therefore, the instructor could check how many challenges students accomplished and how was their production during a period. So, the main objective is to enable the Ptolemy to create and manage challenges to the user, transforming it in something more interactive, playful and educational.
  • Skills: Java [required]
  • Level: Intermediate
  • Benefits to the Student: Learn more about how Ptolemy works inside. Learn gaming and educational issues. Learn to contribute on a specific subject in a large project (Ptolemy II). Practice Java programming and algorithm design.
  • Benefits to the Community: An educational tool to assist docents and students to learn more abstract subjects that are often not trivial to understand just by books.

Project Ideas 9

GNU Radio provides a library of signal processing blocks and the glue code to put the system together by creating a graph of blocks. It is primarily used as a platform for Software Defined Radio (radio partially implemented in software). The GNU Radio software is organized in a two-tier structure. All the performance-critical signal processing blocks are implemented in C++, while the higher-level glue code is done using Python. There is also a graphical environment tool, the GNU Radio Companion, which allows GNU Radio components to be put together graphically.
The goal of this project would be to make Ptolemy a front-end for GNU Radio, i.e., to provide Ptolemy with the features of the GNU Radio Companion tool. A student would start with a certain set of most frequently used blocks in GNU Radio (out of about 100 blocks) and see how they match with already existing Ptolemy actors for signal processing. Some of the Ptolemy actors or GNU Radio blocks would potentially have to be adapted. The project would then focus on building the Ptolemy infrastructure that would generate GNU Radio glue code for a model built from the selected set of actors. Another idea would be to make Ptolemy a back-end for GNU radio programs, i.e., to make software oscilloscope or spectrum analyzer tools using existing Ptolemy code.
  • Skills: Java [required], C++ or Python [recommended]
  • Level: Intermediate
  • Benefits to the Student: Learn compilation and code generation techniques for graphical block-oriented languages. Learn basic signal processing building blocks. Learn to use source version control systems.
  • Benefits to the Community: Expand the space of open-source visual programming environments for software radio.

About pmwiki

A local copy of PmWiki's documentation has been installed along with the software, and is available via the documentation index.

To continue setting up PmWiki, see initial setup tasks.

The basic editing page describes how to create pages in PmWiki. You can practice editing in the wiki sandbox.

More information about PmWiki is available from http://www.pmwiki.org .