Formalizing the Structural Semantics of Domain-Specific Modeling

Total Page:16

File Type:pdf, Size:1020Kb

Formalizing the Structural Semantics of Domain-Specific Modeling 1 Formalizing the Structural Semantics of Domain-Specific Modeling Languages ETHAN JACKSON and JANOS SZTIPANOVITS Institute for Software Integrated Systems, Vanderbilt University Abstract— Model-based approaches to system design simulation. This evolution can be seen in the hybrid are now widespread and successful. These approaches systems [83], embedded systems [34], and security [55] make extensive use of model structure to describe systems communities. However, the immediacy of behavioral using domain-specific abstractions, to specify and imple- issues has dominated the spotlight, leaving issues in the ment model transformations, and to analyze structural structural regime behind. properties of models. In spite of its general importance the structural semantics of modeling languages are not In all fairness, it is not obvious that the founda- well-understood. In this paper we develop the formal tions of DSML syntax should differ from that of exist- foundations for the structural semantics of domain specific ing programming languages. Traditionally, programming modeling languages (DSML), including the mechanisms language construction follows a well-defined path [1]: by which metamodels specify the structural semantics of First, language syntax is defined with an eBNF grammar DSMLs. Additionally, we show how our formalization can [15] and a parser is generated. Second, a type-system complement existing tools, and how it yields algorithms is defined. Third, algorithms are developed that walk for the analysis of DSMLs and model transformations. the abstract syntax tree (AST) and check the well- Index Terms— Model-based Design, Domain Specific typedness of the program. The terms “domain-specific” Modeling Languages, Structural Semantics, Metamodel- and “model” do not by themselves indicate that the ing, Formal Logic, Horn Logic procedure should be any different for DSMLs. The first sign that DSMLs diverge from traditional I. INTRODUCTION language design appears in their specification with meta- Domain-specific modeling languages (DSMLs) play models [5]. Metamodels employ UML-like class dia- an important role in software and system design. They grams to describe rich syntactic constructs with hier- are essential components of the OMG’s model-driven archical internal structure (aggregation) carrying typed architecture (MDA) [76], mature tools exist for con- data (attributes). Metamodeling also focuses attention structing and utilizing DSMLs [31], [36], [64], and many to relations (associations) between syntactic entities, methodologies in model-based design, such as platform- providing n-ary relations over infinite sets. Unlike BNF based design [45] and actor-based design [66] exploit the grammars, metamodels treat these building blocks as DSML metaphor [65]. first-class concepts. Expressive constraint languages, Despite widespread application of DSMLs, many sci- such as the Object Constraint Language (OCL) [79], entific questions remain about their formal properties enrich metamodels by supporting expressive constraints [8], [41], [61], which can be loosely grouped into the on legal model instances [55]. These observations have structural and behavioral regimes. The structural regime already led many researchers to relate metamodels to concerns the specification, representation, and manipula- graph grammars, which natively support relations [23], tion of models as represented in some domain-specific [60]. syntax. Research in the behavioral regime focuses on the The second sign of divergence occurs in the varied ap- specification and analysis of domain-specific execution plications of DSMLs syntax, which include model trans- semantics. Efforts to formalize statecharts [37], [38] and formations, design space exploration, and correct-by- message sequence charts [3], [39] fit into this regime. construction design. Model transformations [70] trans- Others have studied the general problem of linking late between domain-specific syntaxes to change ab- domain-specific syntaxes with execution semantics [14], straction levels [32], compose modeling aspects [35], [72]. and relate platform-independent models with platform Anytime a new community adopts DSML-based mod- specific ones [76]. Modern model transformation lan- eling, its members inevitably desire a precise formaliza- guages utilize extended graphs grammars to capture the tion of behaviors for the purposes of verification and complexities of DSML syntax [23], [60]. Syntax has also 2 been used to perform design space exploration. These UML infrastructure [78], and Meta-Object Facil- techniques employ syntactic perturbations to generate ity (MOF) [75] do not provide sufficiently rigid optimized variants of models [57], [74]. Again, the definitions of the DSML process to permit inter- expressiveness of metamodeling constraints facilitates operability between tools. See [24] for a detailed meaningful design space exploration. This same expres- example of this phenomenon. siveness can be used to project behavioral properties (e.g. In this paper we explore a bottom-up approach to for- deadlock freedom) onto the syntactic level [52]. Correct- malizing metamodeling, DSML syntax, and model trans- by-construction design [33] uses expressive syntactic formations. By bottom-up, we mean that our approach rules in conjunction with a suitable behavioral semantics does not begin with the concepts of metamodeling or to statically identify models with bad behavioral prop- model transformation, but ends with these. Instead, we erties. Note that the correct-by-construction approach start with a simple formal core capable of expressing differs from static analysis of traditional programming the rich syntaxes of a class D of DSMLs. Each member languages, because DSMLs are a priori designed to of this class is simply called a domain (motivated by maximize analysis. Programming language static anal- the phrase domain-specific) and each domain D defines ysis has historically evolved in the other direction: First, some domain-specific syntax. Next, we define a class the language is fixed (e.g. C++), and then reasonable ap- T of functions that relate the syntactic elements of proaches to static analysis develop, e.g. dataflow analysis one domain with the elements of another; this class of software [28]. represents model transformations. Third, we identify a Given the important uses-cases for DSML syntax we special pair (Dmeta;Tmeta) D T that together are might expect that: capable of generating all domains2 × in the class; this 1) There exists a precise mathematical foundation for becomes metamodeling. Finally, we define the classes D metamodeling, model transformations, and DSML and T using the same underlying mathematical apparatus syntax. based on deductive logic. 2) Tool-independent formal descriptions of modeling With our approach we can formulate important prop- artifacts can be extracted from tool-dependent ar- erties over domains and transformations, including: Do- tifacts. main emptiness, domain equivalence, and structure pre- 3) The formal foundation yields analysis techniques serving maps. for DSML syntax, metamodels, and model trans- 1) Domain emptiness refers to DSMLs with no legal formations. syntactic instances. Empty domains are created Unfortunately, this is not the current state of affairs. when metamodel composition introduces inconsis- Metaprogrammable tools (i.e. tools that use metamodels) tencies, or when metamodeling constraints contain and standardized metamodeling languages have evolved mistakes. independently from each other, from formalizations of 2) Two domains are equivalent if they have the same the metamodeling process, and from formalizations of set of syntactic instances, even though their meta- model transformations. Here are some examples that models may differ. Domain equivalence provides illustrate this: a mechanism to compare domains independently 1) The work on KM3 [54] provides a formal meta- from the metamodeling language. modeling language for use with graph transforma- 3) Structure preserving maps refer to model trans- tions, but does not address expressive constraints formations that always rewrite legal syntactic in- incorporated into the source/target languages. Sim- stances to legal syntactic instances. ilar limitations are present in the VMP [87] formal- We have developed a theorem prover called FORMULA ism used by Viatra2 [17]. (FORmal Modeling Using Logic Analysis) that calcu- 2) The mature metaprogrammable Generic Modeling lates these properties when domains/transformations are Environment (GME) [64] and Graph Rewriting described using Horn logic [53] with stratified negation And Transformation (GReAT) tool [29] provide [48], [51]. We will not describe the details of FORMULA expressive DSMLs and extensive model transfor- here, but show some results of the tool. mation features. However, the precise structural Finally, we incorporated our formalization into the semantics of tool artifacts depend on (and are Model Integrated Computing (MIC) tool suite, which has hidden in) the implementation of these complex amassed over a decade of massive modeling efforts rang- tools. ing from models of the NASA space station [12] to the 3) Standards such as the UML superstructure [80], sensor and control networks of automotive plants [68]. 3 We show in detail how our framework can be connected UML includes many capabilities (diagrams) including to this tried-and-tested DSML-based modeling suite. metamodeling, state machines, activities, sequence charts This case study illustrates that the bottom-up
Recommended publications
  • The Model Transformation Language of the VIATRA2 Framework
    View metadata, citation and similar papers at core.ac.uk brought to you by CORE provided by Elsevier - Publisher Connector Science of Computer Programming 68 (2007) 214–234 www.elsevier.com/locate/scico The model transformation language of the VIATRA2 framework Daniel´ Varro´ ∗, Andras´ Balogh Budapest University of Technology and Economics, Department of Measurement and Information Systems, H-1117, Magyar tudosok krt. 2., Budapest, Hungary OptXware Research and Development LLC, Budapest, Hungary Received 15 August 2006; received in revised form 17 April 2007; accepted 14 May 2007 Available online 5 July 2007 Abstract We present the model transformation language of the VIATRA2 framework, which provides a rule- and pattern-based transformation language for manipulating graph models by combining graph transformation and abstract state machines into a single specification paradigm. This language offers advanced constructs for querying (e.g. recursive graph patterns) and manipulating models (e.g. generic transformation and meta-transformation rules) in unidirectional model transformations frequently used in formal model analysis to carry out powerful abstractions. c 2007 Elsevier B.V. All rights reserved. Keywords: Model transformation; Graph transformation; Abstract state machines 1. Introduction The crucial role of model transformation (MT) languages and tools for the overall success of model-driven system development has been revealed in many surveys and papers during the recent years. To provide a standardized support for capturing queries, views and transformations between modeling languages defined by their standard MOF metamodels, the Object Management Group (OMG) has recently issued the QVT standard. QVT provides an intuitive, pattern-based, bidirectional model transformation language, which is especially useful for synchronization kind of transformations between semantically equivalent modeling languages.
    [Show full text]
  • Operational Semantics Page 1
    Operational Semantics Page 1 Operational Semantics Class notes for a lecture given by Mooly Sagiv Tel Aviv University 24/5/2007 By Roy Ganor and Uri Juhasz Reference Semantics with Applications, H. Nielson and F. Nielson, Chapter 2. http://www.daimi.au.dk/~bra8130/Wiley_book/wiley.html Introduction Semantics is the study of meaning of languages. Formal semantics for programming languages is the study of formalization of the practice of computer programming. A computer language consists of a (formal) syntax – describing the actual structure of programs and the semantics – which describes the meaning of programs. Many tools exist for programming languages (compilers, interpreters, verification tools, … ), the basis on which these tools can cooperate is the formal semantics of the language. Formal Semantics When designing a programming language, formal semantics gives an (hopefully) unambiguous definition of what a program written in the language should do. This definition has several uses: • People learning the language can understand the subtleties of its use • The model over which the semantics is defined (the semantic domain) can indicate what the requirements are for implementing the language (as a compiler/interpreter/…) • Global properties of any program written in the language, and any state occurring in such a program, can be understood from the formal semantics • Implementers of tools for the language (parsers, compilers, interpreters, debuggers etc) have a formal reference for their tool and a formal definition of its correctness/completeness
    [Show full text]
  • Extensible Transition System Semantics
    Extensible Transition System Semantics Casper Bach Poulsen Submitted to Swansea University in fulfilment of the requirements for the Degree of Doctor of Philosophy Department of Computer Science Swansea University 2015 Declaration This work has not been previously accepted in substance for any degree and is not being concurrently submitted in candidature for any degree. Signed ............................................................ (candidate) Date ............................................................ Statement 1 This thesis is the result of my own investigations, except where otherwise stated. Other sources are acknowledged by footnotes giving explicit references. A bibliography is appended. Signed ............................................................ (candidate) Date ............................................................ Statement 2 I hereby give my consent for my thesis, if accepted, to be available for photocopying and for inter-library loan, and for the title and summary to be made available to outside organisations. Signed ............................................................ (candidate) Date ............................................................ Abstract Structural operational semantics (SOS) come in two main styles: big-step and small- step. Each style has its merits and drawbacks, and it is sometimes useful to maintain specifications in both styles. But it is both tedious and error-prone to maintain multiple specifications of the same language. Additionally, big-step SOS has poor support for
    [Show full text]
  • Lessons Learned from Building Model-Driven Development Tools
    Noname manuscript No. (will be inserted by the editor) Lessons Learned from Building Model-Driven Development Tools Richard F. Paige1 and D´anielVarr´o2 Department of Computer Science, University of York, UK. e-mail: [email protected] Department of Measurement and Information Systems Budapest University of Technology and Economics, Hungary. e-mail: [email protected] The date of receipt and acceptance will be inserted by the editor Abstract Tools to support modelling in system and of MDD tools. The principles will be distilled from an software engineering are widespread, and have reached analysis of the development of two MDD tools that are a degree of maturity where their use and availability used in practice: VIATRA and Epsilon. These tools are are accepted. Tools to support Model-Driven Develop- used in industry, on real projects, and have developed ment (MDD) { where models are manipulated and man- in very different ways. Arguably, some of the lessons aged throughout the system/software engineering lifecy- learned from the development of these tools can inform cle { have, over the last ten years, seen much research the development of new MDD tools, and can also be and development attention. Over the last ten years, we used to support the evolution of existing tools. Our ob- have had significant experience in the design, develop- jective is not to propose the \ideal" MDD tool; such a ment and deployment of MDD tools in practical settings. tool is unlikely to exist. However, the principles under- In this paper, we distill some of the important lessons pinning the development of MDD tools that are widely we have learned in developing and deploying two MDD used in practice can help in assessing existing tools, and tools: Epsilon and VIATRA.
    [Show full text]
  • Model-Driven Engineering, the System Under Development Is Described and Analyzed Using Models
    X perf =1.00 X loss =0.01 SDSoftware Design and Quality A Declarative Language for Bidirectional Model Consistency Master’s Thesis of Dominik Werle at the Department of Informatics Institute for Program Structures and Data Organization (IPD) Reviewer: Prof. Dr. Ralf H. Reussner Second reviewer: Jun.-Prof. Dr.-Ing. Anne Koziolek Advisor: Dipl.-Inform. Max E. Kramer Second advisor: M.Sc. Michael Langhammer 09. October 2015 – 08. April 2016 Karlsruher Institut für Technologie Fakultät für Informatik Postfach 6980 76128 Karlsruhe I declare that I have developed and written the enclosed thesis completely by myself, and have not used sources or means without declaration in the text. Karlsruhe, 08. April 2016 .................................... (Dominik Werle) Abstract In model-driven engineering, the system under development is described and analyzed using models. Dierent models provide dierent abstractions of the system for dierent purposes. If multiple modeling languages are used, their models can contain overlapping informa- tion about the system. Then, they can become inconsistent after changes and need to be synchronized. The complexity of synchronizing models can be reduced by specifying consistency relationships in specialized languages and by automating the synchronization based on this specication. The languages can hide complexity that is not specic to the domain of the modeling languages, for example by deriving the operations needed for propagating changes from a model to another model for all pairs of models instead of requiring explicit specication for each pair and direction. In the course of this thesis, we designed the mapping language for specifying these consistency relationships and implemented a framework that maintains consistency based on the specication.
    [Show full text]
  • A. Detailed Course Structure of MA (Linguistics)
    A. Detailed Course Structure of M.A. (Linguistics) Semester I Course Course Title Status Module & Marks Credits Code LIN 101 Introduction to Core 20(M1)+20(M2)+10(IA) 4 Linguistics LIN 102 Levels of Language Core 20(M1)+20(M2)+10(IA) 4 Study LIN 103 Phonetics Core 20(M1)+20(M2)+10(IA) 4 LIN 104 Basic Morphology & Core 20(M1)+20(M2)+10(IA) 4 Basic Syntax LIN 105 Indo-European Core 20(M1)+20(M2)+10(IA) 4 Linguistics & Schools of Linguistics Semester II LIN 201 Phonology Core 20(M1)+20(M2)+10(IA) 4 LIN 202 Introduction to Core 20(M1)+20(M2)+10(IA) 4 Semantics & Pragmatics LIN 203 Historical Linguistics Core 20(M1)+20(M2)+10(IA) 4 LIN 204 Indo-Aryan Core 20(M1)+20(M2)+10(IA) 4 Linguistics LIN 205 Lexicography Core 20(M1)+20(M2)+10(IA) 4 Semester III LIN 301 Sociolinguistics Core 20(M1)+20(M2)+10(IA) 4 LIN 302 Psycholinguistics Core 20(M1)+20(M2)+10(IA) 4 LIN 303 Old Indo-Aryan Discipline 20(M1)+20(M2)+10(IA) 4 Specific Elective Lin 304 Middle Indo-Aryan Discipline 20(M1)+20(M2)+10(IA) 4 Specific Elective LIN 305 Bengali Linguistics Discipline 20(M1)+20(M2)+10(IA) 4 1 Specific Elective LIN 306 Stylistics Discipline 20(M1)+20(M2)+10(IA) 4 Specific Elective LIN 307 Discourse Analysis Generic 20(M1)+20(M2)+10(IA) 4 Elective Semester IV LIN 401 Advanced Core 20(M1)+20(M2)+10(IA) 4 Morphology & Advanced Syntax LIN 402 Field Methods Core 20(M1)+20(M2)+10(IA) 4 LIN 403 New Indo-Aryan Discipline 20(M1)+20(M2)+10(IA) 4 Specific Elective LIN 404 Language & the Discipline 20(M1)+20(M2)+10(IA) 4 Nation Specific Elective LIN 405 Language Teaching Discipline 20(M1)+20(M2)+10(IA) 4 Specific Elective LIN 406 Term Paper Discipline 50 6 Specific Elective LIN 407 Language Generic 20(M1)+20(M2)+10(IA) 4 Classification & Elective Typology B.
    [Show full text]
  • Research Report
    RZ 3621 (# 99631) 07/18/2005 Computer Science 10 pages Research Report A Systematic Approach to Designing Model Transformations Jochen M. Kuster,¨ Ksenia Ryndina and Rainer Hauser IBM Research GmbH Zurich Research Laboratory 8803 Ruschlikon¨ Switzerland {jku,ryn,rfh}@zurich.ibm.com LIMITED DISTRIBUTION NOTICE This report will be distributed outside of IBM up to one year after the IBM publication date. Some reports are available at http://domino.watson.ibm.com/library/Cyberdig.nsf/home. Research IBM Almaden · Austin · Beijing · Delhi · Haifa · T.J. Watson · Tokyo · Zurich A Systematic Approach to Designing Model Transformations Jochen M. Kuster¨ , Ksenia Ryndina and Rainer Hauser IBM Zurich Research Laboratory 8803 R¨uschlikon Switzerland jku,ryn,rfh ¡ @zurich.ibm.com Abstract forming them into a formal language [9]. Currently, a great deal of research is focused on the expression of model transformation Design and implementation of model transformations is one designs and appropriate tool support for model transformation de- key prerequisite for the vision of model driven development to be- velopers. This has led to the Query/Views/Transformation (QVT) come true. However, model transformations are quite different proposal by the Object Management Group (OMG) [21], which from other software artifacts since a model transformation design aims to provide a standardized framework for model transforma- typically consists of a set of transformation rules instead of object- tion development. oriented models such as class diagrams and statecharts. There- fore traditional software engineering approaches are not directly Many existing model transformation approaches favor that applicable for the development of model transformations. Never- transformations are captured in a rule-based way by a set of trans- theless, in the line of existing software engineering practice, model formation rules (see VIATRA [5], GReAT [13], UMLX [26], transformations must be developed in a systematic way in order to BOTL [4] and work by Milicev [17]).
    [Show full text]
  • Expressive and Efficient Model Transformation with an Internal DSL
    Expressive and Efficient Model Transformation with an Internal DSL of Xtend Artur Boronat Department of Informatics, University of Leicester, UK [email protected] ABSTRACT 1 INTRODUCTION Model transformation (MT) of very large models (VLMs), with mil- Over the past decade the application of MDE technology in indus- lions of elements, is a challenging cornerstone for applying Model- try has led to the emergence of very large models (VLMs), with Driven Engineering (MDE) technology in industry. Recent research millions of elements, that may need to be updated using model efforts that tackle this problem have been directed at distributing transformation (MT). This situation is characterized by important MT on the Cloud, either directly, by managing clusters explicitly, or challenges [26], starting from model persistence using XMI serial- indirectly, via external NoSQL data stores. In this paper, we draw at- ization with the Eclipse Modeling Framework (EMF) [31] to scalable tention back to improving efficiency of model transformations that approaches to apply model updates. use EMF natively and that run on non-distributed environments, An important research effort to tackle these challenges was showing that substantial performance gains can still be reaped on performed in the European project MONDO [19] by scaling out that ground. efficient model query and MT engines, such as VIATRA[3] and We present Yet Another Model Transformation Language (YAMTL), ATL/EMFTVM [46], building on Cloud technology either directly, a new internal domain-specific language (DSL) of Xtend for defin- by using distributed clusters of servers explicitly, or indirectly, by ing declarative MT, and its execution engine.
    [Show full text]
  • Formal Validation and Model Generationfor Domain-Specific
    Budapest University of Technology and Economics Faculty of Electrical Engineering and Informatics Department of Measurement and Information Systems Formal Validation and Model Generation for Domain-Specific Languages by Logic Solvers Thesis booklet Oszkár Semeráth Thesis supervisor: Prof. Dániel Varró Budapest, 2019 1. Introduction 1 Introduction 1.1 Domain-specific modeling languages My thesis is motivated by the challenges in the development of complex, safety- critical systems such as automotive, avionics or cyber-physical systems, which is characterized by a long development time and strict safety standards (like DO-178C or DO-330). Model-Based System Engineering (MBSE) is a widely used technique in those application domains [WHR14], which facilitates the use of models in different phases of design and on various levels of abstraction. Fur- thermore, MBSE promotes the use of Domain-Specific (Modeling) Languages (DSLs) to precisely capture the main features of a target domain, thus en- abling the engineers to model their solutions with the concepts of the problem domain. Additionally, advanced modeling environments can automate several development steps, with a particular emphasis on verification and validation (V&V). Thus they can significantly improve the overall productivity of the de- velopment and quality of the product. A complex industrial modeling environment supports the development of models by continuously evaluating consistency constraints to ensure that the models satisfy the design rules of the domain. There is already efficient sup- port for automatically validating constraints and design rules over large model instances of the DSL using tools like Eclipse OCL [Wil12; KPP09] or Viatra [Ber+11; Ber+10]. Modeling environments often incorporate the automated generation of various artifacts such as source code, task specific views, or doc- umentation by using code generation or model transformation techniques.
    [Show full text]
  • Axiomatic Semantics I
    Spring 2016 Program Analysis and Verification Lecture 3: Axiomatic Semantics I Roman Manevich Ben-Gurion University Warm-up exercises 1. Define program state: 2. Define structural semantics configurations: 3. Define the form of structural semantics transitions: 2 Tentative syllabus Abstract Program Program Analysis Interpretation Verification Analysis Basics Techniques fundamentals Operational Control Flow Numerical Lattices semantics Graphs Domains Axiomatic Equation Fixed-Points Alias analysis Verification Systems Collecting Chaotic Interprocedural Semantics Iteration Analysis Galois Shape Using Soot Connections Analysis Domain CEGAR constructors Widening/ Narrowing 3 Agenda • Basic concepts of correctness • Axiomatic semantics (pages 175-183) – Motivation – First-order logic reminder – Hoare Logic 4 program correctness 5 Program correctness concepts • Specification = a certain relationship between initial state and final state Main focus of this course • Partial correctness = specifications that hold if the program terminates • Termination = program always terminates – i.e., for every input state partial correctness + termination = total correctness Other correctness concepts exist: liveness, resource usage, … 6 Verifying factorial with structural semantics 7 Structural semantics for While [asssos] x := a, 1 [x Aa] [skipsos] skip, 1 1 S1, 1 S1’, ’ [comp sos] S1; S2, 1 S1’; S2, 2 S1, 1 ’ [comp sos] S1; S2, 1 S2, ’ tt [if sos] if b then S1 else S2, 1 S1, if B b = tt ff [if sos] if b then S1 else S2, 1 S2, if B b = ff while
    [Show full text]
  • Efficient ATL Incremental Transformations
    Journal of Object Technology Published by AITO | Association Internationale pour les Technologies Objets http://www.jot.fm/ Efficient ATL Incremental Transformations Th´eoLe Calvara Fr´ed´ericJouaultb Fabien Chhelb Mickael Clavreulb a. LERIA, University of Angers, France b. ERIS Team, Groupe ESEO, France Abstract Incrementally executing model transformations offers several benefits such as updating target models in-place (instead of creating a new copy), as well as generally propagating changes faster (compared with complete re-execution). Active operations have been shown to of- fer performant OCL-based model transformation incrementality with use- ful properties like fine-grained change propagation, and the preservation of collection ordering. However, active operations have so far only been available as a Java library. This compels users to program at a relatively low level of abstraction, where most technical details are still present. Writing transformations at this level of abstraction is a tedious and error prone work. Using languages like Xtend alleviates some but not all issues. In order to provide active operation users with a more user-friendly front-end, we have worked on compiling ATL code to Java code using the active operations library. Our compiler can handle a significant subset of ATL, and we show that the code it generates provides similar performance to hand-written Java or Xtend code. Furthermore, this compiler also enables new possibilities like defining derived properties by leveraging the ATL refining mode. Keywords Incremental model transformation Active operations ATL. 1 Introduction Incremental model transformation execution offers many advantages over batch (i.e., non-incremental) execution, such as faster change propagation.
    [Show full text]
  • The Train Benchmark: Cross-Technology Performance Evaluation of Continuous Model Queries
    Softw Syst Model DOI 10.1007/s10270-016-0571-8 REGULAR PAPER The Train Benchmark: cross-technology performance evaluation of continuous model queries Gábor Szárnyas1,2,3 · Benedek Izsó1 · István Ráth1,4 · Dániel Varró1,2,3 Received: 30 October 2015 / Revised: 27 March 2016 / Accepted: 3 October 2016 © The Author(s) 2017. This article is published with open access at Springerlink.com Abstract In model-driven development of safety-critical tion rules is challenging for the currently available tools. systems (like automotive, avionics or railways), well- Checking well-formedness constraints can be captured by formedness of models is repeatedly validated in order to declarative queries over graph models, while model update detect design flaws as early as possible. In many indus- operations can be specified as model transformations. This trial tools, validation rules are still often implemented by paper presents a benchmark for systematically assessing the a large amount of imperative model traversal code which scalability of validating and revalidating well-formedness makes those rule implementations complicated and hard constraints over large graph models. The benchmark defines to maintain. Additionally, as models are rapidly increas- well-formedness validation scenarios in the railway domain: ing in size and complexity, efficient execution of valida- a metamodel, an instance model generator and a set of well- formedness constraints captured by queries, fault injection Communicated by Prof. Lionel Briand. and repair operations (imitating the work of systems engi- neers by model transformations). The benchmark focuses This work was partially supported by the MONDO (EU ICT-611125) project, the MTA-BME Lendület Research Group on Cyber-Physical on the performance of query evaluation, i.e.
    [Show full text]