Computer Laboratory

Project suggestions for 2022-23 Part II Projects

If you are interested in these or similar topics, please contact me at

  • Modelling of concurrency-relevant architectural decisions in Agile
    --- Finding concurrency bugs is a hard problem. Existing static and dynamic approaches are imprecise when trying to reverse engineer architectural decisions related to shared memory between threads and intended synchronization. This makes it hard for testers to choose adequate testing approaches for concurrent software.
    Alternative to reverse-engineering is documentation of these decisions during development. There exist approaches that instruct developers which concurrency-related decisions to document during development. However, suggested modelling techniques do not scale. The goal of this approach is to develop a tool that integrates well with Agile environment and enables developers to document and update their concurrency-related decisions.
  • Enhancement of Lockset Eraser algorithm for finding concurrency bugs
    --- Finding concurrency bugs is a hard task, because the problem itself is NP-hard and is conditioned by non-deterministic behavior of software. One approach for finding concurrency bugs is to execute a software under test, observe its execution trace, and then analyze it. For the analysis, there exist various algorithms. One of the most famous algorithms in the community is Eraser Lockset algorithm. However, this algorithm has several flaws.
    This work will be focusing on summarizing existing extensions of Lockset Eraser algorithm and creating new extensions to especially handle the intentions related to initialization of shared variables and deciding which locks protect which shared variables. These challenges have negative effect on the precision of the Lockset algorithm, and this work aims to remove them.
    For execution tracing, we will be using an existing tracing tool.
  • Continuous testing of concurrent software
    --- Continuous software testing considers execution of tests on every software change. While unit tests are perfect for this type of testing, finding concurrency bugs is much more complex. Because of implicit coupling between threads, changes in one thread affect other threads. Therefore, it is necessary to establish a more complex type of testing that includes tracing of execution and analysis of the execution trace.
    This project will focus on building a docker-based environment that contains a tracer (we will be using an existing tracer tool) that can be deployed on a server. On every push of a software change to a version control (e.g., GitHub), a webhook will contact the server with the docker and send changes. Based on these changes, it will be necessary to run tests and perform analysis of the execution trace. The assumption is that unit tests are present in software. The basic, brute force approach will consider execution of all tests to generate a trace. An optimization will consider propagation of committed changes and execution of only relevant tests. For the analysis of the execution traces, we will be using basic Eraser Lockset algorithm that finds data races.
  • GitHub Application for Continuous Engineering
    --- Continuous software engineering and DevOps are transforming software engineering process in companies. However, from the software architectural point of view, there are no good tools to support this process. Most of the existing tools are monoliths that are not suited for cooperation between team members and frequent updates to models.
    Another issue with the existing tools is that they are far away from code and code development processes. After a while, the gap between the design and implementation becomes inevitable. In order to solve this issue, the idea is to build a set of tools that support architecture processes and integrate it with source code repositories. In the concrete case, we will be using GitHub API. For this purpose, it will be first necessary to choose several challenges related to continuous software engineering, on the software architecture level, and for them implement appropriate support.
  • Improving Performance of LLVM Interpreter
    --- LLVM compiler infrastructure is a suitable platform for research projects. One of the most interesting parts of LLVM compiler is its interpreter. It enables a possibility of fine-grained tracing of executed instructions with possibilities for quick quantification of code coverage. However, execution of software with LLVM interpreter introduces a significant overhead. The aim of this project is to identify sources of overhead in LLVM interpreter and implement appropriate changes in order to reduce the overhead to appropriate level. As part of the project, it will be necessary to implement components for writing the traces in JSON trace files.