Improving Error Checking and Unsafe Optimizations using Software Speculation. Kirk Kelsey and Chen Ding University of Rochester

Transcription

1 Improving Error Checking and Unsafe Optimizations using Software Speculation Kirk Kelsey and Chen Ding University of Rochester

2 Outline Motivation Brief problem statement How speculation can help Our software speculation system Compiler Support, Runtime Libraries, Visual Examples An Example Testbed System Compiler Support, Runtime Libraries, Visual Examples Empirical Results Reducing the cost of correctness checking Conclusion 2

3 Problem There is a potential to improve any program (in terms of either robustness or speed) but Programs can be extremely complex, and Code is often inherited by new programmers thus There is uncertainty in making any change 3

4 Our Proposal: Use Software Speculation Keep the existing program implementation Augment it with an alternative version Run the new code speculatively Use the original guaranteeing a baseline Since progress is made by whichever execution is faster, we guarantee that the system can only be marginally worse than the original implementation. Can be applied to guarantee unsafe optimizations, or to reduce the cost of correctness checking. 4

5 Visually... init() foo() fast_foo() bar() bar() 5

6 But what if... init() foo() not_always _fast_foo() not_foo() bar() bar() bar() 6

7 Fast Track Coarse-grained speculative execution using linux processes Applies to sequential C/C++ programs Requires a runtime library and compiler support Automatically selects the faster of two equivalent processes. Our assertion is that two processes are equivalent if: they begin in the same state result in the same memory state are followed by the same instruction sequence 7

8 Compiler Support general Based on a modified GCC 4.1 Moves global variables into heap allocated space inserts new allocation calls adds initialization routines changes accesses so they reference the heap Redirects heap [de]allocation so we can track data Replaces output functions with buffered versions 8

9 Runtime Support Forks new processes to execute two versions of code per-process memory space means rollback is simple operating system copy-on-write limits the memory overhead Tracks which memory pages each process modifies page fault handers trigger once per page Compares memory state after each pair of parallel tracks to ensure correct computation Can ignore data objects known to be inconsequential (based on programmer annotation) Correctness checking can customized using a programmer supplied function pointer 9

10 Testbed System & Introduction to Mudflap We leverage an existing memory checking system as a demonstration testbed for our speculation system GCC included a memory checking ( pointer debugging ) system called mudflap Mudflap comprises compiler support and runtime libraries Use the existing implementation as the fast track The overhead of extra checking creates a slow track Add more compiler support to automate the process 10

11 Mudflap Compiler Support Adds code to register some variables at runtime when the address is taken when the bounds are not known statically (e.g. extern) Inserts runtime checks before pointer dereferences Support is activated by a compile time flag (-fmudflap) 11

12 Mudflap Runtime Library Tracks ranges of valid memory objects heap allocation objects registered by the static analysis Checks for reads of uninitialized objects Reports memory leaks Wraps some common string and heap accesses (think: strcmp, memcpy) Allows for several forms of error reporting spawn gdb output log abort 12

13 Visually... init() foo_plus_ mudflap() foo() bar() bar() 13

14 More Compiler Support Custom GCC (v4.1) optimization pass Generates a copy of each program function (a clone) Changes call sites in function copies to call the clone of the original target Instructs mudflap to skip instrumentation on each clone Programmer must indicate what to fast track by default mudflap is used mudflap variable registration cannot be avoided 14

15 Visually... init() } foo() _clone_foo() { bar() bar() 15

16 Finally, in code The programmer needs to do very little: And even that can be reduced with Macros: if( BeginFastTrack()) { _clone foo( ); } else { foo( ); } PostFastTrack(); return value based on calls to fork mudflap free version of foo() is automatically generated FASTTRACK(foo()); original function foo() setup asynchronous memory checking 16

17 Results: hmmer execution times 300s 225s 234.5s 150s 75s 0s 84.5s 58.1s 47.1s 41.0s 37.8s 34.9s 33.2s 15.6s Mudflap FT 2 FT 3 FT 4 FT 5 FT 6 FT 7 FT 8 Base 17

18 Results: Speedup Over Mudflap SJENG MCF BZIP2 5 4 Speedup FT 2 FT 3 FT 4 FT 5 FT 6 FT 7 FT 8 18

19 Conclusion Software speculation can reduce the overhead of correctness checking The same technique can ensure the correctness of unsafe optimizations, or be used to select amongst different heuristic approaches. The Fast Track system is a working example of such a technique 19

20 Thank You Kirk Kelsey & Chen Ding University of Rochester