While MOF constitutes a standardized and widely accepted language for formally defining a modeling language's abstract syntax, no standardized language for specifying its behavioral semantics exists. This impedes the efficient development of tools which build upon the behavioral semantics of modeling languages, such as model interpreters, debuggers, and testing environments. To address this shortcoming, we propose to adopt the standardized action language fUML as semantics specification language in metamodeling. In this paper we present tool support integrated with the EMF environment for specifying the behavioral semantics of modeling languages with fUML as well as for executing models based on these specifications. A teaser for the demonstration of this tool support can be found at http://www.youtube.com/watch?v= p4alBfqbjk8.
In model-driven engineering (MDE), models constitute the central artifacts in the
software development process. Thus, the success of MDE depends significantly on the
availability of adequate tool support for creating, exploring, analyzing, and utilizing
models. To develop such tools efficiently, modeling languages (i.e., their syntax and
semantics) have to be defined formally [
Due to this lack of a standardized language for specifying the behavioral
semantics of modeling languages, we investigated whether the standardized action language
fUML [
In Section 2 we give an overview of our metamodeling language xMOF. In Section 3 we present our methodology for developing semantics specifications and executing models based on xMOF and its tool support in EMF. In Section 4 we give an overview of the tool demonstration. Finally, in Section 5 we conclude this paper. 2
Semantics Specification Language xMOF
fUML [
For integrating fUML with existing metamodeling languages in order to enable
the specification of the behavioral semantics of modeling languages we identified two
strategies [
The metamodel of xMOF is depicted in Figure 1. For integrating Ecore with the behavioral part of fUML we introduced the metaclasses BehavioredEClassifier, BehavioredEClass, MainEClass, and BehavioredEOperation. The metaclass BehavioredEClassifier is a subclass of EClassifier and can own Behaviors in terms of Activities. BehavioredEClass is a concrete subclass of BehavioredEClassifier and EClass and can therefore own Activities. The class MainEClass is introduced to distinguish one BehavioredEClass in a semantics specification as the main class controlling the execution of a model conforming to the modeling language. We also introduced a subclass of EOperation called BehavioredEOperation whose behavior can be defined by an Activity. 3
With xMOF it is possible to define the abstract syntax and the behavioral semantics of modeling languages. To foster the systematic and efficient development of behavioral semantics specifications using xMOF, as well as the utilization of these specifications 1 The metamodel of xMOF, the source code of our tool support, as well as demos and case studies can be found at our project website http://www.modelexecution.org.
EClassifier
EClass eOperations *
EOperation BehavioredClassifier
BehavioredEClass
MainEClass
BehavioredEOperation specification 0..1 ownedBehavior * classifierBehavior 0..1
Behavior
* method Activity node * edge *
ActivityNode ActivityEdge
for executing models, we elaborated a dedicated methodology which is accompanied by EMF-based tool support. An overview of our methodology is depicted in Figure 2.
In the semantics specification, the behavioral semantics of a modeling language is developed starting from its Ecore-based metamodel. The behavioral semantics is defined in an own artifact called xMOF-based configuration which is automatically initialized. In this initialization one subclass (BehavioredEClass) of each metaclass defined in the metamodel is generated. They are called configuration classes and can be extended with additional attributes, references, operations, and activities for specifying the behavioral semantics of the metaclasses. Also additional configuration classes can be defined. Furthermore, one BehavioredEClass called Initialization is generated which can be used to define supplementary data that is necessary as additional input for executing models based on this semantics specification. This class can be extended with attributes, references, and additional contained classes called initialization classes.
In the model execution preparation, preparatory tasks for executing a model according to the xMOF-based behavioral semantics specification of the used modeling language are carried out. In EMF, models consist of instances of the metaclasses defined in the Ecore-based metamodel of the used modeling language. As the semantics of these metaclasses is defined by the operations introduced in the configuration classes, the model to be executed has to be represented in terms of instances of the respective configuration classes. This representation is called xMOF-based model and is generated automatically. The supplementary data needed as input for executing a model defined by the initialization classes has to be instantiated manually by the modeler.
The xMOF-based model can be executed by leveraging the fUML VM (model
execution). Therefore, it is automatically converted into an fUML-based model conforming
to the format required by the fUML VM. During the execution the fUML VM interprets
the activities specifying the behavioral semantics of the modeling language and
manipulates the fUML-based model accordingly. The result of the execution consists of the
manipulated fUML-based model (fUML extensional values) representing the runtime
state of the executed model after the execution finished. For enabling its visualization
model annotations are generated for the executed model. For this we make use of EMF
Profiles [
Semantics Specification Ecore-based Metamodel
Generate xMOF-based
Configuration Model Execution Preparation
Model Model Execution xMOF-based
Model MCoodnefl MIonditel xMOF-based Configuration [complete] Conf Init Classes Classes
Tramsform xMOF- to fUMLbased Model xMOF-based Configuration
[initial] Conf Init Classes Classes
Specify Semantics xMOF-based Configuration [complete] Conf Init
Classes Classes Instantiate xMOF Conf Classes Instantiate xMOF Init Classes xMOF-based
Model MCoodnefl MIonditel
Caption:
Artifact Manual
Task Automated
Task in/out relation fUML-based
Model
Execute Model
fUML Extensional
Values
Transform Execution Result
Execution
Result Annotations
In the demonstration of our tool support for specifying the behavioral semantics of modeling languages, we will develop a Petri Net modeling language (PNML) following the methodology introduced in Section 3. We will showcase how the following tasks are accomplished using our EMF-based tool support: (i) initialization of the xMOF-based configuration from the Ecore-based metamodel of PNML, (ii) specification of the behavioral semantics of PNML by extending the xMOF-based configuration, (iii) execution of PNML models based on the xMOF-based configuration of PNML.
The Ecore-based metamodel of PNML (cf. Figure 3a) defines that a Net consists of Places and Transitions whereas a Transition is associated with at least one input and one output Place. The xMOF-based configuration of PNML (cf. Figure 3b) consists of the configuration classes NetConfiguration, PlaceConfiguration, and TransitionConfiguration generated for the metaclasses of PNML. For the configuration class TransitionConfiguration the operation fire() was introduced whose behavior is specified by the activity depicted in Figure 3c. This activity specifies that for the output places of a transition the operation addToken() is called while for the input places removeToken() is invoked. Furthermore, the initialization class Token was introduced which has to be used for defining the initial token distribution in the net to enable the executing of a PNML model.
We have presented the metamodeling language xMOF integrating fUML with Ecore. It enables to define the behavioral semantics of modeling languages in an operational way. Furthermore, we gave an overview about our methodology for developing xMOFbased semantics specifications and utilizing them for model execution and we presented accompanying tool support for EMF.
To evaluate the applicability of our semantics specification approach, we carried out several case studies in which we developed the behavioral semantics specifications of distinct modeling languages and utilized these specifications to execute conforming models using the implemented tool support. In summary, the case studies confirmed that xMOF, its accompanying methodology, and its tool support are applicable for defining the behavioral semantics of different kinds of modeling languages. Regarding the suitability of fUML as semantics specification language, we come to the conclusion that due to its object-oriented and imperative nature, fUML is highly suitable.