GEMOC Studio V2.0.1

Major release.

Eclipse package (click to expand)

Download the Eclipse IDE package (~550Mo)

GEMOC Studio 2.0.1 (2016/01/13)

This software is provided for all major OS: Windows 32 and 64 bit, Linux 32 and 64 bit and Mac OS X.

The GEMOC Studio contains components supporting the GEMOC methodology for building and composing executable DSMLs.

It includes the two workbenches:

The GEMOC Language Workbench, intended to be used by language designers: it allows building and composing new executable DSMLs.
The GEMOC Modeling Workbench, intended to be used by domain designers: it allows creating and executing, debugging and animating models conformant to executable DSMLs.

1. New and noteworthy

The purpose of this section is to highligth some of the work done on the GEMOC Studio between the v1.0 and the v2.0.

1.1 Migration & Refactoring

Since the 1.0 version, the GEMOC studio source code was migrated from the INRIA forge to a public organization on Github : https://github.com/gemoc

A refactoring was done to separate the multiple existing components to address the following complementary and incremental scenarios:

Model debugging
Concurrency modeling & analysis
Behavioral coordination

1.1.1 Model debugging

Model debugging regroups the GEMOC studio components used to provide the sequential execution, the trace management capability and the animation. These components help to bring execution and simulation in domain specific tooling built with Sirius and Eclipse Modeling Framework. These components were published on the SiriusLab Github repository : https://github.com/SiriusLab/

Generic execution engine: in this version it is possible to use a method with the @InitializeModel in order to initialize the model before its execution.
Generic animation framework : In this new version, it is now possible to contribute the variable changes to the variable view in debug mode. There is no more need to defined by hand the mapping between the execution engine and the dynamic data, it is now automatically provided by the animation framework.
Trace management : To provide efficient and adapted execution trace management facilities, it is now possible to generated a multidimensional and domain-specific trace metamodel for the considered sequential xDSML defined using Kermeta. This option is available in the language workbench by right-clicking on the xdsml file of a sequential xDSML, and by selection “Generate Trace Addon Project”. A new Eclipse plugin is then created containing the trace metamodel as an ecore file, along with corresponding generated Java code, and with a dedicated trace manager that provides a selection of services to construct a trace, query a trace, and restore the executed model in a previous state. This generated eclipse plugin is also a GEMOC Engine Addon that can be used in the modeling workbench to capture an execution trace, and to enable Omniscient Debugging features (see dedicated section). It can be enabled as any other addon in the Run Configuration of a model.
Omniscient debugging : If a trace addon was generated for a sequential xDSML, and is made available in the modeling workbench, then Omniscient Debugging facilities are automatically enabled when a model is executed with the trace addon. These new facilities allow to explore the previous states of a model during its execution. There are two ways to use these backward facilities. First, the Multidimensional Timeline view provides an interactive representation of the execution trace being captured. When double-clicking on a previous state represented in the timeline, the model is brought back into this state. Moreover, the timeline represents all the different dimensions captured in a trace, each being the sequence of values taken by one specific element of the model. When double-cliking on a value that was reached by an element, the complete model is brought back in the state corresponding to this value. Second, the Eclipse debugging view of the GEMOC Studio possesses additional buttons in the toolbar to go backward in an execution. They provide the following actions: backInto, backOver and backOut. All these actions behave similarly to their forward counterparts, but follow execution steps in the opposite direction.

1.1.2 Concurrency modeling and analysis

The concurrency modeling and analysis features are based on the model debugging components and on other specific components :

MoCCML: the Model of Concurrency and Communication Modeling Language is a metalanguage dedicated to the specification of constraints between some events. These constraints reflect the causal, concurrent and temporal aspect of the operational semantics of a language.
ECL: the Event Constraint Language is a lightweight extension of OCL (Object Constraint Language) with the notion of event and with behavioral invariant. The Event are used to define the DSE and the behavioral invariants are used to constraint the partial ordering of the DSE. These constraints are defined in MoCCML.
Gemoc Events Language (GEL): metalanguage used to specify the Communication Protocol between the MoCC and the DSA of a Concurrency-aware xDSML. The GEMOC Studio integrates a textual editor for GEL (based on Xtext), its model-level target language (microGEL) and the compiler to unfold a GEL specification for a specific model.
Timesquare: TimeSquare is an MDK (Model Development Kit) provided as a set of Eclipse plugins that can be downloaded or installed over an existing Eclipse. TimeSquare is based on the formal Clock Constraint Specification Language (CCSL), which allows the manipulation of logical time. Logical time is a relaxed form of time where any events can be taken as a reference for counting (e.g. do something every 30 openings of the door). It can be used for specifying classical and multiform real-time requirements as well as formally specifying constraints on the behavior of a model (either a UML-based or a DSL model). TimeSquare can solve these constraints to conduct a simulation or to construct the state space representing all possible partial orders of the clocks (if finite).
Concurrent execution engine: The concurrent execution engine allows to simulate conjointly heterogeneous models. More precisely, based on a coordination model (usually generated from a BCOoL specification), it starts and coordinates the execution engine of each models that are part of the coordination. It results an execution where the different model interacts to provide an emerging behavior according to the coordination.
Analysis tool : The Clocksystem exhaustive exploration tool was contributed to the GEMOC Studio. The code generator to create the exploration file was updated. Finally, some plugins dedicated to the Clocksystem service calls were integrated to the studio.

1.1.3 Behavioral coordination

The last scenario supported by the GEMOC Studio is the ability to specify behavioral coordination of possibly heterogeneous models. This is done thanks to a coordination framework based on:

BCOol : a (meta)language to capture behavioral coordination patterns between DSMLs. It is a dedicated language to system designer that eases the understanding and adaptation of coordination patterns. By instantiating a coordination pattern, models can be automatically coordinated. The generated coordination conforms to a formal language, i.e., MOCCML, thus enabling the verification and validation of the coordinated system. While the GEMOC studio supports several facilities, e.g., editing, graphical representation, animation and execution of domain-specific tools, BCOoL adds coordination facilities.
Coordination Engine : a dedicated launcher allows to start heterogeneous models and coordinate their execution according to BCOoL patterns

1.2 GEMOC Discovery catalog

In order to reduce the size of the GEMOC Studio, a new discovery catalog feature was developed. This component provides a simplified UI to allow the installation of additional components in the studio. The installable components catalog is hosted on the GEMOC github repository : https://github.com/gemoc/gemoc-studio/blob/master/gemoc_studio/discovery/catalog.xmi

The UI is accessible to the GEMOC Studio end user from the toolbar menu and shows for each component referenced in the catalog its name, a small description, a website URL, a screenshot. To install a new component the end user just need to select the component and click on the Install button.

1.3 Documentation update

The documentation of the studio is available :

on Github : http://gemoc.github.io/gemoc-studio/
in the Gemoc Studio bundle : Help > Help Contents > GEMOC Studio

The documentation contains a User Guide and the tutorials.

1.4 Tutorials update

The tutorials were updated and are available on :

http://gemoc.github.io/gemoc-studio/publish/tutorials/html_single/TutorialMain.html

The Marked Graph tutorial was reviewed to fixed some issues :

http://gemoc.github.io/gemoc-studio/publish/tutorial_markedgraph/html_single/GuideTutorialMarkedGraph.html

and a new tutorial presenting the SigPML example was contributed :

http://gemoc.github.io/gemoc-studio/publish/tutorial_sigpml/html_single/Tutorial_SigPML.html

1.5 Sample update

The samples integrated to the GEMOC Studio were updated.

Additionally some more advanced examples are publicly available on the organization repository https://github.com/gemoc:

Arduino Modeling : https://github.com/gemoc/arduinomodeling : a sequential language that simulates Arduino components
DSL for Activity Diagram : https://github.com/gemoc/activitydiagram : several implementations of the Activity Diagram from FUML. (it features both concurrent and sequential versions)
Farming Modeling : https://github.com/gemoc/farmingmodeling : a DSL that simulates a farm. It uses a sequential engine.

2. Package description