The goal of vectorizing compilers is to exploit single-instruction multiple data (SIMD) processing automatically. Users can help however by supplying the compiler with additional information; for example, by using directives.
You will often need to make some changes to your loops. Follow these guidelines for loop bodies.
Use:
straight-line code (a single basic block)
vector data only; that is, arrays and invariant expressions on the right hand side of assignments. Array references can appear on the left hand side of assignments.
only assignment statements
Avoid:
function calls
unvectorizable operations (other than mathematical)
mixing vectorizable types in the same loop
data-dependent loop exit conditions
To make your code vectorizable, you will often need to make some changes to your loops. However, you should make only the changes needed to enable vectorization and no others. In particular, you should avoid these common changes:
loop unrolling; the compiler does it automatically.
decomposing one loop with several statements in the body into several single-statement loops.
There are a number of restrictions that you should be consider. Vectorization depends on two major factors: hardware and style of source code.
Factor |
Description |
|---|---|
|
Hardware |
The compiler is limited by restrictions imposed by the underlying hardware. In the case of Streaming SIMD Extensions, the vector memory operations are limited to stride-1 accesses with a preference to 16-byte-aligned memory references. This means that if the compiler abstractly recognizes a loop as vectorizable, it still might not vectorize it for a distinct target architecture. |
|
Style of |
The style in which you write source code can inhibit optimization. For example, a common problem with global pointers is that they often prevent the compiler from being able to prove that two memory references refer to distinct locations. Consequently, this prevents certain reordering transformations. |
Many stylistic issues that prevent automatic vectorization by compilers are found in loop structures. The ambiguity arises from the complexity of the keywords, operators, data references, and memory operations within the loop bodies.
However, by understanding these limitations and by knowing how to interpret diagnostic messages, you can modify your program to overcome the known limitations and enable effective vectorization. The following sections summarize the capabilities and restrictions of the vectorizer with respect to loop structures.