1 INTRODUCTION
At present, the parallel architecture has become a
typical configuration. The multi-thread technique
can improve the efficiency of program. But it can
cause concurrency bug that is nondeterministic.
Such as the 2003 Northeast blackout,it caused a
loss of more than $30,000,000,000 (Poulsen 2004).
How to detect the concurrency bugs has been the
key to reduce the loss.
Concurrency bug can be divided into 3 types:
data races, atomicity violations and ordering
violations. Some researchers think that the program
atomicity characteristic is extremely significant for
the research of concurrency bug detection. The
atomicity violations often appear in some famous
software, like Apache, MySQL, etc. (Fox, Griffith,
Joseph, Katz, Konwinski, Lee & Stoica 2009).
Therefore, the detecting algorithm of atomicity bugs
is proposed in this paper.
Generally, the research of concurrency bug
detection can be divided into 3 categories: symptom
based detection, invariant based detection, and
dynamic bug avoidance (Alam, Begam, Rahman &
Muzahid 2008). Among them, the invariant based
detection is widely researched, and some novel
detection methods have been proposed, such as AI,
Buggaboo, DefUse, DIDUCE (Hangal & Lam 2002,
Lucia 2008, Shi, Park, Yin, Lu, Zhou, Chen &
Zheng 2010, Zhang, Wu, Lu, Qi, Ren & Zheng
2014). If any invariant is violated, it is highly
probable that concurrency bug occur.
In summary, an algorithm is designed for
extracting the communication invariants in this
paper. It uses the Hash table to divide traces into
groups and checks the relationship between
invariants to ensure whether there is an atomicity
bug or not. Context was added into the detection
step to improve the bug recognition ratio.
2 RELATED WORK
In this paper, we select the read-after-write(RAW)
dependency as the communication invariant. (Lee &
Tucker 2012). The invariants are represented by
ordered pair, <W, R>. Obviously, the atomicity bugs
will occur when programs access the shared variable
in different thread.
The communication invariants are < LcWr, LcRd
> and < RmWr, LcRd >. < LcWr, LcRd > means a
local thread read data from the shared variable
which is written by a local thread. <RmWr, LcRd>
means a local thread read data from the shared
variable which is written by a removed thread (Lucia
& Ceze 2009). Whether the write instruction is
remote or local is relative to the read instruction.
The program named Bank which is shown in
Figure 1 demonstrates an instance which has
atomicity bugs. It may be run in follow manner.
When the main thread runs to pthread_create, the
program is switched to thread1. The main thread will
be not executed until thread1 end. Because the
variant num is modified by thread1, the output is 20
rather than 30. Note that the code in line 10 writes
data to the num, and the code in line 15 reads data
from it. The invariant, <LcWr, LcRd>, has occurred.
And the thread1 modifies the num, then another
An algorithm for detecting atomicity bugs in concurrent programs based
on communication invariants
L.Y.Li, J.D.Sun & S.X.Zhu
Harbin University of Science and Technology, Harbin, China
ABSTRACT: The communication between threads may occur when the multi-core program is running. And
the uncertainty of execution order may lead to concurrency bugs. The atomicity characteristic is extremely
important for the research of the concurrency bug detection. For addressing the problem, an algorithm based
on communication invariants was proposed to detect atomicity bugs in this paper. It can be proved by
experiment that atomicity bugs can be detected by this algorithm efficiently.
KEYWORD: Concurrency bug detection; Atomicity violation; Invariant; Concurrent program