A Component-Based Framework for Automatic Code Generation in Multi-Physics Coupling Numerical Simulation

This work presents a Model Driven Engineering (MDE) approach for the automatic generation of a network of timed automata from the functional specification of an embedded application described using UML class and sequence diagrams. By means of transformations on the UML model of the embedded system, a MOF-based representation for the network of timed automata is automatically obtained, which can be used as input to formal verification tools, as the Uppaal model checker, in order to validate desired functional and temporal properties of the embedded system specification. Since the network of timed automata is automatically generated, the methodology can be very useful for the designer, making easier the debugging and formal validation of the system specification. The paper describes the defined transformations between models, which generate the network of timed automata as well as the textual input to the Uppaal model checker, and illustrates the use of the methodology with a case study to show the effectiveness of the approach.

UML-based approaches provide abstraction to deal with the high complexity of embedded applications and when combined with Model-driven Engineering can also provide automation trough automatic code generation. This paper presents an approach to automatically generate structural and behavioral code from UML class and sequence diagrams.This approach is demonstrated through a case study and was validated by the implementation of a code generator.

Modern software systems are becoming more and more complex thus demanding for new powerful development mechanisms. Model-driven engineering has been recognised as a promising paradigm for the development of complex systems especially for its capability of abstracting the problem through models and then manipulating them to reach the implementation. In this work we provide a solution for the problem of automatically generating target code from models expressed in CHESS-ML, a UML profile that leverages the Action Language for Foundational UML. The goal is to produce code that does not require any manual intervention after its automatic generation to be executed on the target platform. Focus is on the generation of complex systems targeting both single and multi process deployment configurations as well as different execution platforms.

The development of IoT-based Android health monitoring mobile applications (apps) using traditional software development methods is a challenging task. Developers need to be familiar with various programming languages to manage the heterogeneity of hardware and software systems and to support different communication technologies. To address these problems, in this paper, we first analyze the domain of health monitoring mobile applications and then propose a framework based on model-driven engineering that accelerates the development of such systems. The proposed framework, called HealMA, includes a domain-specific modeling language, a graphical modeling editor, several validation rules, and a set of model-to-code transformations, all packed as an Eclipse plugin. We evaluated the framework to assess its applicability in generating various mobile health applications, as well as its impact on software productivity. To this end, four different health monitoring applications have been automatically generated. Then, we evaluated the productivity of software developers by comparing the time and effort it takes to use HealMA compared to a code-centric process. As part of the evaluation, we also evaluated the usability of HealMA-generated apps by conducting a user study. The results show that HealMA is both applicable and beneficial for automatic generation of usable IoT-based Android health monitoring apps.

International audience

The fast Fourier transform (FFT) is the cornerstone of many supercomputer applications and therefore needs careful performance tuning. Most often, however the real performance of the FFT implementations is far below the acceptable figures. In this paper we explore several strategies for performance optimisations of the FFT computation, such as enhancing instruction-level parallelism, loop merging, and reducing the memory loads and stores by using a special-purpose automatic loop unroller. Our approach is based on the principle of complete unrolling which we apply to modify the FT kernel of the NAS Parallel Benchmarks (NPB). In experiments on two different IBM SP2 platforms, our automatically generated unrolled FFT subroutine is shown to improve the performance between 40% and 53% in comparison with the original code. Further the execution time of the entire 3-D FFT mega-step of the benchmark is faster than when calls to a similar FFT subroutine from the vendor-optimised PESSL numerical library are used. Preliminary results suggest that the completely unrolled code also outperforms FFTW another high-performance FFT package. Finally, our approach for automatic generation of moderately optimised but specialised codes requires only a modest amount of programming effort.

Model Driven Engineering (MDE) is an important software development paradigm. Within this paradigm, models and constraints are essential components for expressing specifications of a software artefact. Object Constraint Language (OCL), a specification language that allows users to freely express constraints over different model features. However, one major issue is that the lack of OCL benchmarks makes difficult to evaluate existing and newly created OCL tools. In this paper, we present our initial idea about automatic OCL benchmark generation. The purpose of this paper is to show a developing idea rather than presenting a more formal and complete approach. Our idea is to use an OCL metamodel to sketch abstract syntax trees for OCL expressions, and solve generated typing constraints to produce the concrete OCL expressions. We illustrate this idea by using an example, discuss our work-in-progress and outline challenges to be tackled in the future.

Model-Driven Performance Engineering enables the automatic generation of simulation models based on business process models and monitored process instance data. When we applied an initial version of our tooling to a number of real world processes, we experienced that we need to support the mapping of monitored process instance data into simulation models under consideration of cases where confidence in these data is low, for instance due to a high variance in monitored resource demands, or a low number of executed process instances. The current paper proposes an architecture which utilizes a decision tree for the intelligent mapping of monitored process instance data into simulation models and, as a by-product, which ranks uncertainties within the imported data.

The OMG's model-driven architecture is quickly attracting attention as a method of constructing systems that offers advantages over traditional approaches in terms of reliability, consistency, and maintainability. The key concepts in the MDA are models that are related by model transformations. However, for the MDA to provide an adequate alternative to existing approaches, it must offer comparable support for software engineering processes such as requirements analysis, design and testing. This paper attempts to explore the application of the last of these processes, testing, to the most novel part of the MDA, that of model transformation. We present a general view of the roles of testing in the different stages of model-driven development, and a more detailed exploration of approaches to testing model transformations. Based on this, we highlight the particular issues for the different testing tasks, including adequacy criteria, test oracles and automatic test data generation. We also propose possible approaches for the testing tasks, and show how existing functional and structural testing techniques can be adapted for use in this new development context.

Explicit connection patterns (ECP) profile and semantics for modelling and generating explicit connections in complex UML composite structures

Network translation gateways can provide seamless interoperability among different airborne, ground and maritime domains. Effective interconnection between waveforms and protocols through the gateways requires manual intensive development and specialized protocol expertise. Therefore, enabling building versatile gateways that can effectively translate those protocols across different network domains is of utmost importance to improve system interoperability. High-level domain specific languages have been utilized to support agnostic protocol interoperability. However, protocol-specific knowledge specification, the core of protocol translation, is still left to protocol experts with manual coding without advanced tools in support of simplification, guidance or verification. Such a manual and unsupervised method of generating translation logic is complex, time-consuming and error-prone. In order to overcome these problems with much more productive gateway development, we present a novel, visual protocol-agnostic translation toolkit in this paper. This toolkit offers three advanced features: 1) simple, intuitive visualized specification of protocol-specific knowledge, 2) graph-based translation logic verification, and 3) automatic gateway generation. The first two features have not been addressed in currently available protocol translation solutions.

Development of Context-Aware and Mobile (CAM) applications requires software engineers to write complex code (e.g., adaptation mechanisms, context management) and deal with heterogeneity issues regarding devices and sensors. A promise to deal with this issue approach is the combination of MDE (Model-Driven Engineering) design principles and CAM middleware platforms. Following this approach, we present in this paper CRITiCAL, a ConfiguRation Tool for Context Aware and mobiLe applications. This tool enables visual modelling of contextual information and adaptive behaviour of a CAM application. From visual models, a code generation is performed and its result contains all methods required for communication between the application and a context management middleware. We aim at offering a simplified and visual way to define context acquisition mechanisms (e.g., get user location) and context rules in order to accelerate the development of CAM applications.

Traditionally restructuring compilers were only able to apply program transformations in order to exploit certain characteristics of the target architecture. Adaptation of data structures was limited to e.g. linearization or transposing of arrays. However, as more complex data structures are required to exploit characteristics of the data operated on, current compiler support appears to be inappropriate. In this paper we present the implementation issues of a restructuring compiler that automatically converts programs operating on dense matrices into sparse code, i.e. after a suited data structure has been selected for every dense matrix that in fact is sparse, the original code is adapted to operate on these data structures. This simplifies the task of the programmer and, in general, enables the compiler to apply more optimizations.

Computation reuse is known as an effective optimization technique. However, due to the complexity of modern GPU architectures, there is yet not enough understanding regarding the intriguing implications of the interplay of computation reuse and hardware specifics on application performance. In this paper, we propose an automatic code generator for a class of stencil codes with inherent computation reuse on GPUs. For such applications, the proper reuse of intermediate results, combined with careful register and on-chip local memory usage, has profound implications on performance. Current state of the art does not address this problem in depth, partially due to the lack of a good program representation that can expose all potential computation reuse. In this paper, we leverage the computation overlap graph (COG), a simple representation of data dependence and data reuse with “element view”, to expose potential reuse opportunities. Using COG, we propose a portable code generation and tuning framework for GPUs. Compared with current state-of-the-art code generators, our experimental results show up to 56.7 % performance improvement on modern GPUs such as NVIDIA C2050.

The main idea surrounding Model-Based User Interface (MBUI) engineering is to identify useful abstractions that highlight the core aspects and properties of an interactive system and its design. These abstractions are instantiated and iteratively transformed at different levels to create a concrete user interface. However, certain limitations prevent user interface (UI) developers from adopting model-based approaches for UI engineering. One such limitation is the lack of reusability of best design practices and knowledge within such approaches. With a view to fostering reuse in the instantiation and transformation of models, we introduce patterns as building blocks, which can be first used to construct different models and then instantiated into concrete UI artifacts. In particular, we will demonstrate how different kinds of patterns can be used as modules for establishing task, dialog, presentation, and layout models. Starting from an outline of the general process of pattern application, an interface for combining patterns and a possible formalization are suggested. The Task Pattern Wizard, tool we developed, uses an eXtensible markup language (XML approach. It is built on eXtensible user languages (XUL)-based. This tool helps designers for selecting, adapting, and applying patterns to task models. In addition, an extended example will illustrate the intimate complicity of several patterns and the proposed model-driven approach.KeywordsUnify Modeling LanguageTask ModelInteraction ElementFloor PlanTask StructureThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.