写程序最次要的指标就是使它在所有可能的状况下都正确工作。一个运行得很快然而给出谬误后果的程序没有任何用途。程序员必须写出清晰简洁的代码，这样做不仅是为了本人可能看懂代码，也是为了在检査代码和今后须要批改代码时，其他人可能读懂和了解代码。另一方面，在很多状况下，让程序运行得快也是一个重要的思考因素。本章次要介绍了循环展开，减小过程调用，打消不必要的内存援用等优化代码的办法，有助于咱们写出高效的代码，进步代码的性能。

@[toc]
  编写高效程序须要做到以下几点：

  1.适合的算法和数据结构

  2.编写出编译器可能无效优化以转换成高效可执行代码的源代码（例如，在C语言中，指针运算和强制类型转换使得编译器很难对它进行优化）。

  3.针对解决运算量特地大的计算，将一个工作分成多局部，即利用并行性。

优化编译器的能力和局限性

GCC优化指令

  -Og:默认配置，不优化。

  -O1:编译器试图优化代码大小和执行工夫，它次要对代码的分支，常量以及表达式等进行优化，但不执行任何会占用大量编译工夫的优化。

  -O2:GCC执行简直所有不蕴含工夫和空间衡量的优化（比方，尝试更多的寄存器级的优化以及指令级的优化）。与-O相比，此选项减少了编译工夫，但进步了代码的效率。

  -O3:比-O2更优化，对于-O3编译选项，在-O2的根底上，关上了更多的优化项（比方，应用伪寄存器网络，一般函数的内联，以及针对循环的更多优化）。不过可能导致编译进去的二级制程序不能debug。

  -Os:次要是对代码大小的优化，咱们根本不必做更多的关怀。 通常各种优化都会打乱程序的构造，让调试工作变得无从着手。并且会打乱执行程序，依赖内存操作程序的程序须要做相干解决能力确保程序的正确性。

内存别名应用

  两个指针可能指向同一个内存地位的状况成为内存别名应用。

void twiddle1 (long *xp,long*yp){    *xp+ = *yp;    *xp+ = *yp;}void twiddle2(long *xp,long*yp){    *xp+ = 2 * *yp;}

twiddle1它们都是将存储在由指针yp批示的地位处的值两次加到指针xp批示的地位处的值。twiddle2须要3次内存援用（读 xp，读yp，写 xp）。 twiddle1须要6次（2次读 xp，2次读yp，2次写 xp），个别，咱们认为twiddle2要优于twiddle2。那么将twiddle1优化是不是就能产生相似twiddle2的代码了？

答案显然是不能够的。当 xp == yp 时，twiddle1执行后的后果是：xp的值减少4倍。而twiddle2的后果是xp的值减少3倍。因而，两个程序是有实质差异的。

以上这个例子就介绍了内存别名应用，编译器在优化时，并不知道xp 和 yp是否相等，只能假如他们不相等，即xp和yp指针不会指向同一地位。

示意程序性能

  程序性能度量规范：每元素的周期数（Cycles Per Element，CPE）。

  处理器流动的程序是由时钟管制的，时钟提供了某个频率的法则信号，通常用千兆赫兹（GHz），即十亿周期每秒来示意。例如，当表明一个零碎有“4GHz”处理器，这示意处理器时钟运行频率为每秒$4 \times {10^9}$个周期。每个时钟周期的工夫是时钟频率的倒数。通常是以纳秒（ nanosecond，1纳秒等于${10^{ - 8}}$秒）或皮秒（ picosecond，1皮秒等于${10^{ - 12}}$秒）为单位的。例如，一个4GHz的时钟其周期为0.25纳秒，或者250皮秒。从程序员的角度来看，用时钟周期来示意度量规范要比用纳秒或皮秒来示意有帮忙得多。用时钟周期来示意，度量值示意的是执行了多少条指令，而不是时钟运行得有多快。

程序示例

打消循环的低效率(Code Motion)

  举个例子如下所示：

void lower1(char *s){  size_t i;  for (i = 0; i < strlen(s); i++)    if (s[i] >= 'A' && s[i] <= 'Z')      s[i] -= ('A' - 'a');}

<img src="https://gitee.com/dongxingbo/Picture/raw/master//%E6%B7%B1%E5%85%A5%E7%90%86%E8%A7%A3%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%B3%BB%E7%BB%9F/%E7%AC%AC%E4%BA%94%E7%AB%A0/strlen_%E9%95%BF%E5%BA%A6%E5%BD%B1%E5%93%8D%E6%95%88%E7%8E%87%E4%B8%BE%E4%BE%8B.png" alt="image-20201201165824434" style="zoom: 80%;" />

  程序看起来没什么问题，一个很平时的大小写转换的代码，然而为什么随着字符串输出长度的变长，代码的执行工夫会呈指数式增长呢？咱们把程序转换成GOTO模式看下。

void lower1(char *s){   size_t i = 0;   if (i >= strlen(s))     goto done; loop:   if (s[i] >= 'A' && s[i] <= 'Z')       s[i] -= ('A' - 'a');   i++;   if (i < strlen(s))     goto loop; done:}

  咱们能够看到，在C语言中调用strlen一次，这个函数实际上会执行两次。还有一个重要的起因是：字符串的长度并不会随着循环的进行而扭转，因而，咱们能够把strlen放在循环外，防止每次都调用strlen进行计算。

因为C语言中的字符串是以null结尾的字符序列，strlen必须一步一步地查看这个序列，直到遇到null字符。对于一个长度为n的字符串，strlen所用的工夫与n成正比。因为对lower1的n次迭代的每一次都会调用strlen，所以lower1的整体运行工夫是字符串长度的二次项，反比于${n^2}$。

  优化后的代码如下所示：

void lower2(char *s){  size_t i;  size_t len = strlen(s);           /*放在函数体外*/  for (i = 0; i < len; i++)    if (s[i] >= 'A' && s[i] <= 'Z')      s[i] -= ('A' - 'a');}

  二者的执行效率比拟如下所示：

  这种优化是常见的一类优化的办法，称为代码移动（Code motion）。这类优化包含辨认要执行屡次（例如在循环里）然而计算结果不会扭转的计算。因此能够将计算挪动到代码后面不会被屡次求值的局部。

缩小过程调用

/* Move call to vec_length out of loop */void combine2 (vec_ptr v, data_t *dest){    long i;    long length vec_length(v);    *dest = IDENT;    for (i=0;i< length;i++)    {        data_t val;        get_vec_element(v,i,&val);        *dest = *dest OP val;    }}

  从combine2的代码中咱们能够看出，每次循环迭代都会调用get_vec_element来获取下一个向量元素。对每个向量援用，这个函数要把向量索引i与循环边界做比拟，很显著会造成低效率。在解决任意的数组拜访时，边界查看可能是个很有用的个性，然而对 combine2代码的简略分析表明所有的援用都是非法的。

data_t *get_vec_start(vec_ptr v){    return v-data;}/* Move call to vec_length out of loop */void combine3 (vec_ptr v, data_t *dest){    long i;    long length vec_length(v);    data_t *data = get_vec_start(v);    *dest = IDENT;    for (i=0;i< length;i++)    {        *dest = *dest OP data[i];    }}

  作为代替，假如为咱们的抽象数据类型减少一个函数get_vec_start。这个函数返回数组的起始地址，而后就能写出此combine3所示的过程，其内循环里没有函数调用。它没有用函数调用来获取每个向量元素，而是间接拜访数组。

  事实上，通过这一步后，并没有使得性能有较大晋升，前面会具体讲到。这只是咱们优化路上的一步。

打消不必要的内存援用

#Inner loop of combines. data_t double, OP =#dest in %rbx, data+i in %rdx, data+length in %rax .L17:vmovsd (%rbx),%xmm()           # Read product from dest vmulsd (%rdx),%xmm0,%xmm0      # Multiply product by data[i]vmovsd %xmm, (%rbx）           # Store product at destaddq $8,%rdx                   # Increment data+icmp %rax,%rdx                  # Compare to data+length jne .L17

  在这段循环代码中，咱们看到，指针dest的地址寄存在寄存器%rbx中，它还扭转了代码，将第i个数据元素的指针保留在寄存器%rdx中，正文中显示为data+i。每次迭代，这个指针都加8。循环终止操作通过比拟这个指针与保留在寄存器各ax中的数值来判断。咱们能够看到每次迭代时，累积变量的数值都要从内存读出再写入到内存。这样的读写很节约，因为每次迭代开始时从dest读出的值就是上次迭代最初写入的值。

  咱们可能打消这种不必要的内存读写， combine4所示的形式如下。引入一个长期变量acc，它在循环中用来累积计算出来的值。只有在循环实现之后后果才寄存在dest中。正如上面的汇编代码所示，编译器当初能够用寄存器%xmm0来保留累积值。

#Inner loop of combines. data_t double, OP =#dest in %rbx, data+i in %rdx, data+length in %rax .L25:vmulsd (%rdx),%xmm0,%xmm0      # Multiply product by data[i]addq $8,%rdx                   # Increment data+icmp %rax,%rdx                  # Compare to data+length jne .L25
void combine4 (vec_ptr v, data_t *dest){    long i;    long length vec_length(v);    data_t *data = get_vec_start(v);    *data acc = IDENT;    for (i=0;i< length;i++)    {        acc = acc OP data[i];    }    *dest = acc;}

  把后果累积在长期变量中。将累积值寄存在局部变量acc（累积器（ accumulator）的简写）中，打消了每次循环迭代中从内存中读出并将更新值写回的须要。

  程序性能如下（以int整数为例），单位为CPE。

函数办法+*
combine3间接数据拜访7.179.02
combine4累积在长期变量中1.273.01

了解古代处理器

整体操作

基本概念

  超标量（superscalar）：在每个时钟周期执行多个操作

  乱序（out-of-order）：指令执行的程序不肯定要与它们在机器级程序中的程序统一

<img src="https://gitee.com/dongxingbo/Picture/raw/master//%E6%B7%B1%E5%85%A5%E7%90%86%E8%A7%A3%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%B3%BB%E7%BB%9F/%E7%AC%AC%E4%BA%94%E7%AB%A0/%E5%9B%BE5-11_%E4%B9%B1%E5%BA%8F%E5%A4%84%E7%90%86%E5%99%A8%E6%A1%86%E5%9B%BE.png" alt="image-20201202111459465" style="zoom: 80%;" />

  如上图所示，为一个乱序处理器的框图。整个设计有两个次要局部：指令管制单元（ Instruction Control Unit,ICU）和执行单元（ Execution Unit,EU）。前者负责从内存中读出指令序列，并依据这些指令序列生成一组针对程序数据的基本操作；而后者执行这些操作。

  指令高速缓存（Instruction cache）：一个非凡的高速存储器，它蕴含最近拜访的指令。

  分支预测（branch prediction）：处理器会猜想是否会抉择分支，同时还预测分支的指标地址。应用投机执行（ speculative execution）的技术，处理器会开始取出位于它预测的分支，会跳到的中央的指令，并对指令译码，甚至在它确定分支预测是否正确之前就开始执行这些操作。如果过后确定分支预测谬误，会将状态从新设置到分支点的状态，并开始取出和执行另一个方向上的指令。标记为取指管制的块包含分支预测，以实现确定取哪些指令的工作。

  指令译码逻辑：一条指令会被译码成多个操作。例如，addq %rax,8(%rdx)，。这条指令会被译码成为三个操作：一个操作从内存中加载一个值到处理器中，一个操作将加载进来的值加上寄存器%rax中的值,而一个操作将后果存回到内存。

  读写内存是由加载和存储单元实现的。加载单元解决从内存读数据到处理器的操作。这个单元有一个加法器来实现地址计算。相似，存储单元解决从处理器写数据到内存的操作。它也有一个加法器来实现地址计算。如图中所示，加载和存储单元通过数据高速缓存（ data cache）来拜访内存。数据高速缓存是一个高速存储器，寄存着最近拜访的数据值。

  服役单元（ retirement unit）:记录正在进行的解决，并确保它恪守机器级程序的程序语义。服役单元管制这些寄存器的更新。指令译码时，对于指令的信息被搁置在一个先进先出的队列中。这个信息会始终放弃在队列中，直到产生以下两个后果中的一个。首先，一旦一条指令的操作实现了，而且所有引起这条指令的分支点也都被确认为预测正确，那么这条指令就能够服役（ retired）了，所有对程序寄存器的更新都能够被理论执行了。另一方面，如果引起该指令的某个分支点预测谬误，这条指令会被清空（ flushed），抛弃所有计算出来的后果。通过这种办法，预测谬误就不会改变程序的状态了。(任何对程序寄存器的更新都只会在指令服役时才会产生)

  寄存器重命名（ register renaming）：当一条更新寄存器r的指令译码时，产生标记t，失去一个指向该操作后果的惟一的标识符。条目（r,t）被退出到一张表中，该表保护着每个程序寄存器r与会更新该寄存器的操作的标记t之间的关联。当随后以寄存器r作为操作数的指令译码时，发送到执行单元的操作会蕴含t作为操作数源的值。当某个执行单元实现第一个操作时，会生成一个后果（v,t），指明标记为t的操作产生值v。所有期待t作为源的操作都能应用v作为源值，这就是一种模式的数据转发。通过这种机制，值能够从一个操作间接转发到另一个操作，而不是写到寄存器文件再读出来，使得第二个操作可能在第一个操作实现后尽快开始。重命名表只蕴含对于有未进行写操作的寄存器条目。当一条被译码的指令须要寄存器r，而又没有标记与这个寄存器相关联，那么能够间接从寄存器文件中获取这个操作数。有了寄存器重命名，即便只有在处理器确定了分支后果之后能力更新寄存器，也能够预测着执行操作的整个序列。

  提早（ latency）：它示意实现运算所须要的总工夫。

  发射工夫（ Issue time）：它示意两个间断的同类型的运算之间须要的最小时钟周期数。(发射工夫为1：齐全流水线化)

浮点数加法器流水线化分为三个阶段：一个阶段解决指数值，一个阶段将小数相加，而另一个阶段对后果进行舍入。

  容量（ capacity）：它示意可能执行该运算的性能单元的数量。

  提早界线：实现合并运算的函数所须要的最小CPE值。

  最大吞吐量：发射工夫的倒数。给出了CPE的最小界线。

循环展开

  循环展开是一种程序变换，通过减少每次迭代计算的元素的数量，缩小循环的迭代次数。循环展开可能从两个方面改良程序的性能。首先，它缩小了不间接有助于程序后果的操作的数量，例如循环索引计算和条件分支。第二，它提供了一些办法，能够进一步变动代码，缩小整个计算中要害门路上的操作数量。

/*2 * 1 loop unrolling*//*应用2×1循环展开。这种变换能减小循环开销的影响*/void combine5(vec_ptr v, data_t *dest){    long i;    long length = vec_length(v);    long limit = length-1;    data_t *data = get_vec_start(v);    data_t acc = IDENT;        /* Combine 2 elements at a time */    for (i = 0; i < limit; i+=2) {        acc = (acc OP data[i]) OP data[i+1];    }    /* Finish any remaining elements */    for (; i < length; i++) {        acc = acc OP data[i];    }    *dest = acc;}

  上述代码是应用的”2 * 1循环展开“的版本。第一个循环每次解决数组的两个元素。也就是每次迭代，循环索引i加2，在一次迭代中，对数组元素i和i+1应用合并运算。（留神拜访不要越界，正确设置limit，n个元素，个别设置界线n-1）。

  $K \times 1$循环展开次数和性能晋升并不是反比关系，一般来讲，最多循环展开一次后，性能晋升就不会很大了（次要起因是要害门路中n个mul操作，迭代次数减半，然而每次迭代中还是有两个程序的乘法操作。具体参考P367）。

进步并行性

多个累积变量

  ${P_n}$示意${a_0},{a_1} \cdots {a_n}$ 乘积：${P_n} = \sum\limits_{i = 0}^{n - 1} {{a_i}} $。假如n为偶数，咱们还能够把它写成${P_n} = P{E_n} \times P{O_n}$,这里$P{E_n}$是索引为偶数的元素的乘积，而$P{O_n}$是索引值为奇数的元素的乘积。

  代码如下：

/*2 * 2 loop unrolling*//*使用2×2循环展开。通过保护多个累积变量，这种办法利用了多个性能单元以及它们的流水线能力*/void combine6(vec_ptr v, data_t *dest){    long i;    long length = vec_length(v);    long limit = length-1;    data_t *data = get_vec_start(v);    data_t acc0 = IDENT;    data_t acc1 = IDENT;        /* Combine 2 elements at a time */    for (i = 0; i < limit; i+=2) {        acc0 = acc0 OP data[i];        acc1 = acc1 OP data[i+1];    }    /* Finish any remaining elements */    for (; i < length; i++) {        acc0 = acc0 OP data[i];    }    *dest = acc0 OP acc1;}

  上述代码用了两次循环展开，以使每次迭代合并更多的元素，也应用了两路并行，将索引值为偶数的元素累积在变量acc0中，而索引值为奇数的元素累积在变量acc1中。因而，咱们将其称为”2×2循环展开”。同后面一样，咱们还包含了第二个循环，对于向量长度不为2的倍数时，这个循环要累积所有剩下的数组元素。而后，咱们对acc0和acc1利用合并运算，计算最终的后果。

  事实上，combine6比combine5性能晋升近2倍左右。

从新联合变换

/*2 * 1a loop unrolling*//*使用2×1a循环展开，从新联合合并操作。这种办法减少了能够并行执行的操作数量*/void combine7(vec_ptr v, data_t *dest){    long i;    long length = vec_length(v);    long limit = length-1;    data_t *data = get_vec_start(v);    data_t acc = IDENT;        /* Combine 2 elements at a time */    for (i = 0; i < limit; i+=2) {        acc = acc OP (data[i] OP data[i+1]);    }    /* Finish any remaining elements */    for (; i < length; i++) {        acc = acc OP data[i];    }    *dest = acc;}

  咱们能够看到要害门路上只有n/2个操作。每次迭代内的第一个乘法都不须要期待前一次迭代的累积值就能够执行。因而，最小可能的CPE缩小了2倍。这种改良形式简直达到了吞吐量的极限。

  在执行从新联合变换时，咱们又一次扭转向量元素合并的程序。对于整数加法和乘法，这些运算是可联合的，这示意这种从新变换程序对后果没有影响。对于浮点数状况，必须再次评估这种从新联合是否有可能重大影响后果。咱们会说对大多数利用来说，这种差异不重要。

  总的来说，从新联合变换可能缩小计算中要害门路上操作的数量，通过更好地利用性能单元的流水线能力失去更好的性能。大多数编译器不会尝试对浮点运算做从新联合，因为这些运算不保障是可联合的。以后的GCC版本会对整数运算执行从新联合，但不是总有好的成果。通常，咱们发现循环展开和并行地累积在多个值中，是进步程序性能的更牢靠的办法。

Intel在199年引入了SSE指令，SSE是“ Streaming SIMD Extensions（流SIMD扩大）”的缩写，而SIMD（读作“ sim-dee”）是“ Single-In-Struction, Multiple-Data（单指令多数据）”的缩写。SSE性能历经几代，最新的版本为高级向量扩大（ advanced vector extension）或AVX。SIMD执行模型是用单条指令对整个向量数据进行操作。这些向量保留在一组非凡的向量寄存器（ vector register）中，名字为号%ymm0~%ymm15。目前的AVX向量寄存器长为32字节，因而每一个都能够寄存8个32位数或4个64位数，这些数据既能够是整数也能够是浮点数。AVX指令能够对这些寄存器执行向量操作，比方并行执行8组数值或4组数值的加法或乘法。例如，如果YMM寄存器%ymm0蕴含8个单精度浮点数，用${a_0},{a_1} \cdots {a_n}$示意，而%rcx蕴含8个单精度浮点数的内存地址，用${b_0},{b_1} \cdots {b_n}$示意，那么指令vmulps （%rcx）， %ymm0, %ymm1会从内存中读出8个值，并行地执行8个乘法，计算${a_i} \leftarrow {a_i}{b_i},0 \le i \le 7$，并将失去的8个乘积保留到向量寄存器%ymm1。咱们看到，一条指令可能产生对多个数据值的计算，因而称为“SIMD”。（应用SIMD指令重写代码能够使程序性能取得上百倍晋升）

一些限度因素

寄存器溢出

  咱们能够看到对这种循环展开水平的减少没有改善CPE，有些甚至还变差了。古代x86-64处理器有16个寄存器，并能够应用16个YMM寄存器来保留浮点数。一旦循环变量的数量超过了可用寄存器的数量，程序就必须在栈上调配一些变量。
例如，上面的代码片段展现了在10×10循环展开的内循环中，累积变量acc0是如何更新的：

# Updating of accumulator acco in 10 x 10 unrolling vmulsd (%rdx),%xmm,%xmm0       #acc0 *=data[i]

  咱们看到该累积变量被保留在寄存器%xmm0中，因而程序能够简略地从内存中读取data[i],并与这个寄存器相乘。

  与之相比，20×20循环展开的相应局部十分不同：

# Updating of accumulator acco in 20 x 20 unrolling vmovsd 40(%rsp),%xmm0vmulsd (%rdx),%xmm0,%xmm0vmovsd %xmmO,40(%rsp)

  累积变量保留为栈上的一个局部变量，其地位间隔栈指针偏移量为40。程序必须从内存中读取两个数值：累积变量的值和data[i]的值，将两者相乘后，将后果保留回内存。

  一旦编译器必须要诉诸寄存器溢出，那么保护多个累积变量的劣势就很可能隐没。侥幸的是，x86-64有足够多的寄存器，大多数循环在呈现寄存器溢出之前就将达到吞吐量限度。

分支预测何预测谬误惩办

  古代处理器的工作远远超前于以后正在执行的指令。

1.不要过分关怀可预测的分支

  咱们曾经看到谬误的分支预测的影响可能十分大，然而这并不意味着所有的程序分支都会减缓程序的执行。实际上，古代处理器中的分支预测逻辑十分长于分别不同的分支指令的有法则的模式和长期的趋势。例如，在合并函数中完结循环的分支通常会被预测为抉择分支，因而只在最初一次会导致预测谬误处罚。

2.书写适宜用条件传送实现的代码

  程序中的许多测试是齐全不可预测的，依赖于数据的任意个性，例如一个数是正数还是负数。对于这些测试，分支预测逻辑会解决得很蹩脚。对于实质上无奈预测的状况，如果编译器可能产生应用条件数据传送而不是应用条件管制转移的代码，能够极大地提高程序的性能。

  咱们发现GCC可能为以一种更“功能性的”格调书写的代码产生条件传送，在这种格调的代码中，咱们用条件操作来计算值，而后用这些值来更新程序状态，这种格调对抗于一种更“命令式的”格调，这种格调中，咱们用条件语句来有选择地更新程序状态。

void minmax1(long a[],long b[],long n){    long i;    for(i = 0;i,n;i++){    if(a[i]>b[i]){        long t = a[i];        a[i] = b[i];        b[i] = t;    }}}

  在随机数据上测试这个函数，失去的CPE大概为13.50，而对于可预测的数据，CPE为2.5其预测谬误惩办约为20个周期。

  用性能式的格调实现这个函数是计算每个地位i的最大值和最小值，而后将这些值别离赋给a[i]和b[i]。

void minmax2(long a[],long b[],long n){    long i;    for(i = 0;i,n;i++){    long min = a[i] < b[i] ? a[i]:b[i];    long max = a[i] < b[i] ? b[i]:a[i];    a[i] = min;    b[i] = max;    }}

  对于这个函数的测试表明，无论数据是任意的，还是可预测的，CPE都大概为4.0。

了解内存性能

加载的性能

  古代处理器有专门的性能单元来执行加载和存储操作，这些单元有外部的缓冲区来保留未实现的内存操作申请汇合。一个蕴含加载操作的程序的性能既依赖于流水线的能力，也依赖于加载单元的提早。

  要确定一台机器上加载操作的提早，咱们能够建设由一系列加载操作组成的一个计算，一条加载操作的后果决定下一条操作的地址。举例如下：

typedef struct ELE{ struct ELE *next; long data;}list_ele, *list_ptr;long list_len(list_ptr ls){    long len = 0;    while (ls){    len++;    ls = ls->next;     }    return len;} 
.L3:                       #loopaddq $1,%rax               #Increment lenmoveq (%rdi),%rdi          #ls = ls->nexttesatq %rdi,%rdi           #Test lsjne .L3                    # if nonnull,goto loop

  第3行上的movq指令是这个循环中要害的瓶颈。前面寄存器%rdi的每个值都依赖于加载操作的后果，而加载操作又以%rdi中的值作为它的地址。因而，直到前一次迭代的加载操作实现，下一次迭代的加载操作能力开始。这个函数的CPE等于4.00，是由加载操作的提早决定的。

性能进步技术

  尽管只思考了无限的一组应用程序，然而咱们能得出对于如何编写高效代码的很重要的经验教训。总结如下：

(1)高级设计

  为遇到的问题抉择适当的算法和数据结构。要特地警惕，防止应用那些会渐进地产生蹩脚性能的算法或编码技术。

(2)根本编码准则

  防止限度优化的因素，这样编译器就能产生高效的代码。

  打消间断的函数调用。在可能时，将计算移到循环外。思考有选择地斗争程序的模块性以取得更大的效率。

  打消不必要的内存援用。引入长期变量来保留两头后果。只有在最初的值计算出来时，才将后果寄存到数组或全局变量中。

(3)低级优化

  结构化代码以利用硬件性能。

  开展循环，升高开销，并且使得进一步的优化成为可能。

  通过应用例如多个累积变量和从新联合等技术，找到办法进步指令级并行。

  用功能性的格调重写条件操作，使得编译采纳条件数据传送。

(4)使用性能剖析工具

  当解决大型程序时，将注意力集中在最耗时的局部变得很重要。代码分析程序和相干的工具能帮忙咱们系统地评估和改良程序性能。咱们形容了 GPROF，一个规范的Unix分析工具。还有更加简单欠缺的分析程序可用，例如 Intel的VTUNE程序开发零碎，还有 Linux零碎基本上都有的 VALGRIND。这些工具能够在过程级合成执行工夫，预计程序每个基本块（ basic block）的性能。（基本块是外部没有管制转移的指令序列，因而基本块总是整个被执行的。)

  最初要给读者一个忠告，要警觉，在为了提高效率重写程序时防止引入谬误。在引人新变量、扭转循环边界和使得代码整体上更简单时，很容易犯错误。一项有用的技术是在优化函数时，用查看代码来测试函数的每个版本，以确保在这个过程没有引入谬误。查看代码对函数的新版本施行一系列的测试，确保它们产生与原来一样的后果。对于高度优化的代码，这组测试状况必须变得更加宽泛，因为要思考的状况也更多。例如，应用循环展开的检査代码须要测试许多不同的循环界线，保障它可能解决最终单步迭代所须要的所有不同的可能的数字。

总结

  本章中具体介绍了进步程序性能的一些通用办法和工具，在日常编写代码的过程中，应时刻留神代码的格调，养成良好的习惯。当解决大型程序时或者不晓得优化程序的那个局部时，咱们能够借助GPROF，VTUNE，VALGRIND等工具来进一步分析程序，剖析每个函数的性能，找到限度程序性能的因素，逐个解决。
如遇到排版错乱的问题，能够通过以下链接拜访我的CSDN。

**CSDN:[CSDN搜寻“嵌入式与Linux那些事”]