Márk Asztalos

Towards Automated, Formal Verification of Model Transformations

Verification of models and model processing programs are inevitable in real-world model-based software development. Model transformation developers are interested in offline verification methods, when only the definition of the model transformation and the metamodels of the source and target languages are used to analyze the properties and no concrete input models are taken into account. Therefore, the results of the analysis hold for each output model not just particular ones, and we have to perform the analysis only once. Most often, formal verification of model transformations is performed manually or the methods can be applied only for a certain transformation or for the analysis of only a certain property. Previous work has presented a formalism to describe the characteristics of model transformations in separate formal expressions called assertions. This description is based on the first-order logic, therefore, if deduction rules are provided, a reasoning system can use an assertion set to automatically derive additional assertions describing additional properties of model transformations. In this paper, we propose deduction rules and present the verification of a model transformation of processing business process models.

Transformation of UML Models to CSP: A Case Study for Graph Transformation Tools

Graph transformation provides an intuitive mechanism for capturing model transformations. In the current paper, we investigate and compare various graph transformation tools using a compact practical model transformation case study carried out as part of the AGTIVE 2007 Tool Contest [22]. The aim of this case study is to generate formal CSP processes from high-level UML activity diagrams, which enables to carry out mathematical analysis of the system under design.

Manual and automated performance optimization of model transformation systems

Model-based development is one of the most promising solutions for several problems of industrial software engineering. Graph transformation is a proven method for processing domain-specific models. However, in order to be used by domain experts without graph transformation experts, it must be fast even if not tweaked for speed manually based on knowledge available only to the implementers of the transformation system. In this paper, we compare the performance of such manual optimizations with a solution using automated optimization based on sharing of matches between overlapping left-hand-sides of sequentially independent rules. This yields a 11% improvement in our scenario, although our prototypical implementation only exploits overlapping between, at most, two rules, and the analyzed benchmark does not contain many cases where the optimization is applicable.

A formalism for describing modeling transformations for verification

Verification of models and model processing programs are inevitable in model-based software development in order to apply them in real-world solutions. Verification of properties of model transformations means to prove that the application of a model transformation generates the expected output models from the input models. Model transformation developers are interested in offline methods for the verification process. Offline analysis means that only the definition of the model transformation and the metmodels of the source and target languages are used to analyze the properties and no concrete input models are taken into account. Therefore, the results of the analysis hold for each output model not just particular ones, and we have to perform the analysis only once. Most often, formal verification of model transformations is performed manually or the methods can be applied only for a certain transformation or for the analysis of only a certain property. In this paper, we propose a formalization to describe model transformation. A formal description can be automatically generated, and can be extended by the experts. An automated reasoning system may prove some properties of model transformations by deriving new assertions from the original description.

/spl lambda/-path fragmentation and de-fragmentation through dynamic grooming

In multi-layer networks, where more than one layer is dynamic, i.e., connections are set up using not only the upper, e.g., IP layer but the underlying wavelength layer as well leads often to suboptimal performance. In this paper we discuss the lightpath fragmentation and de-fragmentation problem, where the lightpath system cannot follow the traffic changes fast enough. We show what it depends on, when is it critical and how much does it deteriorate the performance of the network.

Multi-layer traffic engineering through adaptive λ-path fragmentation and de-fragmentation

In Multi-Layer networks, where more than one layer is dynamic, i.e., connections are set up using not only the upper, e.g., IP layer but the underlying wavelength layer as well leads often to suboptimal performance due to long wavelength paths, that do not allow routing the traffic along the shortest path. The role of MLTE (Multi-Layer Traffic Engineering) is to cut these long wavelength paths into parts (fragments) that allow better routing at the upper layer (fragmentation), or to concatenate two or more fragments into longer paths (defragmentation) when the network load is low and therefore less hops are preferred. In this paper we present a new model (GG: Grooming Graph) and an algorithm for this model that supports Fragmentation and De-Fragmentation of wavelength paths making the network always instantly adapt to changing traffic conditions. We introduce the notion of shadow capacities to model “lightpath tailoring”. We implicitly assume that the wavelength paths carry such, e.g., IP traffic that can be interrupted for a few microseconds and that even allows minor packet reordering. To show the superior performance of our approach in various network and traffic conditions we have carried out an intensive simulation study.

Formal specification and analysis of functional properties of graph rewriting-based model transformation

Model processing programs are regularly used when working with models or synthetizing the code from them; therefore, their verification has become an essential component of constructing reliable software in model‐based software engineering. Models are usually formalized and visualized as graphs; therefore, model processing programs based on algebraic graph rewriting systems—such programs are called model transformations—are often applied, and their verification has become an important research area. The goal of our research is to support offline transformation analysis by automated methods, where offline means that only the definition of the program itself, the language definitions of its source and target models are used during the analysis. Therefore, the results are independent from concrete source models, and the analysis needs to be performed only once. Based on previous work, this paper provides the synthesis and of a set of individual components and improves them to provide a complete verification solution: (i) a language is introduced to specify the properties to be verified; (ii) a formalism to describe model transformations in a declarative way; and (iii) automated algorithms that can analyse the declarative transformations as well as the properties expressed by the language. Besides its theoretical basis, the implementation of a verification framework is presented, and its operation is illustrated on a case study. Although the formal verification of model transformation properties is algorithmically undecidable in general, our goal is to provide a practically usable, scoped framework that can largely facilitate the manual verification of model transformations. Copyright

Simplifying model transformation chains by rule composition

Many model transformation problems require different intermediate transformation steps, e.g., when platform-specific models (PSM) are generated from platform-independent models (PIM). This requires the presence of several intermediate meta-models between those of the PIM and the PSM. Thus, for achieving the final PSM, a chain of transformation is needed. The solution proposed in this paper is to investigate whether it is possible to generate a single transformation from a chain of transformations, solely involving the initial PIM and final PSM meta-models. The presented work focuses on the composition of algebraic graph transformations at the rule level. Moreover, we discuss about the translation of transformations implemented in dedicated model-to-model transformation languages to algebraic graph transformation specifications. We apply the automatic procedure for composing rules in the context of the evolution of Enterprise Java Beans (EJB), transforming UML models into EJB 2.0 and then to EJB 3.0 models. The composable transformations are specified in the Atlas Transformation Language.

Runtime model validation with parallel object constraint language

In software engineering, model-based development is gaining ground as reliability must be provided while the development time needs to be decreased. As systems modeled become larger, validation methods need to perform better to offer reasonable response times to model checking queries. Our work extends OCL with parallel evaluation features in a way that multi-threaded and sequential programming constructs are interchangeable. To provide a validated parallelization, the sequential and parallel evaluation of OCL expressions has been formalized and analyzed for equivalence with the Communicating Sequential Processes language. The achieved performance gain with parallelization heavily depends on the model size and the appropriate selection of parallelized code parts, measurement results have been concluded in a case study.

Towards Formal Analysis of Multi-paradigm Model Transformations

The Multi-Paradigm Modeling (MPM) approach of model-based development emphasizes the specification of a system by multiple models. We use transformations to automatically transform, integrate and synchronize models. Verification and validation of model transformations are fundamental issues: we need to express what a valid model is and how a valid model transformation may transform the models; otherwise, we have to analyze each transformed model individually, which makes it difficult to automate the process of using models. We have formally analyzed various model transformations in several case studies and industrial projects. From this experience, we have distilled the frequently recurring techniques and solutions, referred to as Model Transformation Analysis (MTA) methods. These instances, similarly to design patterns in object-oriented programming, define special constructions as solutions for recurring problems that arise when one implements a model transformation. Moreover, MTA methods contain special techniques and language features that should be taken into account when one designs a model transformation framework or a model transformation language. We hope that MTA methods may be the basis of automated formal analysis techniques of model transformations. This paper contributes the concept and instances of MTA methods and provides a case study based on an industrial project of mobile application development. With this real-world example, we want to demonstrate the role and use of MTA methods. The case study is implemented in Visual Modeling and Transformation System (VMTS), which is a tool that realizes the MPM concept to provide a model and model transformation-based environment for software development.