You are required to read and agree to the below before accessing a full-text version of an article in the IDE article repository.

The full-text document you are about to access is subject to national and international copyright laws. In most cases (but not necessarily all) the consequence is that personal use is allowed given that the copyright owner is duly acknowledged and respected. All other use (typically) require an explicit permission (often in writing) by the copyright owner.

For the reports in this repository we specifically note that

  • the use of articles under IEEE copyright is governed by the IEEE copyright policy (available at
  • the use of articles under ACM copyright is governed by the ACM copyright policy (available at
  • technical reports and other articles issued by Mälardalen University is free for personal use. For other use, the explicit consent of the authors is required
  • in other cases, please contact the copyright owner for detailed information

By accepting I agree to acknowledge and respect the rights of the copyright owner of the document I am about to access.

If you are in doubt, feel free to contact

Bugs and Debugging of Concurrent and Multicore Software


Licentiate presentation

Start time:

2016-05-23 10:15

End time:

2016-05-23 12:00


Gamma, MDH Västerås


Faculty examiner (opponent):
Professor Håkan Grahn, Blekinge Institute of Technology (BTH)
Grading committee:
Professor Håkan Grahn, Blekinge Institute of Technology (BTH)
Professor Kristina Lundqvist, MDH
Associate Professor Jan Carlson, MDH
Doctor Moris Behnam, MDH (reserve)
Prof. Hans Hansson, Prof. Daniel Sundmark and Dr. Sigrid Eldh

Multicore platforms have been widely adopted in recent years and have resulted in increased development of concurrent software. However, concurrent software is still difficult to test and debug for at least three reasons. (1) concurrency bugs involve complex interactions among multiple threads; (2) concurrent software have a large interleaving space and (3) concurrency bugs are hard to reproduce. Current testing techniques and solutions for concurrency bugs typically focus on exposing concurrency bugs in the large interleaving space, but they often do not provide debugging information for developers (or testers) to understand the bugs.

Debugging, the process of identifying, localizing and fixing bugs, is a key activity in software development. Debugging concurrent software is significantly more challenging than debugging sequential software mainly due to the issues like non-determinism and difficulties of reproducing failures.

This thesis investigates the first and third of the above mentioned problems in concurrent software with the aim to help developers (and testers) to better understand concurrency bugs. The thesis first identifies a number of gaps in the body of knowledge on concurrent software bugs and debugging. Second, it identifies that although a number of methods, models and tools for debugging concurrent and multicore software have already been proposed, but the body of work partially lacks a common terminology and a more recent view of the problems to solve.

Further, this thesis proposes a classification of concurrency bugs and discusses the properties of each type of bug. The thesis maps relevant studies with our proposed classification and explores concurrency-related bugs in real-world software. Specifically, it analyzes real-world concurrency bugs with respect to the severity of consequence and effort required to fix them. The thesis findings indicate that it is still hard for developers and testers to distinguish concurrency bugs from other types of software bugs. Moreover, a general conclusion from the investigations reveal that even if there are quite a number of studies on concurrent and multicore software debugging, there are still some issues that have not been sufficiently covered including order violation, suspension and starvation.

Sara Abbaspour Asadollah,