Wiki source code of SCCharts Development

Version 21.1 by ssm on 2016/04/22 14:56
Hide last authors
ssm 7.1 1 {{layout}}
2 {{layout-section ac:type="single"}}
3 {{layout-cell}}
ssm 5.1 4 This is a light-weight tutorial for developing additions for SCCharts in KIELER. It will use Eclipse, EMF, and Xtend and therefore, finishing the corresponding tutorials could prove useful. However, they are not a strict requirement for this tutorial.
ssm 1.1 5
ssm 12.1 6
7
8 {{toc/}}
9
ssm 1.1 10 = Preliminaries =
11
12 There's a few things to do before we dive into the tutorial itself. For example, to do Eclipse programming, you will have to get your hands on an Eclipse installation first. Read through the following sections to get ready for the tutorial tasks.
13
14 == Required Software ==
15
16 As you're going to develop for KIELER SCCharts we recommend to use the semantic Oomph setup as described in [[doc:KIELER.Getting Eclipse]] (Oomph Setup). However, you could also install all componentes by yourself. Please consult the other tutorials if you want to do that. You would need to install the Modeling Tools and the Xtext SDK.
ssm 7.1 17 {{/layout-cell}}
18 {{/layout-section}}
ssm 1.1 19
ssm 8.1 20 {{layout-section ac:type="three_equal"}}
ssm 7.1 21 {{layout-cell}}
ssm 11.1 22
23
ssm 7.1 24 Additionally, install the** EcoreViz** from the **Ecore Model Visualization** category from the **OpenKieler** update site: [[http:~~/~~/rtsys.informatik.uni-kiel.de/~~~~kieler/updatesite/nightly-openkieler/>>url:http://rtsys.informatik.uni-kiel.de/~~kieler/updatesite/nightly-openkieler/||rel="nofollow" shape="rect"]]. For this, choose //Install New Software...// in the //Help// tab.
ssm 8.1 25
26 Due to the ongoing migration you have to install a workaround for EcoreViz to function. You have to install the KLighD diagram view directly from [[http:~~/~~/rtsys.informatik.uni-kiel.de/~~~~kieler/updatesite/release_pragmatics_2016-02/>>url:http://rtsys.informatik.uni-kiel.de/~~kieler/updatesite/release_pragmatics_2016-02/||shape="rect"]]. Select the features
27
28 * KIELER Lightweight Diagrams - Developer Resources and
29 * KIELER Lightweight Diagrams Generic Diagram View.
30
31 (This step should be obsolete in the near future.)
ssm 7.1 32 {{/layout-cell}}
ssm 1.1 33
ssm 7.1 34 {{layout-cell}}
ssm 11.1 35
36
ssm 7.1 37 [[image:attach:InstallEcoreViz.png]]
ssm 12.1 38
39
ssm 7.1 40 {{/layout-cell}}
ssm 8.1 41
42 {{layout-cell}}
ssm 11.1 43
44
ssm 8.1 45 [[image:attach:InstallKLighDFeatures.png]]
46 {{/layout-cell}}
ssm 7.1 47 {{/layout-section}}
48
49 {{layout-section ac:type="single"}}
50 {{layout-cell}}
ssm 1.1 51 == Recommended Tutorials ==
52
53 We recommend that you have completed the following tutorials before diving into this one (or at least sweep over them). However, this is not a strict requirement.
54
55 1. [[doc:Eclipse Plug-ins and Extension Points]]
56 1. [[doc:Eclipse Modeling Framework (EMF)]]
57 11. This tutorial needs the turingmachine.ecore and the controller you've implemented in the EMF tutorial. If you did not complete the EMF tutorial, you may download a working turing machine here... (in the future).
58 1. (((
59 (% class="with-breadcrumbs" %)
60 [[Xtend 2 - Model Transformations>>url:http://rtsys.informatik.uni-kiel.de/confluence/display/TUT/Xtend+2+-+Model+Transformations||shape="rect"]]
61 )))
62
63 == Helpful Tutorials ==
64
65 When developing within the KIELER semantics team, you will most likely be confronted with Xtext and [[doc:KIELER.Lightweight Diagrams (KLighD)]]. The following tutorials may be helpful but not required for this tutorial.
66
67 1. [[doc:Xtext 2 - Creating a Grammar from Scratch]]
68 1. [[doc:Lightweight Diagrams (KLighD)]]
69
70 == Finding Documentation ==
71
ssm 5.1 72 You can find additional documentation to the aforementioned topics in the corresponding tutorials. If you get stuck with a particular topic, please consult that tutorial. For SCCharts, you should read the SCCharts confluence page in our wiki: [[doc:KIELER.SCCharts]]
ssm 1.1 73
74 As usual, documentation often gets obsolete or wrong if not maintained regularly, so please, if you find missing, misleading, or outdated information, please let us know.
75
76 Additionally, the following list will give a short overview over the most important publications:
77
78 * (% style="color: rgb(0,0,0);" %)**Main paper:**
79 Reinhard von Hanxleden and Björn Duderstadt and Christian Motika and Steven Smyth and Michael Mendler and Joaquín Aguado and Stephen Mercer and Owen O’Brien. SCCharts: Sequentially Constructive Statecharts for Safety-Critical Applications. In (% class="cmti-10" %)Proc. ACM SIGPLAN Conference on Programming Language Design(%%) (% class="cmti-10" %)and Implementation (PLDI’14)(%%), Edinburgh, UK, June 2014. ACM. (%%)[[pdf>>url:http://rtsys.informatik.uni-kiel.de/~~biblio/downloads/papers/pldi14.pdf||shape="rect"]](% style="color: rgb(0,0,0);" %), (%%)[[talk>>url:http://rtsys.informatik.uni-kiel.de/~~biblio/downloads/talks/pldi14-talk.pdf||shape="rect"]](% style="color: rgb(0,0,0);" %), (%%)[[bib>>url:http://rtsys.informatik.uni-kiel.de/~~biblio/cgi-bin/bibcgi.cgi?key=vonHanxledenDM+14||shape="rect"]]
80 * **SLIC Compilation:**
81 (% style="color: rgb(0,0,0);" %)Christian Motika and Steven Smyth and Reinhard von Hanxleden. Compiling SCCharts—A Case-Study on Interactive Model-Based Compilation. In (% class="cmti-10" %)Proceedings of(%%) (% class="cmti-10" %)the 6th International Symposium on Leveraging Applications of Formal(%%) (% class="cmti-10" %)Methods, Verification and Validation (ISoLA 2014)(%%), volume 8802 of (% class="cmti-10" %)LNCS(%%), page 443–462, Corfu, Greece, October 2014. The (%%)[[original publication>>url:http://dx.doi.org/10.1007/978-3-662-45234-9||shape="rect"]](% style="color: rgb(0,0,0);" %) is available at (%%)[[http:~~/~~/link.springer.com>>url:http://link.springer.com/||shape="rect"]](% style="color: rgb(0,0,0);" %). (%%)[[pdf>>url:http://rtsys.informatik.uni-kiel.de/~~biblio/downloads/papers/isola14.pdf||shape="rect"]](% style="color: rgb(0,0,0);" %), (%%)[[bib>>url:http://rtsys.informatik.uni-kiel.de/~~biblio/cgi-bin/bibcgi.cgi?key=MotikaSvH14||shape="rect"]]
82 * **Theoretical Foundations:**
83 (% style="color: rgb(0,0,0);" %)Reinhard von Hanxleden and Michael Mendler and Joaquín Aguado and Björn Duderstadt and Insa Fuhrmann and Christian Motika and Stephen Mercer and Owen O’Brien and Partha Roop. Sequentially Constructive Concurrency—A Conservative Extension of the Synchronous Model of Computation. (% class="cmti-10" %)ACM Transactions on Embedded Computing(%%) (% class="cmti-10" %)Systems, Special Issue on Applications of Concurrency to System Design(%%), 13(4s):144:1–144:26, July 2014. (%%)[[pdf>>url:http://rtsys.informatik.uni-kiel.de/~~biblio/downloads/papers/tecs14.pdf||shape="rect"]](% style="color: rgb(0,0,0);" %), (%%)[[bib>>url:http://rtsys.informatik.uni-kiel.de/~~biblio/cgi-bin/bibcgi.cgi?key=vonHanxledenMA+14||shape="rect"]]
84 * **Overview and High-Level Transformations in Detail:**
85 (% style="color: rgb(0,0,0);" %)Reinhard von Hanxleden and Björn Duderstadt and Christian Motika and Steven Smyth and Michael Mendler and Joaquín Aguado and Stephen Mercer and Owen O’Brien. SCCharts: Sequentially Constructive Statecharts for Safety-Critical Applications. Technical Report 1311, Christian-Albrechts-Universität zu Kiel, Department of Computer Science, December 2013. ISSN 2192-6247. (%%)[[pdf>>url:http://rtsys.informatik.uni-kiel.de/~~biblio/downloads/papers/report-1311.pdf||shape="rect"]](% style="color: rgb(0,0,0);" %), (%%)[[bib>>url:http://rtsys.informatik.uni-kiel.de/~~biblio/cgi-bin/bibcgi.cgi?key=vonHanxledenDM+13b||shape="rect"]]
ssm 13.1 86
87
ssm 9.1 88 {{/layout-cell}}
89 {{/layout-section}}
ssm 1.1 90
ssm 9.1 91 {{layout-section ac:type="two_right_sidebar"}}
92 {{layout-cell}}
ssm 1.1 93 = The SCCharts Metamodel =
94
ssm 9.1 95 Navigate to the {{code language="none"}}models{{/code}} folder of the plugin {{code language="none"}}de.cau.cs.kieler.sccharts{{/code}}. Here, open the {{code language="none"}}sccharts.ecore{{/code}} and right-click on the {{code language="none"}}sccharts.ecore{{/code}} file and select //Visualize Ecore Model//. Since you also installed **EcoreViz** from the OpenKieler Suite, you should now see a graphical representation of the SCCharts metamodel. Every SCChart will be a model of this metamodel.
ssm 1.1 96
ssm 14.1 97 To see all class information check //Attributes/Literals// in the Diagram Options on the right.
98
ssm 15.1 99 EcoreViz gives you an overview over the selected Ecore diagram. However, Ecore model definitions may depend on other Ecore definitions that are not displayed in the diagram. You can open new diagrams for these Ecore files as described before or use the Ecore tree editor to inspect all classes.
100
ssm 1.1 101 Try to understand most parts of the metamodel. You don't have to understand every detail but you should get the idea.
102
103 ==== Model Task ====
104
ssm 9.1 105 1. Answer the following questions
106 11. How do you describe a superstate in the model?
ssm 16.1 107 11. Outline the relationship between states, regions, transitions, and valued objects.\\
108 11. Name the class of the root element of an SCChart.
ssm 9.1 109 11. What is a valued object?
110 11. How do you get the type of an interface variable?
111 11. What other metamodels are needed for the SCCharts metamodel and write down which one is needed for what?
112 1. Write down (on paper, text editor, etc) how the following SCChart models look like
113 11. Open the wiki page that explains the [[doc:KIELER.Textual SCCharts Language SCT]].
114 11. Search the //SCChart, Initial State, State, Transition and Immediate Transition //example and ...
ssm 5.1 115 111. write down (on paper or text editor, etc) how the model of that SCChart looks like.
116 111. The user now marks C as final. What has to be changed in the model? What semantic problem do you see?
ssm 9.1 117 11. Now, navigate to the //Super State: Strong Abort Transition //example. Write down (on paper) how the model of that SCCharts looks like.
ssm 5.1 118 11. And finally a more sophisticated model: Write down the model of ABO (from [[doc:KIELER.Examples]]).
ssm 4.1 119
ssm 9.1 120
121
122 {{info title="KLighD Screenshots"}}
ssm 17.1 123 By the way: You can //right-click// on the Diagram View surface and select //Save as image...// to create a screenshot!
ssm 9.1 124 {{/info}}
125 {{/layout-cell}}
126
127 {{layout-cell}}
128 [[image:attach:sccharts_metamodel.png]]
129
ssm 15.1 130 [[image:attach:sccharts_metamodel_treeEditor.png]]
ssm 9.1 131
132 [[image:attach:KLighDSaveAsImage.png]]
133 {{/layout-cell}}
134 {{/layout-section}}
135
136 {{layout-section ac:type="single"}}
137 {{layout-cell}}
ssm 4.1 138 = Creating SCCharts Models Programmatically =
139
140 == Creating a Test Project ==
141
142 We need a project for testing. Do the following:
143
ssm 18.1 144 1. If you used the standard KIELER Oomph installation setup, create a new Working Set named Tutorial in the Package Explorer. Then...
ssm 4.1 145 1. Create a new empty //Plug-In Project//.
146 1. Add the project that contains the sccharts metamodel as a dependency of your new project through the //Plugin Manifest Editor//.
147 1. Create a simple Java class that implements a main method. Hint: In a new Java class, simply type main and hit Ctrl+Space. Eclipse content assist will create the method for you.
148
149 == Creating a Model ==
150
ssm 18.1 151 To create a model programmatically you cannot directly use the Java classes generated for the model. Instead, the main package contains interfaces for all of your model object classes. The {{code language="none"}}impl{{/code}} package contains the actual implementation and the {{code language="none"}}util{{/code}} package contains some helper classes. Do not instantiate objects directly by manually calling {{code language="none"}}new{{/code}}. EMF generates a Factory to create new objects. The factory itself uses the singleton pattern to get access to it:
ssm 4.1 152
153 {{code language="java"}}
154 SCChartsFactory sccFactory = SCChartsFactory.eINSTANCE;
ssm 19.1 155 State state = sccFactory.createState();
156 Transition transition = sccFactory.createTransition();
ssm 4.1 157 {{/code}}
158
159 Important: The SCCharts grammar is build on top of several other grammars. Therefore, not all language objects can be found in the SCCharts factory. For example, all expression elements are part of the KExpressions grammar and hence, have their own factory. If you need other factories, don't forget to add the corresponding plugin to your plugin dependency list.
160
161 {{code language="java"}}
162 KExpressionsFactory kFactory = KExpressionsFactory.eINSTANCE;
ssm 18.1 163 BoolValue boolValue = kFactory.createBoolValue();
ssm 4.1 164 {{/code}}
165
166 For all simple attributes, there are getter and setter methods:
167
168 {{code language="java"}}
ssm 19.1 169 state.setId("Init");
ssm 4.1 170 boolValue.setValue(true);
171 {{/code}}
172
173 Simple references (multiplicity of 1) also have getters and setters:
174
175 {{code language="java"}}
176 transition.setTrigger(boolValue);
177 {{/code}}
178
179 List references (multiplicity of > 1) have only a list getter, which is used to manipulate the list:
180
181 {{code language="java"}}
ssm 18.1 182 state.getOutgoingTransitions().add(transition);
ssm 4.1 183 {{/code}}
184
ssm 18.1 185 {{info title="Plugin Dependencies"}}
186 You may have noticed that is was not necessary to add a dependency for the kexpressions classes. The SCCharts plugin reexports the dependencies of the other EMF metamodels. Look at the plugin.xml in the SCCharts plugin in the dependency tab for more information.
187 {{/info}}
188
ssm 4.1 189 == Saving a Model ==
190
191 EMF uses the [[Eclipse Resource concept>>url:http://help.eclipse.org/juno/topic/org.eclipse.platform.doc.isv/guide/resInt.htm?cp=2_0_10||rel="nofollow" shape="rect" class="external-link"]] to save models to files and load models from files. It can use different //Resource Factories// that determine how exactly models are serialized. We will use the [[XMIResourceFactoryImpl>>url:http://download.eclipse.org/modeling/emf/emf/javadoc/2.8.0/org/eclipse/emf/ecore/xmi/impl/XMIResourceFactoryImpl.html||rel="nofollow" shape="rect" class="external-link"]] to save our models to XML files:
192
193 1. (((
ssm 19.1 194 Add a dependency to the {{code language="none"}}com.google.inject, org.eclipse.core.resources, {{/code}}and{{code language="none"}} de.cau.cs.kieler.sccharts.text{{/code}} plug-ins.
195
196 {{info title="Additional Dependencies"}}
197 Don't worry. You will be experienced enough to add mandatory dependencies quickly in the future. However, for now just add the dependencies to proceed with the tutorial.
198 {{/info}}
199 )))
200 1. (((
ssm 4.1 201 Use something like the following code to save the model from above:
202
203 {{code language="java"}}
204 // Create a resource set.
205 ResourceSet resourceSet = new ResourceSetImpl();
206
ssm 19.1 207 // Register the resource factory -- only needed for stand-alone!
208 SctStandaloneSetup.doSetup();
209
210  
ssm 4.1 211 // Get the URI of the model file.
212 URI fileURI = URI.createFileURI(new File("myABO.sct").getAbsolutePath());
213
214 // Create a resource for this file.
215 Resource resource = resourceSet.createResource(fileURI);
216
217 // Add the model objects to the contents.
218 resource.getContents().add(myModel);
219
220 // Save the contents of the resource to the file system.
221 try
222 {
223 resource.save(Collections.EMPTY_MAP); // the map can pass special saving options to the operation
224 } catch (IOException e) {
225 /* error handling */
226 }
227 {{/code}}
ssm 20.1 228
229 {{info title="File Extensions"}}
230 File extensions are important! They define the parser/serializer that EMF uses. Always use the file extension that is defined for a particular model.
231 {{/info}}
ssm 4.1 232 )))
ssm 19.1 233 {{/layout-cell}}
234 {{/layout-section}}
ssm 4.1 235
ssm 19.1 236 {{layout-section ac:type="two_right_sidebar"}}
237 {{layout-cell}}
ssm 4.1 238 ==== Model Creation Task ====
239
ssm 19.1 240 You are now equipped with the fundamentals you need to create models programmatically. Let's try it:
ssm 4.1 241
ssm 19.1 242 1. The code fragments listed above do not suffice to create a grammatically correct model. Try to generate a model that corresponds with the serialized model listed on the right side.
243 11. Run the {{code language="none"}}main(){{/code}} method by right-clicking its class and selecting (% style="line-height: 1.42857;" %)//Run as//(%%) -> (% style="line-height: 1.42857;" %)//Java Application//(%%). Note that this runs your {{code language="none"}}main(){{/code}} method as a simple Java program, not a complete Eclipse application. EMF models can be used in any simple Java context, not just in Eclipse applications.
244 11. Execute the main method.
ssm 20.1 245 11. (((
246 Inspect your SCT file. (Press F5 to refresh your file view.)
247
248 {{note title="Kext Warning"}}
249 It is possible that kext generates a Null Pointer Exception when you save your model this way. This is a known issue. We're working on it. Just ignore it for now.
250 {{/note}}
251 )))
ssm 19.1 252 1. Now, create a new Java class and proceed as before to generate a model of ABO in the {{code language="none"}}main(){{/code}} method.
ssm 4.1 253 1. Start your SCChart Editor Eclipse instance and load your SCT file. KLighD should now be able to visualize your ABO correctly.
ssm 20.1 254 11. For this, open tab //Run// and select// Run Configurations...//
255 11. Create a new //Eclipse Application// and name it appropriately.
256 11. As product select {{code language="none"}}de.cau.cs.kieler.core.product.product{{/code}}.
257 11. Click //Run// (or //Debug// if you opened// Debug Configuration...//)
258 11. Create a new project and add you generated model.
ssm 19.1 259
260
ssm 18.1 261 {{/layout-cell}}
ssm 19.1 262
263 {{layout-cell}}
264 {{code language="java" title="Root.sct"}}
265 scchart Root {
266 initial state Init
267 --> Init with true;
268 }
269 {{/code}}
ssm 20.1 270
271 [[image:attach:RunConfiguration.png]]
ssm 19.1 272 {{/layout-cell}}
ssm 18.1 273 {{/layout-section}}
ssm 4.1 274
ssm 19.1 275 {{layout-section ac:type="two_right_sidebar"}}
ssm 18.1 276 {{layout-cell}}
ssm 20.1 277 = Model-to-Model Transformation with KiCo =
278
279 You can use the [[Kieler Compiler>>url:http://rtsys.informatik.uni-kiel.de/confluence/display/KIELER/Kieler+Compiler||shape="rect"]] (KiCo) to handle all the model input/output tasks and concentrate on the actual transformation. If you executed the **Model Creation Task correctly**, you should now have a complete running SCT Editor instance that looks like the one on the right. You should see the //KIELER Compiler Selection// n the lower right part of the working space. Here you can select specific transformations that will be applied to the actual model. Simply select a transformation to test it.
280
281 == Creating a new Transformation ==
282
283 Now, you're going to write your own transformation with **Xtend** *drumroll*, a programming language that looks very similar to Java, but which adds some very convenient features. Xtend code compiles to Java and and was developed using Xtext. In fact, once you gain experience working with Xtend you will probably appreciate the power of Xtext even more. Xtend is particularly useful to browse & modify EMF models. You get the point... we like it. :)
284
ssm 18.1 285
ssm 20.1 286
287 Transformation Creation Task
288
289 1. Therefore, create a new project within your tutorial working set as before.
290 1. Add plugin dependencies to {{code language="none"}}de.cau.cs.kieler.kico{{/code}} and {{code language="none"}}de.cau.cs.kieler.sccharts{{/code}}.
291 1. Create a new //Xtend class// in you package and name it "DoubleStates" and use {{code language="none"}}AbstractProductionTransformation{{/code}} as superclass.
292 1. Here, you can automatically add the missing Xtend files by using the quickfix //Add Xtend lib to class path. //Alternatively you can simply add {{code language="none"}}com.google.guava{{/code}}, {{code language="none"}}org.eclipse.xtext.xbase.lib{{/code}}, {{code language="none"}}org.eclipse.xtend.lib{{/code}}, and {{code language="none"}}org.eclipse.xtend.lib.macro{{/code}} to you plugin dependencies.
293 1. Click on //Add unimplemented methods//.
294 1. (((
295 Now, you should have a class similar to the following one.
296
297 {{code language="java"}}
298 package tutorial.transformation
299
300 import de.cau.cs.kieler.kico.transformation.AbstractProductionTransformation
301
302 class DoubleStates extends AbstractProductionTransformation {
303
304 override getProducedFeatureId() {
305 throw new UnsupportedOperationException("TODO: auto-generated method stub")
306 }
307
308 override getId() {
309 throw new UnsupportedOperationException("TODO: auto-generated method stub")
310 }
311
312 }
313 {{/code}}
314 )))
315 1. (((
316 As you can see, it is mandatory to add an id for the transformation and another id of the feature that this transformation produces. Name your transformation **tutorial.doubleStates **and the id of feature you want to produce is **sccharts.doubleStates**.
317
318 {{info title="Programming Guidelines"}}
319 You should really think about some constants here. You can also look at the sccharts transformation and features constants in the sccharts plugin.
320 {{/info}}
321 )))
322 1. KiCo must know about the new feature and also about your new transformation. 
323 11. Add a new Xtend class with Feature as superclass. Add all unimplemented methods. Also set sccharts.doubleStates as Id.
324 11. Go to the Extension tab inside your plugin configuration. 
325 111. Add a new Extension Point de.cau.cs.kieler.kico.feature. Create a new featureClass and point it to your new feature class.
326 111. Also add a new Extension Point de.cau.cs.kieler.kico.transformation. Create a new productionTransformationClass and point it to your transformation class.
327 111. Finally, you have to link your transformation to the SCT Editor. Add the Extension point de.cau.cs.kieler.kico.ui.transformation. Create an editor link and fill in the following values:
328 1111. editor: de.cau.cs.kieler.sccharts.text.sct.Sct
329 1111. features: sccharts.doubleStates
330 1111. label: Tutorial Compilation
331 1111. priority: 101
332 1111. preferred: (leave it blank)
333 11. If you start your KIELER instance now, you should get a new compilation chain which has only one transformation: yours, which doesn't do anything.
334 1. If you want to rename your feature in the Compiler Selection (without changing its Id), override the getName method and return a new name. Rename your feature appropriately.
ssm 21.1 335 1. Now, fill your transformation with life:
336 11. Inside your transformation class, add a new method with the following signature: def State transform(State rootState, KielerCompilerContext context). This transformation will be executed if the feature is selected in the Compiler Selection.
337 11. (((
338 Add thew following body to the function and try to understand the Xtend code.
ssm 20.1 339
ssm 21.1 340 {{code language="java" title="transform"}}
341 def State transform(State rootState, KielerCompilerContext context) {
342 val newState = SCChartsFactory.eINSTANCE.createState => [
343 id = "ololo"
344 label = "ololo"
345 ]
346
347 rootState.regions.filter(ControlflowRegion).head.states += newState
348
349 rootState
350 }
351 {{/code}}
352 )))
353 11. When selecting your transformation, the SCChart gets transformed and looks like the version on the right.
354 1. Extend the transformation so that each transition is split up in two and connected via a transient state meaning that the original transformation should point to the new state and a new immediate transformation then points to the original target state.
355 1. Try your new transformation with ABO. The result should look like the example on the right.
356
ssm 20.1 357
ssm 18.1 358 {{/layout-cell}}
ssm 19.1 359
360 {{layout-cell}}
ssm 20.1 361 [[image:attach:KielerSCTEditor.png]]
362
ssm 19.1 363
ssm 20.1 364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409 [[image:attach:KielerSCTEditorOwnTransformation.png]]
ssm 19.1 410 {{/layout-cell}}
ssm 18.1 411 {{/layout-section}}
412
413 {{layout-section ac:type="single"}}
414 {{layout-cell}}
ssm 4.1 415 = Transforming SCCharts =
416
417 Transformations from one model to another may be performed within the same metamodel or from metamodel to a different metamodel. Both methods are used in KIELER and in principle they do not really differ in implementation. Nevertheless, if working within the same metamodel you should keep in mind that you're potentially changing the actual model instead of changing another instance (after copying). Both is possible. Just make sure that you know what you're doing.
418
419 Now, you're going to transform the normalized form of HandleA from ABO to an SCG. The Sequentially Constructive Graph is a control-flow graph which can be seen as another representation of the same program. The SCG of the normalized version of ABO's HandleA is depicted on the right.
420
421 |(((
422 {{code}}
423 scchart ABO_norm_HandleA {
424 input output bool A;
425 input output bool B;
426 output bool O1;
427 output bool O2;
428 region HandleA:
429 initial state WaitA
430 --> _S immediate with A
431 --> _Pause immediate;
432 final state DoneA;
433 state _S
434 --> _S2 immediate with / B = true;
435 state _S2
436 --> DoneA immediate with / O1 = true;
437 state _Pause
438 --> _Depth;
439 state _Depth
440 --> _S immediate with A
441 --> _Pause immediate;
442 }
443 {{/code}}
444 )))|(((
445 [[image:attach:abo_norm_HandleA.png]]
446 )))|(% colspan="1" %)(% colspan="1" %)
447 (((
448 [[image:attach:abo_scg_HandleA.png]]
449 )))
450
451 The next figure depicts the direct mapping from normalized SCCharts to their corresponding SCG.
452
453 [[image:attach:sccharts-scg.png]]
454
455 Inspect the metamodel of the SCGs in plugin de.cau.cs.kieler.scg. SCGs are used for analyses and optimization and include a lot of additional elements. However, for this tutorial it should be sufficient to look at the SCGraph class, its nodes attribute, the important node classes and the controlflow class. Important nodes for this SCG are entry, exit, assignment, conditional,
456
457 ==== Transformation Task ====
458
459 Write a transformation that transforms your normalized version of ABO's HandleA into its corresponding SCG.
460
461 1. (((
462 **Writing a Model Transformation**
463
464 This time we want you to integrate your transformation into your SCCharts Editor instance. Therefore,...
465 (% style="color: rgb(51,51,51);line-height: 1.66667;" %)\\
466
467 1. Add a new package 
468
469 {{code language="none"}}
470 <project>.transformations
471 {{/code}} to your project.
472 1. Add an //Xtend Class// to the new package.
473 1. If you notice that your new class is marked with an error marker because of a missing dependency of the new plug-in project to 
474
475 {{code language="none"}}
476 org.eclipse.xtext.xbase.lib, 
477 {{/code}}you can hover over the error with your mouse and have Eclipse add all libraries required by Xtend to your project.
478 1.
479
480 Define an entry method for the transformation that takes an SCChart program instance as an argument and returns an SCG {{code language="none"}}Program{{/code}}. You can use the following (incomplete) method as a starting point:
481
482 (((
483 (% class="syntaxhighlighter sh-confluence nogutter java" %)
484 (((
485
486
487 |(((
488 (% class="container" title="Hint: double-click to select code" %)
489 (((
490 (% class="line number1 index0 alt2" %)
491 (((
492 {{code language="none"}}
493 /**
494 {{/code}}
495 )))
496
497 (% class="line number2 index1 alt1" %)
498 (((
499 {{code language="none"}}
500  
501 {{/code}}
502
503 {{code language="none"}}
504 * Transforms a given SCCharts program into an SCG.
505 {{/code}}
506 )))
507
508 (% class="line number3 index2 alt2" %)
509 (((
510 {{code language="none"}}
511  
512 {{/code}}
513
514 {{code language="none"}}
515 *
516 {{/code}}
517 )))
518
519 (% class="line number4 index3 alt1" %)
520 (((
521 {{code language="none"}}
522 */
523 {{/code}}
524 )))
525
526 (% class="line number8 index7 alt1" %)
527 (((
528 {{code language="none"}}
529 def SCGraph transform(State rootState) {
530 {{/code}}
531 )))
532
533 (% class="line number9 index8 alt2" %)
534 (((
535 {{code language="none"}}
536     
537 {{/code}}
538
539 {{code language="none"}}
540 // Create the SCG
541 {{/code}}
542 )))
543
544 (% class="line number10 index9 alt1" %)
545 (((
546 {{code language="none"}}
547     
548 {{/code}}
549
550 {{code language="none"}}
551 val scg = SCGraphFactory::eINSTANCE.createSCGraph()
552 {{/code}}
553 )))
554
555 (% class="line number11 index10 alt2" %)
556 (((
557 {{code language="none"}}
558   
559 {{/code}}
560 )))
561
562 (% class="line number12 index11 alt1" %)
563 (((
564 {{code language="none"}}
565     
566 {{/code}}
567
568 {{code language="none"}}
569 // TODO: Your transformation code
570 {{/code}}
571 )))
572
573 (% class="line number13 index12 alt2" %)
574 (((
575 {{code language="none"}}
576   
577 {{/code}}
578 )))
579
580 (% class="line number14 index13 alt1" %)
581 (((
582 {{code language="none"}}
583     
584 {{/code}}
585
586 {{code language="none"}}
587 // Return the transformed program
588 {{/code}}
589 )))
590
591 (% class="line number15 index14 alt2" %)
592 (((
593 {{code language="none"}}
594     scg
595 {{/code}}
596 )))
597
598 (% class="line number16 index15 alt1" %)
599 (((
600 {{code language="none"}}
601 }
602 {{/code}}
603 )))
604 )))
605 )))
606
607
608 )))
609 )))
610
611 (((
612 (% class="syntaxhighlighter nogutter java" %)
613 (((
614 There's a few points to note here:
615 )))
616 )))
617
ssm 1.1 618 \\
ssm 4.1 619
620 1.
621 1*. Lines in Xtend code don't have to and with a semicolon.
622 1*. We have been explicit about the method's return type, but we could have easily omitted it, letting Xtend infer the return type.
623 1*. The keyword 
624
625 {{code language="none"}}
626 val
627 {{/code}} declares a constant, while 
628
629 {{code language="none"}}
630 var
631 {{/code}} declares a variable. Try to make do with constants where possible.
632 1*. The methods you call should be declared as 
633
634 {{code language="none"}}
635 def private
636 {{/code}} since they are implementation details and shouldn't be called by other classes.
637 1*. You may be tempted to add a few global variables that hold things like a global input variable or a pointer to the current state. While you could to that, 
638
639 {{code language="none"}}
640 def create 
641 {{/code}}methods might offer a better alternative...
642 \\
643 1. Replace the TODO with an transformation code that takes an extended BF program and transforms it into an semantically equivalent BF program that only uses standard BF instructions. 
644 HINT: Some of the extended BF commands can only be expressed by standard operations if you can write to other cells. Therefore you are allowed to perform side effects on the tape.
645 1. Open the //Plug-In Manifest Editor// and switch to the Runtime tab. Add the package containing your transformation to the list of exported packages. (You may have to check the //Show non-Java packages// option in the //Exported Packages// dialog to see the package.)
646 \\
647 )))
648 1. **Verify your generated SCG**. If you added your transformation correctly, the SCG should be displayed automatically as soon as selected. If your SCG looks like the SCG depicted earlier, then everything is fine.
649 1. Check your SCG semantically. Is there anything you could improve/optimize? 
650 11. Write a second transformation (just as before) and add it to the transformation chain right after the transformation you already added.
651 11. Optimize the given SCG and compare the result with the previous one.
652 11. Make sure that the two SCGs are still semantically identical.
653
654 Congratulations! You finished the SCCharts Development Tutorial. Ask your supervisor for further instructions!
655
656
ssm 7.1 657 {{/layout-cell}}
658 {{/layout-section}}
659 {{/layout}}

Navigation

Quick Links

KIELER on GitHub
RTSYS Homepage