pattern-based synthesis of synchronization for the c++ memory model yuri meshman, noam rinetzky,...
TRANSCRIPT
1
Pattern-based Synthesis of Synchronization for the C++ Memory Model
Yuri Meshman, Noam Rinetzky, Eran Yahav
2
Goal
SynSynCpp
P
S
Verified
Note:Assuming: Asking:
3
Thread 1:
store (flag1, 1);while(load (flag0) = 1 ){ if(load (turn) = 0 ){
store (flag1, 0);while(load (turn) = 0 )yield();store (flag1, 1);
} }... // critical sectionstore (turn, 0);store(flag1, 0);
store (flag0, 0);store (flag1, 0);store (turn, 0);Thread 0:
store(flag0, 1);while(load (flag1) = 1 ){ if(load (turn) =1 ){
store (flag0, 0); while(load (turn) = 1 ) yield();
store (flag0, 1); } }... // critical sectionstore (turn, 1);store (flag0, 0);
Dekkerβs Algorithm
sequential consistency Yesspec: mutual exclusion over critical section
4
Thread 1:
store (flag1, 1);while(load (flag0) = 1 ){ if(load (turn) = 0 ){
store (flag1, 0);while(load (turn) = 0 )yield();store (flag1, 1);
} }... // critical sectionstore (turn, 0);store(flag1, 0);
store (flag0, 0);store (flag1, 0);store (turn, 0);Thread 0:
store(flag0, 1);while(load (flag1) = 1 ){ if(load (turn) =1 ){
store (flag0, 0); while(load (turn) = 1 ) yield();
store (flag0, 1); } }... // critical sectionstore (turn, 1);store (flag0, 0);
Dekkerβs Algorithm
sequential consistency
C++ relaxed model
Yes
No
rf rf
spec: mutual exclusion over critical section
5
Thread 1:
storeSC (flag1, 1);while(loadSC (flag0) = 1 ){ if(loadSC (turn) = 0 ){
storeRLX (flag1, 0);while(loadRLX (turn) = 0 )yield();storeRLX (flag1, 1);
} }... // critical sectionstoreSC (turn, 0);storeREL(flag1, 0);
storeSC (flag0, 0);storeSC (flag1, 0);storeSC (turn, 0);Thread 0:
storeSC(flag0, 1);while(loadSC (flag1) = 1 ){ if(loadSC (turn) =1 ){
storeRLX (flag0, 0); while(loadRLX (turn) = 1 ) yield();
storeRLX (flag0, 1); } }... // critical sectionstoreSC (turn, 1);storeREL (flag0, 0);
Dekkerβs Algorithm
sequential consistency
C++ relaxed model
Yes
No
spec: mutual exclusion over critical section
Yes
6
In a nutshell
β’ Goal Automatic inference of efficient and correct synchronization under C++ memory model.β’ finite-state programs with bounded executions.
β’ Challenge Adding minimal and correct synchronization.
β’ Solution 1. Assume maximally relaxed parameters setting and 2. Iteratively remove behaviors until specification satisfied.
7
Dekkerβs Algorithm
Thread 1:
storeRLX (flag1, 1);while(loadRLX (flag0) = 1 ){ if(loadRLX (turn) = 0 ){
storeRLX (flag1, 0);while(loadRLX (turn) = 0 )yield();storeRLX (flag1, 1);
} }... // critical sectionstoreRLX (turn, 0);storeREL(flag1, 0);
storeRLX (flag0, 0);storeRLX(flag1, 0);storeRLX(turn, 0);Thread 0:
storeRLX (flag0, 1);while(loadRLX (flag1) = 1 ){ if(loadRLX (turn) =1 ){
storeRLX (flag0, 0); while(loadRLX (turn) = 1 ) yield();
storeRLX (flag0, 1); } }... // critical sectionstoreRLX (turn, 1);storeRLX (flag0, 0);
store flag0, 0
store flag1, 0
store turn, 0
store flag0, 1
load flag1
store flag1, 1
store turn, 1
load flag0
sb
sb
sb
sb
sb
asw asw
store flag1, 0store flag0, 0
sb
sb
rf
rf store turn, 0sb
critical section critical section
What is an execution
β’ Execution trace is:β Instructions
β relations:total/partial orders
β Axioms on those relations
8
store flag0, 0
store flag1, 0
store turn, 0
store flag0, 1
load flag1
store flag1, 1
store turn, 1
load flag0
sb
sb
sb
sb
sb
asw asw
store flag1, 0store flag0, 0
sb
sb
rf
rf store turn, 0sb
critical section critical section
*rf β read from sb β sequence before asw β additionally synchronize with sw β synchronize with
Error trace 1 find pattern LB
*rf β read from sb β sequence before asw β additionally synchronize with sw β synchronize with
9
store flag0, 0
store flag1, 0
store turn, 0
store flag0, 1
load flag1
store flag1, 1
store turn, 1
load flag0
sb
sb
sb
sb
sb
asw asw
store flag1, 0store flag0, 0
sb
sb
rf
rf store turn, 0sb
critical section critical section
load buffering
10
Error trace 1 preventedstore flag0, 0
store flag1, 0
store turn, 0
store flag0, 1
loadACQ flag1
store flag1, 1
store turn, 1
load flag0
sb
sb
sb
sb
sb
asw asw
storeREL flag1, 0store flag0, 0
sb
sb
rf
rf store turn, 0sb
critical section critical section
sw
*rf β read from sb β sequence before asw β additionally synchronize with sw β synchronize with
11
Dekkerβs Algorithm
sequential consistency
C++ relaxed model
Yes
No
spec: mutual exclusion over critical section
Thread 1:
storeRLX (flag1, 1);while(loadRLX (flag0) = 1 ){ if(loadRLX (turn) = 0 ){
storeRLX (flag1, 0);while(loadRLX (turn) = 0 )yield();storeRLX (flag1, 1);
} }... // critical sectionstoreRLX (turn, 0);storeREL(flag1, 0);
storeRLX (flag0, 0);storeRLX(flag1, 0);storeRLX(turn, 0);Thread 0:
storeRLX (flag0, 1);while(loadACQ (flag1) = 1 ){ if(loadRLX (turn) =1 ){
storeRLX (flag0, 0); while(loadRLX (turn) = 1 ) yield();
storeRLX (flag0, 1); } }... // critical sectionstoreRLX (turn, 1);storeRLX (flag0, 0);
12
Thread 1:
storeSC (flag1, 1);while(loadSC (flag0) = 1 ){ if(loadSC (turn) = 0 ){
storeRLX (flag1, 0);while(loadRLX (turn) = 0 )yield();storeRLX (flag1, 1);
} }... // critical sectionstoreSC (turn, 0);storeREL(flag1, 0);
storeSC (flag0, 0);storeSC (flag1, 0);storeSC (turn, 0);Thread 0:
storeSC(flag0, 1);while(loadSC (flag1) = 1 ){ if(loadSC (turn) =1 ){
storeRLX (flag0, 0); while(loadRLX (turn) = 1 ) yield();
storeRLX (flag0, 1); } }... // critical sectionstoreSC (turn, 1);storeREL (flag0, 0);
Dekkerβs Algorithm
sequential consistency
C++ relaxed model
Yes
No
spec: mutual exclusion over critical section
Yes
13
Goal
SynSynCpp
P
S
Verified
Note:Assuming: pecAsking:
14
Synthesis of Synchronization for the C++ Memory Model
SynSynCpp
P
SVerified
Note:Assuming: Asking:
Model Checker
}
Detect patterns and avoid traces
ππ΄ππ
implement
All solutions to
15
Challenges
1. ModelChecker: Enumerate error traces? 2. How to detect patterns and avoid traces?3. How to collect all blocked bad traces and produce a
solution?
CDSchecker
Step 1: Get an error trace
16
store flag0, 0
store flag1, 0
store turn, 0
store flag0, 1
load flag1
store flag1, 1
store turn, 1
load flag0
sb
sb
sb
sb
sb
asw asw
store flag1, 0store flag0, 0
sb
sb
rf
rf store turn, 0sb
critical section critical section
Step 2: Find a pattern
17
load flag1 load flag0
store flag1, 0store flag0, 0
sb
rfsb
Load Buffering pattern
18
Step 3: block the pattern
repeat 1-3 for all error traces
Load Buffering pattern
REL -- store flag0, 1
ACQ -- load flag1
REL -- store flag1, 1
ACQ -- load flag0
19
π1
π2
π3
π4
π ππ1βππβππππ£πππ‘ βπΈπππππππ 1=π1β§π4
π ππππ£πππ‘βπΈπππππππ 1= π ππ1βππβππππ£πππ‘βπΈπππππππ 1β¨ π ππ2βππβππππ£πππ‘ βπΈπππππππ1β¨β¦
π= π ππππ£πππ‘ βπΈπππππππ1β§ π ππππ£πππ‘βπΈπππππππ 2β§β¦
π ππ 2βππβππππ£πππ‘ βπΈπππππππ1=π3β§π2
Step 4: construct
REL -- store flag0, 1
ACQ -- load flag1
REL -- store flag1, 1
ACQ -- load flag0
20
Step 5: Constructing Program Solution
ππ΄ππ
πππππππππ‘
avoidance =
sol1 sol2
π1
π2
π3
π4REL -- store flag0, 1
ACQ -- load flag1
REL -- store flag1, 1
ACQ -- load flag0
All solutions to
21
Litmus test patterns
First approach:From litmus tests to patterns
(Store Buffering) (Message Passing) (Write Read Causality)
(Independent Reads Independent Writes) (Load Buffering)
22
Patterns relaxation
(Load Buffering)
Unwindingthe cycle
Abstraction
Abstraction
Generalization
23
Abstract patterns
RD_CL
RD_MSMissed Store
based on C++RMM RD property
Cycle
R one of two:1. R = hb U rf --- preventable with Rel-Acq synchronization2. R = possible order of instruction β preventable with SC
24
Benchmarks
β’ 9 concurrent algorithmsβ Mutual exclusion algorithmsβ RCU where an update waits only for the reads
whose consistency it affectsβ’ Safety specifications
β mutual exclusion and reachability invariantsβ stack/RCU coherence invariants
25
Results
AlgorithmTime(s)
# minimal solutions
Inferred synchronization (SC, REL, ACQ, RLX)
abp 20s.89 5 (5, 0, 0, 1), (4, 0, 0, 2), β¦
dekker 3m:22 13 (10, 1, 0, 8), (13, 0, 1, 5), β¦
d-prcu-v1 3m:14 7 (7, 2, 1, 0), (7, 1, 0, 2), β¦
d-prcu-v2 3h:53m 17 (9, 2, 1, 4), (12, 1, 1, 2), ...
Kessel 57m:16 2 (13, 1, 0, 0), (14, 0, 0, 0)
peterson 26m:41 2 (11, 1, 0, 1), *(12, 1, 0, 0), (13, 0, 0, 0)
bakery 10m:21 6 (16, 1, 1, 0), (17, 0, 1, 0), β¦
ticket 1m:08 4 (9, 0, 0, 1), (8, 0, 0, 2), β¦
treiber stack 1h:05 1 (0, 5, 3, 4) SC
RLX
ACQREL
Memory access patternshierarchy
26
Synthesis of Synchronization for the C++ Memory Model
SynSynCpp
P
SVerified
Note:Assuming: Asking:
Model Checker
}
Detect patterns and avoid traces
ππ΄ππ
implement
avoidance
27
Summary
β’ Synthesis procedure for inferring memory order synchronizations for C++ RMM
β’ Searching for violation patternsβ’ Generalized concrete patterns to abstract onesβ’ Successfully synthesized nontrivial memory order
synchronization for challenging algorithms
Future Work: β’ Violation patterns and avoidance templates are not
completeβ’ Finite-state programs with bounded executions.
Tool: http://www.cs.technion.ac.il/~yurime/SynSynCpp/SynSynCppTool_v1stat.htm