Péter Fehér

Data Type Propagation in Simulink Models with Graph Transformation

Embedded systems are usually modeled to simulate their behavior. Nowadays, this modeling is often implemented in the Simulink environment, which offers strong support for modeling complex systems. Moreover, via modeling, various analyses can be applied to the systems at design time. An important analysis is of the data types assigned to signal variables. Such analysis enables identification of potential problems during model compilation and so prevent runtime surprises. To assist the system designer, Simulink supports which includes a step for automatic data type inferencing (e.g., based on designed signal value ranges and on the connection structure of design elements). In contrast to the Simulink implementation of the inferencing in a code base, which favors efficiency, the work presented here raises the level of abstraction by explicitly modeling the inferencing logic. This unlocks benefits such as the ability to (i) reason about the logic, (ii) implement different logic by advanced users, and (iii) experiment with different ordering of other logic in the model compilation.

The challenges of a model transformation language

With the increasing application of the Model-Driven Development, the model transformation approaches and tools have become an emerging researching field. An important aspect of model-driven approaches is the language that facilitates the definition of model transformations. In case of model transformation languages it is essential to investigate how expressive the language is, e.g. how self-explaining it is, what kind of language constructs it offers, and how effectively this transformation definition can be processed. In this paper we investigate the languages of some popular model transformation tools, particularly their main attributes and specificities. Using a case study, we examine how these aspects support both the effective definition and processing of model transformations. As a conclusion, we summarize the aspects that an expressive and effective model transformation language should address.

A novel algorithm for flattening virtual subsystems in Simulink models

Recently embedded systems are often modeled using Simulink® to simulate their behavior. In order to perform the simulation, the modeling tool has to process the model. An important processing step is to determine the execution order of the elements in a model. This execution order is based on a sorted list of all semantically relevant model elements. Therefore, before simulation, Simulink® removes all model elements that only have a syntactic implication. In Simulink, the virtual subsystems are composite elements with no semantic bearing. Thus, Simulink performs a flattening model transformation that eliminates virtual subsystems. The work presented in this paper provides a novel algorithm for flattening composite elements in hierarchical models. Moreover, an optimized algorithm is also presented for Simulink models. With the implementation of these algorithms the level of abstraction of the model transformation can be raised. In this manner, a reusable, platform independent solution can be achieved for flattening Simulink subsystems.

Detecting subgraph isomorphism with MapReduce

In recent years, the MapReduce framework has become one of the most popular parallel computing platforms for processing big data. MapReduce is used by companies such as Facebook, IBM, and Google to process or analyze massive data sets. Since the approach is frequently used for industrial solutions, the algorithms based on the MapReduce framework gained significant attention within the scientific community. The subgraph isomorphism is a fundamental graph theory problem. Finding small patterns in large graphs is a core challenge in the analysis of applications with big data sets. This paper introduces two novel algorithms, which are capable of finding matching patterns in arbitrary large graphs. The algorithms are designed for utilizing the easy parallelization technique offered by the MapReduce framework. The approaches are evaluated regarding their space and memory requirements. The paper also provides the applied data structure and presents formal analysis of the algorithms.

INVESTIGATING THE CANDIDATE PAIR GENERATION OF THE VF2 ALGORITHM

Recently, model transformation approaches are becoming increasingly popular; therefore their efficiency and us- ability are key factors and require further investigation. These approaches are regularly used in software engi- neering, most often as part of the model-driven develop- ment methodology. In the case of the graph rewriting- based model transformation approaches, the applied graph matching algorithm greatly determines the efficiency of the transformation approach. The matching algorithm is used to identify sub-graph isomorphism between the transfor- mation rules and the host graph. A widely applied graph matching algorithm is the VF2 algorithm. In this paper we briefly introduce the original VF2 algorithm - specifically, its method - which manages the next possible node pairs. We present a new approach, which increases the efficiency of choosing these node pairs. We also introduce an order- ing function, which increases the performance even further. Finally, the effects of these new approaches are presented based on our experimental results.

A MapReduce-based approach for finding inexact patterns in large graphs

Finding patterns in graphs is a fundamental problem in graph theory, and also a practical challenge during the analysis of big data sets. Inexact patterns may correspond to a set of possible exact graphs. Their use is important in many fields where pattern matching is applied (e.g. mining in social networks or criminal investigations). Based on previous work, this paper introduces a pattern specification language with special language features to express inexact patterns. We also show a MapReduce approach-based algorithm that is able to find matches. Our methods make it possible to define inexact patterns and to find the exact matches in large graphs efficiently.

Visual debugging support for graph rewriting-based model transformations

Graph rewriting-based model transformation is an essential tool with a strong mathematical background used to process graph-based models. The most recent modeling tools tend to support the definition of rewriting rule based transformations in a visual or textual way. However, only a few of these support the continuous animation of the modifications performed on the models, which makes the traceability and the debugging of transformations more challenging. This paper presents the visual model transformation debugger realized in the Visual Modeling and Transformation System. The solution facilitates the step-by-step execution of model transformations, the visualization of the overall state of the transformation and also supports individual matches. Furthermore, it provides the possibility to influence the behavior of the transformation at runtime. The realized features are illustrated in a case study from the MATLAB Simulink domain.

The power of graph transformation - implementing a Shadow Casting algorithm

Nowadays model transformation is used frequently in software development. Therefore, its effectiveness and usability have a big influence on the whole development phase. The attributes of the model transformation are mainly determined by the applied model transformation language. The goal is to develop an expressive, versatile but still effectively processable transformation language. Using a case study, in this paper the potential of the graph rewriting-based model transformation is presented with respect to some frequent transformation language related problems, e.g. the information sharing between transformation rules. Furthermore, the authors also introduce approaches that make the model transformation languages expressive and summarize the aspects that an efficient model transformation language should address.