mdh.sePublications
Change search
CiteExportLink to record
Permanent link

Direct link
Cite
Citation style
  • apa
  • ieee
  • modern-language-association-8th-edition
  • vancouver
  • Other style
More styles
Language
  • de-DE
  • en-GB
  • en-US
  • fi-FI
  • nn-NO
  • nn-NB
  • sv-SE
  • Other locale
More languages
Output format
  • html
  • text
  • asciidoc
  • rtf
Concurrency Bugs: Characterization, Debugging and Runtime Verification
Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.ORCID iD: 0000-0002-5058-7351
2018 (English)Doctoral thesis, comprehensive summary (Other academic)
Abstract [en]

Concurrent software has been increasingly adopted in recent years, mainly due to the introduction of multicore platforms. However, concurrency bugs are still difficult to test and debug due to their complex interactions involving multiple threads (or tasks). Typically, real world concurrent software has huge state spaces. Thus, testing techniques and handling of concurrency bugs need to focus on exposing the bugs in this large space. However, existing solutions typically do not provide debugging information to developers (and testers) for understanding the bugs.

Our work focuses on improving concurrent software reliability via three contributions: 1) An investigation of concurrent software challenges with the aim to help developers (and testers) to better understand concurrency bugs. We propose a classification of concurrency bugs and discuss observable properties of each type of bug. In addition, we identify a number of gaps in the body of knowledge on concurrent software bugs and their debugging. 2) Exploring concurrency related bugs in real-world software with respect to the reproducibility of bugs, severity of their consequence and effort required to fix them. Our findings here is that concurrency bugs are different from other bugs in terms of their fixing time and severity, while they are similar in terms of reproducibility. 3) A model for monitoring concurrency bugs and the implementation and evaluation of a related runtime verification tool to detect the bugs. In general, runtime verification techniques are used to (a) dynamically verify that the observed behaviour matches specified properties and (b) explicitly recognize understandable behaviors in the considered software. Our implemented tool is used to detect concurrency bugs in embedded software and is in its current form tailored for the FreeRTOS operating system. It helps developers and testers to automatically identify concurrency bugs and subsequently helps to reduce their finding and fixing time.

Place, publisher, year, edition, pages
Västerås: Mälardalen University , 2018.
Series
Mälardalen University Press Dissertations, ISSN 1651-4238 ; 278
National Category
Embedded Systems
Research subject
Computer Science
Identifiers
URN: urn:nbn:se:mdh:diva-41237ISBN: 978-91-7485-412-1 (print)OAI: oai:DiVA.org:mdh-41237DiVA, id: diva2:1259239
Public defence
2018-12-04, Kappa, Mälardalens högskola, Västerås, 13:30 (English)
Opponent
Supervisors
Available from: 2018-10-29 Created: 2018-10-29 Last updated: 2018-11-02Bibliographically approved
List of papers
1. A Runtime Verification based Concurrency Bug Detector for FreeRTOS Embedded Software
Open this publication in new window or tab >>A Runtime Verification based Concurrency Bug Detector for FreeRTOS Embedded Software
Show others...
(English)In: Article in journal (Other academic) Submitted
National Category
Engineering and Technology
Identifiers
urn:nbn:se:mdh:diva-41236 (URN)
Available from: 2018-10-26 Created: 2018-10-26 Last updated: 2018-10-31Bibliographically approved
2. Concurrency bugs in open source software: a case study
Open this publication in new window or tab >>Concurrency bugs in open source software: a case study
2017 (English)In: Journal of Internet Services and Applications, ISSN 1867-4828, Vol. 8, no 1, article id 4Article in journal (Refereed) Published
Abstract [en]

Concurrent programming puts demands on software debugging and testing, as concurrent software may exhibit problems not present in sequential software, e.g., deadlocks and race conditions. In aiming to increase efficiency and effectiveness of debugging and bug-fixing for concurrent software, a deep understanding of concurrency bugs, their frequency and fixing-times would be helpful. Similarly, to design effective tools and techniques for testing and debugging concurrent software, understanding the differences between non-concurrency and concurrency bugs in real-word software would be useful. This paper presents an empirical study focusing on understanding the differences and similarities between concurrency bugs and other bugs, as well as the differences among various concurrency bug types in terms of their severity and their fixing time, and reproducibility. Our basis is a comprehensive analysis of bug reports covering several generations of five open source software projects. The analysis involves a total of 11860 bug reports from the last decade, including 351 reports related to concurrency bugs. We found that concurrency bugs are different from other bugs in terms of their fixing time and severity while they are similar in terms of reproducibility. Our findings shed light on concurrency bugs and could thereby influence future design and development of concurrent software, their debugging and testing, as well as related tools.

Place, publisher, year, edition, pages
Springer London, 2017
Keywords
Apache Accumulo, Apache Hadoop, Apache Oozie, Apache spark, Apache ZooKeeper, Bug severity, Case study, Concurrency bugs, Fixing time, Open source software, Computer programming, Computer software, Concurrency control, Open systems, Software engineering, Software testing, Program debugging
National Category
Computer and Information Sciences
Identifiers
urn:nbn:se:mdh:diva-35210 (URN)10.1186/s13174-017-0055-2 (DOI)000398668000001 ()2-s2.0-85016955041 (Scopus ID)
Available from: 2017-04-20 Created: 2017-04-20 Last updated: 2018-10-29Bibliographically approved
3. 10 Years of research on debugging concurrent and multicore software: a systematic mapping study
Open this publication in new window or tab >>10 Years of research on debugging concurrent and multicore software: a systematic mapping study
Show others...
2017 (English)In: Software quality journal, ISSN 0963-9314, E-ISSN 1573-1367, Vol. 25, no 1, p. 49-82Article in journal (Refereed) Published
Abstract [en]

Debugging – the process of identifying, localizing and fixing bugs – is a key activity in software development. Due to issues such as non-determinism and difficulties of reproducing failures, debugging concurrent software is significantly more challenging than debugging sequential software. A number of methods, models and tools for debugging concurrent and multicore software have been proposed, but the body of work partially lacks a common terminology and a more recent view of the problems to solve. This suggests the need for a classification, and an up-to-date comprehensive overview of the area. 

This paper presents the results of a systematic mapping study in the field of debugging of concurrent and multicore software in the last decade (2005– 2014). The study is guided by two objectives: (1) to summarize the recent publication trends and (2) to clarify current research gaps in the field.

Through a multi-stage selection process, we identified 145 relevant papers. Based on these, we summarize the publication trend in the field by showing distribution of publications with respect to year , publication venues , representation of academia and industry , and active research institutes . We also identify research gaps in the field based on attributes such as types of concurrency bugs, types of debugging processes , types of research  and research contributions.

The main observations from the study are that during the years 2005–2014: (1) there is no focal conference or venue to publish papers in this area, hence a large variety of conferences and journal venues (90) are used to publish relevant papers in this area; (2) in terms of publication contribution, academia was more active in this area than industry; (3) most publications in the field address the data race bug; (4) bug identification is the most common stage of debugging addressed by articles in the period; (5) there are six types of research approaches found, with solution proposals being the most common one; and (6) the published papers essentially focus on four different types of contributions, with ”methods” being the type most common one.

We can further conclude that there is still quite a number of aspects that are not sufficiently covered in the field, most notably including (1) exploring correction  and fixing bugs  in terms of debugging process; (2) order violation, suspension  and starvation  in terms of concurrency bugs; (3) validation and evaluation research  in the matter of research type; (4) metric  in terms of research contribution. It is clear that the concurrent, parallel and multicore software community needs broader studies in debugging.This systematic mapping study can help direct such efforts.

National Category
Computer Systems
Identifiers
urn:nbn:se:mdh:diva-31419 (URN)10.1007/s11219-015-9301-7 (DOI)000394524400003 ()2-s2.0-84955305408 (Scopus ID)
Projects
SYNOPSIS project
Available from: 2016-04-12 Created: 2016-04-12 Last updated: 2018-10-29Bibliographically approved
4. Towards Classification of Concurrency Bugs Based on Observable Properties
Open this publication in new window or tab >>Towards Classification of Concurrency Bugs Based on Observable Properties
2015 (English)In: Proceedings - 1st International Workshop on Complex Faults and Failures in Large Software Systems, COUFLESS 2015, 2015, p. 41-47Conference paper, Published paper (Refereed)
Abstract [en]

In software engineering, classification is a way to find an organized structure of knowledge about objects. Classification serves to investigate the relationship between the items to be classified, and can be used to identify the current gaps in the field. In many cases users are able to order and relate objects by fitting them in a category. This paper presents initial work on a taxonomy for classification of errors (bugs) related to concurrent execution of application level software threads. By classifying concurrency bugs based on their corresponding observable properties, this research aims to examine and structure the state of the art in this field, as well as to provide practitioner support for testing and debugging of concurrent software. We also show how the proposed classification, and the different classes of bugs, relates to the state of the art in the field by providing a mapping of the classification to a number of recently published papers in the software engineering field.

National Category
Computer Systems
Identifiers
urn:nbn:se:mdh:diva-28159 (URN)10.1109/COUFLESS.2015.14 (DOI)000380460500007 ()2-s2.0-84960328955 (Scopus ID)978-147991934-5 (ISBN)
External cooperation:
Conference
First International Workshop on Complex Faults and Failures in Large Software systems, COUFFLESS 2015, May 23, 2015
Projects
SYNOPSIS - Safety Analysis for Predictable Software Intensive Systems
Available from: 2015-06-12 Created: 2015-06-08 Last updated: 2018-10-29Bibliographically approved

Open Access in DiVA

fulltext(9858 kB)48 downloads
File information
File name FULLTEXT02.pdfFile size 9858 kBChecksum SHA-512
c23db6f5ec53d623e66777bfe05cf32b4a800d87e094d9a035db6c7f204bda72ee2ffe066b0ad1051606b3eb24904ee613b63f4be431e3262f13401d8f6e6a10
Type fulltextMimetype application/pdf

Authority records BETA

Abbaspour Asadollah, Sara

Search in DiVA

By author/editor
Abbaspour Asadollah, Sara
By organisation
Embedded Systems
Embedded Systems

Search outside of DiVA

GoogleGoogle Scholar
Total: 48 downloads
The number of downloads is the sum of all downloads of full texts. It may include eg previous versions that are now no longer available

isbn
urn-nbn

Altmetric score

isbn
urn-nbn
Total: 1004 hits
CiteExportLink to record
Permanent link

Direct link
Cite
Citation style
  • apa
  • ieee
  • modern-language-association-8th-edition
  • vancouver
  • Other style
More styles
Language
  • de-DE
  • en-GB
  • en-US
  • fi-FI
  • nn-NO
  • nn-NB
  • sv-SE
  • Other locale
More languages
Output format
  • html
  • text
  • asciidoc
  • rtf