The Experts below are selected from a list of 1074033 Experts worldwide ranked by ideXlab platform
Yuanyuan Zhou - One of the best experts on this subject based on the ideXlab platform.
-
learning from mistakes a comprehensive study on real world Concurrency bug characteristics
Architectural Support for Programming Languages and Operating Systems, 2008Co-Authors: Soyeon Park, Eunsoo Seo, Yuanyuan ZhouAbstract:The reality of multi-core hardware has made concurrent programs pervasive. Unfortunately, writing correct concurrent programs is difficult. Addressing this challenge requires advances in multiple directions, including Concurrency bug detection, concurrent program testing, concurrent programming model design, etc. Designing effective techniques in all these directions will significantly benefit from a deep understanding of real world Concurrency bug characteristics. This paper provides the first (to the best of our knowledge) comprehensive real world Concurrency bug characteristic study. Specifically, we have carefully examined Concurrency bug patterns, manifestation, and fix strategies of 105 randomly selected real world Concurrency bugs from 4 representative server and client open-source applications (MySQL, Apache, Mozilla and OpenOffice). Our study reveals several interesting findings and provides useful guidance for Concurrency bug detection, testing, and concurrent programming language design. Some of our findings are as follows: (1) Around one third of the examined non-deadlock Concurrency bugs are caused by violation to programmers' order intentions, which may not be easily expressed via synchronization primitives like locks and transactional memories; (2) Around 34% of the examined non-deadlock Concurrency bugs involve multiple variables, which are not well addressed by existing bug detection tools; (3) About 92% of the examined Concurrency bugs canbe reliably triggered by enforcing certain orders among no more than 4 memory accesses. This indicates that testing concurrent programs can target at exploring possible orders among every small groups of memory accesses, instead of among all memory accesses; (4) About 73% of the examinednon-deadlock Concurrency bugs were not fixed by simply adding or changing locks, and many of the fixes were not correct at the first try, indicating the difficulty of reasoning concurrent execution by programmers.
-
muvi automatically inferring multi variable access correlations and detecting related semantic and Concurrency bugs
Symposium on Operating Systems Principles, 2007Co-Authors: Soyeon Park, Weihang Jiang, Raluca Ada Popa, Yuanyuan ZhouAbstract:Software defects significantly reduce system dependability. Among various types of software bugs, semantic and Concurrency bugs are two of the most difficult to detect. This paper proposes a novel method, called MUVI, that detects an important class of semantic and Concurrency bugs. MUVI automatically infers commonly existing multi-variable access correlations through code analysis and then detects two types of related bugs: (1) inconsistent updates--correlated variables are not updated in a consistent way, and (2) multi-variable Concurrency bugs--correlated accesses are not protected in the same atomic sections in concurrent programs.We evaluate MUVI on four large applications: Linux, Mozilla,MySQL, and PostgreSQL. MUVI automatically infers more than 6000 variable access correlations with high accuracy (83%).Based on the inferred correlations, MUVI detects 39 new inconsistent update semantic bugs from the latest versions of these applications, with 17 of them recently confirmed by the developers based on our reports.We also implemented MUVI multi-variable extensions to tworepresentative data race bug detection methods (lock-set and happens-before). Our evaluation on five real-world multi-variable Concurrency bugs from Mozilla and MySQL shows that the MUVI-extension correctly identifies the root causes of four out of the five multi-variable Concurrency bugs with 14% additional overhead on average. Interestingly, MUVI also helps detect four new multi-variable Concurrency bugs in Mozilla that have never been reported before. None of the nine bugs can be identified correctly by the original race detectors without our MUVI extensions.
Joachim Parrow - One of the best experts on this subject based on the ideXlab platform.
-
an implementation of a translational semantics for an imperative language
International Conference on Concurrency Theory, 1990Co-Authors: Lars-Åke Fredlund, Bengt Jönsson, Joachim ParrowAbstract:We present a semantics for an imperative programming language, Lunsen, with constructs for Concurrency and communication. The semantics is given through a translation into CCS. We have implemented this translation within the framework of the Concurrency Workbench, which is a tool for analysis of finite-state systems in CCS. The point of the translational semantics is that by imposing restrictions on Lunsen so that the semantics of a program is finite-state, we can analyze Lunsen programs automatically using the Concurrency Workbench. As an illustration we include an analysis of a mutual exclusion algorithm.
-
CONCUR - An Implementation of a Translational Semantics for an Imperative Language
CONCUR '90 Theories of Concurrency: Unification and Extension, 1990Co-Authors: Lars-Åke Fredlund, Bengt Jönsson, Joachim ParrowAbstract:We present a semantics for an imperative programming language, Lunsen, with constructs for Concurrency and communication. The semantics is given through a translation into CCS. We have implemented this translation within the framework of the Concurrency Workbench, which is a tool for analysis of finite-state systems in CCS. The point of the translational semantics is that by imposing restrictions on Lunsen so that the semantics of a program is finite-state, we can analyze Lunsen programs automatically using the Concurrency Workbench. As an illustration we include an analysis of a mutual exclusion algorithm.
Hans Hansson - One of the best experts on this subject based on the ideXlab platform.
-
Concurrency bugs in open source software: a case study
Journal of Internet Services and Applications, 2017Co-Authors: Sara Abbaspour Asadollah, Daniel Sundmark, Sigrid Eldh, Hans HanssonAbstract: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.
Soyeon Park - One of the best experts on this subject based on the ideXlab platform.
-
learning from mistakes a comprehensive study on real world Concurrency bug characteristics
Architectural Support for Programming Languages and Operating Systems, 2008Co-Authors: Soyeon Park, Eunsoo Seo, Yuanyuan ZhouAbstract:The reality of multi-core hardware has made concurrent programs pervasive. Unfortunately, writing correct concurrent programs is difficult. Addressing this challenge requires advances in multiple directions, including Concurrency bug detection, concurrent program testing, concurrent programming model design, etc. Designing effective techniques in all these directions will significantly benefit from a deep understanding of real world Concurrency bug characteristics. This paper provides the first (to the best of our knowledge) comprehensive real world Concurrency bug characteristic study. Specifically, we have carefully examined Concurrency bug patterns, manifestation, and fix strategies of 105 randomly selected real world Concurrency bugs from 4 representative server and client open-source applications (MySQL, Apache, Mozilla and OpenOffice). Our study reveals several interesting findings and provides useful guidance for Concurrency bug detection, testing, and concurrent programming language design. Some of our findings are as follows: (1) Around one third of the examined non-deadlock Concurrency bugs are caused by violation to programmers' order intentions, which may not be easily expressed via synchronization primitives like locks and transactional memories; (2) Around 34% of the examined non-deadlock Concurrency bugs involve multiple variables, which are not well addressed by existing bug detection tools; (3) About 92% of the examined Concurrency bugs canbe reliably triggered by enforcing certain orders among no more than 4 memory accesses. This indicates that testing concurrent programs can target at exploring possible orders among every small groups of memory accesses, instead of among all memory accesses; (4) About 73% of the examinednon-deadlock Concurrency bugs were not fixed by simply adding or changing locks, and many of the fixes were not correct at the first try, indicating the difficulty of reasoning concurrent execution by programmers.
-
muvi automatically inferring multi variable access correlations and detecting related semantic and Concurrency bugs
Symposium on Operating Systems Principles, 2007Co-Authors: Soyeon Park, Weihang Jiang, Raluca Ada Popa, Yuanyuan ZhouAbstract:Software defects significantly reduce system dependability. Among various types of software bugs, semantic and Concurrency bugs are two of the most difficult to detect. This paper proposes a novel method, called MUVI, that detects an important class of semantic and Concurrency bugs. MUVI automatically infers commonly existing multi-variable access correlations through code analysis and then detects two types of related bugs: (1) inconsistent updates--correlated variables are not updated in a consistent way, and (2) multi-variable Concurrency bugs--correlated accesses are not protected in the same atomic sections in concurrent programs.We evaluate MUVI on four large applications: Linux, Mozilla,MySQL, and PostgreSQL. MUVI automatically infers more than 6000 variable access correlations with high accuracy (83%).Based on the inferred correlations, MUVI detects 39 new inconsistent update semantic bugs from the latest versions of these applications, with 17 of them recently confirmed by the developers based on our reports.We also implemented MUVI multi-variable extensions to tworepresentative data race bug detection methods (lock-set and happens-before). Our evaluation on five real-world multi-variable Concurrency bugs from Mozilla and MySQL shows that the MUVI-extension correctly identifies the root causes of four out of the five multi-variable Concurrency bugs with 14% additional overhead on average. Interestingly, MUVI also helps detect four new multi-variable Concurrency bugs in Mozilla that have never been reported before. None of the nine bugs can be identified correctly by the original race detectors without our MUVI extensions.
Sara Abbaspour Asadollah - One of the best experts on this subject based on the ideXlab platform.
-
Concurrency bugs in open source software: a case study
Journal of Internet Services and Applications, 2017Co-Authors: Sara Abbaspour Asadollah, Daniel Sundmark, Sigrid Eldh, Hans HanssonAbstract: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.
-
A Study of Concurrency Bugs in an Open Source Software
2016Co-Authors: Sara Abbaspour Asadollah, Daniel Sundmark, Sigrid Eldh, Hans Hansson, Eduard EnoiuAbstract: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. Our basis is a comprehensive analysis of bug reports covering several generations of an open source software system. The analysis involves a total of 4872 bug reports from the last decade, including 221 reports related to Concurrency bugs. We found that Concurrency bugs are different from other bugs in terms of their fixing time and their severity. 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.
