Tamás Fekete

Synthesis and characterization of superabsorbent hydrogels based on hydroxyethylcellulose and acrylic acid

Hydroxyethylcellulose (HEC)/acrylic acid (AAc) copolymer gels with superabsorbent properties were synthesized from aqueous solutions by radiation-initiated crosslinking. The effect of the acrylic acid content on gel properties was determined at different synthesis conditions. The partial replacement of the cellulose derivative with acrylic acid improved the gelation, leading to higher gel fraction and lower water uptake even in very low concentrations (1-5%). In the presence of acrylic acid lower dose and solute concentration was required for the gel synthesis. The molecular properties of the hydroxyethylcellulose also had a major effect on the gelation: higher molecular mass resulted in better gel properties. The acrylic acid also affected the electrolyte sensitivity of the hydrogels: while pure HEC gels were unaffected by the ionic strength of the solvent, the water uptake of HEC/AAc gels decreased with the salt concentration. The sensitivity also depended on the acrylic acid ratio.

Creating a GPGPU-accelerated framework for pattern matching using a case study

Nowadays, general purpose personal computers often contain a separated GPU card. The card can be used to extend the computing power of the CPU. This possibility is getting bigger and bigger focus in several areas such as bioinformatics or audio signal processing. Our goal is to build a heterogeneous GPU-CPU based framework which can search for user defined patterns in a domain-specific model. Efficient pattern matching is useful in various fields, for example in refactoring software systems, or in financial analysis applications. We started building the framework by defining and solving a simple case study to analyze the difficulties in the field and find the keys of success based on a practical example. Several challenges were faced and solved including performance and scalability. At the end, we gained enough experience to create a robust and performant framework. The paper presents the case study, its solution and the architecture of our general, GPU-based pattern matching framework.

Truly Parallel Model-Matching Algorithm in OpenCL

The Model-driven Engineering (MDE) is coming into focus faster and faster nowadays because it can significantly simplify and accelerate the software development and maintenance processes. MDE can efficiently reduce resource requirements not only in development, but also in refactoring and maintenance tasks of complex software systems. There are several tools to support MDE. Although, these tools can deal with the average size of the currently applied domain models, the growing software systems can cause challenges in model manipulations. The growing size of systems can result in such a slow computation which cannot be accepted anymore. Therefore, more efficient model processing methods are needed. We are working on a complex, high performant model-transformation engine for MDE tools. Our solution can take the advantage of parallel computation available for example in modern GPUs. The engine is referred to as PaMMTE (Parallel Multiplatform Model-transformation Engine). In earlier publications, the architecture and functionality of our engine has been introduced and the functional correctness has also been proven. In this paper, we introduce a new pattern matching algorithm. The algorithm is truly parallel, it is scalable and more efficient than the previous version. Moreover, we analyze the current and the new pattern matching algorithms in general and the performance gain achieved. The new pattern matching algorithm can be effectively used not only in PaMMTE, but in any other cases, when high-performant pattern matching computation is required.

Introduction of an OpenCL-Based Model Transformation Engine.

As model-driven engineering (MDE) became a popular software development methodology, several tools are built to support working with MDE. Nowadays, the importance of performance is getting higher as the size of the systems grow. New solutions are needed that can take advantage of modern hardware components and architectures. One step towards this goal is to use the unique processing power of GPUs in model-driven environments. Our overall goal is to create a graph transformation framework that fits into the parallel execution environment provided by GPUs. Our approach is based on the OpenCL framework and it is referred to as PaMMTE (Parallel Multiplatform Model-transformation Engine). This paper presents an overview of our tool and the description of the implementation. We believe that this new approach will be an attractive way to accelerate MDE tools efficiently.

OpenCL-Based Performance Enhancement of Model Transformations

The software industry is currently facing challenges that involve processing larger and larger amounts of data as well as having to manage this data faster. Optimizing the efficiency of an algorithm or application with different hardware and software platforms can be challenging. OpenCL offers a solution for this issue. Building on top of the OpenCL provides multi platform support and efficient usage of hardware devices having multiple computing units. Our goal is to create a model transformation tool with high performance. We built our solution based upon OpenCL. We soon realized that benefit from the advantages of using the OpenCL are not obvious. We have identified the challenges and created solutions for them. In this poster, we present an overview of our approach extended by incremental searching which also increases the performance of the computation.

Towards a model transformation tool on the top of the OpenCL framework

Nowadays, applications must often handle a large amount of data and apply complex algorithms on it. It is a promising and popular way to apply the computation in parallel in order to meet the performance requirements. Since GPUs are designed to apply highly parallel computations efficiently, using CPU+GPU heterogeneous architecture have gained an increasing popularity in computation intensive applications. Model-driven development (MDE) is a widely used software development methodology in the software industry. MDE is heavily building on model transformations in converting and processing the models. Graph transformation-based model transformation is a popular technique in this field. It is based on isomorphic subgraphs matching, which often require serious computing power. Currently, model transformation tools are not capable of using the computation power of the GPUs. Our research goal is to create a general model matching and later a model transformation solution, which can take the advantages of the computation power of the GPUs. We are now focusing on pattern matching of the transformations. We would like to create a general solution which is independent of the hardware vendor; therefore, our method is based on the OpenCL framework. The novelty of this paper is a GPGPU-based pattern matching tool and some accelerating techniques to achieve faster computation. In this paper we present an overview of the solution and test results based on one of the biggest freely available movie database (IMDb). The main properties such as the performance and the scalability are discussed. The applied architecture and the steps towards the final solution are also included in the paper.

Towards creating a GPGPU-accelerated framework for pattern matching

Model-driven engineering (MDE) is a popular software development methodology in the software industry. Finding a predefined pattern in a domain-specific model can be requested in MDE. This technique can help in optimizing or refactoring the models or to translate from one language to another one. The goal of the current researching is to create a framework for MDE which can find patterns defined by the users. Performance is a key issue. Using heterogeneous computation system (e.g.: CPU+GPU) is a promising way to increase the performance of the calculation. Therefore, we created a solution based on the OpenCL framework which is one of the most popular heterogeneous platforms. In this paper, the new pattern matching framework and the main steps of its creation are presented. The applied conception consists of two main steps. Firstly, a simpler case study is solved and experiences are collected from the occurring challenges. Secondly, the achieved solution was extended for general pattern matching. In both steps, the core algorithms are implemented according to the test-driven development methodology. To elaborate these steps, a new technique is provided which can be useful in creating any GPU-based model transformation and thus MDE approaches are improved in general.