E. Farchi, Itai Segall, João M. Lourenço, Diogo Sousa
{"title":"Using program closures to make an application programming interface (API) implementation thread safe","authors":"E. Farchi, Itai Segall, João M. Lourenço, Diogo Sousa","doi":"10.1145/2338967.2336810","DOIUrl":"https://doi.org/10.1145/2338967.2336810","url":null,"abstract":"Consider a set of methods implementing an Application Programming Interface (API) of a given library or program module that is to be used in a multithreaded setting. If those methods were not originally designed to be thread safe, races and deadlocks are expected to happen. This work introduces the novel concept of program closure and describes how it can be applied in a methodology used to make the library or module implementation thread safe, by identifying the high level data races introduced by interleaving the parallel execution of methods from the API. High-level data races result from the misspecification of the scope of an atomic block, by wrongly splitting it into two or more atomic blocks sharing a data dependency. \u0000 Roughly speaking, the closure of a program P, clos(P), is obtained by incrementally adding new threads to P in such a way that enables the identification of the potential high level data races that may result from running P in parallel with other programs. \u0000 Our model considers the methods implementing the API of a library of program module as concurrent programs and computes and analyses their closure in order to identify high level data races. These high level data races are inspected and removed to make the interface thread safe. We illustrate the application of this methodology with a simple use case.","PeriodicalId":291507,"journal":{"name":"Parallel and Distributed Systems: Testing, Analysis, and Debugging","volume":"17 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2012-07-16","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"128083365","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Yasushi Negishi, H. Murata, Guojing Cong, H. Wen, I. Chung
{"title":"A static analysis tool using a three-step approach for data races in HPC programs","authors":"Yasushi Negishi, H. Murata, Guojing Cong, H. Wen, I. Chung","doi":"10.1145/2338967.2336809","DOIUrl":"https://doi.org/10.1145/2338967.2336809","url":null,"abstract":"Multicore processors are becoming dominant in the high performance computing (HPC) area, so multithread programming with OpenMP is becoming a key to good performance on such processors, though debugging problems remain. In particular, it is difficult to detect data races among threads with nondeterministic results, thus calling for tools to detect data races. Because HPC programs tend to run for long periods, detection tools that do not need to run the target programs are strongly preferred. We developed a static program analysis tool to detect data races in OpenMP loops in FORTRAN programs. Programmers can quickly use the tool at compile time without executing the target program. Because static analysis tools tend to report many false positives, we counted the false positives in some large applications to assess the utility and limits of static analysis tools. We have devised a new approach to detect data races. Our approach combines existing program analysis methods with a new analysis. We experimented with NAS parallel benchmarks and two real applications, GTC for plasma physics and GFMC for nuclear physics. Our new analysis method also reduces number of reported candidates from totally 97 to 33 in these applications. We found 13 previously unknown bugs out of 33 candidates reported by our prototype. Our analysis is fast enough for practical use, since the analysis time for the NAS parallel benchmark was shorter than the compilation time (18.5 seconds compared to 33.0 seconds).","PeriodicalId":291507,"journal":{"name":"Parallel and Distributed Systems: Testing, Analysis, and Debugging","volume":"64 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2012-07-16","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"125865404","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
{"title":"Noise-based testing and analysis of multi-threaded C/C++ programs on the binary level","authors":"Jan Fiedor, Tomáš Vojnar","doi":"10.1145/2338967.2336813","DOIUrl":"https://doi.org/10.1145/2338967.2336813","url":null,"abstract":"This paper aims at allowing noise-based testing and dynamic analysis of multi-threaded C/C++ programs on the binary level. First, several problems of monitoring multi-threaded C/C++ programs on the binary level are discussed together with their possible solutions. Next, a brief overview of noise injection techniques is provided along with a proposal of improving them using a fine-grained combination of several noise injection techniques within a single program. The proposed ideas have been implemented in a prototype way using the PIN framework for Intel binaries and tested on a~set of multi-threaded C/C++ programs. The obtained experimental evidence justifying the proposed solutions and illustrating the effect of various noise settings in the context of multi-threaded C/C++ programs is discussed.","PeriodicalId":291507,"journal":{"name":"Parallel and Distributed Systems: Testing, Analysis, and Debugging","volume":"10 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2012-07-16","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"114138754","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Ok-Kyoon Ha, In-Bon Kuh, G. M. Tchamgoue, Yong-Kee Jun
{"title":"On-the-fly detection of data races in OpenMP programs","authors":"Ok-Kyoon Ha, In-Bon Kuh, G. M. Tchamgoue, Yong-Kee Jun","doi":"10.1145/2338967.2336808","DOIUrl":"https://doi.org/10.1145/2338967.2336808","url":null,"abstract":"OpenMP provides a portable way to achieve high performance and simple compiler directives to transform a sequential program into parallel program. It is important to detect data races in OpenMP programs, because they may lead to unpredictable results from an execution of the programs. To detect data races that occur during an execution of OpenMP programs, the representative on-the-fly technique, Helgrind+, mainly focuses on reducing false positives. Unfortunately, this technique is still imprecise and inefficient, when applied to large OpenMP programs which use a structured fork-join parallelism with a large number of threads. This paper presents a novel approach which efficiently detects apparent data races without false positives in large OpenMP programs. This approach combines an efficient thread labeling to maintain the logical concurrency of thread segments with a precise detection protocol to analyze conflicting accesses to every shared memory location. We implemented this approach on top of the Pin binary instrumentation framework and compared it with Helgrind+. Empirical results using OpenMP benchmarks show that our technique detects apparent data races without false positives contrarily to Helgrind+, while reducing the average runtime overhead to 19% of Helgrind+ with a similar amount of space overhead.","PeriodicalId":291507,"journal":{"name":"Parallel and Distributed Systems: Testing, Analysis, and Debugging","volume":"4 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2012-07-16","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"122322245","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
J. S. Bradbury, Itai Segall, E. Farchi, Kevin Jalbert, D. Kelk
{"title":"Using combinatorial benchmark construction to improve the assessment of concurrency bug detection tools","authors":"J. S. Bradbury, Itai Segall, E. Farchi, Kevin Jalbert, D. Kelk","doi":"10.1145/2338967.2336812","DOIUrl":"https://doi.org/10.1145/2338967.2336812","url":null,"abstract":"Many different techniques for testing and analyzing concurrency programs have been proposed in the literature. Currently, it is difficult to assess the fitness of a particular concurrency bug detection method and to compare it to other bug detection methods due to a lack of unbiased data that is representative of the kinds of concurrency programs that are used in practice. To address this problem we propose a new benchmark of concurrent Java programs that is constructed using combinatorial test design. In this paper we present our combinatorial model for creating a benchmark, we propose a new concurrency benchmark and we discuses the relationship between our new benchmarks and existing benchmarks. Specific combinations of the model parameters define different interleaving spaces, thus differentiating between different test tools.","PeriodicalId":291507,"journal":{"name":"Parallel and Distributed Systems: Testing, Analysis, and Debugging","volume":"14 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2012-07-16","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"126452341","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
{"title":"Refactoring Java programs using concurrent libraries","authors":"K. Ishizaki, S. Daijavad, T. Nakatani","doi":"10.1145/2002962.2002970","DOIUrl":"https://doi.org/10.1145/2002962.2002970","url":null,"abstract":"Multithread programming is becoming ever-more important to exploit the capabilities of multicore processors. Versions of Java prior to version 5 provide only the synchronized construct as a consistency primitive, which causes a performance scalability problem for multicore machines. Therefore, Java 5 added the java.util.concurrent package to reduce lock contention. Programmers must manually rewrite their existing code to use this package in existing programs. There are two typical rewritings methods. One is to replace an operation on a variable within a synchronized block with an atomic-lock-free version. The other is to replace a sequential concurrent class with its concurrent version. The conventional rewriting approach has three deficiencies. One problem is transformations that may change the behavior of a program. The second problem is missed modifications to be rewritten. The third problem is two difference writing techniques are applied individually to each code fragment even in the same method. This paper describes our refactoring algorithms that address these three problems as they rewrite Java code for scalable performance. We use inter-procedural pointer analysis and consistency tests among the candidate code fragments.","PeriodicalId":291507,"journal":{"name":"Parallel and Distributed Systems: Testing, Analysis, and Debugging","volume":"4 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2011-07-17","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"121899601","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
{"title":"Deterministic replay for MCAPI programs","authors":"Mohamed M. Elwakil, Z. Yang","doi":"10.1145/2002962.2002966","DOIUrl":"https://doi.org/10.1145/2002962.2002966","url":null,"abstract":"The Multicore Communications API (MCAPI) is a new message passing API that was released by the Multicore Association. MCAPI provides an interface designed for closely distributed embedded systems with multiple cores on a chip and/or chips on a board. Similar to concurrent programs in other domains, debugging MCAPI programs is a challenging task due to their non-deterministic behavior. In this paper we present a tool that is able to deterministically replay the executions of MCAPI programs, which provides valuable insight for MCAPI developers in case of failure.","PeriodicalId":291507,"journal":{"name":"Parallel and Distributed Systems: Testing, Analysis, and Debugging","volume":"1 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2011-07-17","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"131198483","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
{"title":"Extending a distributed loop network to tolerate node failures","authors":"A. Farrag","doi":"10.1145/2002962.2002971","DOIUrl":"https://doi.org/10.1145/2002962.2002971","url":null,"abstract":"We examine the problem of extending a distributed loop network by adding spare nodes and links so as to make it more fault-tolerant. The optimization criterion used in finding a fault-tolerant solution is to reduce the node-degree of the overall network. This is important in practice due to the limitation on the number of links allowed per node in VLSI design. Our results indicate that the solutions obtained (numerically or analytically) are efficient, i.e., either optimal or nearly-optimal.","PeriodicalId":291507,"journal":{"name":"Parallel and Distributed Systems: Testing, Analysis, and Debugging","volume":"76 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2011-07-17","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"123823252","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
S. Souza, Maria A. S. Brito, Rodolfo A. Silva, P. L. D. Souza, E. Zaluska
{"title":"Research in concurrent software testing: a systematic review","authors":"S. Souza, Maria A. S. Brito, Rodolfo A. Silva, P. L. D. Souza, E. Zaluska","doi":"10.1145/2002962.2002964","DOIUrl":"https://doi.org/10.1145/2002962.2002964","url":null,"abstract":"The current increased demand for distributed applications in domains such as web services and cloud computing has significantly increased interest in concurrent programming. This demand in turn has resulted in new testing methodologies for such systems, which take account of the challenges necessary to test these applications. This paper presents a systematic review of the published research related to concurrent testing approaches, bug classification and testing tools. A systematic review is a process of collection, assessment and interpretation of the published papers related to a specific search question, designed to provide a background for further research. The results include information about the research relationships and research teams that are working in the different areas of concurrent programs testing.","PeriodicalId":291507,"journal":{"name":"Parallel and Distributed Systems: Testing, Analysis, and Debugging","volume":"72 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2011-07-17","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"124872928","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
{"title":"Java replay for dependence-based debugging","authors":"Jan Lönnberg, M. Ben-Ari, L. Malmi","doi":"10.1145/2002962.2002967","DOIUrl":"https://doi.org/10.1145/2002962.2002967","url":null,"abstract":"In this article, we present a system intended to help students understand and debug concurrent Java programs. The system instruments Java classes to produce execution traces. These traces can then be used to construct a dynamic dependence graph showing the interactions between the different operations performed in the program. These interactions are used as the basis for an interactive visualisation that can be used to explore the execution of a program and trace incorrect program behaviour back from a symptom to the execution of incorrect code.","PeriodicalId":291507,"journal":{"name":"Parallel and Distributed Systems: Testing, Analysis, and Debugging","volume":"548 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2011-07-17","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"123127851","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}