Available Theses

Title Stud ent(s) Supervisor Description
A comparative study of algorithms between pthreads, openmp, cilk++ and mpi
1 Thomas Fahringer details
Produktives Arbeiten mit einem Tauchlackier-Simulationstool der Automobilindustrie 1 Thomas Fahringer details
Compilation environment of the Insieme Compiler Framework 1 Thomas Fahringer details
A Visualization Tool for Code-Performance Association 1 Thomas Fahringer details
Automated test data generation 1 Thomas Fahringer details
Task parallelism using Insieme 1 Thomas Fahringer details
Support for recursive data types in the Insieme Runtime 1 Thomas Fahringer details
Insieme INSPIRE property deduction 1 Thomas Fahringer details
Automated Characterizing of OpenCL Devices Using Micro Benchmarks 1 Thomas Fahringer details
OpenCL Host Code Frontend for the Insieme Compiler Environment 1 Thomas Fahringer details

Title A comparative study of algorithms between pthreads, openmp, cilk++ and mpi
Number of students 1
Language English
Supervisors Thomas Fahringer
Description The goal of this thesis is to select a few algorithms (e.g. reduction, prefix scan, parallel sorting, wavefront parallelism, parallel linear algebra) and implement different parallelization strategies based on task and data parallelism as well as recursive parallelism and measure the corresponding performance on shared and distributed memory parallel computers. The scaling behavior for different input data and increasing number of cores should be investigated.
Tasks
  •  Select a variety of algorithms and implement them with different parallelization strategies
  •  Select a proper performance tool such as Tau for performance analysis
  •  Run the codes for different input data on several shared and distributed memory parallel architectures
  •  Quantify performance results for increasing number of processors
Theoretical Skills Parallel Computing
Practical Skills C, C++, OpenMP, MPI
Additonal Information

 

Title Produktives Arbeiten mit einem Tauchlackier-Simulationstool der Automobilindustrie
Number of students 1
Language Deutsch
Supervisors Thomas Fahringer, Partner: ESS Engineering Software Steyr
Description Wurde in den Pionierzeiten des Automobils der Lack in Handarbeit auf die Karosserie aufgetragen, durchlaufen Fahrzeige heute vollautomatische Lackierstraßen, sowie ein oder mehrere Tauchbäder. Dieser Prozess der Tauchlackierung ist einer der finalen Schritte in der Automobilproduktion, deshalb ist es sehr problematisch, wenn sich Designfehler erst in dieser Phase auswirken. Als Lösung hierfür bietet das Engineering Software Steyr (ESS) ein Simulationstool (ALSIM) zur dynamischen Simulation der Tauchlackierung. Hiermit können die Entstehung und Wanderung von unterwünschten Luftblasen, welche die Ursache für nicht benetzte und damit nicht beschichtete Bereiche sind, beim Eintauchen und im Baddurchlauf visualisiert werden. Ebenso können unterwünschte Pfützen-Bildungen beim Austauchen aus dem Bad und in der anschließenden Ablaufstrecke sichtbar gemacht werden.

Dieser rechenaufwändige Simulationsvorgang ist an sich ein sequenzieller Prozess und kann grob in folgende Schritte unterteilt werden:
1. Eintauchen des Fahrzeugs in das Bad
2. Rotierung des Fahrzeugs im Bad
3. Austauchen

Tasks
Theoretical skills
Practical skills
  • Simulation
  • Parallelität
  • Software-Entwicklung
  • Verifizieren von Algorithmen
Additional information Der/die Student/in bekommt für die Erstellung der Masterarbeit eine marktübliche Entlohnung.
Die Arbeiten sollte primär direkt bei der Firma ESS in Steyr durchgeführt werden.

 

Title Compilation environment of the Insieme Compiler Framework
Number of students 1
Language English
Supervisors Thomas Fahringer
Description The purpose of the work is to analyse the current built environment of the Insieme Compiler in order to improve usability and compilation time. The Work consists on two phases: – Analyse the code dependencies and build a new CMake infrastructure that handles automatically those dependencies. – Study Compilation techniques to improve compilation time, compare and implement some of those in within the compiler infrastructure.
Tasks
  • Familiarize yourself with the Insieme infrastructure (with support from its developers)
  • Master the usage of CMake in large developments
  • Study compilation techniques applicable to any development
Theoretical skills Operating Systems
Practical skills
  • Good general programming skills
  • Familiar with compilation tools (Make, CMake, Ant…)
Additional information

 

Title
A Visualization Tool for Code-Performance Association
Number of students 1
Language English
Supervisor Thomas Fahringer
Description The aim of this master thesis is to develop a graphical user interface tool that visualizes given performance data for given source code for parallel programs. When doing performance analysis, one usually measures performance data (run time, cache misses, retired instructions, …) for several code regions of the program. The tool developed in the course of this thesis should visualize this performance data and associate it to the code (e.g. show performance bars with numbers, units, etc… next to the code)
Tasks
  • Familiarize with existing editors and graphics libraries that can be extended
  • Implement an editor or extend an existing one to support visualizing performance data next to program code.
Practical skills
  • Programming in C/C++ or Java
  • No skills or background in parallel programming necessary

 

Title
Automated test data generation
Number of students 1
Language English
Supervisor Thomas Fahringer
Description One goal of the Insieme project is the development of a compiler capable of optimizing parallel programs. Iterative compilation will be one of the major concepts. This approach is based on the repeated compilation of a given code fragment and collection of information regarding the dynamic execution. The results are used to steer the compilation process, especially the selection of code transformations to be applied to the programs.

To enable the compiler to handle larger applications, sub-regions of the code have to be handled individually. Unfortunately, this makes it harder to apply iterative compilation, since for this approach executable programs equipped with representative input data sets are required.

In the Insieme compiler, every program is represented using INSPIRE – the Insieme parallel intermediate representation – which is a compact, semi-functional, strongly typed formal language for parallel applications. Within this representations, candidates for sub-regions can be easily identified and converted into executables.

The goal of this thesis is to automatically provide valid input data for those executables covering sub-regions. For instance, if the extracted region is a function processing two vectors of a given type, matching input data should be generated and passed to the executable. The generation process should also be extended to support the generation of sequences of input values for more extensive investigations of the sub-regions in the context of machine learning driven optimizations. Particularly, the generated input values may be required to satisfy certain statistical properties.

Tasks all in cooperation with the Insieme team:

  • Familiarize yourself with the Insieme project, in particular INSPIRE
  • Investigate the potential data types occuring as input for sub-regions
  • Formally limit the potential input types based on the INSPIRE types
  • Investigate literature regarding the automated generation of test data
  • Implement a test data generator
  • Integrate the test data generation into the Insieme project by offering a modul for generating an executable based on a sub-region and the generated data
Theoretical skills
Practical skills
  • C/C++ skills (the compiler is implemented using C++0x, the target code is C99)
Additional information

 

Title
Task parallelism using Insieme
Number of students 1
Language English
Supervisor Thomas Fahringer
Description The Insieme project aims to develop an optimizing programming tool chain for parallel programs including a compiler capable of static analysis and transformations and a runtime managing and tuning the execution of programs within shared and distributed memory systems. The system should be able to cover basic parallel paradigms like data or functional parallelism as well as task based work distribution.

The goal of this thesis is to verify and improve the system’s ability to handle task based parallelism. Therefore, a certain number of task parallel test cases close to real-world examples should be implemented using a format which can be handled by the Insieme compiler (e.g. OpenMP). The test cases should cover a wide range of potential task-based parallel algorithms, and at least some of them should be parameterized for benchmarking.

The processing of these input codes should be investigated throughout the various compiler stages and, if possible, improved. Finally, the handling and mapping of the individual tasks within the runtime should be examined and refined.

Tasks all in cooperation with the Insieme team:

  • Familiarize yourself with the Insieme project, in particular INSPIRE and the runtime process model
  • Find and implement 3-5 real world examples for task parallelism fitting the test case requirements
  • Investigate the processing of the examples throughout the various compiler stages and the runtime
  • Derive proposals for improving Insieme’s capability of handling tasks => Specification
  • Implement improvements to verify expected effects
Theoretical skills
  • Parallel Systems
Practical skills
  • C/C++ skills (the compiler is implemented using C++0x, the target code and runtime system is C99)
Additional information

 

Title
Support for recursive data types in the Insieme Runtime
Number of students 1
Language English
Supervisor Thomas Fahringer
Description The core of the Insieme Compiler project is formed by a compact, semi-functional, strongly typed formal language for parallel programs called INSPIRE. Within the backend of the compiler, this representation is converted into equivalent C code using functionality offered by the Insiem Runtime. This runtime is capable of processing units of work within shared and distributed memory systems. However, to allow the runtime to control the distribution of data among its managed environment, the compiler has to provide the necessary meta information.

The INSPIRE language allows the specification of recursive data types, that is, types including their own definition as an element. For instance, a linked list defined by a struct including a value element and a next pointer to the same struct is a recursive type. The goal of this thesis is to investigate possibilities of mapping such recursive types to the virtual environment offered by the runtime such that recursive data like lists or trees can be effectively managed.

Tasks all in cooperation with the Insieme team:

  • Familiarize yourself with the Insieme project, in particular INSPIRE and the runtime process model
  • Investigate the concept of recursive data types and propose potential beneficial modifications
  • Investigate and propose a specification on how to map recursive types to the runtime
  • Implement your proposal
Theoretical skills
  • Parallel Systems
  • Functional Programming
Practical skills
  • C/C++ skills (the compiler is implemented using C++0x, the target code and runtime system is C99)
Additional information

 

Title
Insieme INSPIRE property deduction
Number of students 1
Language English
Supervisor Thomas Fahringer
Description The core of the Insieme Compiler project is formed by a compact, semi-functional, strongly typed formal language for parallel programs called INSPIRE. This language is the basis for all analysis and transformations within the compiler.

For this language, a generic property deduction framework is required. For instance, the framework should allow the identification of dead code regions or replicated code as well as live variable, alias and exit analysis. The goal of this thesis is the design, specification and implementation of such a framework and the demonstration of its abilities by realizing one or two well known analyses.

Tasks all in cooperation with the Insieme team:

  • Familiarize yourself with the Insieme project, in particular INSPIRE
  • Familiarize yourself with Control Flow Graphs and related analyses
  • Derive a proposal for a property deduction system based on INSPIRE
  • Implement your system
  • Demonstrate its abilities by realizing 1-2 concrete analyses
Theoretical skills
  • functional programming
  • compiler construction
  • interest in logic and program analyses
Practical skills
  • C++ skills (the compiler is implemented using C++0x)
Additional information

 

Title
Automated Characterizing of OpenCL Devices Using Micro Benchmarks
Number of students 1
Language English
Supervisor Thomas Fahringer
Description uCLbench is a benchmark suite to determine the most importatn characterisits of an OpenCL device such as GPUs or CPUs. The goal of this thesis is to develop further this benchmark suite in terms of scope of operation and ease of use. New benchamrks characterizing important poperties should be implemented and added to this benchmark suite. Furthermore the output of all benchmarks should be formatted in a common and machine readable format.
Tasks
  • Familiarize with uCLbench
  • Extend suite with new benchmarks
  • Brint the output in a machine readable form
Theoretical skills Basic knowledge of OpenCL device characteristics (mainly GPUs)
Practical skills Programming C and OpenCL
Additional information OpenCL: http://www.khronos.org/opencl/

 

Title
OpenCL Host Code Frontend for the Insieme Compiler Environment
Number of students 1
Language English
Supervisor Thomas Fahringer
Description The Insieme compiler frontend is aiming at translating several C dialects, like C with OpenMP/MPI or OpenCL to a common intermediate representation (called INSPIRE). Goal of this thesis is to implement a forntend for OpenCL host code. The OpenCL host language consists of many pre-implemented functions for allocating/copying memory, compiling OpenCL kernels at runtime etc. The first task is to port the semantics of these pre-implemented functions to INSPIRE. The second task is to implement mechanisms to aquire the OpenCL kernel code at compile time and add it to the program.
Tasks
  • Familiarize with the Insieme project, in particular INSPIRE and the runtime process model
  • Read into OpenCL standard
  • Implement a subset of the pre-implemented OpenCL host functionalities in INSPIRE
Theoretical skills Basic knowledge of compiler construction
Practical skills Programming C++
Additional information OpenCL: http://www.khronos.org/opencl/
Insieme: http://www.dps.uibk.ac.at/insieme/