Which compiler optimization options should I use for detecting data races in multithreaded programs?

Software transactional memory is an effective mechanism to avoid concurrency bugs in multithreaded programs. However, two problems hinder the adoption of such traditional systems in the wild world: high human cost for equipping programs with transaction functionality and low compatibility with I/O calls and conditional variables. This paper presents Convoider to solve these problems. By intercepting interthread operations and designating code among them as transactions in each thread, Convoider automatically transactionalizes target programs without any source code modification and recompiling. By saving/restoring stack frames and CPU registers on beginning/aborting a transaction, Convoider makes execution flow revocable. By turning threads into processes, leveraging virtual memory protection and customizing memory allocation/deallocation, Convoider makes memory manipulations revocable. By maintaining virtual file systems and redirecting I/O operations onto them, Convoider makes I/O effects revocable. By converting lock/unlock operations to no-ops, customizing signal/wait operations on condition variables, and committing memory changes transactionally, Convoider makes deadlocks, data races, and atomicity violations impossible. Experimental results show that Convoider succeeds in transparently transactionalizing twelve real-world applications with averagely incurring only 28% runtime overhead and perfectly avoid 94% of thirty-one concurrency bugs used in our experiments. This study can help efficiently transactionalize legacy multithreaded applications and effectively improve the runtime reliability of them.

Download Full-text

IDENTIFICATION OF HIDDEN VULNERABILITIES IN THE SOURCE CODE MULTI-THREAD PROGRAMS BY ANALYSIS OF FUNCTIONAL TRANSITIONS

Journal of the Ural Federal district Information security ◽

10.14529/secur200207 ◽

2020 ◽

pp. 43-48

Author(s):

D. A. Morgunov ◽

Keyword(s):

Mathematical Modeling ◽

Computer Program ◽

Source Code ◽

Theoretic Model ◽

Verification Method ◽

Stochastic Nature ◽

Multithreaded Programs ◽

Function Call ◽

Data Races ◽

Time Required

The article presents a new set-theoretic model and procedures that reduce the time required to detect hidden vulnerabilities in the source code of multi-threaded computer programs, as well as the results of mathematical modeling. Hidden vulnerabilities in the article are under-stood as vulnerabilities leading to data races and deadlocks, since they have a stochastic nature of manifestation during testing, which greatly complicates their identification. The presented model describes the state of each thread of a multi-threaded computer program currently exe-cuting a function and the contents of the function call stack. At the same time, it remains pos-sible to use the model in verification by the Model Checking method, and also eliminates the need to solve the problem of searching for the model invariant. The presented procedures make it possible to formulate specifications for the verification method on models, the implementa-tion of which makes it possible to identify vulnerabilities leading to data races and deadlocks in the source code of multithreaded programs

Download Full-text

An Efficient Algorithm for On-the-Fly Data Race Detection Using an Epoch-Based Technique

Scientific Programming ◽

10.1155/2015/205827 ◽

2015 ◽

Vol 2015 ◽

pp. 1-14 ◽

Cited By ~ 6

Author(s):

Ok-Kyoon Ha ◽

Yong-Kee Jun

Keyword(s):

Efficient Algorithm ◽

Data Race ◽

Concurrency Bugs ◽

Data Race Detection ◽

Detection Algorithms ◽

Race Detection ◽

Multithreaded Programs ◽

Memory Overhead ◽

Data Races ◽

Vector Clocks

Data races represent the most notorious class of concurrency bugs in multithreaded programs. To detect data races precisely and efficiently during the execution of multithreaded programs, the epoch-based FastTracktechnique has been employed. However, FastTrackhas time and space complexities that depend on the maximum parallelism of the program to partially maintain expensive data structures, such as vector clocks. This paper presents an efficient algorithm, callediFT, that uses only the epochs of the access histories. Unlike FastTrack, our algorithm requiresO(1)operations to maintain an access history and locate data races, without any switching between epochs and vector clocks. We implement this algorithm on top of the Pin binary instrumentation framework and compare it with other on-the-fly detection algorithms, including FastTrack, which uses a state-of-the-art happens-before analysis algorithm. Empirical results using the PARSEC benchmark show thatiFT reduces the average runtime and memory overhead to 84% and 37%, respectively, of those of FastTrack.

Download Full-text

Summary of Data Races Solution Algorithms for Multithreaded Programs

Advances in Intelligent Systems and Computing - Big Data Analytics for Cyber-Physical System in Smart City ◽

10.1007/978-981-33-4572-0_86 ◽

2020 ◽

pp. 597-601

Author(s):

Chun Fang

Keyword(s):

Multithreaded Programs ◽

Solution Algorithms ◽

Data Races

Download Full-text

Testing Multi-Threaded Applications Using Answer Set Programming

International Journal of Software Engineering and Knowledge Engineering ◽

10.1142/s021819401850033x ◽

2018 ◽

Vol 28 (08) ◽

pp. 1151-1175 ◽

Cited By ~ 1

Author(s):

Xiaozhen Xue ◽

Sima Siami-Namini ◽

Akbar Siami Namin

Keyword(s):

Answer Set Programming ◽

Test Case ◽

Multithreaded Programs ◽

Java Programs ◽

Hard Problems ◽

Race Conditions ◽

Data Races ◽

Execution Order ◽

Np Hard Problems ◽

Answer Set

We introduce a technique to formally represent and specify race conditions in multithreaded applications. Answer set programming (ASP) is a logic-based knowledge representation paradigm to formally express belief acquired through reasoning in an application domain. The transparent and expressiveness representation of problems along with powerful non-monotonic reasoning power enable ASP to abstractly represent and solve some certain classes of NP hard problems in polynomial times. We use ASP to formally express race conditions and thus represent potential data races often occurred in multithreaded applications with shared memory models. We then use ASP to generate all possible test inputs and thread interleaving, i.e. scheduling, whose executions would result in deterministically exposing thread interleaving failures. We evaluated the proposed technique with some moderate sized Java programs, and our experimental results confirm that the proposed technique can practically expose common data races in multithreaded programs with low false positive rates. We conjecture that, in addition to generating threads scheduling whose execution order leads to the exposition of data races, ASP has several other applications in constraint-based software testing research and can be utilized to express and solve similar test case generation problems where constraints play a key role in determining the complexity of searches.

Download Full-text

ASN: A Dynamic Barrier-Based Approach to Confirmation of Deadlocks from Warnings for Large-Scale Multithreaded Programs

IEEE Transactions on Parallel and Distributed Systems ◽

10.1109/tpds.2014.2307864 ◽

2015 ◽

Vol 26 (1) ◽

pp. 13-23 ◽

Cited By ~ 10

Author(s):

Yan Cai ◽

Changjiang Jia ◽

Shangru Wu ◽

Ke Zhai ◽

Wing Kwong Chan

Keyword(s):

Large Scale ◽

Multithreaded Programs

Download Full-text

Platform Independent Analysis of Probabilities on Multithreaded Programs

International Journal of Software Innovation ◽

10.4018/ijsi.2013070104 ◽

2013 ◽

Vol 1 (3) ◽

pp. 48-65

Author(s):

Yuting Chen

Keyword(s):

Operating System ◽

Static Analysis ◽

Main Idea ◽

Experimental Results ◽

Machine To Machine ◽

Concurrent Program ◽

Acceptable Accuracy ◽

Multithreaded Programs ◽

Independent Analysis ◽

And Performance

A concurrent program is intuitively associated with probability: the executions of the program can produce nondeterministic execution program paths due to the interleavings of threads, whereas some paths can always be executed more frequently than the others. An exploration of the probabilities on the execution paths is expected to provide engineers or compilers with support in helping, either at coding phase or at compile time, to optimize some hottest paths. However, it is not easy to take a static analysis of the probabilities on a concurrent program in that the scheduling of threads of a concurrent program usually depends on the operating system and hardware (e.g., processor) on which the program is executed, which may be vary from machine to machine. In this paper the authors propose a platform independent approach, called ProbPP, to analyzing probabilities on the execution paths of the multithreaded programs. The main idea of ProbPP is to calculate the probabilities on the basis of two kinds of probabilities: Primitive Dependent Probabilities (PDPs) representing the control dependent probabilities among the program statements and Thread Execution Probabilities (TEPs) representing the probabilities of threads being scheduled to execute. The authors have also conducted two preliminary experiments to evaluate the effectiveness and performance of ProbPP, and the experimental results show that ProbPP can provide engineers with acceptable accuracy.

Download Full-text