Look-ahead SLP: auto-vectorization in the presence of commutative operations

Porpodas, Vasileios; Rocha, Rodrigo C. O.; Góes, Luís F. W.

doi:10.1145/3168807

Cited by 12 publications

(7 citation statements)

References 24 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Figure 9 shows an example of a commutative instruction where an operand selection can be avoided by reordering operands. This property of commutative operations has been exploited before by other optimizations [26][27][28] Figure 10. Label selection for mismatched terminator instruction operands L f1 and L f2 corresponding to labels of two different basic blocks.…”

Section: Operand Assignmentmentioning

confidence: 99%

Effective function merging in the SSA form

Rocha

Petoumenos

Wang

et al. 2020

Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation

Self Cite

View full text Add to dashboard Cite

Function merging is an important optimization for reducing code size. This technique eliminates redundant code across functions by merging them into a single function. While initially limited to identical or trivially similar functions, the most recent approach can identify all merging opportunities in arbitrary pairs of functions. However, this approach has a serious limitation which prevents it from reaching its full potential. Because it cannot handle phi-nodes, the state-of-the-art applies register demotion to eliminate them before applying its core algorithm. While a superficially minor workaround, this has a threefold negative effect: by artificially lengthening the instruction sequences to be aligned, it hinders the identification of mergeable instruction; it prevents a vast number of functions from being profitably merged; it increases compilation overheads, both in terms of compile-time and memory usage. We present SalSSA, a novel approach that fully supports the SSA form, removing any need for register demotion. By doing so, we notably increase the number of profitably merged functions. We implement SalSSA in LLVM and apply it to the SPEC 2006 and 2017 suites. Experimental results show that our approach delivers on average, 7.9% to 9.7% reduction on the final size of the compiled code. This translates to around 2× more code size reduction over the state-of-theart. Moreover, as a result of aligning shorter sequences of instructions and reducing the number of wasteful merge operations, our new approach incurs an average compile-time overhead of only 5%, 3× less than the state-of-the-art, while also reducing memory usage by over 2×.

show abstract

Section: Operand Assignmentmentioning

confidence: 99%

Effective function merging in the SSA form

Rocha

Petoumenos

Wang

et al. 2020

Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation

Self Cite

View full text Add to dashboard Cite

show abstract

“…In [50] vectorization is enabled for SIMD widths that are not supported by the target hardware. Finally, extensions to SLP that focus on commutative operations are presented in [38,39].…”

Section: Slp Auto-vectorizationmentioning

confidence: 99%

Vectorization-aware loop unrolling with seed forwarding

Rocha

Porpodas

Petoumenos

et al. 2020

Proceedings of the 29th International Conference on Compiler Construction

Self Cite

View full text Add to dashboard Cite

Loop unrolling is a widely adopted loop transformation, commonly used for enabling subsequent optimizations. Straightline-code vectorization (SLP) is an optimization that benefits from unrolling. SLP converts isomorphic instruction sequences into vector code. Since unrolling generates repeatead isomorphic instruction sequences, it enables SLP to vectorize more code. However, most production compilers apply these optimizations independently and uncoordinated. Unrolling is commonly tuned to avoid code bloat, not maximizing the potential for vectorization, leading to missed vectorization opportunities.We are proposing VALU, a novel loop unrolling heuristic that takes vectorization into account when making unrolling decisions. Our heuristic is powered by an analysis that estimates the potential benefit of SLP vectorization for the unrolled version of the loop. Our heuristic then selects the unrolling factor that maximizes the utilization of the vector units. VALU also forwards the vectorizable code to SLP, allowing it to bypass its greedy search for vectorizable seed instructions, exposing more vectorization opportunities.Our evaluation on a production compiler shows that VALU uncovers many vectorization opportunities that were missed by the default loop unroller and vectorizers. This results in more vectorized code and significant performance speedups for 17 of the kernels of the TSVC benchmarks suite, reaching

show abstract

“…SuperGraph SLP [25] operates on larger code regions and is able to vectorize previously unreachable code. Look-ahead SLP [28] extends SLP to commutative operations, and is implemented in both LLVM and GCC. The latest development, SuperNode SLP [27] enables straight-line vectorization for expressions involving a commutative operator and its inverse.…”

Section: Current Trends In Optimization Researchmentioning

confidence: 99%

Loop optimizations in C and C++ compilers: an overview

Kovács¹,

Porkoláb²

2020

AMI

View full text Add to dashboard Cite

The evolution of computer hardware in the past decades has truly been remarkable. From scalar instruction execution through superscalar and vector to parallel, processors are able to reach astonishing speeds -if programmed accordingly. Now, writing programs that take all the hardware details into consideration for the sake of efficiency is extremely difficult and error-prone. Therefore we increasingly rely on compilers to do the heavy-lifting for us.A significant part of optimizations done by compilers are loop optimizations. Loops are inherently expensive parts of a program in terms of run time, and it is important that they exploit superscalar and vector instructions. In this paper, we give an overview of the scientific literature on loop optimization technology, and summarize the status of current implementations in the most widely used C and C++ compilers in the industry.

show abstract

Look-ahead SLP: auto-vectorization in the presence of commutative operations

Cited by 12 publications

References 24 publications

Effective function merging in the SSA form

Effective function merging in the SSA form

Vectorization-aware loop unrolling with seed forwarding

Loop optimizations in C and C++ compilers: an overview

Contact Info

Product

Resources

About