Marathon - RV2011

Marathon: Detecting Atomic-
Set Serializability Violations
with Conﬂict Graphs
William Sumner Christian Hammer Julian Dolby
Purdue Utah State IBM Watson

RV 2011 - September 2011 - San Francisco, CA
Thursday, September 29, 2011 1

Outline

Motivation: ﬁnding concurrency errors

Approach: atomic sets and serializability

Implementation: conﬂict graphs

Results

Related work and conclusions


Finding Concurrency Errors

Parallel hardware is ubiquitous, even phones

Software must exploit this concurrency

Concurrency allows new kinds of bugs

Multiple threads simultaneously access data

Bugs when simultaneous access is “incorrect”


Atomic Sets
class Point {
double x;
double y;
}

Fields x and y make up a logical point

Fields x and y denote an atomic set

Atomic Set Serializability

Concurrent operations see consistent points


Units of Work
class Point { Threads
double x; move mag
double y; x x
}
x
void move(int x, int y) {
this.x += x; x y
this.y += y; y y
}
y
double mag() {
return Math.sqrt(x*x+y*y);
}

Concurrency Errors
class Point { Threads
double x; move mag
double y; x x
}
x
void move(int x, int y) {
x
this.x += x;
this.y += y; y
} y
y
double mag() {
return Math.sqrt(x*x+y*y); y
}

Concurrency Errors
Look for concurrency errors per atomic set

Improve accuracy:

Focus on related memory locations

Focus on conceptual units of work on them

Aid implementation:

Short-running units of work, small sets

Enables compact conﬂict graph structure


Inferring Atomic Sets
Must infer atomic sets

Make approach applicable to existing code

Minimize burden on developer or tester

Exploit object structure to infer atomic sets

Assume each object deﬁnes an atomic set

Heuristics to include “child” objects


“Child” Object Example
class Point { class Rectangle {
double x; Point ll;
double y; Point ur;
} }
double area() {
return
(ur.x - ll.x) * (ur.y - ll.y);
}

heuristic: direct access to field
of a field means field is a child

Conﬂict Graph Implementation
A conﬂict graph records tasks, memory uses

A node in the graph is a unit of work

Edges capture memory dependence

write-read, read-write, write-write

Atomic sets model keep graph manageable

Individual units of work tend to be short

Old tasks can be garbage collected


Conﬂict Graph Examples
move mag move mag
x x
x x
x x
x WAR
y
y y
y
RAW x
y y WAR
y y

Evaluation
Assess quality of error reports

how many bugs?

false positives: not real bugs?

false negatives: missed known bugs?

Measure overhead

Suite of standard benchmarks and real codes


Evaluation
slowdown slowdown
benchmark size cycles reports FP
(memory) (disk)
ConTest 241 141 139 5 1.4 1.1
Jigsaw 142K 1 1 0 3.9 3.9
Jspider 56K 4 4 0 1.2 1.2
Weblech 1874 2 2 0 1.0 1.0
ArrayBQ 1576 2 7 0 26.6 14.1
ArrayList 2266 79 60 0 48.9 19.6
LinkedBQ 1620 1 1 0 20.1 16.9
DelayQueue 1961 43 43 0 23.0 17.5
Vector 2636 131 131 0 52.8 10.4

Related Work

Low-level data races: do not denote errors

Atomicity: full heap atomicity vs atomic sets

Serializability: relaxed criteria vs atomic sets

Velodrome[]: bug focus, fuller implementation

Prior atomic sets: patterns vs conﬂict graph


Conclusions
Efficient and sound concurrency bug finding

Overhead comparable or better than prior

Sound w.r.t. atomic set model

Atomic sets accurately model intent

Heuristics allow inference

Evaluated w.r.t. programmer intent

Few false positives and negatives

Future work: further refine heuristics

Evaluation
resultBuf[i] = vector.getFreeBlockIndex();
if (resultBuf[i] != -1) {
vector.markAsAllocatedBlock(resultBuf[i]);
}

False negative example

API of AllocationVector not encapsulated

Requires client to synchronize pair of calls


Marathon - RV2011

Recommended

Recommended

More Related Content

Viewers also liked

Viewers also liked (7)

Similar to Marathon - RV2011

Similar to Marathon - RV2011 (6)

Marathon - RV2011