Section: Scientific Foundations
Model-based optimization and compilation techniques
Optimization for parallelism
We study optimization techniques to produce “good” schedules and mappings of a given application onto a hardware SoC architecture. These heuristic techniques aim at fulfilling the requirements of the application, whether they be real time, memory usage or power consumption constraints. These techniques are thus multi-objective and target heterogeneous architectures.
We aim at taking advantage of the parallelism (both data-parallelism and task parallelism) expressed in the application models in order to build efficient heuristics.
Our application model has some good properties that can be exploited by the compiler: it expresses all the potential parallelism of the application, it is an expression of data dependencies –so no dependence analysis is needed–, it is in a single assignment form and unifies the temporal and spatial dimensions of the arrays. This gives to the optimizing compiler all the information it needs and in a readily usable form.
Transformation and traceability
Model to model transformations are at the heart of the MDE approach. Anyone wishing to use MDE in its projects is sooner or later facing the question: how to perform the model transformations? The standardization process of Query View Transformation  was the opportunity for the development of transformation engine as Viatra, Moflon or Sitra. However, since the standard has been published, only few of investigating tools, such as ATL(http://www.eclipse.org/m2m/atl ) (a transformation dedicated tool) or Kermeta (http://www.kermeta.org ) (a generalist tool with facilities to manipulate models) are powerful enough to execute large and complex transformations such as in the Gaspard2 framework. None of these engine is fully compliant with the QVT standard. To solve this issue, new engine relying on a subset of the standard recently emerged such as QVTO (http://www.eclipse.org/m2m/qvto/doc ) and smartQVT. These engines implement the QVT Operational language.
Traceability may be used for different purposes such as understanding, capturing, tracking and verification on software artifacts during the development life cycle  . MDE has as main principle that everything is a model, so trace information is mainly stored as models. Solutions are proposed to keep the trace information in the initials models source or target  . The major drawbacks of this solution are that it pollutes the models with additional information and it requires adaptation of the metamodels in order to take into account traceability. Using a separate trace model with a specific semantics has the advantage of keeping trace information independent of initial models  .
Contributions of the team
We focus on two particular subjects in the optimization field: data-parallelism efficient utilization and multi-objective hierarchical heuristics.
Data-parallel code transformations
We have studied Array-OL to Array-OL code transformations  ,  ,  ,  ,   . Array-OL allows a powerful expression of the data access patterns in such applications and a complete parallelism expression. It is at the heart of our metamodel of application, hardware architecture and association.
The code transformations that have been proposed are related to loop fusion, loop distribution or tiling but they take into account the particularities of the application domain such as the presence of modulo operators to deal with cyclic frequency domains or cyclic space dimensions (as hydrophones around a submarine for example).
We pursue the study of such transformations with three objectives:
Propose utilization strategies of such transformations in order to optimize some criteria such as memory usage, minimization of redundant computations or adaptation to a target hardware architecture.
Stretch their application domain to our more general application model (instead of just Array-OL).
Multi-objective hierarchical scheduling heuristics
When dealing with complex heterogeneous hardware architectures, the scheduling heuristics usually take a task dependence graph as input. Both our application and hardware architecture models are hierarchical and allow repetitive expressions. We propose a Globally Irregular, Locally Regular (GILR) combination of heuristics to allow to take advantage of both task and data parallelism  and have started evaluating multi-objective evolutionary meta-heuristics in this context. These evolutionary meta-heuristics deal with the irregular (task parallelism) part of the design  while we have proposed a heuristic to deal with the regular part (data parallelism)  .
Furthermore, local optimizations (contained inside a hierarchical level) decrease the communication overhead and allow for a more efficient usage of the memory hierarchy. We aim at combining the data-parallel code transformations presented before and the GILR heuristics in order to deal efficiently with the data-parallelism of the application by using repetitive parts of the hardware architecture.
In 2006, in front of the absence of transformation tool that supports external black box calls (e.g., native function calls), recursive rule call, rule inheritance and integration of imperative code, we developed, our own tool MoMoTE. MoMoTE is a Java framework defined to enhance model to model transformations. Another tool MoCode has also been defined, for the model to text transformation (i.e., the code generation). It relies on JET principles. It takes in charge the calls of the right templates as well as the link between the JET and the Ecore worlds.
We also focus on another difficulty encountered in the design of the Gaspard2 supply chain: document and specify transformations. Based on the principle that a model transformation specification is it-self a model, we proposed TrML, a UML profile dedicated to transformation. TrML is a graphical representation of the transformation to increase documentation, exchange around transformations. This notation is independent from any existing transformation engines and focus on what should be transformed, rather than how to implement the transformation.