Scalability in Model-Driven Engineering (MDE) remains an open challenge and an active research topic. This paper presents an overview of ongoing work, which aims to signi cantly improve the performance of model management tasks (e.g., transformation and validation) through parallelisation and distribution. We believe our solution will be highly scalable due to hardware trends; namely, higher core counts, diminishing single-threaded performance improvements and increasing prevalence of cloud computing. We intend to implement our solutions in the Epsilon suite of model management tools and evaluate both the performance gains and correctness of our concurrent implementation(s) using a range of models and test scripts. Initial experiments with parallelisation of the Epsilon Validation Language show promising results both in terms of correctness and performance.
Scalability is one of the most oft-mentioned challenges associated with
ModelDriven Engineering (MDE) [
The problem of scalability is a multi-faceted concern. On one front, the issues are in the storage and loading of very large models (VLMs). The current defacto standard model persistence format (XMI) and modelling framework (EMF) do not support concurrent modi cation of models, which makes collaboration more di cult. Another front is model management { that is, performing tasks using models { which is typically done using domain-speci c languages (DSLs). Such tasks include querying, validation, merging, comparison, transformation and generation of textual artefacts. Although there are several tools which exist for each of these tasks, few (if any) were initially designed for execution over
This research is in its initial stages (less than 6 months), so technical developments
are in their infancy; although the overall research direction and goals are unlikely to
undergo major changes.
very large models. This is especially problematic for large models that undergo
frequent changes and need re-validating and transforming into other models
and/or artefacts, such as real-time data from sensors [
This research aims to improve scalability by drastically reducing the execution time of model management programs using concurrency. The scope of this research extends to most model management tasks (i.e., not just model-to-model transformations). For our implementation, we are targeting the Epsilon suite of tools and domain-speci c languages.
Epsilon1 o ers multiple DSLs for model management tasks. The rationale for choosing Epsilon is that our research group is familiar with the codebase, although the ndings should generalise to other implementations and execution engines. It also allows us to minimise duplication since the DSLs are built on top of a common model-oriented language. Furthermore, it provides an opportunity to investigate the similarities of model management tasks with regards to concurrency and highlight any challenges speci c to particular tasks. 2
The main computational approaches for improving the performance of model
management programs are Incremental, Lazy and Parallel execution.
Incremental Approaches. Incrementality is a technique for avoiding
unnecessary re-computations; typically implemented using caching. In a modelling
context, the idea is that if only a subset of a source model changes, then the
program (e.g., transformation or constraint validation) can be re-executed on
the changed subset only. Incrementality is the most commonly explored solution
in the MDE literature. Works featuring incremental model-to-model
transformations are abundant { for example, in [
Lazy Approaches. Lazy evaluation refers to the notion of delaying execution
until the result is required. For instance, if a program makes a query for some
data or a computation but then never uses it, then the computation and/or
loading could have been avoided. Tisi et al. (2011) [
Gap Analysis. All three approaches to improving performance of programs
identi ed in the literature (laziness, incrementality and parallelism) are
orthogonal. For example, laziness and incrementality are often necessary for reactive
approaches, such as [
As far as we are aware, there are currently no model management language execution engines (even in prototype stage) which are reactive (i.e., incremental + lazy) and parallel. Furthermore, we are also not aware of any concurrent execution engines which are capable of scaling across both local and distributed computing resources. Although there has been increasing interest in parallel and distributed model transformations in recent years, the same is not true of other model management tasks such as validation, comparison and code generation.
We are also not aware of any works which attempt to execute model management programs on Graphics Processing Units (GPUs). Given the rapid pace of developments in GPU architectures (with no sign of a slowdown) and relatively stagnant CPU improvements in recent years, the potential performance gains from GPU computing could be several orders of magnitude greater than what would be achievable with CPUs. Modern graphics cards are capable of simultaneously executing hundreds of thousands of threads, with enthusiast-grade GPUs boasting over 11 TFLOPs compute performance. Furthermore, modern graphics cards have several gigabytes of high-speed memory, which could be used to store even the largest of models. 3
Our proposed solution is to architect and implement data-parallel execution for model management programs. This can potentially reduce execution times to a fraction of the original without reliance on pre-computation (as with incremental approaches). This is further justi ed by hardware developments; as almost all modern general-purpose CPUs can execute multiple threads simultaneously. A parallelised approach can also be distributed across multiple computers or cloud servers for further performance bene ts; albeit being more complex due to the need to handle node failures, communication and distributed memory.
We plan to focus initially on a single task/language such as the Epsilon Validation Language (EVL) as proof-of-concept, and then abstract the execution semantics such that local-parallel and distributed-parallel solutions can be handled transparently in a more or less equivalent manner for other tasks. We will therefore initially target data-parallelism; where each thread executes the entire program over a subset of the model. This approach is arguably more scalable and is likely to provide better speedups because it minimizes the need for threads to communicate, as each thread can work independently without computational dependencies. This is especially relevant for distributed computing, where communication costs over a network may be much higher and/or undesirable.
We recognize that data dependencies are inevitable and that they pose a signi cant challenge for a data-parallel approach. We also understand that although parallelising the declarative parts of domain-speci c languages is relatively straightforward, automatic parallelisation of imperative constructs is beyond the scope of this project. However, if time permits we may also consider parallel execution of lambda expressions ( rst-order logic operations) on collections by assuming them to be pure functions (i.e., without side-e ects). Perhaps the most interesting challenges we expect to face will be with the implementation of model management tasks which mutate models; namely model transformations and model merging, since the level of granularity with regards to concurrent execution is likely to play a large role in the performance bene ts and the overall complexity of the implementation.
With regards to GPU-accelerated execution, the greatest challenge is the
notoriously limited and di cult programming model of graphics devices. Both
CUDA and OpenCL frameworks require programs to be written in a subset of the
C/C++ language; with limited support for non-primitive data types. Although
the SIMD (Single Instruction Multiple Data) architecture of GPUs is ideal for
our data-parallel approach, it is unclear whether the overhead of converting
models and scripts to a compatible format for execution on GPUs, as well as
transferring them to graphics memory, will outweigh the gains from increased
parallelisation. A potential starting point for such an investigation would be in
using MapReduce to de ne the execution semantics of a model management task
(such as in [
From a technical aspect, we have identi ed a number of ways to reduce the
complexity of introducing concurrency in both local and distributed scenarios;
namely JSCOOP [
So far, our implementation has focused on parallelisation of EVL based on
previous work in an MSc project [
Whilst our research is broad in scope with many avenues for investigation, we endeavour to make signi cant contributions to the MDE community in the following areas: { Thorough investigation of the challenges and approaches to executing model management programs concurrently { A prototype parallel implementation of Epsilon supporting model validation, model comparison, model querying and model transformations { A study of the similarities and di erences between various model management tasks from a concurrent computation perspective { An investigation of the extent to which GPU computing can be applied to accelerate the execution of model management programs { An investigation of potential solutions for combining parallelism with incrementality and laziness for various model management tasks.
Our focus will be on model validation, model comparison and model-to-text transformations as these areas are deeply under-studied with regards to concurrent execution in the MDE literature. 5
To evaluate the scalability of our solutions, we intend on utilizing a common suite of models with varying sizes, ranging from hundreds to millions of elements. We will then compare speedups with the original single-threaded engines using multiple threads. We will also ensure that we test our solutions on hardware which can execute many threads simultaneously (e.g., 16, 32 or even more).
The domain-speci c nature of modelling applications makes it di cult to
obtain real-world models and programs from industry due to the intellectual
properties. However, alternative sources such as [
A further concern is that of correctness, since concurrent programs are notorious for non-deterministic behaviour. Although formal veri cation methods may theoretically be possible, they may be di cult to carry out for such large execution engines. At the very least, we plan to write a comprehensive suite of unit and system tests to build con dence of our implementation and results, ensuring that the outputs of the concurrent engines are identical to those of the original, non-concurrent engine implementations. 6
This research is in its initial stages (less than six months in). We are currently working on laying down the foundations for making Epsilons engines threadsafe and identifying the parts which can be trivially parallelised. Our intention is to nd the optimal balance between minimizing modi cations and architectural changes to the existing engines whilst maximizing the performance gains. We expect the project to be complete by 2020; though we plan to publish any signi cant intermediate results for near-complete parallelised engines sooner.