Reducing the energy consumption of a complex, especially cyber-physical, system is a cross-cutting concern through the system layers, and typically requires long feedback loops between experts in several engineering disciplines. Having an immediate automatic estimation of the global system consumption at design-time would significantly accelerate this process, but cross-layer tools are missing in several domains.Executable domain-specific modeling languages (xDSLs) can be used to design several layers of the system under development in an integrated view. By including the behavioral specification for software and physical components of the system, they are an effective source artifact for cross-layer energy estimation.In this paper we propose EEL, a language for annotating xDSL primitives with energy-related properties, i.e. how their execution would contribute to the energy consumption on a specific runtime platform. Given an xDSL, energy specialists create EEL models of that xDSL for each considered runtime platform. The models are used at design time, to predict the energy consumption of the real systems. This avoids the need of energetic analysis by deployment and measurement on all runtime platforms, that is slow and expensive.We augment an existing language workbench for xDSLs with an editor for EEL models and a component that computes energy-consumption estimations during model editing. The evaluation shows that EEL can be used to represent

Cyber-Physical Systems (CPSs) encompass both Information Infrastructures and networks of physical devices. Applications for monitoring them are usually implemented after the physical systems that they have to monitor: the CPS has to be running in order to monitor it. Monitoring applications define communications between the elements of those systems, and are compliant with their designs. Such applications can be complicated to develop, maintain and evolve, especially if the physical system changes. This paper brings an approach for engineering CPS monitoring applications, relying on model-driven techniques for generating a platform using the MQTT communication protocol for monitoring the CPS. First, it provides a metamodel for modeling sensors and actuators networks. Second, it introduces EMIT a monitoring platform for sensors and actuators networks. Third, it presents a transformation from models of sensors and actuators networks to automatically generate EMIT monitoring configuration. We illustrate our approach on a case study and discuss its limitations and improvement points.

Energy consumption is becoming a major subject when designing, developing and running programs. Most developers code and run their applications in an energy oblivious manner, mostly because of a lack of energy-related knowledge about their system. This problem also exists in the realm of executable domain-specific modeling languages, where end-users create models conforming to a given meta-model and execute them with little knowledge about their operational semantic and related energy consumption. In this work, we propose a domainspecific language for decorating meta-models of executable languages with platform-specific energy estimation formulas. We also extend the GEMOC execution engine to dynamically perform energy estimations on any executable model conforming to the decorated meta-model. The energy estimation model defined can then be easily adapted to other models and platforms, without requiring any measurement tooling or knowledge from the enduser.

Abstract. Model-Driven Engineering (MDE) has been successfully used in static program analysis. Frameworks like MoDisco inject the program structure into a model, available for further processing by query and transformation tools, e.g., for program understanding, reverse-engineering, modernization. In this paper we present our first steps towards extending MoDisco with capabilities for dynamic program analysis. We build an injector for program execution traces, one of the basic blocks of dynamic analysis. Our injector automatically instruments the code, executes it and captures a model of the execution behavior of the program, coupled with the model of the program structure. We use the trace injection mechanism for model-driven impact analysis on test sets. We identify some scalability issues that remain to be solved, providing a case study for future efforts in improving performance of model-management tools.

In order to ensure that existing functionalities have not been impacted by recent program changes, test cases are regularly executed during regression testing (RT) phases. The RT time becomes problematic as the number of test cases is growing. Regression test selection (RTS) aims at running only the test cases that have been impacted by recent changes. RTS reduces the duration of regression testing and hence its cost. In this paper, we present a model-driven approach for RTS. Execution traces are gathered at runtime, and injected in a static source-code model. We use this resulting model to identify and select all the test cases that have been impacted by changes between two revisions of the program. Our MDE approach allows modularity in the granularity of changes considered. In addition, it offers better reusability than existing RTS techniques: the trace model is persistent and standardised. Furthermore, it enables more interoperability with other model-driven tools, enabling further analysis at different levels of abstraction (e.g., energy consumption). We evaluate our approach by applying it to four well-known opensource projects. Results show that our MDE proposal can effectively reduce the execution time of RT, by up to 32 % in our case studies. The overhead induced by the model building makes our approach slower than dedicated RTS tools, but the reuse of trace models for further analysis compensates for the time.