Executable Runtime Megamodels


With this project, we propose the seamless model-driven engineering approach, called EUREMA (Executable Runtime Megamodels), for modeling, executing, adapting, and evolving self-adaptive software.


Self-adaptive software is often split into two parts: an adaptation engine implementing a feedback loop to control the underlying adaptable software. EUREMA aims at the engineering of adaptation engines with multiple feedback loops. Individual feedback loops may address different concerns such as self-optimization or self-healing or they may even operate on top of each other in a layered architecture. Such layered architectures are required for realizing adaptive or hierarchical control schemes, in which a higher-layer feedback loop controls a lower-layer feedback loop. Moreover, EUREMA supports off-line adaptation by means of changes induced and controlled by humans to enable the long-term evolution of the self-adaptive software.

Therefore, EUREMA provides a modeling language for feedback loops, the coordination of feedback loops, and the adaptation engine, as well as an interpreter for EUREMA models to execute the feedback loops.

Modeling Language

The EUREMA modeling language provides two types of diagrams. A Feedback Loop Diagramm (FLD) to specify feedback loops and a Layer Diagram (LD) to specify the structuring of feedback loops in the adaptation engine.

Feedback Loop Diagramms (FLD)

Using FLDs, feedback loops employing runtime models can be explicitly specified by capturing the flow of adaptation activities, such as MAPE, that operate on runtime models. Thus, EUREMA considers adaptation activities as model Operations that are linked with each other by Control flow relationships. Such operation take Models as input or output, which is made explicit by Model usage relationships. These main concepts are reflected in the concrete syntax for FLDs:

FLD Syntax

Initial and final states are special operations that define the entry and exit points for executing a feedback loop instance. A destruction state is a final state that destroys the feedback loop instance when this state is reached. Adaptation activities are specified as model operations represented by hexagon block arrows labeled with their names. A model operation has at least one named exit compartment, one for each return status of the operation. At runtime, the implementation of the operation determines the return status and therefore, which compartment is activated to continue the control flow. Complex model operations abstract from and invoke adaptation activities modeled in other FLDs. The control flow between operations is specified by solid arrows and can be exclusively branched by a decision node (diamond element) and conditions. Such conditions use generic information about EUREMA concepts to branch the control flow while the different exit compartments of operations may depend on information only known internally to user-defined runtime models and operation implementations. Model operations work on runtime models represented by rectangles and the usage of models as input or output is depicted by dotted arrows. Finally, an FLD model can be used as a runtime model within another FLD, which is relevant for layering feedback loops in layered architectures.

The following figures show example FLDs that specify the analysis activities of a self-repair feedback loop (left hand side) and a self-repair feedback loop invoking the analysis activities by a complex model operation (right hand side):


Layer Diagrams (LD)

Having modeled individual feedback loops, these feedback loops are placed in an adaptation engine. Therefore, EUREMA proposes the layer diagram that provide an architectural view of the self-adaptive software. This view refers to an instance situation of the software and it captures the employed feedback loops, their relationships to each other and to the adaptable software, and their triggering conditions. Therefore, an LD structures the self-adaptive software into layers containing modules and relationships among modules.  The detailed concepts are reflected by the concrete syntax for LDs:

LD Syntax

The partitions in an LD represent the layers of the self-adaptive software, which contain modules. An instance of an FLD constitutes a megamodel module that encapsulates the details of a concrete feedback loop or adaptation activities. Such a module is depicted as a package with a white tab in an LD since EUREMA provides white-box views of megamodel modules by means of the FLDs. In contrast, a package with a black tab represents software modules that are not specified by EUREMA, like an instance of the adaptable software. Sense and effect relationships between modules are reflected by dotted arrows, either labeled with r (for reading the sensed module) or w/a (for writing/annotating the effected module), respectively. A sense relationship is labeled with a triggering condition for the sensing module, which specifies when an instance of the feedback loop should be executed.
Usage relationships between megamodel modules are modeled in LDs to make the dependencies between FLDs explicit. A use relationship is reflected by a solid arrow and it is labeled with the name of an FLD element to bind this element to another FLD.

The following figure shows an example LD on the right hand side while the left hand side illustrates how an LD refers to an FLD:


More details on the EUREMA language such as the triggering conditions and its application to multiple, interacting feedback loops, layered feedback loops, and off-line adaptation can be found in [1,2].

Modeling Editor

The EUREMA modeling language has been developed for the Eclipse Modeling Framework (EMF) and the modeling editors provided by EMF are used to create and modify EUREMA models. Additionally, we are currently working on a graphical editor supporting all concepts of the EUREMA language.


For the EUREMA language we have developed an interpreter to execute the adaptation engine of a self-adaptive software. On the one hand, the interpreter executes feedback loops as they are specified by FLDs. On the other hand, it maintains the LD as a reflection model of the self-adaptive software, particularly to adjust the adaptation engine such as adding or removing feedback loops from the adaptation engine. The interpreter supports the execution of multiple and layered feedback loops and it leverages off-line adaptation by providing an interface for changes induced and controlled by humans.

Keeping FLDs and the LD alive at runtime, they become runtime models, which provides the flexibility to adjust the adaptation engine at runtime. The interpreter is able to cope with dynamic changes of the EUREMA models.

The interpreter implementation is based on EMF though the interpreter works in a standalone mode. Thus, it is not required having the complete Eclipse workbench available in order to execute EUREMA models. This supports embedding the interpreter into a self-adaptive system for using the interpreter on-line.

Status and Availability of the Language, Editor, and Interpreter

The EUREMA language, editor, and interpreter have been employed to academic case studies for self-adaptive software, e.g., to mRUBiS as the adaptable software. They are currently enhanced and elaborated to cover further concepts of self-adaptive software, like incrementally making a system self-adaptive. Thus, they are available on request. Please contact us for further information.


  1. Thomas Vogel and Holger Giese. Model-Driven Engineering of Self-Adaptive Software with EUREMA. ACM Trans. Auton. Adapt. Syst. 8(4):18:1-18:33, 1 2014.
    (Up-to-date discussion of EUREMA)
  2. Thomas Vogel and Holger Giese. Model-Driven Engineering of Adaptation Engines for Self-Adaptive Software: Executable Runtime Megamodels. Technical Report 66, Hasso Plattner Institute for Software Systems Engineering, University of Potsdam, Germany, 4 2013.
    (Comprehensive discussion of EUREMA, partially superseded by [1])
  3. Thomas Vogel and Holger Giese. A Language for Feedback Loops in Self-Adaptive Systems: Executable Runtime Megamodels. In Proceedings of the 7th International Symposium on Software Engineering for Adaptive and Self-Managing Systems (SEAMS 2012), pages 129-138, 6 2012. IEEE Computer Society.
    (Initial proposal of EUREMA)
  4. Thomas Vogel and Andreas Seibel and Holger Giese. The Role of Models and Megamodels at Runtime. In Juergen Dingel and Arnor Solberg, ed., Models in Software Engineering, Workshops and Symposia at MODELS 2010, Oslo, Norway, October 3-8, 2010, Reports and Revised Selected Papers, vol. 6627of Lecture Notes in Computer Science (LNCS), pages 224-238. Springer-Verlag, 5 2011.
    (Motivates and discusses the use of megamodels at runtime; extends [5])
  5. Thomas Vogel and Andreas Seibel and Holger Giese. Toward Megamodels at Runtime. In Nelly Bencomo and Gordon Blair and Franck Fleurey and Cedric Jeanneret, ed., Proceedings of the 5th International Workshop on Models@run.time at the 13th IEEE/ACM International Conference on Model Driven Engineering Languages and Systems (MoDELS 2010), Oslo, Norway, volume 641 of CEUR Workshop Proceedings, pages 13-24, 10 2010. CEUR-WS.org. (best paper)
    (Motivates and discusses the use of megamodels at runtime)

Project Team

Related MDELab Tools

Comments are closed.