Tamás Kozsik

Discovering parallel pattern candidates in Erlang

The ParaPhrase Refactoring Tool for Erlang PaRTE provides automatic, comprehensive and reliable pattern candidate discovery to locate parallelisable components in Erlang programs. It uses semi-automatic and semantics-preserving program transformations to reshape source code and to introduce high level parallel patterns that can be mapped adaptively to the available hardware resources. This paper describes the main PaRTE tools and demonstrates that significant parallel speedups can be obtained.

An extension to the subtype relationship in C++ implemented with template metaprogramming

Families of independent classes, where each class represents a separate, orthogonal concern are highly attractive for implementing collaboration-based design. However, required subtype relationship between such families cannot be expressed in many programming languages. This paper presents a framework to handle collaborating groups of classes using template metaprogramming based on standard C++ features in the style of Loki::Typelist. Our solution provides tailor-made implicit conversion rules between appropriate groups, inclusion polymorphism and a tool for dynamic binding.

Impact analysis of erlang programs using behaviour dependency graphs

During the lifetime of a software product certain changes could be performed on its source code. After those changes a regression test should be performed, which is the most expensive part of the software development cycle. This paper focuses on programs written in a dynamic functional programming language Erlang, and discusses a mechanism that could select those test cases, which are affected by a change, i.e. altering the program on some point may have impact on the result/behaviour of those test cases. In the result of that analysis it is possible to reduce the number of necessary test cases, and after modifying the source code, just a subset of the test cases should be retested. The discussed approach introduces a behaviour dependency graph for Erlang programs to represent the dependencies in the source code. The impact of a change can be calculated by traversing the graph.

Introducing records by refactoring

This paper focuses on introducing a new transformation to our existing model for refactoring Erlang programs. The goal of the transformation is to introduce a new abstraction level in data representation by substituting a group ofrelated data with a record. Using records enhances the legibility of the source code, makes further development easier, and makes programming less error-prone by providing better possibilities for both compilation time and runtime checks. There is a strong industrial demand for such a transformation in refactoring legacy code. Erlang is a dynamically typed language, and many of its semantical rules are also dynamic. Therefore the main challenge in this research is to ensure the safety of statically performed refactoring steps.

Refactorings to Enable Parallelization

We propose program analyses to identify parallelizable code fragments, and program transformations to change those fragments into applications of high-level parallel patterns. The methodology has been worked out, and is presented here, in the context of the Erlang programming language, but the approach is applicable in other languages as well.

Tutorial on Subtype Marks

When developing safety critical applications, the programmer might want to be able to prove his or her code correct. The integration of a proof system and a programming language of industrial strength can be fairly useful in this respect, like in the case of, for instance, the B method [1], the Java Modelling Language [5] or the functional programming languages Erlang [3,7,9,24] and Clean [11,23,25]. This paper presents the concept of subtype marks, a concept that establishes still closer links between a programming language and a proof system by letting the programmer encode certain important properties of programs within the type system of the language. Subtype marks are introduced here as part of a simple functional language. This language can be regarded as a small subset of Clean.

Multicore C++ Standard Template Library with C++0x

Nowadays, one of the most important challenges in the programming is the efficient usage of multicore processors. Many new programming languages and libraries support multicore programming. C++0x, the proposal of the next standard of C++ also supports multithreading at low level.In this paper we argue for some extensions of C++ Standard Template Library based on the features of C++0x. These extensions enhance the standard library to be more powerful in the multicore realm. In this paper we deal with the functors and lambda expressions that are a major extension in the language. We present a technique to write effective pipelines. Speculative functors aim at the effective evaluation of composite functors. Algorithms are overloaded on the associativity of lambda expressions as well.

A method for job scheduling in Grid based on job execution status

The execution of data intensive Grid applications still raises several questions regarding job scheduling, data migration and replication. The optimisation techniques applied by these services significantly determine how fast a job can be executed and how quickly the user can get the execution results. In this paper new strategies are presented for scheduling the execution of data intensive, parameter-sweep applications. By taking into account the way applications access their data, the extended Grid middleware can achieve lower response times and earlier execution results. Therefore, the proposed improved Grid middleware (1) monitors the execution of jobs and gathers resource access information, (2) analyses the compiled information and generates a description of the behaviour of the job, and (3) uses this newly generated behaviour description to run scheduling algorithm(s). The proposed job behaviour description allows new schedulers to estimate the job completion time more precisely, therefore it leads to better scheduling decisions. Besides, the proposed monitoring technique and analyser tool enable the user to generate the required job behaviour description automatically.

Data access optimization on grid systems

The execution of data intensive grid applications still raises several questions regarding job scheduling, data migration and replication. The optimization techniques applied by these services significantly determine how fast a job can be executed and how early the user can get the execution results. In this paper we present strategies for scheduling the execution of data intensive applications. We deem that by taking into account the way applications access their data, the grid middleware can achieve lower response times and earlier execution results. Therefore, we (1) monitor the execution of jobs and gather the necessary resource access information, (2) analyze the compiled information and generate a description of the behavior of the job, and (3) use the generated behavior description to implement optimized scheduling algorithms. This technique can be extremely useful in the case of parameter-sweep applications.

Analysis of preprocessor constructs in Erlang

Program analysis and transformation tools work on source code, which - as in the case of Erlang - may contain macros and other preprocessor directives. Such preprocessor constructs have to be treated in an utterly different way than lexical and syntactical constructs. This paper presents an approach to treat preprocessor constructs in a non-invasive way that is reasonably efficient and supports code transformations and analyses in an Erlang specific framework.