向量化的方法

使用英特尔编译器进行自动向量化

作者：Yang Wang (Intel)

自动向量化是英特尔编译器提供的一个可以自动的使用SIMD指示的功能。在处理数据时，编译器自动选择MMX?, Intel? Streaming SIMD 扩展（Intel? SSE, SSE2, SSE3 和SSE4）等指令集，对数据进行并行的处理。使用编译器提供的自动向量化功能是提高程序性能的一个非常有效的手段。自动向量化在IA-32和Intel? 64的平台上均提供很好的支持。

英特尔编译器提供的自动向量化相关的编译选项如下所示。”/Q”开头的选项是针对Windows平台的，“-“开头的选项是针对Linux*和Mac平台的。

-x, /Qx

按照该选项指定的处理器类型生成相应的优化代码。比如-xSSE3, 该选项指定编译器生成Intel? SSE3指令的代码。又比如-xSSE3_ATOM, 该选项针对Intel? Atom? 处理器进行优化。

-ax, /Qax

如果指定该选项，在生成的单一目标文件中，不但会生成专门针对指定的处理器类型进行优化的代码，同时也生成通用的IA-32架构的代码。该选项主要是为了生成代码的兼容性考虑。

-vec, /Qvec

打开或者关闭编译器的向量化优化。默认情况下自动向量化是打开的。

-vec-report, /Qvec-report

该选项用户控制在编译过程中产生的向量化消息报告。

编译器提供的自动向量化优化默认情况下是打开的。在编译过程中我们可以使用-vec-report选项来打开向量化诊断消息报告。这样编译器可以告诉我们有哪些循环被向量化了，有哪些循环没有被向量化已经无法向量化的原因。

在编译程序的过程中，有时候我们会发现编译器报告说某个循环无法被向量化。很多时候无法向量化的原因都是因为循环中存在的变量依赖关系。有时候我们可以修改程序来消除这种依赖关系，有的时候我们可以使用编译器提供的一些编译指示来显示的告诉编译器如何处理这种依赖关系。即使在某个循环已经可以被自动向量化的时候，使用编译器提供的对向量化的语言支持和编译指示还可以提高编译器向量化的效率，提高程序执行的性能。

下面我们来详细解释一下编译器提供的编译指示以及这些指示对编译器编译的影响。

在Intel编译器中，我们提供下面这样一些对自动向量化的语言支持和编译指示。

__declspec(align(n))

指导编译器将变量按照n字节对齐

__declspec(align(n,off))

指导编译器将变量按照n字节再加上off字节的编译量进行对齐

restrict

消除别名分析中的二义性

__assume_aligned(a,n)

当编译器无法获取对齐信息时，假定数组a已经按照n字节对齐

#pragma ivdep

提示编译器忽略可能存在的向量依赖关系

#pragma vector {aligned|unaligned|always}

指定向量化的方式

#pragma novector

指定不做向量化

下面我们就这些编译指示做一些详细的了解。

__declspec(align(n))

首先我们来看看如何使用__declspec(align(n))来进行自动向量化。该指示主要是用来告诉编译器一个变量的对齐方式。当一个变量的对齐方式为16字节对齐时，生成的向量化指令是最高效的。当编译器不知道一个变量的对齐方式的时候，他可能没有办法对该变量的使用进行向量化，或者编译器会不得不生成条件语句来进行有条件的向量化。我们来看一下下面这个例子。

File: vec1.c

char a[];

void vec1(void)

{

int i;

for(i=0;i<1024;i++)

a[i] = 1;

}

使用下面命令编译该程序:

icl vec1.c -O2 -c /Qvec-report:3

这时编译器输出：

vec1.c

vec1.c(10) (col. 2): remark: LOOP WAS VECTORIZED.

我们可以看到编译器对上面这个程序进行了自动向量化。但是实际上，由于编译器不知道a的对齐字节数，所以他对变量a数据进行了一些条件处理。我们可以在编译的时候加上-S选项来查看编译器生成的汇编代码。实际上，编译器对该程序做了如下处理：

temp = a&0x0f;

if(temp != 0)

{

temp = 16-temp;

for(i=0;i

}

/*下面是对齐的访问*/

for(i=temp;i<1024;i++) a[i] = 1;

如果我们指定了a的对齐方式，比如我们使用__declspec(align(16))来定义变量a, 如下所示：

__declspec(align(16)) char a[];

void vec1(void)

{

int i;

for(i=0;i<1024;i++)

a[i] = 1;

}

对于上面这段程序，编译器做了自动向量化。如果我们检查生成的汇编代码可以发现，对于a的对齐方式的条件处理代码已经不见了。

正确使用__declspec(align(n))以及其他align相关编译指示可以帮助编译器进行自动向量化以及提高编译器自动向量化的效率。

restrict

使用restrict关键字可以显式的告诉编译器取消指针之间的二义性。我们还是用下面这个例子来说明restrict的使用。

File: vec2.c

void vec2(char* a, char* b, int n)

{

int i;

for(i=0;i

a[i] = b[i];

}

使用以下命令进行编译：

icl vec2.c -O2 -c /Qvec-report:3

编译器输出：

vec2.c

restrict.c(5) (col. 2): remark: LOOP WAS VECTORIZED.

restrict.c(5) (col. 2): remark: loop skipped: multiversioned.

此时编译器输出multiversioned向量化代码，对同一个循环产生了多个版本的实现。实际上编译器对代码进行了条件处理，如下所示：

void vec2(char* a, char* b, int n)

{

int i;

if(a+n

for(i=0;i

else

for(i=0;i

}

可以看出，由于编译器不知道指针a 和b之间是否存在重叠，所以他对循环进行了条件处理。如果我们从语义上能够保证a和b是不会发生重叠的，那么我们就可以使用restrict关键字来显式的告诉编译器这一点。

void vec2(char* restrict a, char* restrict b, int n)

{

int i;

for(i=0;i

a[i] = b[i];

}

此时编译器输出没有multiversioned。

restrict.c

restrict.c(5) (col. 2): remark: LOOP WAS VECTORIZED.

注意C90里面不支持restrict关键字，在windows平台编译的时候我们需要加上选项/Qrestrict来让编译器认识restrict关键字。

?#pragma vector

使用#pragma vector编译指示来显式告诉编译器使用某种方式来进行自动向量化。比如在下面这个例子中，我们可以保证变量a的地址是16字节对齐的，那么我们就可以使用#pragma vector aligned来显式的告诉编译器不需要考虑非对齐的情况。这样产生的向量化代码是最高效的。

File: vec3.c

#include

void vec3(void)

{

int i;

char* a=_aligned_malloc(1024, 16);

#pragma vector aligned

for(i=0;i<1024;i++)

a[i] = 1;

}

在上面这个例子中，如果我们不加上#pragma vector aligned, 编译器会对循环进行条件处理后的向量化。大家可以对比一下两种情况下生成的汇编代码的区别。请注意我们在使用#pragma vector aligned的时候需要保证被处理变量的对齐方式是16字节对齐的，否则在使用了该编译指示后可能会产生错误的结果。在上面这个例子中，我们稍作如下修改：

#include

void vec3(void)

{

int i;

char* a=_aligned_malloc(1024, 16);

char* b = a+1;

#pragma vector aligned

for(i=0;i<1023;i++)

b[i] = 1;

}

循环中的b的地址不是16字节对齐的，但是如果我们还是按照aligned的方式来做向量化，产生的结果是编译出来的可执行程序运行时异常。在上面的例子中，我们需要使用#pragma vector unaligned 编译指示来正确的引导编译器。

?#pragma ivdep

使用#pragma ivdep显式的告诉编译器忽略向量之间可能存在的依赖关系。参考下面这个例子。

File: vec4.c

void vec4(int* a, unsigned int n, unsigned int m)

{

int i;

for(i=0;i

a[i] = a[i+m];

}

使用编译器编译该程序：

icl vec4.c –O2 -c /Qvec-report:3

编译器输出：

vec4.c

vec4.c(6) (col. 2): remark: loop was not vectorized: existence of

vector dependence.

vec4.c(7) (col. 3): remark: vector dependence: assumed ANTI dependence between a line 7 and a line 7.

vec4.c(7) (col. 3): remark: vector dependence: assumed FLOW dependence between a line 7 and a line 7.

vec4.c(7) (col. 3): remark: vector dependence: assumed FLOW dependence between a line 7 and a line 7.

vec4.c(7) (col. 3): remark: vector dependence: assumed ANTI dependence between a line 7 and a line 7.

如果我们可以保证a[0]到a[n-1]和a[m]到a[m+n-1]之间不存在重叠，那么我们就可以使用#pragma ivdep 来显式的告诉编译器可以忽略a[i]和a[i+m]之间的依赖关系，修改程序如下:

void vec4(int* a, unsigned int n, unsigned int m)

{

int i;

#pragma ivdep

for(i=0;i

a[i] = a[i+m];

}

这样程序中的循环就可以被自动向量化了。

英特尔编译器提供了强大的自动向量化支持，并且对自动向量化的优化也一直在进行之中。在新版本的编译器中，我们可以看到更多的自动向量化有关的支持。更多的内容请参考后续博客更新。

Optimization Notice

Intel? Compiler includes compiler options that optimize for instruction sets that are available in both

Intel? and non-Intel microprocessors (for example SIMD instruction sets), but do not optimize equally for non-Intel microprocessors. In addition, certain compiler options for Intel? Compiler are reserved for Intel microprocessors. For a detailed description of these compiler options, including the instruction sets they implicate, please refer to "Intel? Compiler User and Reference Guides > Compiler Options". Many library routines that are part of Intel? Compiler are more highly optimized for Intel microprocessors than for other microprocessors. While the compilers and libraries in Intel? Compiler offer optimizations for both Intel and Intel-compatible microprocessors, depending on the options you select, your code and other factors, you likely will get extra performance on Intel microprocessors.

While the paragraph above describes the basic optimization approach for Intel? Compiler, with respect to Intel's compilers and associated libraries as a whole, Intel? Compiler may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include Intel? Streaming SIMD Extensions 2 (Intel? SSE2), Intel? Streaming SIMD Extensions 3 (Intel? SSE3), and Supplemental Streaming SIMD Extensions 3 (Intel? SSSE3) instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of

any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors.

Intel recommends that you evaluate other compilers to determine which best meet your requirements. 使用#pragma simd进行自动向量化

#pragma simd

该编译指示(SIMD)是12.0编译器最新提供的功能。他可以强制性的让编译器做自动并行化。对于其他编译指示比如#pragma ivdep来说，如果编译器编译时发现用户提供的编译指示条件不满足，那么编译器是不会根据编译指示来进行自动向量化的。也就是说，编译器实际上还是会进行编译时的依赖关系检查。而对于#pargam simd来说，无论编译时条件如何，编译器总是会进行自动向量化。这种情况下，用户需要自己去保证被向量化的循环上语义的正确性，需要自己保证被向量化变量之间的依赖关系的正确性。我们用一个例子来说明编译器的行为区别。

File vec5.c

void vec5(int* a, int n)

{

int i;

for(i=0;i

a[i] = a[i-1];

}

对上面这个例子，由于存在flow-dependence关系，程序中的循环明显是不能被向量化的。

vec5.c

C:\test\vec5.c(6) (col. 2): remark: loop was not vectorized: existence of vector dependence.

C:\test\vec5.c(7) (col. 3): remark: vector dependence: assumed FLOW dependence between a line 7 and a line 7.

此时我们加上#pragma ivdep想让编译器忽略循环之间的依赖关系(当然这种操作是不符合原始语义的)。void vec5(int* a, int n)

{

int i;

#pragma ivdep

for(i=0;i

a[i] = a[i-1];

}

这时编译该程序，程序的输出与不加#pragma ivdep时相同。编译器在进行编译的时候检查发现了循环之间不可避免的依赖关系，即使有#pragma ivdep存在，编译器也还是不会对该循环进行向量化。

如果我们加上#pragma simd，重新编译程序:

void vec5(int* a, int n)

{

int i;

#pragma simd

for(i=0;i

a[i] = a[i-1];

}

这时编译输出:

vec5.c

C:\test\vec5.c(6) (col. 2): remark: SIMD LOOP WAS VECTORIZED.

程序中的循环被向量化了，但是此时我们显然不会得到一个正确的结果。

我们再看一个用SIMD的正确的例子。比如下面这个程序：

void vec5(int* a, int n, int m)

{

int i;

for(i=0;i

a[i] = a[i-m];

}

编译该程序: icl /O2 /c /Qvec_report:3, 编译器会报告该程序因为存在向量依赖关系而不能被向量化。在该程序中，如果我们可以保证m大于等于4，那么我们可以加入#pragma simd指示如下所示：

void vec5(int* a, int n, int m)

{

int i;

#prgama simd

for(i=0;i

a[i] = a[i-m];

}

此时编译该程序可以得到正确的自动向量化的代码。

SIMD的支持可以使得程序员可以更自由的控制程序中的向量化。相比其他编译指示来说，SIMD提供更丰富的语法来满足程序员在各种条件下的向量化处理。如果你发现现有的编译指示如法满足语义的需要或者向量化性能无法满足期望，你可以尝试使用SIMD指示。但是由于SIMD是有程序员来保证程序向量化语义的正确性，在自由使用的同时，程序员需要很小心的检查程序的语义以保证程序的正确性。

关于SIMD编译指示的详细使用，请参考其他文档。

Optimization Notice

Intel? Compiler includes compiler options that optimize for instruction sets that are available in both Intel? and non-Intel microprocessors (for example SIMD instruction sets), but do not optimize equally for non-Intel microprocessors. In addition, certain compiler options for Intel? Compiler are reserved for Intel microprocessors. For a detailed description of these compiler options, including the instruction sets they implicate, please refer to "Intel? Compiler User and Reference Guides > Compiler Options". Many library routines that are part of Intel? Compiler are more highly optimized for Intel microprocessors than for other microprocessors. While the compilers and libraries in Intel? Compiler offer optimizations for both Intel and Intel-compatible microprocessors, depending on the options you select, your code and other factors, you likely will get extra performance on Intel microprocessors.

While the paragraph above describes the basic optimization approach for Intel? Compiler, with respect to Intel's compilers and associated libraries as a whole, Intel? Compiler may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include Intel? Streaming SIMD Extensions 2 (Intel? SSE2), Intel? Streaming SIMD Extensions 3 (Intel? SSE3), and Supplemental Streaming SIMD Extensions 3 (Intel? SSSE3) instruction

sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors.

Intel recommends that you evaluate other compilers to determine which best meet your requirements.