Optimizing Subroutines in Assembly Language an Optimization Guide for X86 Platforms
Total Page:16
File Type:pdf, Size:1020Kb
2. Optimizing subroutines in assembly language An optimization guide for x86 platforms By Agner Fog. Copenhagen University College of Engineering. Copyright © 1996 - 2008. Last updated 2009-01-21. Contents 1 Introduction ....................................................................................................................... 4 1.1 Reasons for using assembly code .............................................................................. 5 1.2 Reasons for not using assembly code ........................................................................ 5 1.3 Microprocessors covered by this manual .................................................................... 6 1.4 Operating systems covered by this manual................................................................. 7 2 Before you start................................................................................................................. 7 2.1 Things to decide before you start programming .......................................................... 7 2.2 Make a test strategy.................................................................................................... 8 2.3 Common coding pitfalls............................................................................................... 9 3 The basics of assembly coding........................................................................................ 11 3.1 Assemblers available ................................................................................................ 11 3.2 Register set and basic instructions............................................................................ 14 3.3 Addressing modes .................................................................................................... 18 3.4 Instruction code format ............................................................................................. 24 3.5 Instruction prefixes.................................................................................................... 25 4 ABI standards.................................................................................................................. 27 4.1 Register usage.......................................................................................................... 27 4.2 Data storage ............................................................................................................. 27 4.3 Function calling conventions..................................................................................... 28 4.4 Name mangling and name decoration ...................................................................... 30 4.5 Function examples.................................................................................................... 30 5 Using intrinsic functions in C++ ....................................................................................... 33 5.1 Using intrinsic functions for system code .................................................................. 34 5.2 Using intrinsic functions for instructions not available in standard C++ ..................... 35 5.3 Using intrinsic functions for vector operations ........................................................... 35 5.4 Availability of intrinsic functions................................................................................. 35 6 Using inline assembly in C++ .......................................................................................... 35 6.1 MASM style inline assembly ..................................................................................... 36 6.2 Gnu style inline assembly ......................................................................................... 41 7 Using an assembler......................................................................................................... 44 7.1 Static link libraries..................................................................................................... 45 7.2 Dynamic link libraries................................................................................................ 46 7.3 Libraries in source code form.................................................................................... 47 7.4 Making classes in assembly...................................................................................... 47 7.5 Thread-safe functions ............................................................................................... 49 7.6 Makefiles .................................................................................................................. 49 8 Making function libraries compatible with multiple compilers and platforms..................... 51 8.1 Supporting multiple name mangling schemes........................................................... 51 8.2 Supporting multiple calling conventions in 32 bit mode ............................................. 52 8.3 Supporting multiple calling conventions in 64 bit mode ............................................. 55 8.4 Supporting different object file formats...................................................................... 56 8.5 Supporting other high level languages ...................................................................... 58 9 Optimizing for speed ....................................................................................................... 58 9.1 Identify the most critical parts of your code ............................................................... 58 9.2 Out of order execution .............................................................................................. 59 9.3 Instruction fetch, decoding and retirement ................................................................ 61 9.4 Instruction latency and throughput ............................................................................ 62 9.5 Break dependency chains......................................................................................... 63 9.6 Jumps and calls........................................................................................................ 64 10 Optimizing for size......................................................................................................... 71 10.1 Choosing shorter instructions.................................................................................. 71 10.2 Using shorter constants and addresses .................................................................. 73 10.3 Reusing constants .................................................................................................. 74 10.4 Constants in 64-bit mode ........................................................................................ 74 10.5 Addresses and pointers in 64-bit mode................................................................... 75 10.6 Making instructions longer for the sake of alignment............................................... 76 11 Optimizing memory access............................................................................................ 79 11.1 How caching works................................................................................................. 79 11.2 Trace cache............................................................................................................ 81 11.3 Alignment of data.................................................................................................... 81 11.4 Alignment of code ................................................................................................... 83 11.5 Organizing data for improved caching..................................................................... 85 11.6 Organizing code for improved caching.................................................................... 86 11.7 Cache control instructions....................................................................................... 86 12 Loops ............................................................................................................................ 86 12.1 Minimize loop overhead .......................................................................................... 86 12.2 Induction variables.................................................................................................. 89 12.3 Move loop-invariant code........................................................................................ 90 12.4 Find the bottlenecks................................................................................................ 90 12.5 Instruction fetch, decoding and retirement in a loop ................................................ 91 12.6 Distribute µops evenly between execution units...................................................... 91 12.7 An example of analysis for bottlenecks on PM........................................................ 92 12.8 Same example on Core2 ........................................................................................ 96 12.9 Loop unrolling ......................................................................................................... 97 12.10 Optimize caching .................................................................................................. 99 12.11 Parallelization ..................................................................................................... 100 12.12 Analyzing dependences...................................................................................... 101 12.13 Loops on processors without out-of-order execution ..........................................