Detecting atomic-set serializability violations in multithreaded programs through active randomized testing

Lai, Zhifeng; Cheung, Shing-Chi; Chan, W. K.

doi:10.1145/1806799.1806836

Cited by 73 publications

(46 citation statements)

References 33 publications

Supporting

Mentioning

Contrasting

Unclassified

Order By: Relevance

“…There are several tools and techniques that follow this philosophy: for instance, the CHESS tool from Microsoft [18] tests all interleavings that use a bounded number preemptions (unforced context-switches), pursuing the belief that most errors can be made to manifest this way. Several tools concentrate on testing atomicity violating patterns (for varying notions of what atomicity means), with the philosophy that they are much more likely to contain bugs [17,19,20,33]. However, systematically testing even smaller classes of interleavings is often impossible in practice, as there are often too many of them.…”

Section: Approximation To the Shared Communication Levelmentioning

confidence: 99%

Predicting null-pointer dereferences in concurrent programs

Farzan

Madhusudan

Razavi

et al. 2012

Proceedings of the ACM SIGSOFT 20th International Symposium on the Foundations of Software Engineering

View full text Add to dashboard Cite

We propose null-pointer dereferences as a target for finding bugs in concurrent programs using testing. A null-pointer dereference prediction engine observes an execution of a concurrent program under test and predicts alternate interleavings that are likely to cause null-pointer dereferences. Though accurate scalable prediction is intractable, we provide a carefully chosen novel set of techniques to achieve reasonably accurate and scalable prediction. We use an abstraction to the shared-communication level, take advantage of a static lock-set based pruning, and finally, employ precise and relaxed constraint solving techniques that use an SMT solver to predict schedules. We realize our techniques in a tool, ExceptioNULL, and evaluate it over 13 benchmark programs and find scores of nullpointer dereferences by using only a single test run as the prediction seed for each benchmark.

show abstract

Section: Approximation To the Shared Communication Levelmentioning

confidence: 99%

Predicting null-pointer dereferences in concurrent programs

Farzan

Madhusudan

Razavi

et al. 2012

Proceedings of the ACM SIGSOFT 20th International Symposium on the Foundations of Software Engineering

View full text Add to dashboard Cite

show abstract

“…Note that we do not address here the problem of executing the test program on a random schedule. There exists much prior work on generating thread schedules for testing concurrent software, including noise making [7,25], active random scheduling [22,13], or model checking [27,17].…”

Section: Phase I Of Relaxermentioning

confidence: 99%

“…This work applies active random testing [22,13] to predict and reproduce violations of sequential consistency in parallel programs. Several other recent techniques have been proposed to confirm potential bugs in parallel programs using random testing.…”

Section: Related Workmentioning

confidence: 99%

“…Active testing [22] is a two-phase analysis and testing approach for predicting and confirming concurrency bugs. Active testing techniques have been developed for detecting real data races [22,13], atomicity violations [19,13], and deadlocks [11]. In the first phase of active testing, a static or dynamic analysis is used to predict potential concurrency bugs in a test program-e.g.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Testing concurrent programs on relaxed memory models

Burnim

Sen

Stergiou

2011

Proceedings of the 2011 International Symposium on Software Testing and Analysis

View full text Add to dashboard Cite

High-performance concurrent libraries, such as lock-free data structures and custom synchronization primitives, are notoriously difficult to write correctly. Such code is often implemented without locks, instead using plain loads and stores and low-level operations like atomic compare-and-swaps and explicit memory fences. Such code must run correctly despite the relaxed memory model of the underlying compiler, virtual machine, and/or hardware. These memory models may reorder the reads and writes issued by a thread, greatly complicating parallel reasoning.We propose RELAXER, a combination of predictive dynamic analysis and software testing, to help programmers write correct, highly-concurrent programs. Our technique works in two phases. First, RELAXER examines a sequentially-consistent run of a program under test and dynamically detects potential data races. These races are used to predict possible violations of sequential consistency under alternate executions on a relaxed memory model. In the second phase, RELAXER re-executes the program with a biased random scheduler and with a conservative simulation of a relaxed memory model in order to create with high probability a predicted sequential consistency violation. These executions can be used to test whether or not a program works as expected when the underlying memory model is not sequentially consistent.We have implemented RELAXER for C and have evaluated it on several synchronization algorithms, concurrent data structures, and parallel applications. RELAXER generates many executions of these benchmarks with violations of sequential consistency, highlighting a number of bugs under relaxed memory models.

show abstract

“…Reasoning about conflicting accesses that are simultaneously enabled but ineffective on the rest of the execution is the main challenge in both static [7,16,31] and dynamic [3,14,21,23,33,34] techniques for checking atomicity and linearizability. The Purity work [13] and QED [10] provide static analyses to rule out spurious warnings due to such conflicts by abstracting these operations to no-op's.…”

Section: Related Workmentioning

confidence: 99%

NDetermin: Inferring Nondeterministic Sequential Specifications for Parallelism Correctness

Burnim¹,

Elmas²,

Necula³

et al. 2011

View full text Add to dashboard Cite

A key reason for the great difficulty of writing, testing, and verifying parallel programs is the need to reason simultaneously about not only the sequential correctness of each part of a program in isolation, but also about all possible nondeterministic interleavings of the program's parallel threads. Thus, there has been much interest in techniques for separately testing or verifying the correctness of a program's use of parallelism, allowing the program's functional correctness to be tested or verified in a sequential way.Nondeterministic Sequential (NDSeq) specifications have been proposed as a means for achieving this decomposition in testing, debugging, and verifying a program's parallelism correctness and its sequential functional correctness. An NDSeq specification for a parallel program is a sequential version of the program, with no parallel threads but with some limited, controlled nondeterminism. A program's use of parallelism is correct if, for every execution of the parallel program, there exists an execution of the NDSeq specification producing the same result. Functional correctness can then be checked on this NDSeq specification, without any interleaving of parallel threads.While NDSeq specifications have been used successfully to check parallelism correctness, manually writing NDSeq specifications for programs can be a challenging and time-consuming process. Thus, in this work, we propose a technique for automatically inferring a likely NDSeq specification for a parallel program. Given a few representative executions of a parallel program, our technique combines dynamic data flow analysis and Minimum-Cost Boolean Satisfiability (MinCostSAT) solving to infer a likely NDSeq specification for the program's parallelism. We have implemented our technique for Java in a prototype tool called NDETERMIN. For a number of benchmarks, our tool infers equivalent or stronger NDSeq specifications than those previously written manually.

show abstract

Detecting atomic-set serializability violations in multithreaded programs through active randomized testing

Cited by 73 publications

References 33 publications

Predicting null-pointer dereferences in concurrent programs

Predicting null-pointer dereferences in concurrent programs

Testing concurrent programs on relaxed memory models

NDetermin: Inferring Nondeterministic Sequential Specifications for Parallelism Correctness

Contact Info

Product

Resources

About