Multiple Aspect Modeling of the Synchronous Language Signal

1
Multiple Aspect Modeling of the Synchronous
Language Signal
Institute for Software Integrated
Systems Vanderbilt University Janos Sztipanovits,
Ethan Jackson http//www.isis.vanderbilt.edu
Multiple Aspect Modeling
A
A
A
spects
ccessible Properties
pplying
partition the abstract syntax while partitioning
accessible properties
are glimpses into the inner workings of a
semantic domain
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.

• 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.

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.

• 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.
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

Storage Aspect
Data 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
bstract Syntax
spects
are Structure and Implementation
addresses program structure only
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
Sub-process invocation
Passing result up hierarchy
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
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
Dataflow Semantics
I1

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
In
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.
Signal Clock Semantics
Signal Dataflow And 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.
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 broken by clock absence
A causality cycle