Magnus Morton (University of Glasgow): Costing JIT Traces for Adaptive Parallelism

Tracing JIT compilation generates units of compilation that are easy to analyse and are known to execute frequently. The AJITPar project aims to investigate whether the information in JIT traces can be used to make better scheduling decisions or perform code transformations to adapt the code for a specific parallel architecture. To achieve this goal, a cost model must be developed to estimate the execution time of an individual trace.

This talk presents the design and implementation of a system for ex- tracting JIT trace information from the Pycket JIT compiler. We define four increasingly parametric cost models for Pycket traces. We test the accuracy of these cost models for predicting the cost of individual traces on a set of loop-based micro-benchmarks. We also compare the accuracy of the cost models for predicting whole program execution time over the Pycket benchmark suite. Our preliminary results show the two simplest models provide only limited accuracy. The accuracy of the more com- plex models depends on the choice of parameters; in ongoing work we are systematically exploring the parameter space.

Gábor Oláh, Gergely Nagy and Zoltán Porkoláb (Eötvös Loránd University): Scale-free Properties are Preserved in Paradigm-agnostic Coupling Metrics

The optimal modularization and the right level of coupling between components are important for the stability, maintainability and the overall quality of the software systems. Although the generic suggestion is to minimalize the coupling between modules, earlier researches on object-oriented programming show that there is a natural limitation of eliminating dependencies between classes. In our research we extend these findings for non-OOP systems and show that this limitation is paradigm-independent. For this purpose we define paradigm-agnostic metrics for coupling and evaluate them. Our results measuring Scala and Erlang sources prove that the coupling behaviour shows the same scale-free properties as earlier OOP results. Our contribution could be useful to avoid unnecessary or harmful refactorings to chase overall low coupling in systems.

Artúr Poór (Eötvös Loránd University): Semantic Query Language for RefactorErl

RefactorErl is a static source code analyzer tool for the Erlang programming language. The tool stores the results of lexical, syntactical and semantical analysis in a program graph. The information stored in the graph is available via a semantic query language. Unfortunately the query language proved to be inflexible during years causing several problems while implementing new language features. In this talk we will give an overview of the query language of RefactorErl, and we will attempt to identify the causes led to the current state. We will present a new query language and its new features, and will compare the two languages on extensibility and readability.

Barnabás Králik, Tamás Kozsik (Eötvös Loránd University): Term-rewriting and Subtyping

Pattern matching and term rewriting are generally considered to be good vehicles for specifying the semantics of programming languages. Mainstream languages supporting these features exist, yet they have some features missing which make the today's programmer feel constrained when implementing compilers. Experience with the Scala and Stratego languages suggest that both a rich type system (as in Scala) and deep pattern matching (as in Stratego) aid the process of compiler construction and maintenance. We are designing a typed language for software transformation that has both of these features. We introduce W#, a purely functional, strongly typed term rewriting language. Design challenges include enabling unbounded pattern matching and enabling subtyping while letting rewriting rules keep the dynamic type of terms intact. For the former purpose, we have based our answer on Stratego's notion of strategies. For the latter, we propose the introduction of a new type construct that aids in partially modifying terms even if its static and dynamic types differ.

Veronika Szabóová, Zdeněk Havlice (Technical University of Košice): An MDA Approach for Integrating Requirement Models as Content of a Knowledge Layer into Self-Aware Systems

In this paper we propose a new method for integrating an auto-reflexive knowledge layer containing requirement models at the source code level as a tool for preventing and resolving inconsistencies that could be introduced into the system by modifying it directly. The method proposes a module integrated into the development environment that utilizes the knowledge layer by using the model-driven architecture approach to perform consistency testing of the modified model with the current version of the source code. The work further proposes a method for using the knowledge layer directly in the application as a tool for visualizing the software architecture on a higher level of abstraction. This is useful for an easy and straightforward self-monitoring of the system and allows for prompt resolving of problems that may occur in the system during it’s use by visualizing them.

Tamás Cséri, Gábor Horváth and Zalán Szűgyi (Eötvös Loránd University): Measuring the Instantiation Coverage of C++ Template Metaprograms

Template metaprogramming is a functional programming technique in C++ where we execute algorithms at compile time with the help of cleverly defined templates. Template metaprograms are used in the foundations of modern C++ applications and libraries, therefore we should very rigorous in their testing. As the tests are also executed at compile time, it is not trivial to reason about their completeness. Particularly, we require an almost full coverage on the template instantiations. Since standard test coverage tools operate at run-time, we had to implement our own tool that assesses test coverage at compile time. Our goal is to aid the programmers in testing of complex template metaprograms. For a good test suite we expect that every template specialization is checked at least once. Therefore we investigate the template definitions and their instantiations. We extended the Clang C++ compiler to identify template definitions and detect the missing instantiations. We report the untested templates.