Code motion

From HandWiki
Short description: Generic term for compiler optimization

In computer science, code motion, also known as code hoisting, code sinking, loop-invariant code motion, or code factoring, is a blanket term for any process that moves code within a program for performance or size benefits, and is a common optimization performed in most optimizing compilers. It can be difficult to differentiate between different types of code motion, due to the inconsistent meaning of the terms surrounding it.

Uses

Code motion has a variety of uses and benefits, many of which overlap each other in their implementation.

Removing unused/useless operations

A diagram depicting an optimizing compiler removing a potentially useless call to assembly instruction "b" by sinking it to its point of use.

Code Sinking, also known as lazy code motion, is a term for a technique that reduces wasted instructions by moving instructions to branches in which they are used:[1] If an operation is executed before a branch, and only one of the branch paths use the result of that operation, then code sinking entails moving that operation into the branch where it will be used.

This technique is a form of dead code elimination in the sense that it removes code when its results are discarded or unused, but in contrast to dead code elimination, it can remove pointless instructions even if there is a possible use of that instruction’s results in an execution code path.

Reducing the size of the program

A diagram that demonstrates optimizing for size using code factoring, assuming all operations are not dependent on other operations executing before it.

Code Factoring is a term for a size-optimization technique that merges common dependencies in branches into the branch above it.[2] Just like factorizing integers decomposes a number into its smallest possible forms (as factors), code factorization transforms the code into the smallest possible form, by merging common "factors" until no duplicates remain.

Reducing dependency stalls

Main page: Instruction scheduling
An example of how a compiler might prevent dependency stalls in assembled code with code movement, by observing a dependency graph. Due to Out-of-order execution advancements, optimization may not have any benefit on modern CPUs.

Global code motion, local code motion, code scheduling, Instruction scheduling and code hoisting/sinking are all terms for a technique where instructions are rearranged (or "scheduled") to improve the efficiency of execution within the CPU.[3][4] Modern CPUs are able to schedule five or more instructions per clock cycle. However, a CPU cannot schedule an instruction that relies on data from a currently (or not yet executed) instruction. Compilers will interleave dependencies in a manner that maximizes the amount of instructions a CPU can process at any point in time.[5]

On the defunct Intel Itanium architecture, the branch predict (BRP) instruction is manually hoisted above branches by the compiler to enable the branch to be immediately taken by the CPU. Itanium relies on additional code scheduling from the CPU to maximize efficiency in the processor.[6]

Loop-invariant code motion

Main page: Loop-invariant code motion
A diagram depicting loop-invariant code motion over an execution graph. This assumes that D is invariant between loop executions.

Loop-invariant code motion is the process of moving loop-invariant code to a position outside the loop, which may reduce the execution time of the loop by preventing some computations from being done twice for the same result.

Compiler examples

LLVM

LLVM has a sinking pass in its single static assignment form. LLVM 15.0 will not sink an operation if any of its code paths include a store instruction, or if it may throw an error.[7] Additionally, LLVM will not sink an instruction into a loop.

GCC

The GNU Compiler Collection implements code motion under the name "code factoring", with the purpose of reducing the size of a compiled program.[8] GCC will move any code upwards or downwards if it "[does not] invalidate any existing dependences nor introduce new ones".[9]

LuaJIT

LuaJIT uses code sinking under the name "Allocation sinking", to reduce the amount of time compiled code spends allocating and collecting temporary objects within a loop.[10] Allocation sinking moves allocations to execution paths where the allocated object may escape the executing code, and will thus require heap allocation. All removed allocations are filled in with load-to-store forwarding over their fields.[11]

See also

References

  1. ↑ Craft, Michael; Offut, Jefferson (1994). "Using compiler optimization techniques to detect equivalent mutants". Software Testing, Verification & Reliability 4 (3): 131–154. doi:10.1002/stvr.4370040303. https://onlinelibrary.wiley.com/doi/10.1002/stvr.4370040303. Retrieved 25 February 2022. 
  2. ↑ Lóki, Gábor, et al. "Code factoring in GCC." Proceedings of the 2004 GCC Developers’ Summit. 2004.
  3. ↑ Fasse, Justus, et al. Code Transformations to Increase Prepass Scheduling Opportunities in CompCert. Diss. Master Thesis of Science. Université Grenoble Alpes. https://www-verimag. imag. fr/~ boulme/CPP_2022/FASSE-Justus-MSc-Thesis_2021. pdf, 2021.
  4. ↑ Gupta, Rajiv (1998). "A code motion framework for global instruction scheduling". Compiler Construction. Lecture Notes in Computer Science 1383: 219–233. doi:10.1007/BFb0026434. ISBN 978-3-540-64304-3. 
  5. ↑ Chang, Pohua P., et al. "The importance of prepass code scheduling for superscalar and superpipelined processors." IEEE Transactions on Computers 44.3 (1995): 353-370.
  6. ↑ Sharangpani, H.; Arora, H. (September 2000). "Itanium processor microarchitecture". IEEE Micro 20 (5): 24–43. doi:10.1109/40.877948. ISSN 1937-4143. https://ieeexplore.ieee.org/document/877948. 
  7. ↑ "LLVM: lib/Transforms/Scalar/Sink.cpp Source File". https://llvm.org/doxygen/Sink_8cpp_source.html. 
  8. ↑ "Code Factoring Optimizations - GNU Project". https://gcc.gnu.org/projects/cfo.html. 
  9. ↑ "GCC Developer's Summit 2004 - Code Factoring.pdf". https://gcc.gnu.org/pub/gcc/summit/2004/Code%20Factoring.pdf. 
  10. ↑ "Allocation sinking in git HEAD - luajit - FreeLists" (in en). https://www.freelists.org/post/luajit/Allocation-sinking-in-git-HEAD. 
  11. ↑ "Allocation Sinking Optimization". http://wiki.luajit.org/Allocation-Sinking-Optimization. 



Retrieved from "https://handwiki.org/wiki/index.php?title=Code_motion&oldid=3375055"