Skip to navigation
Site Primary Navigation:
- About SDSC
- Services
- Support
- Research & Development
- Education & Training
- News & Events
Search The Site:
Published 02/04/2004
DATE, TIME & PLACE: Febuary 4, 2004, 3 pm, SDSC Auditorium
SPEAKER: Steve Neuendorffer ( neuendor@eecs.berkeley.edu ), Ptolemy Research Group ( http://ptolemy.eecs.berkeley.edu ), UC Berkeley
SPEAKER HOST: Bertram Ludaescher ( ludaesch@sdsc.edu )
ABSTRACT: The design of embedded software systems is significantly complicated by the system's interaction with the physical world. Concurrent interaction and the passage of time are central to this interaction. Unfortunately, most software systems practice today relies on programming languages that primarily represent sequential operations that complete in an unknown amount of time. Attempts to improve the situation through operating system mechanisms such as interrupts, timers, and threads often introduce as many new problems as they solve. These mechanisms provide a programmer with significant flexibility, while also exposing many programming pitfalls. One approach to solving this design problem is to provide better programming languages with structured notions of time and concurrency which can be more easily understood.
I describe an actor-oriented system modeling approach that forms the basis for a better way to architect embedded systems. An actor is a completely encapsulated component that interacts with other actors through explicit communication channels, rather than through shared memory. Because of this restriction, the interaction between actors can be understood entirely through analysis of their interfaces. The interaction between actors can also be orthogonalized from the actors themselves, allowing it to be specified separately through a Model of Computation. We specify embedded systems using Models of Computation that represent time, concurrency, and interaction with the physical world.
Although we model embedded software using behavioral components, it is important to recognize that this does not require a run-time component architecture, such as CORBA. Efficient embedded software can be generated from actor models by specializing generically specified actors to their context in a model. We call this approach to system design "Actor-oriented Metaprogramming" to distinguish it from other component-based techniques. Metaprogramming allows the use of highly generic and reusable actors for design without sacrificing implementation efficiency.
This talk will introduce Actors and Models of Computation and talk specifically about how they are implemented within Ptolemy II. I'll discuss parts of the framework that enable generic actors and give some examples of heterogenous modeling.
ABOUT THE SPEAKER: Steve Neuendorffer is one of the principal architects of Ptolemy II, a high level modeling program which has received extensive funding from DARPA. His areas of expertise are programming languages, system modeling and synthesis, embedded software, and software engineering. Steve did his undergraduate work at the University of Maryland and his Masters Degree in EECS at Berkeley. He is currently finishing his PhD work at UC Berkeley, EECS.