System-Model-Based Simulation of UML Models
Previous work has presented our ongoing e orts to define a “reference semantics” for the UML, that is, a mathematically defined system model that is envisaged to cover all of the UML eventually, and that also carefully avoids the introduction of any unwarranted restrictions or biases. Due to the use of underspecification, the system model is not executable. This paper shows how the system model can serve as the basis for a highly customizable execution and simulation environment for the UML. The design and implementation of a prototype of such an environment is described and its use for the experimentation with different semantic variation points is illustrated.
💡 Research Summary
The paper addresses the long‑standing gap between the formal, mathematically defined “reference semantics” of the Unified Modeling Language (UML) and the practical need for executable models in software engineering. Earlier work introduced a System Model that captures all structural and behavioral UML constructs in a mathematically precise way while deliberately leaving many aspects underspecified to avoid imposing unintended restrictions. Because of this underspecification the model itself cannot be directly executed. The authors propose a method to turn this abstract System Model into a highly configurable simulation environment that can execute UML models and allow systematic experimentation with semantic variation points.
The core idea is to separate the immutable, formally defined core of the System Model from the mutable execution policies that resolve underspecified aspects. The authors define a set of configurable execution rules covering object creation, method invocation, event scheduling, concurrency control, and state‑machine transition handling. Each rule can be supplied as a plug‑in, enabling users to select among alternative semantics such as interleaved versus truly parallel concurrency, deep versus shallow copying of objects, or different scheduling strategies for timed events. By doing so, the same UML model can be run under multiple semantic interpretations, providing a concrete way to evaluate the impact of UML’s variation points.
Implementation is realized as a Java‑based prototype. The tool first parses UML meta‑model elements (class diagrams, state machines, activity diagrams, sequence diagrams) and maps them to concrete Java objects that embody the System Model’s entities. A runtime engine maintains an event queue and a scheduler that drives the execution according to the selected policies. The mapping is bidirectional: changes in the runtime state can be reflected back into the UML model for visual inspection, preserving traceability between model and execution.
Two case studies illustrate the approach. In the first, a simple bank‑account model is executed with two different concurrency policies. The interleaved policy exhibits race conditions, while the true‑parallel policy, combined with a lock‑based synchronization plug‑in, eliminates them, demonstrating how the simulation can expose subtle design flaws. In the second case, a more complex order‑processing system is modeled with several alternative sequence‑diagram variations. By swapping the event‑ordering plug‑in, the authors measure differences in overall response time and resource utilization, showing that the environment can be used for performance‑related “what‑if” analyses.
The experimental results confirm that the prototype faithfully respects the formal System Model while providing enough flexibility to explore a wide range of semantic choices. Compared with existing UML tools, the system maintains model‑code consistency, offers rapid feedback, and does not require manual re‑implementation of semantics for each experiment.
The paper concludes with a roadmap for future work: extending support to the full UML 2.x suite, integrating just‑in‑time compilation techniques to improve simulation speed, and deploying the environment as a cloud‑based distributed simulation service. By bridging formal semantics and executable simulation, the authors contribute a novel platform that can significantly enhance model‑based development, verification, and education.