2,251 research outputs found
Thread-Modular Static Analysis for Relaxed Memory Models
We propose a memory-model-aware static program analysis method for accurately
analyzing the behavior of concurrent software running on processors with weak
consistency models such as x86-TSO, SPARC-PSO, and SPARC-RMO. At the center of
our method is a unified framework for deciding the feasibility of inter-thread
interferences to avoid propagating spurious data flows during static analysis
and thus boost the performance of the static analyzer. We formulate the
checking of interference feasibility as a set of Datalog rules which are both
efficiently solvable and general enough to capture a range of hardware-level
memory models. Compared to existing techniques, our method can significantly
reduce the number of bogus alarms as well as unsound proofs. We implemented the
method and evaluated it on a large set of multithreaded C programs. Our
experiments showthe method significantly outperforms state-of-the-art
techniques in terms of accuracy with only moderate run-time overhead.Comment: revised version of the ESEC/FSE 2017 pape
Event Stream Processing with Multiple Threads
Current runtime verification tools seldom make use of multi-threading to
speed up the evaluation of a property on a large event trace. In this paper, we
present an extension to the BeepBeep 3 event stream engine that allows the use
of multiple threads during the evaluation of a query. Various parallelization
strategies are presented and described on simple examples. The implementation
of these strategies is then evaluated empirically on a sample of problems.
Compared to the previous, single-threaded version of the BeepBeep engine, the
allocation of just a few threads to specific portions of a query provides
dramatic improvement in terms of running time
McMini: A Programmable DPOR-based Model Checker for Multithreaded Programs
Model checking has become a key tool for gaining confidence in correctness of
multi-threaded programs. Unit tests and functional tests do not suffice because
of race conditions that are not discovered by those tests. McMini is an
extensible model checker based on DPOR (Dynamic Partial Order Reduction). A
mechanism was invented to declare to McMini new, primitive thread operations,
typically in 100~lines or less of C~code. The mechanism was extended to also
allow the end user to declare alternative thread wakeup policies, including
spurious wakeups from condition variables. One declares: (I) under what
conditions an operation is enabled; (ii) which thread operations are
independent of each other; and (iii) when two operations can be considered as
co-enabled. An optional wakeup policy is implemented by defining when a wait
operation (on a semaphore, condition variable, etc.) is enabled. A new enqueue
thread operation is described, allowing a user to declare alternative wakeup
policies. McMini was first confirmed to operate correctly and efficiently as a
traditional, but extensible model checker for mutex, semaphore, condition
variable, and reader-writer. McMini's extensibility was then tested on novel
primitive operations, representing other useful paradigms for multithreaded
operations. An example is readers-and-two-writers. The speed of model checking
was found to be five times faster and more, as compared to traditional
implementations on top of condition variables. Alternative wakeup policies
(e.g., FIFO, LIFO, arbitrary, etc.) were then tested using an enqueue
operation. Finally, spurious wakeups were tested with a program that exposes a
bug only in the presence of a spurious wakeup.Comment: 24 pages, 1 figur
- …