Polymorphism is a foundational concept within the object-oriented paradigm and is a feature of any mainstream object-oriented language that supports reusability and abstraction in software designs. With fUML being a standard specification of execution semantics of UML activity diagrams, it defines functionalities to simulate polymorphic behavior within such model executions. fUML only provides a simple standard implementation for simulating dynamic polymorphism at runtime. This default implementation does not meet the criteria of polymorphism as it is well-known and established by most mainstream object-oriented programming languages over the last decades, nor does it comply with the constraints for method overriding imposed by the original UML specification. However, fUML offers extension capabilities to add user-defined behavior for semantic variation points like polymorphism handling. This paper presents an extension of fUML execution semantics, enabling refined and more sophisticated simulation of polymorphism for executable UML models to comply with UML and the general understanding and functioning principles of polymorphic behavior within the object-oriented paradigm.

OMG's PSCS specification extends the execution model of fUML by precise runtime semantics for UML composite structures. With composite structures being a concept for describing structural properties of a model, the majority of execution semantics specified by PSCS concern analysis and processing of static information about the model's fine-grained structure at runtime. Using Model-To-Text-Transformation to generate source code, which serves as an input for PSCS's actual execution environment, the runtime level of model execution can be relieved by outsourcing analysis and processing of static information to the level of code generation. By inserting this step of preprocessing, the performance of the actual model execution at runtime can be improved. This paper introduces an implementation of the PSCS specification for C++ based on code generation using Model-to-Text-Transformation. Moreover, it presents a set of test models validating the correct functionality of the implementation a s well as a performance benchmark. The PSCS implementation presented by this paper was developed as a part of the MDE4CPP* project.

One of the goals of the Foundational UML Subset (fUML) is a consistent and well-defined execution of UML activity diagrams. However, the specification is not done in a formal mathematical model and leaves room for implementation-specific tool details. This paper shows how this may lead to problems for concurrent program semantics. To this end, the paper introduces a transformation and basic analysis methods for activity diagrams under the current fUML sequential execution semantics. The analysis is conducted using Petri nets, which are mathematical models with a graphical representation to describe distributed systems. There are numerous well-established analysis methods to validate specific desirable properties of a concurrent program including liveliness, the absence of deadlocks, fairness, mutual exclusion, and detection of unreachable states. In this paper, we show that the intuitive translation to Petri nets does not fit the current fUML execution implementation; therefore, we i ntroduce a new model-to-model transformation realized with QVTo, that translates a set of the most used fUML elements to Petri nets. Moreover, we propose methods to analyze the models with the tool TimeNET.

This paper shows and discusses the realization of advanced data structures used in the UML specification (namely subsets, unions, and subset-unions) for a C++ execution engine. Those data structures have been realized thanks to the use of variadic templates, which were first introduced in C++11. Thanks to those templates which allow to take as parameters a non-fixed number of elements in an elegant manner, it has been possible to automatically generate from the Ecore and UML ecore models type-safe data structures which avoid elements being duplicated or the generation of additional lists during run-time. A performance analysis is presented to show how our implementation behaves compared to the other possible approaches.

This paper introduces an execution engine that is able to run fUML models, described by a subset of UML's class and activity diagrams' elements. The execution engine is realized in C++, which leads, in certain conditions, to better memory efficiency and performance of the generated code, compared for example to the fUML standard implementation in Java. As it does not use any platform specific code, it is possible to compile it on any C++ compliant platform. The paper then shows how the engine has been applied to a simulated annealing optimization heuristic as a validation example and finally a performance evaluation regarding occupied memory, storage requirements, and execution time is carried out.

The optimization of complex systems as well as other design methods require a description of the system parameters, or the design space. Explicit encoding of all possible variants is practically impossible, thus an implicit method is needed. While this is easy for purely numerical parameters and a fixed number of them as usually assumed in direct or indirect optimization, it is quite hard for systems in which the architecture and thus the structure of the parameters themselves can be varied. This paper introduces an approach to specify system architecture variants in a concise way and proposes a UML profile for this task. Standard UML meta model elements are used for the description of variant-specific stereotypes. An example of a variant specification for a communication network model is presented.

Model-driven architecture is a well-known approach for the development of complex software systems. The most famous tool chain is provided by Eclipse with the tools of the Eclipse modeling project. Like Eclipse itself, these tools are based on Java. However, there are numerous legacy software packages written in C++, which often use only an implicit meta-model. A real C++ implementation of this meta-model would be necessary instead to be used at run time. This paper presents a generator for C++ to create the classes, meta-model packages, and factories to realize modeling, transformation, validation, and comparison of UML models. It gives an overview of its workflow and major challenges. Moreover, a comparison between Java and C++ implementations is given, considering different benchmarks.

Analysis and validation using simulation is a helpful tool in systems engineering, but requires in-depth knowledge of various aspects of the system itself, used model classes, and an appropriate software tool. Usually, this expertise is spread over a number of team members, thus making it a non-trivial task. A domain-specific simulation-based system design tool (termed here simulation-based application, SBA) could fill this gap. It hides the complexity of the model from the system designer and allows to configure parameters and analyze results in one single application. The necessary extra effort in software development compared to a bare modeling tool can be reduced with techniques for model-driven development. This paper presents an approach to use such methods to improve the development of SBA as a case of domain-specific software product lines. The workflow is described as well as the existing meta-model and applied techniques from model-driven development. The paper also shows the necessary elements of a meta model to describe SBAs. An example shows the complete workflow using an example of a wireless sensor networks for avionic applications.