At the moment, we need to complete the AS (markedgraph.ecore) with the ED and EF. In the next release of the GEMOC Studio this step replaced by the use of Melange to automatically extend the AS with ED and EF.

The ED and EF are already defined on the provided metamodel. Thus, there is no need to add the 'runtimeTokenCount' ED on Place, 'fire()' on Transition and 'initialize()' on MarkedGraph.

Figure 4.1. Abstract Syntax of MarkedGraph extended with Execution Data (ED) and Execution Functions (EF)

In the Project Explorer, right click on any file of the xDSML project and choose GEMOC Languge > Create DSA Project for language to start the wizard.

Figure 4.2. Create a DSA Project

The wizard first add for the language: select 'MarkedGraphL' and click OK. On the next screen, the project name is already initialized. Click 'Finish' and the 'org.gemoc.sample.markedgraph.k3dsa' is created and the Melange file is completed with references to aspects implemented the ED and EF.

Figure 4.3. The Melange file with references to aspects implementing ED and EF

Open the markedgraphAspects.xtend file. It is located in the org.gemoc.sample.markedgraph.k3dsa project in src/markedgraph.aspects. The file has been initialized with a template that can be discarded and replaced with the following text.

package markedgraph.aspects

import fr.inria.diverse.k3.al.annotationprocessor.Aspect
import markedgraph.MarkedGraph
import markedgraph.Place
import markedgraph.Transition

import static extension markedgraph.aspects.PlaceAspect.*

@Aspect(className=MarkedGraph)
class MarkedGraphAspect {
	def public void initialize() {
		println("Graph " + _self.name + " initialized.")
		_self.places.forEach [ pl | pl.initialize ]
	}
}

@Aspect(className=Place)
class PlaceAspect {
	public int runtimeTokenCount

	// @Helper
	def public void initialize() {
		println("Place " + _self.name + ": initialized.")
		_self.runtimeTokenCount = _self.tokenCount
	}
}

@Aspect(className=Transition)
class TransitionAspect {
	def public void fire() {
		println("Transition " + _self.name + ": fired.")
		_self.inputs.forEach[ runtimeTokenCount = runtimeTokenCount - 1 ]
		_self.outputs.forEach[ runtimeTokenCount = runtimeTokenCount + 1 ]
	}
}

Figure 4.4. Definition of the DSA (ED and EF)

There is an error in the Melange file because no aspect has been defined on the NamedElement metaclass. Just comment out the corresponding line.

Figure 4.5. Corrected Melange file

Like for the DSA Project, right click on any file of the xDSML project and choose GEMOC Languge > Create DSE Project for language to start the wizard.

Figure 4.6. Create a DSE Project

Then :

Figure 4.7. Initializing the DSE project

Once the wizard has been completed, the org.gemoc.sample.markedgraph.dse project is created with a template for the MarkedGraphL.ecl file (found in the ecl directory).

Figure 4.8. Template of the ECL file

Replace the content of the ECL file with the following code (explanations on this code are given bellow):

The file MarkedGraphL.ecl. 

import 'platform:/resource/org.gemoc.sample.markedgraph.model/model/markedgraph.ecore'

ECLimport "platform:/plugin/fr.inria.aoste.timesquare.ccslkernel.model/ccsllibrary/kernel.ccslLib"
ECLimport "platform:/plugin/fr.inria.aoste.timesquare.ccslkernel.model/ccsllibrary/CCSL.ccslLib"

package markedgraph

	context MarkedGraph
		def: initIt: Event = self.initialize()

	context Transition
		def: fireIt: Event = self.fire()

	context Place
		inv tokenCountIsNull:
			(self.tokenCount = 0) implies
				(Relation Precedes(self.input.fireIt, self.output.fireIt))
		inv tokenCountIsNotNullDelayRequired:
			(self.tokenCount > 0) implies
				let delay: Integer = self.tokenCount in
				let outputDelayed: Event =
					Expression DelayFor(self.output.fireIt, self.output.fireIt, delay) in
						Relation Precedes(self.input.fireIt, outputDelayed)

	context MarkedGraph
        inv initFirst:
                let firstInit : Event = Expression OneTickAndNoMore(self.initIt) in
                let allFire : Event = Expression Union(self.transitions.fireIt) in
                let firstOfAllFire : Event = Expression OneTickAndNoMore(allFire) in
                Relation Precedes(firstInit, firstOfAllFire)

        inv onlyOneInit:
                let firstInit2 : Event = Expression OneTickAndNoMore(self.initIt) in
                Relation Coincides(self.initIt, firstInit2)

endpackage

Figure 4.9. Definition of the DSE (events and constraints)

This step has three main purposes:

Rigth-click on any file of the org.gemoc.sample.markedgraph.xdsml project and select GEMOC Language > Create Animator Project for language.

Figure 6.1. Launch the Animator wizard

On the first screen of the wizad, select "Extends an existing diagram description".

Figure 6.2. Select "Extends an existing diagram description"

Select the viewpoint to extend "MarkedGraph diagram".

Figure 6.3. Select the viewpoint to extend

Finally, we can fill in the Project Name in which the newly creating viewpoint file will take place (org.gemoc.sample.markedgraph.animation), the name of the viewpoint file (markedgraph-animation.odesign), the viewpoint name (MarkedGraphAnimationViewpoint) and the diagram name (MarkedGraphAnimation).

Figure 6.4. Information of the animation viewpoint

The last screen allows to choose the name of the layer to be created. Debug is a good name.

Press Finish to create the project. The markedgraph-animation.odesign file is opened.

Open the markedgraph-animation.odesign file and unfold its content.

Figure 6.5. Initial makedgraph-animation.odesign file

To be able to complete the definition of the odesign file, we first need to load the existing markedgraph.odesign as a resource :

Perform the same action as above to set the background color of places to yellow.

You have to select the first element named "ecliple white" (the second one is used to diplay the name).

First of all, we need to restart (File > restart) the MarkedGraph Modeling Workbench to take into account the modifications of the MarkedGraph xDSML.

Right click on wikipedia.aird and select Viewpoints Selection. If Viewpoints Selection is not in the menu, double-click on the file wikipedia.aird.

Select Viewpoint Selection. 

Select MarkedGraphAnimationViewpoint. 

You can now open the wikipedia graphical representation (wikipedia.air / Representation per category / markedgraph / MarkedGraph diagram / wikipedia MarkedGraph diagram). On the visualization, all places should be with a yellow background.

Open the "run wikipedia example" configuration" (Debug > Debug Configuration…​). Complete the "Animator" field with "/org.gemoc.sample.markedgraph.sample/wikipedia.aird" (use Browse to select it).

First, we will create a run configuration. Select "run / run Configurations"

We can now run the "gemoc" configuration (using debug). It opens the different views we have already seen but also the graphical visualization on the model.

On the "Mapping Based Decoration Enabled breakpoint" and "Mapping Based Decoration Disabled breakpoint" of the "Debug" layer, under "Decorations" element, select the "Place" and "Transition" element. Change "Position" to "North East".

It indicates that a breakpoint can be enabled or disabled on Place and Transition elements of a MarkedGraph model. It will be graphically shown as icon displayed in the corresponding graphical element, at the nort east.

In both mappings, change the directory of the icon from "org.gemoc.executionframework.extensions.sirius" to "org.gemoc.gemoc_heterogeneous_modeling_workbench.ui". Do the same change for the icons of "Operation Action Debug" and "Operation Action Toggle breakpoint".

For explanations on how to use the MoCCML editor, please refer to the GEMOC manual.

We first define the declaration of a relation (placeReadWrite). Here after is its graphical representation. This relation is parameterized by the r clock (some one how wants to read a token), the w clock (someone how wants to write a token, and n the initial count of token in the place).

Figure 8.1. Graphical declaration of the placeReadWriteDef relation

Then we can define this relation. Here after is the resulting automaton. The local variable count represent the number of tokens in this place. s0 is the initial state. The action on the transition from s0 to s initialize count with n (the parameter). The two reflexive transitions on s explain what happens when w or r occurs. The write transition is fired when w occurs and a token is assed in the place (count is incremented). The read transition is fired when r occurs. It removes a token and thus decrements count. A guard prevents the read transition to be fired if there is not at liste one token in the place (count >= one).

Figure 8.2. Automaton defining the placeReadWriteDef relation.

Here is the textual representation of this constraint automata.

Textual representation of the constraint automata. 

AutomataConstraintLibrary markedgraph{
	import "platform:/plugin/fr.inria.aoste.timesquare.ccslkernel.model/ccsllibrary/kernel.ccslLib" as kernel;
	import "platform:/plugin/fr.inria.aoste.timesquare.ccslkernel.model/ccsllibrary/CCSL.ccslLib" as ccsl;

	RelationLibrary placeLib {

		AutomataRelationDefinition placeReadWriteDef[placeReadWrite]{

			variables {
				Integer MAX = 10
				Integer count = 0

			}

			init: s0

			from s0 to s : init
			-> (do count = n.value)

			from s to s : read
			-> ( when r if( count >= one) do count = (count - one))

			from s to s : write
			-> ( when w do count = (count + one))

			State s0 (out : init)
			State s( in : read, write, init
				out : write, read
			)

		}

		RelationDeclaration placeReadWrite(r:clock, w: clock, n: int)
	}
}