1 / 54

Towards Automatic Model Synchronization from Model Transformation

Towards Automatic Model Synchronization from Model Transformation. Yingfei Xiong, 2007. ASE Work. The Problem of Data Interchange. Suppose we have a software modeling system We want to write a code generating system that generates code from the models in the modeling system. ------------

solada
Download Presentation

Towards Automatic Model Synchronization from Model Transformation

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Towards Automatic Model Synchronization from Model Transformation Yingfei Xiong, 2007

  2. ASE Work

  3. The Problem of Data Interchange • Suppose we have a software modeling system • We want to write a code generating system that generates code from the models in the modeling system ------------ ------------ ------------ ------------ Modeling System Code Generator Models Code

  4. Difficulties • The format how the models are stored is unknown • Even if the format is known, there are many trivial details to deal with • Byte encoding: high bit first? Low bit first? • Char encoding: GB2312? UTF-8? • …

  5. Solution • Standards • W3C XML • OMG MOF • Standards for data interchange that • Provide a generic data structure to describe data • XML: tree • MOF: graph • Provide means to define the format of data • XML: DTD, Schema • MOF: meta model • Define how the data are stored into and loaded from files • XML: part of the basic XML standard • MOF: XMI • Provide a set of general APIs to operate data

  6. The resulting system • The modeling system produces data in MOF models for data interchange. ------------ ------------ ------------ ------------ Modeling System MOF Models Code Generator Code

  7. A More General Situation • The code generating system wants to support more modeling system • The system proposes a meta model and supports input of models in the meta model Modeling System A Models in Metamodel A Models in Metamodel C Code Generator Modeling System B Models in Metamodel B

  8. Solution • Provide specific languages for converting model formats between meta models Modeling System A Models in Metamodel A Models in Metamodel C Transform A2C Transform B2C Modeling System B Models in Metamodel B Code Generator

  9. Walk a little further • Software development yields artifacts in different formats • Requirement documents • Design models • Code • … • If we can provide transformations between these artifacts, we can automate software development

  10. Model-Driven Development • MDD • An model-based approach to software development • Developing software by transforming models • MDA • The set of standards by OMG for realizing MDD • Model Transformation Languages • ATL [F. Jouault and I. Kurtev. 2005] • QVT [OMG, 2006]

  11. A UML2Java Transformation in ATL module UML2Java ; create OUT : Java from IN : UML ; rule Class2Class { from u : UML ! Class to j : Java ! Class ( name <- u.name , fields <- u.attrs ) } rule Attribute2Field { from a : UML ! Attribute to f : Java ! Field ( name <- ’_’ + a.name , type <- a. type ) }

  12. UML!Class name = “Book” description = “a demo class” UML!Attribute UML!Attribute name = “title” type = “String” name = “price” type = “Double” An Example of Executing UML2Java

  13. Java!Class UML!Class name = “Book” comment = “” name = “Book” description = “a demo class” Java!Field UML!Attribute Java!Field UML!Attribute name = “_title” type = “String” name = “title” type = “String” name = “_price” type = “Double” name = “price” type = “Double” The Transformation Result

  14. Java!Class name = “Book” comment = “_bookTitle cannot be null” UML!Class name = “Book” description = “a demo class” UML!Attribute Java!Field Java!Field UML!Attribute UML!Attribute name = “title” type = “String” name = “_title” type = “String” name = “_price” type = “Double” name = “price” type = “Double” name = “authors” type = “String” Modifications _bookTitle

  15. Model Synchronization • Model synchronization is a process that propagates modifications across different models, making the models consistent with each other.

  16. Model Synchronization Src0 Tar0 Transform Modify Modify Src1 Tar1 Synchronize Src2 Tar2

  17. Existing Approaches • General Frameworks • Multi-view synchronization [J. Grundy et al. 1998] • Rely on users to write code to handle each type of modifications in each side • It is users who should ensure the consistency of the code • Specific Languages • FSML [M. Antkiewicz and et al. 2006] • Feature model to code synchronization

  18. Our Contributions • A clear semantics of model synchronization • Four properties • An automatic model synchronization approach • Using the existing unidirectional ATL byte code program • Requiring no extra code • Satisfying the four properties • A prototype tool for synchronizing EMF models

  19. Our Contributions • A clear semantics of model synchronization • Four properties • An automatic model synchronization approach • Using the existing unidirectional ATL byte code program • Requiring no extra code • Satisfying the four properties • A prototype tool for synchronizing EMF models

  20. Our Contributions • A clear semantics of model synchronization • Four properties • An automatic model synchronization approach • Using the existing unidirectional ATL byte code program • Requiring no extra code • Satisfying the four properties • A prototype tool for synchronizing EMF models

  21. The ATL Transformation System ATL Program QVT Program Compile ATL Byte-code

  22. Our Contributions • A clear semantics of model synchronization • Four properties • An automatic model synchronization approach • Using the existing unidirectional ATL byte code program • Requiring no extra code • Satisfying the four properties • A prototype tool for synchronizing EMF models

  23. The ATL Transformation System ATL Virtual Machine Original Source Models Original Target Models Modified Source Models Modified Target Models ATL Byte-code MetaModels

  24. Our System Original Source Models Modified Source Models Modified Target Models Our System ATL Byte-code MetaModels Synchronized Source Models Synchronized Target Models

  25. Our Contributions • A clear semantics of model synchronization • Four properties • An automatic model synchronization approach • Using the existing unidirectional ATL byte code program • Requiring no extra code • Satisfying the four properties • A prototype tool for synchronizing EMF models

  26. Java!Class name = “Book” comment = “_bookTitle cannot be null” UML!Class name = “Book” description = “a demo class” UML!Attribute Java!Field Java!Field UML!Attribute UML!Attribute name = “title” type = “String” name = “_title” type = “String” name = “_price” type = “Double” name = “price” type = “Double” name = “authors” type = “String” Review the example _bookTitle

  27. Java!Class name = “Book” comment = “_bookTitle cannot be null” UML!Class name = “Book” description = “a demo class” Java!Field UML!Attribute Java!Field UML!Attribute UML!Attribute Java!Field name = “_title” type = “String” name = “title” type = “String” name = “_price” type = “Double” name = “authors” type = “String” name = “price” type = “Double” name = “_authors” type = “String” The Synchronized Result _bookTitle bookTitle

  28. Our Contributions • A clear semantics of model synchronization • Four properties • An automatic model synchronization approach • Using the existing unidirectional ATL byte code program • Requiring no extra code • Satisfying the four properties • A prototype tool for synchronizing EMF models

  29. Content • Background and Motivation • Outline of our work • Details of our work • A clear semantics • An automated approach • A prototype tool

  30. Properties of Synchronization • To ensure the synchronization process exhibits reasonable behavior, we need to define clear semantics to model synchronization • Our semantics includes four important properties: • Stability • Preservation • Propagation • Composibility

  31. UML!Class UML!Class Java!Class Java!Class Java!Class UML!Class name = “book” name = “book” name = “book” name = “book” name = “book” name = “book” description = “demo” comment = “” description = “demo” comment = “” comment = “” description = “demo” Stability If no model is modified, the synchronized models are not modified. Transform Synchronize

  32. UML!Class UML!Class Java!Class Java!Class Java!Class UML!Class name = “book” name = “book” name = “book” name = “book” name = “book” name = “book” description = “demo” comment = “” description = “demo” comment = “persistent” comment = “persistent” description = “demo” Preservation Modifications on both sides should be kept. Transform Synchronize

  33. UML!Class UML!Class Java!Class Java!Class Java!Class UML!Class name = “book” name = “book” name = “book” name = “book” name = “book” name = “book” comment = “” comment = “” description = “demo” description = “demo” comment = “” description = “demo” Propagation The modifications should be propagated to the other side if necessary. Transform publication Synchronize publication publication

  34. UML!Class UML!Class Java!Class Java!Class Java!Class UML!Class name = “book” name = “book” name = “book” name = “book” name = “book” name = “book” comment = “” comment = “” description = “demo” description = “demo” comment = “” description = “demo” Composibility – Step 1 A series of modifications have the same effect regardless of whether is applied once or is applied incrementally Transform publication Synchronize publication publication

  35. UML!Class UML!Class Java!Class Java!Class UML!Class Java!Class name = “book” name = “book” name = “book” name = “book” name = “book” name = “book” comment = “persistent” description = “demo” description = “demo” comment = “” comment = “persistent” description = “demo” Composibility – Step 2 A series of modifications have the same effect regardless of whether is applied once or is applied incrementally publication publication publication Synchronize publication publication

  36. UML!Class UML!Class Java!Class Java!Class Java!Class UML!Class name = “book” name = “book” name = “book” name = “book” name = “book” name = “book” comment = “persistent” comment = “persistent” description = “demo” description = “demo” comment = “” description = “demo” Composibility - Composed A series of modifications have the same effect regardless of whether is applied once or is applied incrementally Transform publication Synchronize publication publication

  37. Content • Background and Motivation • Outline of our work • Details of our work • A clear semantics • An automated approach • A prototype tool • Conclusion

  38. Backward Modification Propagation • To put back modifications from target to source, we need to know which source items are related to a target item • Bidirectional ATL Virtual Machine • Record trace information when performing the transformation • Trace the sources of items • Trace how items are transformed

  39. Examples of Tracing to f : Java ! Field ( name <- ’_’ + a.name , type <- a. type ) • The f.name is created from a.name by prefixing an underscore • When f.name is modified, we modify a.name by removing the prefixed underscore

  40. UML!Class Java!Class name = “Book” description = “a demo class” name = “Book” comment = “” UML!Attribute Java!Field Java!Field UML!Attribute name = “_title” type = “String” name = “title” type = “String” name = “price” type = “Double” name = “_price” type = “Double” Propagate Modifications I am from here! When I am deleted, delete the source class and all its attributes I am from here! When I am changed, find corresponding attributeand set that attribute back I am from here! When I am changed, remove the leading ‘-’ and copy me back!

  41. Tar1 Tagged Src Tagged Tar Inter. Src Inter. Tar Tar2 Src2 Synchronization Algorithm Src. Modifications Transform Src0 Tar0 Tar. Modifications Shared Modifications Difference Src1 Difference Backward Propagate Source Merging Supplementray Merging Transform

  42. Content • Background and Motivation • Outline of our work • Details of our work • A clear semantics • An automated approach • A prototype tool • Conclusion

  43. A prototype tool Synchronizing EMF models Using an ATL byte-code program Requiring no extra code Available at: http://www.ipl.t.u-tokyo.ac.jp/~xiong/modelSynchronization.html Implementation

  44. Content • Background and Motivation • Outline of our work • Details of our work • A clear semantics • An automated approach • A prototype tool

  45. Ongoing Work

  46. Problem in the ASE work • Cannot deal with insertions • Lack of well-defined semantics for references • My recent study shows that in our ASE work, properties may be violated when there are complex reference operations • Synchronization is slow • Some applications require instant updating of models • EclipseUML • Synchronization of document and view in MVC applications • Cannot apply to data that is not XMI files • Other data includes: XML files, in-memory structures

  47. My Current Work: Objectives • Provide a general framework for implementing synchronization applications • To support all kinds of modifications • To support incremental synchronization • Finding out what modification operations should be taken to make models consistent from some initial modification operations • To allow users to define new data structures • Can easily correspond to a unidirectional imperative program

  48. My Current Work: Approach • Provide a framework to allow users to construct execution graphs • Execution graphs can be analyzed from imperative programs • Execution graphs can be invoked when there are modifications on values

  49. source int a, b; target int x, y; x = a + 1; y = a + b; An Execution Graph a b +1 a+b x y

  50. a = 1 b = 2 Forward Transformation a = 1 Mod Mod b = 2 +1 a+b x y

More Related