Tamás Vajk

Generation of Sierpinski Triangles: A Case Study for Graph Transformation Tools

In this paper, we consider a large variety of solutions for the generation of Sierpinski triangles, one of the case studies for the AGTIVE graph transformation tool contest [15]. A Sierpinski triangle shows a well-known fractal structure. This case study is mostly a performance benchmark, involving the construction of all triangles up to a certain number of iterations. Both time and space performance are involved. The transformation rules themselves are quite simple.

Analyzing computation offloading energy-efficiency measurements

No one disputes that mobile phones have become part of everyday life. Besides phone calling we use them for browsing, messaging, playing games and many other things which were possible only on a desktop computer several years ago. Although these devices are even more “smart”, but due to the growing resource requirements their batteries are discharging in a very short period. This is a very important phenomenon, which forces to find alternative ways to reduce the energy consumption of the smartphones. One of them is the method of “computation offloading” where a part of the processes are executed on a remote device (e.g. in the cloud). The creation of an energy-efficiency model consists of several steps. One of the hardest part is to understand how a smartphone behaves in different circumstances. During the execution of an application every step has its own energy cost. To make the execution energy-efficiency, we need first to measure and analyse these costs. In this paper we are going to present a measurement system which is used to analyse the energy consumption of smartphones. The measurements were made in different scenarios and the goal was to save energy through offloading some tasks. The offloading process is based on scheduling theory.

Automatic NoSQL Schema Development: A Case Study

Cloud service providers offer a huge variety of schema-less NoSQL data storage solutions. The flexibility of these data stores offer greater freedom in structuring the data than relational databases. However, it would be desirable to make use of the strong mathematical background of relational data structures. In this paper, we introduce an automatic NoSQL schema optimization that uses a normalized data schema as starting point. We analyze the predefined set of queries, and compile the schema that can serve the queries with minimal cost at a certain query load. The introduced process is performed on a conceptual model of the database, and the queries are defined in Object Constraint Language to simplify the analysis. The optimization algorithm is introduced through a case study.

Raising the Abstraction of Domain-Specific Model Translator Development

Model-based development methodologies are gaining ground as software applications are getting more and more complex while the pressure to decrease time-to-market continually increase. Domain-specific modeling tools that support system analysis, simulation, and automatic code generation can increase productivity. However, most domain-specific model translators are still manually written. This paper presents a technique that automatically generates a domain-specific application programming interface from the same metamodels that are used to define the domain-specific modeling language itself. This facilitates the creation of domain-specific model translators by providing a high-level abstraction hiding all the cumbersome modeling tool-specific implementation details from the developer. The approach is illustrated using the Generic Modeling Environment and the Microsoft .NET C# language.

Energy-efficient computation offloading model for mobile phone environment

The popularity of smartphones is growing every day. Thanks to the more powerful hardware the applications can run more tasks and use broadband network connection, however there are several known issues. For example, under typical usage (messaging, browsing, and gaming) a smartphone can be discharged in one day. This makes the battery life one of the biggest problems of the mobile devices. That is a good motivation to find energy-efficient solutions. One of the possible methods is the “computation offloading” mechanism, which means that some of the tasks are uploaded to the cloud. In this paper we are going to present a new energy-efficient job scheduling model and a measurement infrastructure which is used to analyze the energy consumption of smartphones. Our results are going to be demonstrated through some scenarios where the goal is to save energy. The offloading task is based on LP and scheduling problems.

An Incremental OCL Compiler for Modeling Environments

In software engineering, reliability and development time are two of the most important aspects, therefore, modeling environments, which aide both, are widely used during software development. UML and OCL became industry standards, and are supported by many CASE tools. OCL code checking, which has to be performed by these tools, has a specialty, as not all of the information necessary for compilation is available from the code, the related model contains the types, navigations and attributes. The build time of OCL code fragments is increased if the development tool supports distributed modeling, because in this case, model element checking has to be performed in a model repository that cannot be held in memory. In this paper, we introduce a method that enables incremental OCL code building and therefore reduces the development time. Incremental builds require higher complexity than simple builds, thus balancing between the two methods is also considered.

Incremental Type Checking in OCL Compilers

In software engineering, modeling tools have become widely accepted to increase application reliability and decrease development time. The UML and the OCL became industry standards and are supported by many Computer-Aided Software Engineering tools. The increasing number of modeled functionalities results in complex models that need more and more textual constraints to express the hidden restrictions applying to the systems. The usual scenario of model development is to create an initial model of the system, and then fine-tune it with simple modifications. During development, rebuilding all the constraints is unnecessary when only a few changes have been applied. In this paper, we present an algorithm that handles changes incrementally on expression level, thus required rebuilds are kept to a minimum. The background and implementation framework for the discussed compiler is the Visual Modeling and Transformation System, but the algorithm is general enough to support any tree-based compiler integrated into an IDE.

Runtime model validation with parallel object constraint language

In software engineering, model-based development is gaining ground as reliability must be provided while the development time needs to be decreased. As systems modeled become larger, validation methods need to perform better to offer reasonable response times to model checking queries. Our work extends OCL with parallel evaluation features in a way that multi-threaded and sequential programming constructs are interchangeable. To provide a validated parallelization, the sequential and parallel evaluation of OCL expressions has been formalized and analyzed for equivalence with the Communicating Sequential Processes language. The achieved performance gain with parallelization heavily depends on the model size and the appropriate selection of parallelized code parts, measurement results have been concluded in a case study.

Graph partitioning algorithm for model transformation frameworks

Software modeling has become an everyday practice. Modeling extra-large models have enormous constraints: both memory and computational capacity of a single computer might be insufficient for handling model transformations. One solution to overcome this barrier is to extend the infrastructure. Cloud computing provides feasible realizations for these needs. However, existing algorithms have to be extended/modified to support cloud computing and use its advantages most efficiently. Generally, models can be easily mapped to graphs. This paper provides an algorithm for partitioning graphs representing models. Models can be mapped onto several computational instances and processed on these instances in a distributed fashion. Our algorithm is based on the heuristic Kernighan-Lin method, but we allow manually altering the number of partitions dynamically based on the actual needs. Moreover, we do not build on knowing the entire model when creating the partitions, since it would not fit into the memory of a single instance. Instead, model nodes are received and processed one by one. Our algorithm is fine tuned to these special conditions. The efficiency of the algorithm is illustrated by a case study.

Incremental OCL to C# code generation

In software engineering, modeling with UML and OCL became industry standards and are supported by many computer-aided software engineering tools. The increasing number of the modeled functionalities results in complex models that need more and more textual constraints to express the hidden restrictions applied to the systems. During the development of the metamodel, rebuilding all the constraints is unnecessary when only a few changes have been applied due to the iterative, incremental manner of modifications. In this paper, we present an algorithm that incrementally generates code from modified constraints, thus, the required rebuild operations are kept to a minimum. With the proposed method, the duration of metamodel development can be decreased, thus, the efficiency of the environment is improved.