Modeling and Visualization of CFSM Networks in JavaTime

Michael ShilmanJames Shin Young

EE249 Project PresentationDecember 8, 1998

Outline

• Introduction• JavaTime Components• Abstract Reactive Model• Modeling of CFSM’s• AR and CFSM JavaTime Packages• Visualization of CFSM Networks• Design Example - Seatbelt Controller• Conclusions

Introduction

• The JavaTime Project– Collection of tools, libraries, and methodologies for

embedded systems design.– Use JavaTM, enhanced via packages, as textual design

input syntax.– Graphical input syntax and visualization

infrastructure.– Common model for system representation

• Goals for EE249– Incorporate CFSM model into JavaTime environment.– Describe, visualize, and execute CFSM networks on

standard Java platforms.

JavaTime Component Package

• Components– Central design entities.

• Ports– Access points for

connecting components.

Conta iner

Component

Connection

Port

• Connections– Relation between ports.

• Containers– Hierarchical nesting of

components and containers

The Abstract Reactive Model

• Components react to all input events.• Events are changes in signal values.• Fully asynchronous communication.

– No events happen “at the same time.”

• Networks for abstraction– Temporal and structural abstraction – Fundamental-mode asynchronous assumption.– All internal signals converge to a stable value before

output is emitted.

• Used in JavaTime as building block for describing other models.

The javatime.jcp.ar Package

• ARComponent– User specifies behavior by

defining the react(ARPort p, Object v) method.

• ARNetwork– Executes components

contained within according to semantics of AR model.

• ARThread– Enables Esterel-style

description of component behavior.

public class Foo extends ARComponent { public void react() { // do something }}

Modeling CFSM’s in AR

• CFSM’s are modeled as AR components with two implicit ports.– Activate input, runnable output

• Transitions of CFSM’s controlled by scheduler component.

Scheduler

CFSM Netw ork

ac

tiv

ate

run

na

ble

CFSM

CFSM

CFSM

The javatime.jcp.cfsm Package

• Implemented using the javatime.jcp.ar package.

• CFSM– User specifies behavior by

defining transition() method.– eventPresent(Input I) method

tests for presence of events.

• CFSMNet– Contains a scheduler component

responsible for activating CFSM’s.

• CFSMThread– Esterel-style input for CFSM’s.

public class Bar extends CFSM { public void transition() { // do something }}

Esterel-style Programs in Java

• Esterel provides compact syntax for synchronous reactive programming.– await, do watching, ||, etc.

• Construct similar conveniences in Java.– Provided in ARThread, CFSMThread classes.– await, awaitWatching, methods.– Uses standard Java threads,

monitors to implement Esterel-like facilities.

– Maintains compatibility with standard Java syntax, tools, and execution platforms.

public class Blah extends ARThread { public void run() { while(true) { // do something await(); } }}

CFSM Visualization

• Focus on infrastructure rather than application– Make it easy to construct visualizations, rather than

trying to pre-package all possible visualizations.– Able to develop in parallel with modeling effort.

Design

CustomVisualizations

Editors

Probes

• Our goal: view, edit, and animate component networks at different levels of abstraction

Visualization Probes

• Components which sample signals to construct visualizations.– Modular and easy to write; drag and drop just like

any other component.– Probe to modify network display as system executes,

via protocol-based API.

Image probes at different stages in a JPEG decoder

Animation and Instrumentation

• Listener interface allows monitoring of execution state.

• Instrumentation by procedural insertion of probes.– Simple traversal of JCP design hierarchy.

• Code instrumentation using JavaTime AST tools.– Create extra output ports to communicate

instrumentation results.

Visualization Protocols

• Software protocols for reusable visualization surfaces.– Support for incremental update.– Read/modification capabilities.

• Sample protocols:

Protocol Data typesGeometry Shape, color, line thickness, etc.

Graph Graph, node, edge.

Tuple String, number, tuple.

Schematic Component, port, network, connection.

Anatomy of a Protocol

javatime.jcp

Schematic Model

{ net, com ponent, port, connection }

{ graph, node, edge }

{ shape, color, line, ... }

GraphModel

View

Filters:- scheduler, activate/runnable ports- visualization probes

Filters:- scheduler, activate/runnable ports- visualization probes

Multiple views:- standard- sketch- ...

Multiple views:- standard- sketch- ...

Multi-Syntax Editing

• Different visual syntax for different models of computation.– Illustrate relationship between different models.

CFSM ViewAR View

Design Example

• Implemented the POLIS seatbelt controller example using javatime.jcp.cfsm package.

• Original design– CFSM behavior described with two Esterel modules.– CFSM network described in Ptolemy.

• Ported design– CFSM’s described as Java classes.– Network also a Java class.

Design Example - Esterel

module belt_control:

input reset, key_on, key_off, belt_on, end_5, end_10;

output alarm(boolean), start_timer;

loop

do

emit alarm(false);

every key_on do

do

emit start_timer;

await end_5;

emit alarm(true);

await end_10;

watching [key_off or belt_on];

emit alarm(false);

end

watching reset

end.

Design Example - JavaTime

public void run() {

Condition watch = new Condition() {

public boolean isTrue() {

return (eventPresent(_reset) ||

eventPresent(_keyOff) ||

eventPresent(_beltOn));

}

};

while (true) {

try {

emit(_alarm,Boolean.FALSE);

awaitWatching(_reset);

if (eventPresent(_keyOn)) {

try {

emit(_startTimer);

awaitWatching(_end5, watch);

emit(_alarm,Boolean.TRUE);

awaitWatching(_end10, watch);

} catch (WatchException e) {

if (eventPresent(_reset)) {

throw e;

}

}

emit(_alarm,Boolean.FALSE);

}

} catch (WatchException e) {}

}

}

Conclusions

• Java as an input syntax for reactive systems.– Resulting specification not as concise as Esterel...– …but provides compatibility with standard Java tools.

• Programming language “extensions” as packages.– Extends utility of a language without compromising

compatibility.– Avoid high overhead of new language development;

a good option for niche domains.

• Relationship between AR and CFSM models.– CFSM networks can be modeled as AR systems.– The reverse is probably also true.

More Conclusions

• Visual editing and animation of systems– Multi-syntax editing reveals relationship between

models of computation.– Software protocols enable rapid development of

interactive visualizations. – Visualization probes simplify user-level construction

of visualizations.