GCC优化浅析

一、前言

GCC（GNU Compiler Collection）是一个免费的编译软件，能够支持Ada、C、C++、Fortran、Java和Objective-C多种语言，并且适用于多个平台包括x86、ARM、MIPS、PowerPC等等。GCC的功能是相当强大的，本文主要集中在GCC的代码优化方面进行探讨，努力将优化算法和具体实现讲述清楚完全。本文规划如下：第二部分是GCC的简单介绍，包括一些简要历史和体系结构；第三部分是本文的重点，即代码优化；第四部分是结论，主要是对工作进行总结和一些感悟。

 

二、GCC介绍

2.1 GCC历史

GCC的官方主页是http://gcc.gnu.org，在该网站上你可以找到GCC的相关信息和各个版本源代码下载。GCC3.0被认为是现代版本，由于包括了C++编译器。目前可用的最新版本是GCC 4.6.1，而本文的代码示例也是采用的GCC 4.6.1。GCC项目组正在进行4.7.0的开发工作，如果感兴趣可以在官网上看到相关信息。

2.2 GCC体系结构

要想探讨GCC的代码优化，就不得不介绍GCC的体系结构，可以说正因为GCC有了这样的体系结构，所以它才采用了相应的优化算法。本文先介绍GCC的体系结构，能够先从总体上把握GCC的实现策略，从而进行代码优化方面的探讨。

上图是GCC体系结构的简单示意图。GCC为了实现其多语言、多应用平台支持分为三部分：前端（Front End）、中端（Middle End）和后端（Back End）。前端：实现了GCC的多语言支持，将其所支持的语言先翻译成抽象语法树（AST），通过AST生成GENERIC表达，这样就使得各种语言形成统一的表示，这样的策略是有其优点的，在后面会介绍到；中端：GENERIC比较复杂，所以GCC将GENERIC转变为GIMPLE，由GIMPLE转变为SSA（static single assignment），如图所示，这时就要结果多遍优化（opt pass N），形成优化后的un-SSA，实际上GCC优化不仅仅在生成un-SSA，在中间的一些过程中可能就涉及到优化，最后生成RTL（register transfer language）；后端：为了实现多平台支持，GCC通过中端生成的RTL根据不同的平台生成相应的机器码。这样GCC就实现了编译，这个过程看起来很简单，但是实际上是相当复杂的，特别是在某些优化，GCC要遍历二三十遍。实际上该图没有完整的表达GCC的体系结构，例如对于Fortran来说，不会生成GENERIC而是一种相应的特殊表达。当然，这不影响总体。

我们将上面尚未了解的名词放一放，先介绍下GCC的目录结构。GCC顶级源目录主要结构如下：

boehm-gc	Java运行时支持
config	配置文件
contrib	别人贡献的代码
fixincludes	修正的头文件
gcc	GCC本身，包括前端、中端、后端和优化
gnattools	Ada工具
include	头文件

还有一些C、C++等运行时支持。本文主要涉及的是gcc目录，该目录下文件结构如下：

ada	Ada语言前端
config	平台相关的配置信息
cp	C++语言前端
doc	Gcc文档
fortran	Fortran语言前端
java	Java语言前端
ginclude	头文件
objc	Objective-C 语言前端
objcp	Objective-C++语言前端
po	翻译，多语言信息
testsuite	测试包

       阅读代码时，根据相关的目录结构，会更见便捷。下面对gcc重要的结构进行介绍。

   GCC预处理后，为源文件的每个函数生成抽象语法树（AST），每一个AST是一定数量的树结构的链接节点，这与编译原理中所说的经过词法分析和语法分析生成的相似。

   GENERIC是一种通用表示，由AST得到，引入GENERIC的原因是GCC要加入SSA支持，但是SSA没有增加到RTL上，而是想增加在Tree上，然而GCC不同的前端使用不同的Tree，如果直接给各个语言前端增加SSA支持的话就太繁琐。所以GCC引入了GENERIC Tree。

GIMPLE将GENERIC转化为三地址的形式（即操作数个数小于3），这是因为优化经过简化的GIMPLE上更为容易。GENERIC到GIMPLE的lower主要是：（1）指令都被转化为三地址的形式；（2）所有变量使用同一个命名空间；（3）控制流降低，指令序列+jump，指令序列仍然被组织成Tree。

SSA全称Static Single Assignment，翻译过来就是静态单一赋值。Gcc的优化从这里开始，gcc要在SSA树上进行多于20遍的不同优化。在经过SSA优化后，树被转变回GIMPLE，该GIMPLE用于生成register-transfer（RTL）。RTL是基于带有无限数量的寄存器的抽象目标机的硬件语言。

RTL例子：

(set (reg/v:SI 59 [ b ]) (plus:SI (reg/v:SI 60 [ a ] (const_int -1 [0xffffffff]))))

三、代码优化

至此，可以进入核心部分，GCC如何实现代码优化的。总体上来讲，GCC的优化大致分为两部分：（1）作用于GIMPLE/Tree-SSA上的全局优化，大约100遍；（2）作用于RTL上的标量优化，大约70遍。GCC从其诞生至今，历经了16年，实现了大量的只在文献中的优化算法。由于GCC实现的优化算法是如此之多，本文仅仅介绍其中的几个。

3.1自动向量化（auto vectorization）

3.1.1 原理：

很多早期的超级计算机使用向量指令，向量运算以流水线化的方式执行，该向量的元素被串行获取，对不同元素的计算相互重叠。在先进的向量计算机中，向量运算可以链接起来：当生成结果向量的元素时，它们立刻被另一个向量指令的运算消耗掉，不需要等待所有的结果都计算完成。另一类指令级并行是SIMD，SIMD指令制定了对连续内存位置执行的相同运算。这些指令从内存中并行加载数据，把它们存放在宽寄存器中，并使用并行硬件来计算它们。很多媒体、图形和数字信号处理应用可以利用这些运算。

GCC将串行指令变成向量指令的依据如下例：

Example1: int a[N], b[N], c[N]; foo () {   int i;     for (i=0; i<N; i++){     a[i] = b[i] + c[i];   } }

Example1中a[i]=b[i]+c[i]，数组a、b和c没有依赖关系，完全可以实现向量化，循环如下：

for (i=0; i<N; i+=VF) {       a[i:i+VF] = b[i:i+VF] + c[i:i+VF];    }

其中VF是向量指令的操作数个数，经过这样的优化在向量处理机上，运行效率得到了VF倍的提升。

GCC中得向量自动化是在循环优化实现的，这是可以想象的，根据上面的示例可知，循环中存在着向量化的潜力。然而，要使得指令有标量转变为向量是极为不容易的，这需要很多相关性分析，才能找到正确的向量化。

3.1.2 现状：

在主要的GCC开发trunk中，有一个开发分支（autovect-branch）。该分支就是GCC中实现自动向量化的工程，主要的开发者为：Dorit Naishlos、Olga Golovanevsky、Ira Rosen等。然而，该分支的最近一次更新在2009-12-03，说明对于自动向量化已经很完善了，并且该分支似乎已经停止了。

3.1.3 代码分析：

这里将会探讨GCC如何实现自动向量化。该优化实现在tree-vectorizer.c、tree-vect-loop.c、tree-vect-loop-manip.c、tree-vect-slp.c、tree-vect-stmts.c、tree-vect-data-refs.c和tree-vect-data-refs.c等文件中。其中SLP（Superword Level Parallelism）超长指令字。

对于循环和基本块向量化，GCC实现了三种：循环向量化（迭代间并行）；循环明确SLP（loop-aware SLP，迭代内并行）；基本块并行化（Basic block，循环外）。下图是简要的流程刻画：

tree-vectorizer.c:      loop_vect()  loop_aware_slp()  slp_vect()           |        /           \          /           |       /             \        /           tree-vect-loop.c  tree-vect-slp.c                 | \      \  /      /   |                 |  \      \/      /    |                 |   \     /\     /     |                 |    \   /  \   /      |          tree-vect-stmts.c  tree-vect-data-refs.c                        \      /                     tree-vect-patterns.c

以vectorize_loops()函数为例进行分析。代码如下：

unsigned vectorize_loops (void) {   unsigned int i;   unsigned int num_vectorized_loops = 0;   unsigned int vect_loops_num;   loop_iterator li;   struct loop *loop;     vect_loops_num = number_of_loops ();     /* Bail out if there are no loops.  */   if (vect_loops_num <= 1)     return 0;     /* Fix the verbosity level if not defined explicitly by the user.  */   vect_set_dump_settings (false);     init_stmt_vec_info_vec ();     /*  ----------- Analyze loops. -----------  */     /* If some loop was duplicated, it gets bigger number      than all previously defined loops.  This fact allows us to run      only over initial loops skipping newly generated ones.  */   FOR_EACH_LOOP (li, loop, 0)     if (optimize_loop_nest_for_speed_p (loop))       {        loop_vec_info loop_vinfo;          vect_location = find_loop_location (loop);        loop_vinfo = vect_analyze_loop (loop);        loop->aux = loop_vinfo;          if (!loop_vinfo || !LOOP_VINFO_VECTORIZABLE_P (loop_vinfo))          continue;          vect_transform_loop (loop_vinfo);        num_vectorized_loops++;       }     vect_location = UNKNOWN_LOC;     statistics_counter_event (cfun, "Vectorized loops", num_vectorized_loops);   if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS)       || (num_vectorized_loops > 0          && vect_print_dump_info (REPORT_VECTORIZED_LOCATIONS)))     fprintf (vect_dump, "vectorized %u loops in function.\n",             num_vectorized_loops);     /*  ----------- Finalize. -----------  */     mark_sym_for_renaming (gimple_vop (cfun));     for (i = 1; i < vect_loops_num; i++)     {       loop_vec_info loop_vinfo;         loop = get_loop (i);       if (!loop)        continue;       loop_vinfo = (loop_vec_info) loop->aux;       destroy_loop_vec_info (loop_vinfo, true);       loop->aux = NULL;     }     free_stmt_vec_info_vec ();     return num_vectorized_loops > 0 ? TODO_cleanup_cfg : 0; }

该函数实现了循环的向量化。主要过程：

（1）初始化阶段：定义必要的变量，调用number_of_loops函数得到循环的个数，若循环个数为0，返回0；否则冗余级。为stmt_vec_info创建哈希表。

（2）分析阶段：初始化完成后，进入循环分析阶段。该阶段通过调用optimize_loop_nest_for_speed_p函数分析循环是否可以向量化。如果能够向量化，则调用vect_transform_loop将该循环向量化。

（3）收尾阶段：该阶段调用mark_sym_for_renaming函数，SYM被update_ssa重命名；通过destroy_loop_vec_info和free_stmt_vec_info_vec函数将中间过程用到而随后不需要的数据删除。

   对于loop-aware SLP和basic block向量化于循环向量化分析类似，都要经过三种阶段，区别是循环分析的方法和内容不同。具体的分析方法还是比较复杂的。

   对于向量化，GCC还有一种优化方法“用于向量化的Tree级if转换（Tree level if-conversion for vectorizer）。该过程变现为这样的形式，是向量化能够对语句和可用的向量操作进行一一映射。该过程位于tree-if-conv.c，并由pass_if_conversion来描述。该过程如下：

Ø  确定循环是否是if转换

Ø  以宽度优先遍历所有的循环基本块

                                    i.             移除条件表达（在基本块末端），并且将条件传播到目的基本块。

                                  ii.             用使用当前基本块的条件修改表达式替换修改的表达式。

Ø  合并所有的基本块。

下图是该优化的转换样例：

INPUT      -----        # i_23 = PHI <0(0), i_18(10)>;      <L0>:;      j_15 = A[i_23];      if (j_15 > 41) goto <L1>; else goto <L17>;        <L17>:;      goto <bb 3> (<L3>);        <L1>:;        # iftmp.2_4 = PHI <0(8), 42(2)>;      <L3>:;      A[i_23] = iftmp.2_4;      i_18 = i_23 + 1;      if (i_18 <= 15) goto <L19>; else goto <L18>;        <L19>:;      goto <bb 1> (<L0>);        <L18>:;

OUTPUT      ------        # i_23 = PHI <0(0), i_18(10)>;      <L0>:;      j_15 = A[i_23];        <L3>:;      iftmp.2_4 = j_15 > 41 ? 42 : 0;      A[i_23] = iftmp.2_4;      i_18 = i_23 + 1;      if (i_18 <= 15) goto <L19>; else goto <L18>;        <L19>:;      goto <bb 1> (<L0>);        <L18>:;

 

3.2 自动并行化（auto parallelization）

在tree-ssa的循环优化中，还有另一类优化：自动并行化。该遍优化将循环迭代转变为多线程，实现代码在“tree-parloops.c”。现代计算机包含多个CPU，多个核，特别是超级计算机可能包含成千上万个CPU，这就要求编写的程序能够充分利用这些计算资源，所以编译器的并行化就变得很重要。GCC通过将不相关的代码实现线程级的并行化，来提高整体的执行效率。GCC支持OpenMP并行编程，以充分利用计算机的计算能力。线程，有时被称为轻量级进程，是程序执行流的最小单元。

自动向量化很长一阶段都是一个难点，可以想见串行指令变为并行指令是极为困难的。然而，目前并行性是提高整体性能的关键因素，GCC支持四种同步模式：

向量化前面已经探讨了，对于并行编程，GCC直接支持OpenMP，而MPI尚没有直接支持。

GCC使用vect_force_simple_reduction()去检测减少模式，下面是代码转换的例子：

parloop {   int sum=1;     for (i = 0; i < N; i++)    {     x[i] = i + 3;     sum+=x[i];    } }   gimple-like code: header_bb:     # sum_29 = PHI <sum_11(5), 1(3)>   # i_28 = PHI <i_12(5), 0(3)>   D.1795_8 = i_28 + 3;   x[i_28] = D.1795_8;   sum_11 = D.1795_8 + sum_29;   i_12 = i_28 + 1;   if (N_6(D) > i_12)     goto header_bb;     exit_bb:     # sum_21 = PHI <sum_11(4)>   printf (&"%d"[0], sum_21);     after reduction transformation (only relevant parts):   parloop {   ....       # Storing the initial value given by the user.  #     .paral_data_store.32.sum.27 = 1;     #pragma omp parallel num_threads(4)     #pragma omp for schedule(static)     # The neutral element corresponding to the particular   reduction's operation, e.g. 0 for PLUS_EXPR,   1 for MULT_EXPR, etc. replaces the user's initial value.  #     # sum.27_29 = PHI <sum.27_11, 0>     sum.27_11 = D.1827_8 + sum.27_29;     GIMPLE_OMP_CONTINUE     # Adding this reduction phi is done at create_phi_for_local_result() #   # sum.27_56 = PHI <sum.27_11, 0>   GIMPLE_OMP_RETURN     # Creating the atomic operation is done at   create_call_for_reduction_1()  #     #pragma omp atomic_load   D.1839_59 = *&.paral_data_load.33_51->reduction.23;   D.1840_60 = sum.27_56 + D.1839_59;   #pragma omp atomic_store (D.1840_60);     GIMPLE_OMP_RETURN    # collecting the result after the join of the threads is done at   create_loads_for_reductions().   The value computed by the threads is loaded from the   shared struct.  #       .paral_data_load.33_52 = &.paral_data_store.32;   sum_37 =  .paral_data_load.33_52->sum.27;   sum_43 = D.1795_41 + sum_37;     exit bb:   # sum_21 = PHI <sum_43, sum_26>   printf (&"%d"[0], sum_21);   ... }

自动并行化涉及到很多分析步骤，每一个优化的编译器都必须要实现相似的过程，具体的实现过程可能不相同，这就决定了编译器的能力。GCC是功能强大的，在自动并行化的优化上主要涉及以下几步：

Ø  别名分析：确定那个存储位置能够被超过一种方式访问。

Ø  迭代变数分析：对于自动并行化，循环迭代必须是可计算的。

Ø  归纳变量分析：自动并行化的工作是将循环迭代分配到线程中去。为了实现这个目的，每个线程必须有自己的私有归纳变量拷贝。

Ø  数据相关性分析：由串行指令变为并行指令，数据相关性分析是极为重要的，数据相关性直接制约着程序的并行潜力。当前GCC包括两种框架实现数据相关性分析：lambda和GRAPHITE。

四、结论

通过这一阶段的GCC学习，充分认识到GCC强大的功能，以前仅仅认为GCC只支持C和C++，然而GCC能够支持很多通用的语言，并且也支持并行化编程（OpenMP）。对于GCC的开发者，深深地折服。

GCC的学习是一个“浩瀚的工程”，仅仅GCC的源码就超过400MB，阅读起来相当的吃力，甚至于上面的优化分析的代码很多也是没有读懂的，猜测是这个意思，也就写上了；GCC的学习也是一个“任重道远的工作”，GCC是如此的优秀，值得我们深入学习：编译器架构、优化算法、代码等等。

收获也是颇丰的，能够进一步了解GCC，知道其中的编译选项的用法，极大地提高了阅读代码的能力。

五、参考文献

本部分罗列一些参考文献和网站，很多都是能够在http://gcc.gnu.org上找到的。

²  GNU Compiler Collection Internals

²  Compilers Principles,Techniques,&Tools(龙书)

²  www.wiki.com

²  Auto-vectorization in GCC

²  Debugging Options-Using the GNU CompilerCollection

                                                                                                         

                                                                                                                                                                                                                                       转自：http://blog.youkuaiyun.com/lingdongjiangzhi/article/details/7576721