November 18, 2004

1
Arkadeb Ghosal Alessandro Pinto Daniele
Gasperini Alberto Sangiovanni-Vincentelli
Embedded System Design Flow
http//chess.eecs.berkeley.edu
Language Features
xGiotto

• Reaction Blocks
• - Basic programming blocks in xGiotto
• - Consists of release statements and
  trigger statements
• and a termination event
• - Releases tasks and invokes triggers
• react reaction block until event
• Schedule Instruction
• Schedule tasks
• Tasks are released with the invocation of the
  reaction block
• Tasks are terminated with the termination of the
  reaction block
• release task (input ports) (output ports)
• Trigger Statements
• Defines the invoking action associated with an
  event
• when event reaction block
• Repetition construct using whenever

• Programming language targeted towards event
  driven control applications
• The language is based on Logical Execution Time
  (LET) model of tasks
• The programmer specifies when the output of a
  task becomes available
• Event Scoping
• Events are the main structuring principle
• Event can be implicitly scoped by program
  definition
• A scope can be
• active events are handled as soon as they occur
• passive events are ignored or remembered so
  that the related action is taken when the
  surrounding scope becomes active again

Abstract
Metropolis Framework
We present a design flow for the design of
embedded systems with control emphasis including
software and the underlying computing platform
and a case study for its application to a
multi-media design an MP3 player. We use
Metropolis as integration environment and xGiotto
as software design tool.
Metropolis allows representing the functionality
of the design and the architecture of the
implementation platform in the same environment
so that design exploration can be done quickly
and efficiently. xGiotto provides a number of
facilities that make software analysis and design
easier by using a rigorous semantic approach that
eliminates some of the most prominent reasons for
errors and facilitates the correct implementation
of the original control algorithm. The flow
starts with xGiotto that is used as an input to
the Metropolis environment. xGiotto designs are
mapped to the Metropolis MetaModel. Platform
architectures are directly input into Metropolis
using the MetaModel natively. Mapping of the
functionality to the architecture is performed in
the Metropolis environment. The analysis of the
mapped architecture can be used to feed back
performance and other quantities related to the
platform of interest to the software designer who
then can modify the software to improve its
design and to meet constraints.
Analysis
LET model

• Race Condition Detection
• Verifying whether a program variable is updated
  with multiple values and thus leading to
  non-determinism
• Resource Size Analysis
• Predicting run-time memory requirements for
  executing an xGiotto program
• Schedulability Analysis
• Ensuring that all task invocations get access to
  the executing platform at least equal to their
  worst-case-execution-times before their
  termination

Proposed Design Flow
xGiotto Run-time and Compile Time Implementation
xGiotto-on-Metropolis
xGiotto Program Description
Functional
Task 1
xGiotto Run-time System
Environment
xGiotto operational Semantics
Task n
Mapping
Denotational framework equivalent (using Tagged
Signal Model)

• Functionality Capture
• The embedded system application is captured
  using a real-time programming language
• Constraints Generation
• The constraints for execution are generated
• Platform Modeling
• The real-time platform characteristics are
  modeled
• Functional Simulation
• The functionality of the applications is studied
  to verify for desired behavior under test-case
  scenarios
• Quantity Estimation
• Platform dependent quantities (e.g. execution
  time) are estimated
• Formal Analysis
• Properties like races and schedulability are
  formally verified for the designed system
• Platform Selection
• Different platforms are explored and one of them
  is chosen based upon optimization
• criteria such as power and cost that involve
  the results of the estimation phase
• Code Synthesis
• Code generator produces code for the target
  platform

Task 1
Task n
RTOS
CPU Arbitrator
Equivalent Action Automata Model
Execution Time Task 1
Architectural
CPU
Power
Equivalent MMM Language Model
BUS Arbitrator
BUS
Process Medium Quantity Manager
Execution Time Task n
Time
MEM
Case Study (mp3 player)

• task dac
• -- reads buffer with the decoded stream
• task read
• -- accesses the external storage
• task decode
• -- decodes the stream stored in buffer
• task battchk
• -- checks battery life

• task tempo
• -- modifies the speed of the song
• task pitch
• -- modifies the pitch and key
• task rate
• -- changes both the tempo and pitch
• task vol
• -- updates the volume
• task editlist
• -- edits the list of songs to be played
• task skip
• -- skips songs to be played
• task usb
• -- downloads songs into the player

Integrating xGiotto and Metropolis in the Flow
Implemented on Lego Mindstorm RCX unit
Execution time analysis and power measurements
for the tasks on different platforms
Basic Functionality
User Interface
Interaction Functionality
Real-Time Operating System
xGiotto run-time system is implemented on
Motorola coldfire m68k
CPU
BUS
Memory
Two different hardware configuration are
tested -- ARM processor using simplescalar
ISS -- PowerPC 750 processor using ppc750sim ISS
External Storage
Power and Energy estimation is done by
Simplescalar-Arm Power Modeling Project
Flash Memory
November 18, 2004