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