Markus Scheidgen

Automated and transparent model fragmentation for persisting large models

Existing model persistence frameworks either store models as a whole or object by object. Since most modeling tasks work with larger aggregates of a model, existing persistence frameworks either load too many objects or access many objects individually. We propose to persist a model broken into larger fragments. First, we assess the size of large models and describe typical usage patterns to show that most applications work with aggregates of model objects. Secondly, we provide an analytical framework to assess execution time gains for partially loading models fragmented with different granularity. Thirdly, we propose meta-model-based fragmentation that we implemented in an EMF based framework. Fourthly, we analyze our approach in comparison to other persistence frameworks based on four common modeling tasks: create/modify, traverse, query, and partial loads. We show that there is no generally optimal fragmentation, that fragmentation can be achieved automatically and transparently, and that fragmentation provides considerable performance gains.

Human comprehensible and machine processable specifications of operational semantics

This paper presents a method to describe the operational semantics of languages based on their meta-model. We combine the established high-level modelling languages MOF, OCL, and UML activities to create language models that cover abstract syntax, runtime configurations, and the behaviour of runtime elements. The method allows graphical and executable language models. These models are easy to read by humans and are formal enough to be processed in a generic model interpreter. We use Petri-nets as a running example to explain the method. The paper further proposes design patterns for common language concepts. The presented method was applied to the existing modelling language SDL to examine its applicability.

Textual Modelling Embedded into Graphical Modelling

Although labelled graphical, many modelling languages represent important model parts as structured text. We benefit from sophisticated text editors when we use programming languages, but we neglect the same technology when we edit the textual parts of graphical models. Recent advances in generative engineering of textual model editors make the development of such sophisticated text editors practical, even for the smallest textual constructs of graphical languages. In this paper, we present techniques to embed textual model editors into graphical model editors and prove our approach for EMF-based textual editors and graphical editors created with GMF.

A metamodel for SDL-2000 in the context of metamodelling ULF

Today the syntax of many languages is defined by using context-free grammars. These syntax definitions suffer from a major drawback: grammars do not allow the definition of abstract, reusable concept definitions. Especially in families of related languages, where multiple languages often share the same concepts, this limitation leads to unnecessary reproduction of concept definitions and a missing shared base for these related languages. Metamodels can contain inheritance hierarchies of concepts; thus multiple specifications can reuse and refine existing shared concept definitions. Therefore we propose a method to develop metamodels from existing syntax definitions. We explain our method by applying it to SDL-2000. The method starts with a mapping from BNF grammars into simple preliminary metamodels. Then, by supplying a relation between elements of these simple metamodels and abstract concepts, these metamodels are automatically transformed into metamodels that use existing descriptions of abstract concepts and thus allow a shared basis of common abstract concepts definitions.

Type-Safe model transformation languages as internal DSLs in scala

Although there are powerful model transformation languages (MTLs) like ATL, model-to-model transformations still are often implemented in general-purpose languages (GPLs) like Java, especially in EMF-based projects. Developers might hesitate to learn another language, use new tools, or they feel limited by the specific but less versatile constructs an MTL provides. However, model transformation code written in a GPL is less readable, contains redundancies or verbose expressions, and there are fewer possibilities for formal reasoning. Our approach combines some benefits of MTLs with GPL programming. We use the GPL Scala to realize MTLs similar to ATL as internal domain-specific languages. The benefits are seamless integration with EMF and state-of-the-art tool support as well as the possibility to extend MTLs and to mix MTL and GPL code. In contrast to similar approaches with dynamically typed languages like Ruby, Scala allows for static type-safety without adding syntactic clutter.

A model-based standard for SDL

Language descriptions have much information captured in plain (English) text, and even the formalised parts are often informally connected with the overall language definition. These imprecise descriptions are hardly usable to automatically generate language tool environments out of the language standard. SDL has already managed to define syntax and semantics in a quite formal way. Currently, this formality is connected by using different types of grammars. Meta-models, however, have proven to be a good way of expressing complex facts and relations. Moreover, there are tools and technologies available realising all language aspects based on completely formal and still easily understandable meta-model-based descriptions. This paper is about an experiment of combining all these existing techniques to create a definition of (a subset of) SDL. This allows to have immediate tool support for the language. This experiment includes the language aspects concrete syntax representation, static semantic constraints, and language behaviour. It turns out that this is almost possible.

Reference representation techniques for large models

If models consist of more and more objects, time and space required to process these models becomes an issue. To solve this we can employ different existing frameworks that use different model representations (e.g. trees in XMI or relational data with CDO). Based on the observation that these frameworks reach different performance measures for different operations and different model characteristics, we rise the question if and how different model representations can be combined to mitigate performance issues of individual representations. In this paper, we analyze different techniques to represent references, which are one important aspect to process large models efficiently. We present the persistence framework EMF-Fragments, which combines the representation of references as source-object contained sets of target-objects (e.g. in XMI) within the representation as relations similar to those in relational databases (e.g. with CDO). We also present a performance evaluation for both representations and discuss the use of both representations in three applications: models for source-code repositories, scientific data, and geo-spatial data.

ClickWatch — An experimentation framework for communication network test-beds

It is hard to experiment with test-beds for communication networks: data produced in the network has to be retrieved and analyzed, networks must be reconfigured before and between experiments, data is often little structured (log-files) and analysis methods and tools are generic. Even though many problems of experimentation are the same for all experiments, re-use is sparse and even simple experiments require large efforts. We present a framework that attempts to solve these problems: we define a set of requirements for experimenting with network test-beds, we describe the principles and inner workings of our framework, demonstrate it with a typical example experiment, and present measurement results that illustrate the feasibility and scalability of our approach. Some qualitative and quantitative aspects of ClickWatch are compared to the commonly used logfile based approach to experimentation.

HWL — A high performance wireless sensor research network

Current Wireless Sensor Networks (WSN) consist of low powered energy efficient nodes with short range radios and limited computation capabilities. Sensing applications with multiple sensors, high sample rates, and large spatial coverage are not realizable with conventional WSNs. We propose High Performance WSNs (HP-WSN) with an 802.11n based physical layer and opportunistic routing to overcome the limitations of existing WSNs. We present a research test-bed for such HP-WSNs. As an intermediate step towards actual HP-WSNs, our test-bed (HWL) collects raw data into a centralized data store to provide an experiment friendly environment. The collected raw data includes sensor data (to develop new sensing applications) and data about network and system operation (to develop the sensor network). We provide an example HP-WSN application, derive research objectives for the development of HP-WSNs, provide a test-bed architecture and present evaluation results on network and data storage performance to show the principle feasibility of HP-WSNs.

Map/reduce on EMF models

Map/Reduce is the programming model in cloud computing. It enables the processing of data sets of unprecedented size, but it also delegates the handling of complex data structures completely to its users. In this paper, we apply Map/Reduce to EMF-based models to cope with complex data structures in the familiar an easy-to-use and type-safe EMF fashion, combining the advantages of both technologies. We use our framework EMF-Fragments to store very large EMF models in distributed key-value stores (Hadoops Hbase). This allows us to build Map/Reduce programs that use EMFs generated APIs to process those very large EMF-models. We present our framework and two example Map/Reduce jobs for querying software models and for analyzing sensor data represented as EMF-models.