CS377P Programming for Performance Leveraging the Compiler for Performance

Transcription

1 CS377P Programming for Performance Leveraging the Compiler for Performance Sreepathi Pai UTCS October 5, 2015

2 Outline 1 Compiler Performance 2 Compiler Internals 3 Domain-specific Languages (DSLs)

3 Outline 1 Compiler Performance 2 Compiler Internals 3 Domain-specific Languages (DSLs)

4 Performance Advice Use pre-increment instead of post-increment. Instead of: Use: for (i=0; i<10; i++) for (i=0; i<10; ++i)

5 Why? Pre-increment simply performs the operation on the variable and returns its value. Post-increment requires that the previous value be retained somewhere, ready for return, so some additional storage may be required. Thus, the two statements are potentially able to generate different code. The pre-increment version is clearly preferable. Source. Note: this was just the first Google hit. There are many such pages.

6 Verifying this advice $ gcc testpost.c -o testpost $ gcc testpre.c -o testpre $ objdump -S testpost > post $ objdump -S testpre > pre $ diff -u post -1,5 -testpost: +testpre: file format elf64-x86-64 file format elf64-x86-64 $ Disassembly of section.init:

7 Beyond compiler optimizations Very few, rare Almost always algorithmic Most can be added to compiler as soon as they are discovered Or they re wrong Or not general enough Or too expensive to implement Report a bug if you think a compiler should optimize something If you re wrong, you ll learn something

8 Outline 1 Compiler Performance 2 Compiler Internals 3 Domain-specific Languages (DSLs)

9 Intermediate Representations (IR) - AST = Abstract Syntax Tree (AST) a = (b + c) * 3 Id: a BinOp: * Const: a BinOp: + Id: b Id: c

10 IR - 3-address code add b, c, tmp # tmp = b + c mul tmp, 3, a # a = tmp * 3 (part after # is another way of writing it) Organized as basic blocks. This is machine-independent code.

11 IR - Control Flow Graph Nodes represent basic blocks, edges represent control flow. condition condition true-code false-code code end end

12 Device-independent Optimizations int main(void) { int a; int x = 3, y = 0; if(x + y > 3) { x = 1; } else { x = 2; } a = x; printf("a = %d\n", a); }

13 Code generated without optimization : 55 push %rbp : e5 mov %rsp,%rbp 40052c: ec 10 sub $0x10,%rsp : c7 45 fc movl $0x3,-0x4(%rbp) : c7 45 f movl $0x0,-0x8(%rbp) 40053e: 8b 55 fc mov -0x4(%rbp),%edx : 8b 45 f8 mov -0x8(%rbp),%eax : 01 d0 add %edx,%eax : 83 f8 03 cmp $0x3,%eax : 7e 09 jle <main+0x2c> 40054b: c7 45 fc movl $0x1,-0x4(%rbp) : eb 07 jmp 40055b <main+0x33> : c7 45 fc movl $0x2,-0x4(%rbp) 40055b: 8b 45 fc mov -0x4(%rbp),%eax 40055e: f4 mov %eax,-0xc(%rbp) : 8b 45 f4 mov -0xc(%rbp),%eax : 89 c6 mov %eax,%esi : bf 6c mov $0x40066c,%edi 40056b: b mov $0x0,%eax : e8 2b fe ff ff callq 4003a : c9 leaveq : c3 retq

14 Code generated at -O : be mov $0x2,%esi : bf 3c mov $0x40063c,%edi 40053a: 31 c0 xor %eax,%eax 40053c: e9 5f fe ff ff jmpq 4003a0

15 Optimizations applied (not exhaustive) Value Numbering Constant propagation Copy propagation Dead code elimination

16 Goals of Optimization Rewrite code to equivalent cheaper form size cost Equivalent Same input, same output Internal state (invisible to outside world) not guaranteed to be the same

17 How it works y = 0 x = 3 x + y > 3 x = 2 x = 1 a = x printf("a = %d\n", a)

18 How it works Constant Propagation y = 0 x = > 3 x = 2 x = 1 a = x printf("a = %d\n", a)

19 How it works Dead Code Elimination y = 0 x = 3 false x = 2 x = 1 a = x printf("a = %d\n", a)

20 How it works Copy Propagation y = 0 x = 3 false x = 2 x = 1 a = 2 printf("a = %d\n", 2)

21 Limitations Safety Must do what original code did Conservativeness Must infer about all executions from source code Abstract interpretation, Data-flow Analysis More details in any good compilers textbook or class Cooper and Torczon, Engineering a Compiler, 2nd Ed.

22 Device-specific Optimizations We now have optimized CFG in 3-address code What next?

23 Device-specific Optimizations Register Allocation Which values should live in registers? What to do when number of registers is less than number of values? NP-complete. Instruction Selection How to use special instructions? e.g. FMA instead of MUL + ADD How to replace integer divides by multiplies and shifts? Peephole optimization Instruction Scheduling How to order instructions so that pipeline is full and functional units utilized? List scheduling, Modulo scheduling NP-complete

24 What about dynamic languages? Java Javascript Python Perl etc.

25 Dynamic languages use compiler technology Java: HotSpot Javascript: V8 Python: PyPy Perl: Parrot etc.

26 Outline 1 Compiler Performance 2 Compiler Internals 3 Domain-specific Languages (DSLs)

27 Commonly-used DSLs SQL (for database operations) Matlab (for linear algebra) R (for statistical computation) Makefiles (for dependency-based build systems) JavaScript (originally for annoying web users) Cryptol (for cryptography)

28 Goals For aforementioned DSLs, performance was not originally a first-order goal productivity was. For JavaScript, it now is.

29 High-performance DSLs These were built from ground-up to be performant DSLs: Julia (for linear algebra) Halide (for image processing) Honorable mentions (performance added later): SQL

30 When can a DSL be used? High-level or restricted set of datatypes High-level or restricted set operations Productivity/Ease is important (For this class) Optimizations known for operations

31 Advantages of using a DSL Productivity No low-level details to worry about Performance Good DSL optimizer can yield faster code than general optimizer: it has more semantic information May even beat handwritten code

32 Costs of developing a DSL Compiler development can be costly Can be amortized over programs But, industrial-strength compilers available for modification LLVM Scala-based toolkits Engineering decision

33 Conclusion Take a (graduate) compilers class! Or read a good textbook Concentrate on the midend and backend Write a few compilers How fast can you write a DSL compiler using off-the-shelf components?