1 / 114

Pin ASPLOS Tutorial

Pin ASPLOS Tutorial. Kim Hazelwood Vijay Janapa Reddi. About Us. Kim Hazelwood Assistant Professor at University of Virginia Tortola Research Group: HW/SW Collaboration, Virtualization Vijay Janapa Reddi Ph.D. Student at Harvard University VM Optimizations, VM Scalability. Agenda.

micol
Download Presentation

Pin ASPLOS Tutorial

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Pin ASPLOS Tutorial Kim Hazelwood Vijay Janapa Reddi

  2. About Us • Kim Hazelwood • Assistant Professor at University of Virginia • Tortola Research Group: HW/SW Collaboration, Virtualization • Vijay Janapa Reddi • Ph.D. Student at Harvard University • VM Optimizations, VM Scalability

  3. Agenda • Pin Intro and Overview • Using Pin in Your Research • Hands-On Workshop

  4. Part One: Introduction and Overview Kim Hazelwood Vijay Janapa Reddi

  5. What is Instrumentation? • A technique that inserts extra code into a program to collect runtime information • Instrumentation approaches: • Source instrumentation: • Instrument source programs • Binary instrumentation: • Instrument executables directly

  6. Why use Dynamic Instrumentation? • No need to recompile or relink • Discover code at runtime • Handle dynamically-generated code • Attach to running processes

  7. How is Instrumentation used in Computer Architecture Research? • Trace Generation • Branch Predictor and Cache Modeling • Fault Tolerance Studies • Emulating Speculation • Emulating New Instructions

  8. How is Instrumentation used in PL/Compiler Research? Program analysis • Code coverage • Call-graph generation • Memory-leak detection • Instruction profiling Thread analysis • Thread profiling • Race detection

  9. Advantages of Pin Instrumentation • Easy-to-use Instrumentation: • Uses dynamic instrumentation • Do not need source code, recompilation, post-linking • Programmable Instrumentation: • Provides rich APIs to write in C/C++ your own instrumentation tools (called Pintools) • Multiplatform: • Supports x86, x86-64, Itanium, Xscale • Supports Linux, Windows, MacOS • Robust: • Instruments real-life applications: Database, web browsers, … • Instruments multithreaded applications • Supports signals • Efficient: • Applies compiler optimizations on instrumentation code

  10. Other Advantages • Robust and stable • Pin can run itself! • Several active developers • Nightly testing of 25000 binaries on 15 platforms • Large user base in academia and industry • Active mailing list (Pinheads) • 20,000 downloads

  11. Using Pin • Launch and instrument an application $ pin –t pintool –- application Instrumentation engine (provided in the kit) Instrumentation tool (write your own, or use one provided in the kit) • Attach to and instrument an application $ pin –t pintool –pid 1234

  12. Pin Instrumentation APIs • Basic APIs are architecture independent: • Provide common functionalities like determining: • Control-flow changes • Memory accesses • Architecture-specific APIs • e.g., Info about segmentation registers on IA32 • Call-based APIs: • Instrumentation routines • Analysis routines

  13. Instrumentation vs. Analysis • Concepts borrowed from the ATOM tool: • Instrumentation routinesdefine where instrumentation is inserted • e.g., before instruction C Occurs first time an instruction is executed • Analysis routinesdefine what to do when instrumentation is activated • e.g., increment counter C Occurs every time an instruction is executed

  14. counter++; counter++; counter++; counter++; counter++; Pintool 1: Instruction Count • sub $0xff, %edx • cmp %esi, %edx • jle <L1> • mov $0x1, %edi • add $0x10, %eax

  15. Pintool 1: Instruction Count Output $ /bin/lsMakefile imageload.out itrace proccount imageload inscount0 atrace itrace.out $ pin -t inscount0.so -- /bin/ls Makefile imageload.out itrace proccount imageload inscount0 atrace itrace.out • Count 422838

  16. ManualExamples/inscount0.cpp #include <iostream> #include "pin.h" UINT64 icount = 0; void docount() { icount++; } void Instruction(INS ins, void *v) { INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)docount, IARG_END); } void Fini(INT32 code, void *v) { std::cerr << "Count " << icount << endl; } int main(int argc, char * argv[]) { PIN_Init(argc, argv); INS_AddInstrumentFunction(Instruction, 0); PIN_AddFiniFunction(Fini, 0); PIN_StartProgram(); return 0; } analysis routine instrumentation routine

  17. Print(ip); Print(ip); Print(ip); Print(ip); Print(ip); Pintool 2: Instruction Trace • sub $0xff, %edx • cmp %esi, %edx • jle <L1> • mov $0x1, %edi • add $0x10, %eax Need to pass ip argument to the analysis routine (printip())

  18. Pintool 2: Instruction Trace Output $ pin -t itrace.so -- /bin/lsMakefile imageload.out itrace proccount imageload inscount0 atrace itrace.out • $ head -4 itrace.out 0x40001e90 0x40001e91 0x40001ee4 0x40001ee5

  19. ManualExamples/itrace.cpp argument to analysis routine • #include <stdio.h> • #include "pin.H" • FILE * trace; • void printip(void *ip) { fprintf(trace, "%p\n", ip); } • void Instruction(INS ins, void *v) { • INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)printip, IARG_INST_PTR, IARG_END); • } • void Fini(INT32 code, void *v) { fclose(trace); } • int main(int argc, char * argv[]) { • trace = fopen("itrace.out", "w"); • PIN_Init(argc, argv); • INS_AddInstrumentFunction(Instruction, 0); • PIN_AddFiniFunction(Fini, 0); • PIN_StartProgram(); • return 0; • } analysis routine instrumentation routine

  20. Examples of Arguments to Analysis Routine • IARG_INST_PTR • Instruction pointer (program counter) value • IARG_UINT32 <value> • An integer value • IARG_REG_VALUE <register name> • Value of the register specified • IARG_BRANCH_TARGET_ADDR • Target address of the branch instrumented • IARG_MEMORY_READ_EA • Effective address of a memory read And many more … (refer to the Pin manual for details)

  21. cmp %esi, %edx jle <L1> mov $0x1, %edi count() count() count() <L1>: mov $0x8,%edi Instrumentation Points • Instrument points relative to an instruction: • Before (IPOINT_BEFORE) • After: • Fall-through edge (IPOINT_AFTER) • Taken edge (IPOINT_TAKEN_BRANCH)

  22. Instrumentation Granularity • Instruction • Basic block • A sequence of instructions terminated at a control-flow changing instruction • Single entry, single exit • Trace • A sequence of basic blocks terminated at an unconditional control-flow changing instruction • Single entry, multiple exits Instrumentation can be done at three different granularities: sub $0xff, %edx cmp %esi, %edx jle <L1> mov $0x1, %edi add $0x10, %eax jmp <L2> 1 Trace, 2 BBs, 6 insts

  23. counter++; counter++; counter++; counter++; counter++; Recap of Pintool 1: Instruction Count sub $0xff, %edx cmp %esi, %edx jle <L1> mov $0x1, %edi add $0x10, %eax Straightforward, but the counting can be more efficient

  24. Pintool 3: Faster Instruction Count counter += 3 sub $0xff, %edx cmp %esi, %edx jle <L1> mov $0x1, %edi add $0x10, %eax basic blocks (bbl) counter += 2

  25. ManualExamples/inscount1.cpp • #include <stdio.h> • #include "pin.H“ • UINT64 icount = 0; • void docount(INT32 c) { icount += c; } • void Trace(TRACE trace, void *v) { • for (BBLbbl = TRACE_BblHead(trace); • BBL_Valid(bbl); bbl = BBL_Next(bbl)) { • BBL_InsertCall(bbl, IPOINT_BEFORE, (AFUNPTR)docount, • IARG_UINT32, BBL_NumIns(bbl), IARG_END); • } • } • void Fini(INT32 code, void *v) { • fprintf(stderr, "Count %lld\n", icount); • } • int main(int argc, char * argv[]) { • PIN_Init(argc, argv); • TRACE_AddInstrumentFunction(Trace, 0); • PIN_AddFiniFunction(Fini, 0); • PIN_StartProgram(); • return 0; • } analysis routine instrumentation routine

  26. Modifying Program Behavior • Pin allows you not only to observe but also change program behavior • Ways to change program behavior: • Add/delete instructions • Change register values • Change memory values • Change control flow

  27. Instrumentation Library • #include <iostream> • #include "pin.H" • UINT64 icount = 0; • VOID Fini(INT32 code, VOID *v) { • std::cerr << "Count " << icount << endl; • } • VOID docount() { • icount++; • } • VOID Instruction(INS ins, VOID *v) { • INS_InsertCall(ins, IPOINT_BEFORE,(AFUNPTR)docount, IARG_END); • } • int main(int argc, char * argv[]) { • PIN_Init(argc, argv); • INS_AddInstrumentFunction(Instruction, 0); • PIN_AddFiniFunction(Fini, 0); • PIN_StartProgram(); • return 0; • } Instruction counting Pin Tool • #include <iostream> • #include "pin.H" • #include "instlib.H" • INSTLIB::ICOUNT icount; • VOID Fini(INT32 code, VOID *v) { • cout << "Count" << icount.Count() << endl; • } • int main(int argc, char * argv[]) { • PIN_Init(argc, argv); • PIN_AddFiniFunction(Fini, 0); • icount.Activate(); • PIN_StartProgram(); • return 0; • }

  28. Useful InstLib abstractions • ICOUNT • # of instructions executed • FILTER • Instrument specific routines or libraries only • ALARM • Execution count timer for address, routines, etc. • FOLLOW_CHILD • Inject Pin into new process created by parent process • TIME_WARP • Preserves RDTSC behavior across executions • CONTROL • Limit instrumentation address ranges

  29. $ pin –pause_tool 5 –t inscount0.so -- /bin/ls Pausing to attach to pid 32017 (gdb) attach 32017 (gdb) break main (gdb) cont Debugging Pintools • Invoke gdb with pin (don’t “run”) • In another window, start your pintool with the “-pause_tool” flag • Go back to gdb window: • Attach to the process • “cont” to continue execution; can set breakpoints as usual $ gdb pin (gdb)

  30. Pin Internals

  31. Pin Source Code Organization • Pin source organized into generic, architecture-dependent, OS-dependent modules: C~50% code shared among architectures

  32. Application Operating System Hardware Pin’s Software Architecture Address space Pintool Pin Instrumentation APIs Virtual Machine (VM) Code Cache JIT Compiler Emulation Unit

  33. 1’ 1 3 2 2’ 4 5 7’ 6 7 Dynamic Instrumentation Original code Code cache Exits point back to Pin Pin Pin fetches trace starting block 1 and start instrumentation

  34. 1’ 2’ 7’ Dynamic Instrumentation Original code Code cache 1 3 2 4 5 6 7 Pin Pin transfers control into code cache (block 1)

  35. 1’ 3’ 1 3 2 5’ 2’ 4 5 6’ 7’ 6 7 Dynamic Instrumentation Original code Code cache trace linking Pin Pin fetches and instrument a new trace

  36. Implementation Challenges • Linking • Straightforward for direct branches • Tricky for indirects, invalidations • Re-allocating registers • Maintaining transparency • Self-modifying code • Supporting MT applications…

  37. Redirect all other pthreads function calls to application’s libpthread set up signal handlers System’s libpthread signal handler Pintool Pin’s mini-libpthread signal handler Pin’s Multithreading Support • Thread-safe accesses Pin, Pintool, and App • Pin: One thread in the VM at a time • Pintool: Locks, ThreadID, event notification • App: Thread-local spill area • Providing pthreadsfunctions to instrumentation tools Application

  38. Optimizing Pintools

  39. Reducing Instrumentation Overhead Total Overhead = Pin Overhead + Pintool Overhead • Pin team’s job is to minimize this • ~5% for SPECfp and ~20% for SPECint • Pintool writers can help minimize this!

  40. Pin Overhead • SPEC Integer 2006

  41. Adding User Instrumentation

  42. Reducing the Pintool’s Overhead Pintool’s Overhead Instrumentation Routines Overhead Analysis Routines Overhead + Frequency of calling an Analysis Routine Work required in the Analysis Routine x Work required for transiting to Analysis Routine Work done inside Analysis Routine

  43. Analysis Routines: Reduce Call Frequency • Key: Instrument at the largest granularity whenever possible Trace > Basic Block > Instruction

  44. counter++; counter++; counter++; counter++; counter++; Slower Instruction Counting sub $0xff, %edx cmp %esi, %edx jle <L1> mov $0x1, %edi add $0x10, %eax

  45. Counting at Trace level counter += 5 sub $0xff, %edx cmp %esi, %edx jle <L1> mov $0x1, %edi add $0x10, %eax counter-=2 L1 Faster Instruction Counting Counting at BBL level counter += 3 sub $0xff, %edx cmp %esi, %edx jle <L1> mov $0x1, %edi add $0x10, %eax counter += 2

  46. Reducing Work in Analysis Routines • Key: Shift computation from analysis routines to instrumentation routines whenever possible

  47. Edge Counting: a Slower Version • ... • void docount2(ADDRINT src, ADDRINT dst, INT32 taken) • { • COUNTER *pedg = Lookup(src, dst); • pedg->count += taken; • } • void Instruction(INS ins, void *v) { • if (INS_IsBranchOrCall(ins)) • { • INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)docount2, • IARG_INST_PTR, IARG_BRANCH_TARGET_ADDR, • IARG_BRANCH_TAKEN, IARG_END); • } • } • ...

  48. Edge Counting: a Faster Version • void docount(COUNTER* pedge, INT32 taken) { • pedg->count += taken; • } • void docount2(ADDRINT src, ADDRINT dst, INT32 taken) { • COUNTER *pedg = Lookup(src, dst); • pedg->count += taken; • } • void Instruction(INS ins, void *v) { • if (INS_IsDirectBranchOrCall(ins)) { • COUNTER *pedg = Lookup(INS_Address(ins), • INS_DirectBranchOrCallTargetAddress(ins)); • INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR) docount, • IARG_ADDRINT, pedg, IARG_BRANCH_TAKEN, IARG_END); • } else • INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR) docount2, • IARG_INST_PTR, IARG_BRANCH_TARGET_ADDR, • IARG_BRANCH_TAKEN, IARG_END); • } • …

  49. Reducing Work for Analysis Transitions • Key: Help Pin’s optimizations apply to your analysis routines: • Inlining • Scheduling

  50. Inlining Not-inlinable Inlinable int docount1(int i) { if (i == 1000) x[i]++; return x[i]; } int docount0(int i) { x[i]++ return x[i]; } Not-inlinable Not-inlinable int docount2(int i) { x[i]++; printf(“%d”, i); return x[i]; } void docount3() { for(i=0;i<100;i++) x[i]++; }

More Related