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.
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
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
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-reﬂexive 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 modiﬁed 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