Yuxi Chen, Shu Wang, Shan Lu, and Karthikeyan Sankaralingam *

Transcription

1 Yuxi Chen, Shu Wang, Shan Lu, and Karthikeyan Sankaralingam * *

2 2 q Synchronization mistakes in multithreaded programs Thread 1 Thread 2 If(ptr){ tmp = *ptr; ptr = NULL; } Segfault

3 q Common q Hard to diagnose and fix correctly q Disasters in production runs 3

4 4 q Semantic correctness q Performance v Low recovery latency v Low overhead So what s the solution?

5 5 Thread 1 Thread 2 Thread 3 Execution Failure site

6 6 Traditional Roll-back Recovery Thread 1 Thread 2 Thread 3 Execution Whole-program memory-state checkpoint Failure site

7 7 Recovery capability Rx good capability poor performance 0.5 Overhead (%) 10 [1]Rx: Treating bugs as allergies a safe method to survive software failure, SOSP 05

8 8 ConAir Roll-back Recovery Thread 1 Thread 2 Execution Thread 3 setjmp longjmp Failure site

9 9 Recovery capability Rx good capability poor performance poor capability good performance ConAir 0.5 Overhead (%) 10

10 10 q ConAir cannot reexecute shared-variable writes Thread 1 Thread 2 Heap If(ptr){ *buf = newbuf(); tmp = *ptr; ptr = NULL; *buf = 0x123 0x234 *buf old = 0x123 *buf new = 0x234 } Segfault

11 11 Recovery capability Rx better capability worse performance worse capability better performance ConAir 0.5 Overhead (%) 10

12 12 BugTM static analysis code transformation Xbegin Xabort Xend Leveraging HTM Recovery capability BugTM H Rx ConAir Overhead (%) 10

13 13 BugTM static analysis code transformation Xbegin/Setjmp Xabort/Longjmp Xend Recovery capability Rx BugTM HS BugTM H ConAir Overhead (%)

14 Outline: 1. BugTM H 2. BugTM HS 3. Evaluation Methodology 4. Experiment Results 5. Conclusion 14

15 15 q Implicit checkpoint q Rollback-reexecution OPPORTUNITY CHALLENGE

16 16 q Performance challenges v High frequency of transaction uses v Unsuitable content of transactions (eg. trapping instructions) v Nesting && Loops

17 17 q Performance challenges q Correctness challenges v Unpaired transaction-start and transaction-commit v Deterministic aborts (eg. trapping instruction aborts)

18 18 q Performance challenges q Correctness challenges q Failure recovery challenges v Surround the buggy codes when failures happen v HTM-abort handlers 1. Carefully design HTM start, commit, and abort routines 2. Selectively insert HTM start, commit, and abort routines

19 19 q Xbegin q Xend q Xtest q Xabort Thread 1 +Xbegin(); + Xabort(); assertion(); +if(xtest()) +Xend(); + Xend();

20 20 mxbegin(){ if(!xtest()) Xbegin(); } No nested TM! mxend(){ if(xtest()) Xend(); } No unpaired Xbegin and Xend during run time!

21 21 Principle: put mxabort before where failures might happen If(ptr){ *buf = newbuf(); if(ptr == NULL){ +mxabort(); *buf assert_fail; = newbuf(); }else{ tmp = *ptr; tmp = *ptr; } }

22 22 Principle: q Avoid trapping instructions abort q Minimize capacity abort time(); + mxbegin(); If(ptr){ *buf = newbuf(); if(ptr==null){ + mxabort(); assert_fail; }else{ tmp = *ptr; } }

23 23 mxbegin() CFG node Potential failure mxbegin() Trapping/Call/loop-exit Instruction or function entrance

24 24 Principles: q Avoid trapping instructions abort q Minimize capacity abort Ø End TM before loop entry Ø End TM before function exit time (); + mxbegin(); If(ptr){ *buf = newbuf(); if(ptr==null){ + mxabort(); assert_fail; }else{ tmp = *ptr; } } + mxend();

25 25 mxend() CFG node mxend() Potential failure Trapping/Call/loop-header instruction Function exit mxend()

26 26 Design fallback and retry Principle: Reexecution only when aborts might be caused by concurrency bugs q Concurrency bug relevant aborts (reexecute in Tx mode) Ø Data conflict abort && Xabort abort q Concurrency bug irrelevant aborts (reexecute in non-tx mode) Ø Capacity abort && Trapping instruction abort

27 Outline: 1. BugTM H 2. BugTM HS 3. Evaluation Methodology 4. Experiment Results 5. Conclusion 27

28 28 Loc setjmp : locations where ConAir inserts setjmp Loc mxbegin : locations where BugTM H inserts mxbegin q Insert setjmp at every Loc setjmp q Insert mxbegin only when Loc mxbegin is farther than Loc setjmp q Not insert mxbegin if Loc setjmp and Loc mxbegin are same

29 29 mxbegin() setjmp mxbegin() CFG node Potential failure Trapping instruction setjmp Shared-variable writes Function entrance

30 30 qhtm rollback first (under an active transaction) Ølonger reexecution region qlongjmp rollback (not under an active transaction) ØIf HTM rollback fails, longjmp rollback can still have a chance

31 Outline: 1. BugTM H 2. BugTM HS 3. Evaluation Methodology 4. Experiment Results 5. Conclusion 31

32 32 Evaluation methodology q Benchmarks (29 bugs [1,2,3,4,5,6] ). q micro architecture Broadwell (4-core Intel Core i7-5775c) q LLVM [1] Guoliang Jin, et al, Automated atomicity-violation fixing, PLDI 11 [2] Horatiu Jula, et al, Deadlock immunity: Enabling systems to defend against deadlocks, OSDI 08 [3] Yao Shi, et al, Do I use the wrong definition? DefUse: Definition-use invariants for detecting concurrency and sequential bugs, OOPSLA 10 [4] Wei Zhang, et al, ConAir: Featherweight concurrency bug recovery via single-threaded idempotent execution, ASPLOS 13 [5] Wei Zhang, et al, ConSeq: Detecting concurrency bugs through sequential errors, ASPLOS 11 [6] Wei Zhang, et al, ConMem: Detecting Crash-Triggering Concurrency Bugs through an Effect-Oriented Approach, ACM TOSEM, 2012.

33 33 Recovery capability Recovery capability comparison Benchmarks(ID) Root Cause ConAir BugTM H BugTM HS Mysql2011 RAR Atomicity Violation - Mysql38883 RAR Atomicity Violation - Apache21287 RAW Atomicity Violation - Moz-JS18025 RAW Atomicity Violation - Moz-JS RAW Atomicity Violation - Bank WAR Atomicity Violation - Transmission Order Violation - Total ConAir < BugTM H < BugTM HS

34 34 Performance Overhead ConAir > BugTM HS > BugTM H overhead comparing with baseline: % BugTM ConAir: HS H : 0.31% 3.08% 1.39% ConAir BugTMH BugTMHS 2 0 Mysql2011 Mysql3596 Mysql38883 Apache21287 Moz-JS18025 Moz-JS Bank Moz-ex52111 Moz-ex Mysql791 Mysql16582 Benchmark Click FFT HTTrack Moz-xpcom61369 Transmission zsnes HawkNL Moz-JS79054 SQLite1672

35 Outline: 1. BugTM H 2. BugTM HS 3. Evaluation Methodology 4. Experiment Results 5. Conclusion 35

36 36 Conclusions q BugTM can help recover all major types of concurrency-bug failures in production run Ø Low run-time overhead Ø Outperform the state of art approach (ConAir) Ø Present novel ways of using HTM techniques (failure recovery) Come and eat this free lunch!

37