170 research outputs found
Solving the TTC 2011 Reengineering Case with VIATRA2
The current paper presents a solution of the Program Understanding: A
Reengineering Case for the Transformation Tool Contest using the VIATRA2 model
transformation tool.Comment: In Proceedings TTC 2011, arXiv:1111.440
Evaluation of Kermeta for Solving Graph-based Problems
Kermeta is a meta-language for specifying the structure and behavior of graphs of interconnected objects called models. In this paper,\ud
we show that Kermeta is relatively suitable for solving three graph-based\ud
problems. First, Kermeta allows the specification of generic model\ud
transformations such as refactorings that we apply to different metamodels\ud
including Ecore, Java, and Uml. Second, we demonstrate the extensibility\ud
of Kermeta to the formal language Alloy using an inter-language model\ud
transformation. Kermeta uses Alloy to generate recommendations for\ud
completing partially specified models. Third, we show that the Kermeta\ud
compiler achieves better execution time and memory performance compared\ud
to similar graph-based approaches using a common case study. The\ud
three solutions proposed for those graph-based problems and their\ud
evaluation with Kermeta according to the criteria of genericity,\ud
extensibility, and performance are the main contribution of the paper.\ud
Another contribution is the comparison of these solutions with those\ud
proposed by other graph-based tools
Modelling and Analysis Using GROOVE
In this paper we present case studies that describe how the graph transformation tool GROOVE has been used to model problems from a wide variety of domains. These case studies highlight the wide applicability of GROOVE in particular, and of graph transformation in general. They also give concrete templates for using GROOVE in practice. Furthermore, we use the case studies to analyse the main strong and weak points of GROOVE
Interoperability on low power devices
Dissertação para obtenção do Grau de Mestre em
Engenharia Electrotécnica e de ComputadoresModel transformation is the process of turning one data format into another according to a specification that contains the operations needed to accomplish it. Therefore it assumes a relevant role on handling interoperability on an “Internet of Things” environment composed by interconnected heterogeneous things with heterogeneous information. However, operate interoperability specifications on this environment is challenging, because model transformation technologies were developed considering an environment composed of devices with processing power and memory, as opposed to the environment exposed. The proposed solution consists in a specific approach, the clear separation of run-time and design time processes and the redefinition of formats used to describe model data and interoperability specification without changing their information. To do so an execution engine architecture is specified, able to execute model transformations according to a lite model data format and an interoperability specification defined as part of the solution
Static Type Checking of Model Transformation Programs
Model transformation is seen as a promising approach to automate software development and verification, thus improving quality and reducing production costs significantly. However, errors of transformation programs can propagate into the generated artifacts complicating the detection of errors. The current paper proposes a static type checking approach for early detection of typing errors of partially typed transformation programs. The approach describes type safety as constraint satisfaction problems, and uses a dedicated back-annotation mechanism for error feedback
Model transformation by graph transformation: A comparative study
This is an electronic version of the paper presented at the Model Transformation in Practice, held in Montego Bay on 2005Graph transformation has been widely used for expressing
model transformations. Especially transformations of visual models can
be naturally formulated by graph transformations, since graphs are well
suited to describe the underlying structures of models. Based on a common
sample model transformation, four different model transformation
approaches are presented which all perform graph transformations. At
first, a basic solution is presented and crucial points of model transformations
are indicated. Subsequent solutions focus mainly on the indicated
problems. Finally, a first comparison of the chosen approaches to model
transformation is presented where the main ingredients of each approach
are summarized
Generic Search Plans for Matching Advanced Graph Patterns
In the current paper, we present search plans which can guide pattern
matching for advanced graph patterns with edge identities, containment
constraints, type variables, negative application conditions, attribute
conditions, and injectivity constraints. Based on a generic search graph
representation, all search plan operations (e.g. checking the existence of
an edge, or extending a matching candidate by navigating along an edge) are
uniformly represented as special predicates with heuristically assigned
costs. Finally, an executable search plan is defined as an appropriate
ordering of these predicates. As a main consequence, attribute, injectivity,
and negative application conditions can be checked early (but not
unnecessarily early) in the pattern matching process to cut off infeasible
matching candidates at the right time
Parallelization of Graph Transformation Based on Incremental Pattern Matching
oai:journal.ub.tu-berlin.de:article/265Graph transformation based on incremental pattern matching explicitly stores all occurrences of patterns (left-hand side of rules) and updates this result cache upon model changes. This allows instantaneous pattern queries at the expense of costlier model manipulation and higher memory consumption.
Up to now, this incremental approach has considered only sequential execution despite the inherently distributed structure of the underlying match caching mechanism. The paper explores various possibilities of parallelizing graph transformation to harness the power of modern multi-core, multi-processor computing environments: (i) incremental pattern matching enables the concurrent execution of model manipulation and pattern matching; moreover, (ii) pattern matching itself can be parallelized along caches
- …