DEBT 2024 – Proceedings

2nd ACM International Workshop on Future Debugging Techniques (DEBT 2024)

Frontmatter

Keynote

Advanced Debugging Techniques in Practice (Keynote)
Robert O’Callahan
(Google, New Zealand)
It’s been ten years since the first release of “rr”, an open-source record-and-replay debugger with many real-world users. It’s been five years since the release of “Pernosco”, a commercial omniscient debugger with some real-world users. I’ll give a brief overview of these tools and the technology behind them. I’ll explain why users adopted these tools and how they are used in practice. Just as importantly, I’ll present my understanding of why users have NOT adopted these kinds of tools and what we might be able to do about that. I’ll discuss some aspects of the debugging problem where I think academic research would be really useful.

@InProceedings{DEBT24p1, author = {Robert O’Callahan}, title = {Advanced Debugging Techniques in Practice (Keynote)}, booktitle = {Proc.\ DEBT}, publisher = {ACM}, pages = {1--1}, doi = {10.1145/3678720.3695756}, year = {2024}, } Publisher's Version

Technical Paper

In-Field Debugging of Automotive Microcontrollers for Highest System Availability
Gašper Skvarč Božič, Ibai Irigoyen Ceberio, and Albrecht Mayer
(Infineon Technologies, Germany)
The software content in vehicles is increasing, including their system complexity, which leads to a higher probability of bugs appearing in a production vehicle. Consequently, there is an increasing need to observe what the production system is doing also once it is already in the field. This paper introduces an emerging topic of in-field diagnosis of microcontrollers in the automotive domain. This includes the architecture and how to address the safety and security challenges. We describe the necessary components of an in-field diagnosis architecture, including the required properties of an on-chip debug monitor. We provide several ways an on-chip debug monitor can be implemented by utilizing the available and, in some cases, unused system resources. With the described approach, we can utilize the same debug concepts and tools for local, remote, and in-field diagnosis, enabling runtime verification throughout a system's lifecycle.

@InProceedings{DEBT24p2, author = {Gašper Skvarč Božič and Ibai Irigoyen Ceberio and Albrecht Mayer}, title = {In-Field Debugging of Automotive Microcontrollers for Highest System Availability}, booktitle = {Proc.\ DEBT}, publisher = {ACM}, pages = {2--8}, doi = {10.1145/3678720.3685314}, year = {2024}, } Publisher's Version

Work-in-Progress Papers

Bug Localisation in Model-Based Testing using Model-Centric Shrinking
Susan van den Broek, Ana Oprescu, and Theo C. Ruys
(University of Amsterdam, Netherlands; Axini, Netherlands)
In Model-Based Testing (MBT), long traces to errors complicate bug localisation. Shrinking of these long traces, aimed at finding smaller counterexamples from existing ones, traditionally operates at the trace-level. However, leveraging the detailed behaviour captured by MBT models suggests potential for more effective shrinking methods. We propose a model-centric shrinking approach, the ShortestPathShrinker. It centres around the idea that finding shorter traces in MBT is similar to finding shorter paths in graphs. Our experimental results show that the algorithm yields smaller or comparable traces to existing methods, in a faster fashion depending on the type of bug. Future work is discussed.

@InProceedings{DEBT24p9, author = {Susan van den Broek and Ana Oprescu and Theo C. Ruys}, title = {Bug Localisation in Model-Based Testing using Model-Centric Shrinking}, booktitle = {Proc.\ DEBT}, publisher = {ACM}, pages = {9--15}, doi = {10.1145/3678720.3685315}, year = {2024}, } Publisher's Version

A Reversible Debugger for MPI Applications
Mihkel Tiks, Ott-Kaarel Martens, Eero Vainikko, and Stefan Kuhn
(University of Tartu, Estonia)
Cluster machines are gaining importance, for example in high-performance computing and eScience. For this, programs need to be parallelized and run with appropriate tools, typically MPI (Message Passing Interface) in a scientific context. Since writing programs for parallel computation is significantly more difficult than programming for sequential execution, debugging tools, which are considered a necessary part of the toolset of software developers, are of even higher importance there. Reversibility, providing the ability to progress backwards in the program execution in some form, has been added to some debuggers and is a useful feature for debugging MPI applications as well. This paper presents a debugger for MPI applications which offers reversible debugging commands. This is done using a checkpoint-restore mechanism. We demonstrate the viability of this approach to enable reversible debugging for parallel computation.

@InProceedings{DEBT24p16, author = {Mihkel Tiks and Ott-Kaarel Martens and Eero Vainikko and Stefan Kuhn}, title = {A Reversible Debugger for MPI Applications}, booktitle = {Proc.\ DEBT}, publisher = {ACM}, pages = {16--21}, doi = {10.1145/3678720.3685316}, year = {2024}, } Publisher's Version

Language-Agnostic Debugging for Microcontrollers
Carlos Rojas Castillo, Matteo Marra, and Elisa Gonzalez Boix
(Vrije Universiteit Brussel, Belgium; Nokia Bell Labs, Belgium)
With the advent of WebAssembly (Wasm), programming microcontrollers (MCUs) has become possible by leveraging on a wide range of languages (e.g., Rust, AssemblyScript, C, C#, Go, C++) that compile to Wasm. However, current WebAssembly debugging support is still in early development and is designed for applications running on desktop machines, making it too resource-intensive for MCUs. While DWARF and OpenOCD have facilitated language-agnsotic debugging for languages like Rust, Go, and C, these solutions are limited to languages that compile to native machine code and fail to target IoT systems. Consequently, IoT systems often undergo only partial debugging, increasing the likelihood of severe and frequent concurrency and communication bugs. In this position paper, we explore the challenges and issues associated with language-agnostic debugging. We identify several key requirements for effective language-agnostic debugging, such as the need for over-the-air debugging and the ability to perform distributed debugging operations. Additionally, we present an envisioned language-agnostic debugging approach based on WebAssembly, designed to support the debugging of large-scale distributed IoT systems.

@InProceedings{DEBT24p22, author = {Carlos Rojas Castillo and Matteo Marra and Elisa Gonzalez Boix}, title = {Language-Agnostic Debugging for Microcontrollers}, booktitle = {Proc.\ DEBT}, publisher = {ACM}, pages = {22--27}, doi = {10.1145/3678720.3685317}, year = {2024}, } Publisher's Version

Demo Papers

Concolic Multiverse Debugging
Maarten Steevens, Tom Lauwaerts, and Christophe Scholliers
(Universiteit Gent, Belgium)
Developing and debugging software for microcontrollers can be rather challenging. Firstly, microcontrollers are often programmed in low-level languages. Secondly, debugging tools are often very limited or simply non-existent. Thirdly, the non-deterministic nature of connected sensors, makes it hard to reproduce bugs. These challenges make finding and reproducing bugs in microcontroller programs tedious. To overcome these challenges, we propose building a new debugger for microcontrollers based on the ideas of multiverse debugging, which allows exploring all non-deterministic execution paths of a program. Our approach builds upon two main ideas: Time Travel and Concolic Debugging. Time Travel Debugging allows developers to explore execution both forwards and backwards in time. Concolic Debugging allows a developer to debug a specifically chosen execution of a non-deterministic program. When doing so concolic execution is used to mitigate the problem of state explosion. We call our novel approach that combines these two techniques Concolic Multiverse Debugging. In this demo we present our prototype Concolic Multiverse Debugger for the WARDuino WebAssembly virtual machine. We show how this prototype can be used to debug an STM32 powered robot.

@InProceedings{DEBT24p28, author = {Maarten Steevens and Tom Lauwaerts and Christophe Scholliers}, title = {Concolic Multiverse Debugging}, booktitle = {Proc.\ DEBT}, publisher = {ACM}, pages = {28--29}, doi = {10.1145/3678720.3685318}, year = {2024}, } Publisher's Version

Reversible Debugging of Erlang Programs in CauDEr
Ivan Lanese and Germán Vidal
(University of Bologna, Italy; Inria, France; Universitat Politècnica de València, Spain)
This talk presents the notion of causal-consistent reversible debugging and its instance on Erlang provided by CauDEr. Reversible debugging allows us to explore an execution back and forth looking for a bug. Causal-consistent debugging tailors this approach to concurrent systems so that actions can be undone in any order as long as their consequences, if any, are undone first.

@InProceedings{DEBT24p30, author = {Ivan Lanese and Germán Vidal}, title = {Reversible Debugging of Erlang Programs in CauDEr}, booktitle = {Proc.\ DEBT}, publisher = {ACM}, pages = {30--31}, doi = {10.1145/3678720.3685319}, year = {2024}, } Publisher's Version

Abstract Debugging with GobPie
Karoliine Holter, Juhan Oskar Hennoste, Simmo Saan, Patrick Lam, and Vesal Vojdani
(University of Tartu, Estonia; University of Waterloo, Canada)
GobPie is an IDE integration designed to enhance the usability and explainability of the abstract interpretation-based static analyzer Goblint. GobPie features abstract debugging, a novel approach to presenting static analysis results, which complements traditional debugging methods by making program analysis results visible. Its goal is to help resolve rare but real software issues. Unlike traditional debugging, which proceeds step-by-step to observe concrete states, abstract debugging uses static analysis results to simulate the same steps, offering insights into all possible execution paths.

@InProceedings{DEBT24p32, author = {Karoliine Holter and Juhan Oskar Hennoste and Simmo Saan and Patrick Lam and Vesal Vojdani}, title = {Abstract Debugging with GobPie}, booktitle = {Proc.\ DEBT}, publisher = {ACM}, pages = {32--33}, doi = {10.1145/3678720.3685320}, year = {2024}, } Publisher's Version Video

Localizer: A Visual Debugging Assistant for Python Programs
Shehroz Khan, Gaadha Sudheerbabu, Dragos Truscan, and Tanwir Ahmad
(Åbo Akademi University, Finland)
We present the Localizer tool, which is targeted at assisting developers and testers in debugging their Python code. The tool combines program slicing and program spectra analysis to analyze the difference between the execution paths of the passing tests and of the failing tests, respectively. In addition, it suggests suspicious parts of the code where the fault can be potentially located. To assist the user in inspecting the code, the tool graphically presents the structure of the code as control flow graphs annotated with program spectra information. Preliminary studies show that the tool facilitates the identification of faults by reducing the complexity of the code analysis process.

@InProceedings{DEBT24p34, author = {Shehroz Khan and Gaadha Sudheerbabu and Dragos Truscan and Tanwir Ahmad}, title = {Localizer: A Visual Debugging Assistant for Python Programs}, booktitle = {Proc.\ DEBT}, publisher = {ACM}, pages = {34--35}, doi = {10.1145/3678720.3685321}, year = {2024}, } Publisher's Version Video

proc time: 3.13