1. Multiple Aspect Modeling of the Synchronous Language Signal
Institute for Software Integrated Systems
Vanderbilt University
Janos Sztipanovits, Ethan Jackson
Multiple Aspect Modeling A A A
ccessible Properties
spects
pplying
are glimpses into the inner workings of a semantic domain
partition the abstract syntax while partitioning accessible properties
multiple aspect modeling means carefully choosing the abstract syntax
A DSML is defined by a meta-model, which provides an abstract syntax (AS), a concrete syntax, and a static semantics.
Accessible properties allow formal design-time reasoning about properties relevant to the semantic domain. Aspects should partition the AS in a way that also partitions relevant accessible properties. This modularizes reasoning about the semantic domain.
An abstract syntax must be chosen so that:
The represented concepts are intuitive
Important properties can be made accessible
Accessible properties can be evaluated within clearly defined subsets (aspects) of the abstract syntax.
We use the synchronous dataflow language Signal as a non-
trivial candidate for demonstrating these principles because:
Signal programs are completely declarative systems of dataflow equations
Control flow is implicit and requires a global reasoning process to extract
Signal is the most expressive of the synchronous languages supporting under-sampling, over-sampling, and arbitrarily complicated clock relations.
Some static semantics are due to the particular AS (max. name length), but others reflect the underlying semantic domain (there must be a start state). The later type are accessible properties.
Two-aspect example for describing data and storage.
“Is there enough storage for the data?” is an accessible property, but this property straddles the aspects. Hence, these aspects are bad because important reasoning is not modularized.
Static Semantics
Accessible Properties
Semantic Domain
A property is accessible iff:
Our future work includes:
Describing generative constraints using formal graph transformation languages (e.g. GReAT)
Formally characterizing an abstract syntax with respect to the underlying semantic domain
Extending the HFGMM (described below) representation to encompass other discrete time models of computation
Data Issues
Storage Issues
Is enough?
Data Aspect
Storage Aspect
Data Aspect
Storage Aspect
in every statically correct model that has an error in property p, a semantically equivalent model can be found where the static semantics are not satisfied.
Is enough?
Is enough?
Data Issues
Storage Issues
However, a generative constraint that generates a storage element for each data element does modularize the reasoning.
Case I: Simple Multiple Aspect Signal Front-End A A
this type of front-end using GME-based MDA tools is straightforward A
pplying
bstract Syntax
spects
addresses program structure only
are Structure and Implementation
In this multiple aspect environment, the AS concepts are hierarchy, module interface, module interconnections, and dataflow equations.
The structure aspect shows all AS having to do with program structure. Relevant accessible properties include proper use of module interconnection, signal scoping, and sub process invocation.
Combining these two aspects into Signal code involves a simple depth first search of the model
The first time a module is seen, a preamble is written. The second time a module is seen (when DFS backs up), all equations and a post-amble are written.
The implementation aspect groups dataflow equations into equation boxes, the but meaning of the actual equations is not accessible. This environment has no accessible properties relating to the behavior of the program.
The static semantics restrict the type of interconnections that can be formed.
Code generation is not performed directly on the model, but an AST is built from the model and contains the node types shown below.
Equations like this are stored in the model, but the static semantics does not give them any meaning during design time.
Sub-process result binding to local
Sub-process invocation with local
start := true when go
default start$
Passing result up hierarchy
Sub-process invocation
The aspects are orthogonal, i.e. there are no cross aspect consistency constraints. These aspects are also an intuitive way to partition a programming language. However, they lack the ability to formally reason about what the program will do.
Passing constant parameters
Instantiating parameters
Case II: HFGMM Front-End with Generative Constraints A A
spects
are non-orthogonal Dataflow and Clock A
bstract Syntax
pplying
captures structural and behavioral concepts
this type of front-end requires generative constraints and non-trivial interpretation
The underlying dataflow is the dataflow aspect and the modes comprise the clock aspect. Notice that the dataflow in each mode is a permutation of the dataflow aspect. This is a generative consistency constraint that must be maintained.
Signal is modeled with hierarchical fine-grained modal models (HFGMM).
Converting from this representation to Signal requires non-trivial synthesis techniques, particularly to generate realistic undersampling conditions. I1 …
In this representation, synchrony constraints become static semantics. Specifically, a synchrony constraint has been violated if any n-ary operator in a mode cannot be categorized into one of the cases on the left.
While combining aspects is non-trivial, the HFGMM representation is general enough to be easily specialized for different models of computation. … O Op … In I1
Dataflow
Semantics … … O
Clock
Semantics Op … In
Checking this property is straightforward because it is a local property of each node. When an error is detected, it is easily localized to the offending component and mode.
Dataflow and
Clock
Semantics
Signal programs are hierarchical dataflow graphs with n-ary synchronous operators, inputs, outputs, polymorphic parameters, delay lines, and muxes that are sensitive to clocks. I1 … … O Op …
Signal Dataflow
Semantics
A Signal system has a set of modes that represent the possible clock configurations and define which dataflow components are active and inactive at a given instant. In
Signal Clock
Semantics
Similarly, causality errors become static semantics. While a causality error it not a local property, it can still be checked for efficiently: Find any cycle made entirely of present components and without delay.
Signal Dataflow
And Clock
Semantics
Our current synthesis tool exploits the “feed-forward” modularity of the HFGMM representation so that synthesis can be reused an easily specialized. For example, the “Signal Clock Semantics” module could be replaced by a purely monochronous module.
These are fine-grained modes because the system could switch modes at the resolution of the base clock.
A causality cycle
A causality cycle broken by clock absence