高性能计算应用优化之代码实现调优(一)

本文主要是介绍高性能计算应用优化之代码实现调优(一)，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

本章将介绍代码实现过程中使用到的调优方法。在软件开发早期，开发者更多关注代码功能的实现，对代码的性能关注较少，随着代码规模增加，不合理的代码实现方法所带来的性能包袱逐渐凸显。因此，需要对原有代码实现进行优化，如修改不合理的访存顺序，使代码更易于被编译器优化等。

浮点数运算

浮点数运算是科学计算中开销最大的部分之一，特别是双精度除法，合理地设计实现浮点数运算环节可以显著提高程序的性能。

由于单精度类型和双精度类型之间的向量长度（即向量寄存器中的元素数）不同，同一循环中混合使用单精度数组和双精度数组会减少自动向量化的机会。考虑一个使用不同大小数据的循环，例如，REAL和DOUBLE PRECISION。对于REAL数据，编译器尝试从四个（SSE）或八个（AVX）连续迭代（32位x4=128位，32位x8=256位）中打包数据元素。对于双精度数据，编译器尝试从两个（SSE）或四个（AVX）连续迭代（64位x2=128位，64位x4=256位）中打包数据元素。由于迭代次数不匹配，编译器在尝试自动纠正这种情况后，有时无法执行循环的自动向量化。

避免在同一计算中混合整数和浮点（REAL）数据。将浮点算术表达式中的所有整型数字表示为浮点值，无需在固定格式和浮点格式之间转换数据。将整数算术表达式中的所有数字表示为整数值也可以实现这一点。例如，假设I和J都是整数变量，将常数（2.0）表示为整数值（2）就不需要转换数据。下面的示例演示了低效和高效的代码。

Inefficient code: INTEGER I, J I = J / 2.0Efficient code: INTEGER I, J I = J / 2

使用开销小的运算代替开销大的运算。

例如可以使用r*r代替r**2，后者可能会隐式调用pow函数，增加一次函数调用开销；除一个常数可以优化为乘一个常数，x/2.0可以优化为x*0.5。

r = r**2   -> r = r * rr = r / 2    -> r = r * 0.5

循环优化

循环是应用程序中执行计算任务最重要的部分，一般其开销也是最大的。理想的循环有如下的特性：

• 只执行必要的工作，移除所有无关和不必要的计算；

• 应当使用最快的可使用指令来实现目标；也即循环内指令最少；

• 循环应尽量便于进行SIMD指令优化；

• 指令应当尽可能平衡的使用CPU单元；例如如果循环中的除法指令过多，就会导致整个循环在等待除法指令的执行从而成为性能瓶颈；

• 循环内的内存访问模式应当尽可能好，尽可能提高缓存命中率，好的访存模式能够带来好的性能。

循环中函数调用与IO

循环中的函数调用会影响循环的性能，原因之一是函数调用可能会改变内存的情况。例如如下代码：

for (int i = 0; i < n; i++){   if (debug)       A();   else       B();}

在某些情况下，函数可能会修改debug的值。如果编译器知道debug的值不会发生变化的话，编译器可以尝试将这个代码做如下优化：

if (debug) {     for (int i = 0; i < n; i++)        A(); } else {     for (int i = 0; i < n; i++)         B();}

我们可以通过设置局部变量的方式让编译器了解到这个变量并不会发生变化：

bool debug_local = debug; for (int i = 0; i < n; i++) {    if (debug_local)        A();    else        B(); }

此外，在有函数出现的情况下，编译器自身的优化能力就会下降。下面的代码中，如果编译器能够将add函数进行内联，那么编译器就可以尝试做更多的优化（如向量化）；但是如果add函数无法被内联，编译器只能每次迭代都调用add函数。而一旦涉及到函数的调用，就需要进行跳转，过多的跳转会影响到程序的性能。

double add(double a, double b) {    return a + b; } for (int i = 0; i < n; i++) {     c[i] = add(a[i], b[i]); }

包含在循环或循环嵌套中的 I/O 会严重降低性能。花在 I/O 库上的 CPU 时间数量可能构成了循环所用时间的主要部分（I/O 还会引起进程中断，降低程序处理能力）。用户在编写代码时需要尽可能将 I/O 移出计算循环，可以大大减少 I/O 库的调用次数。

将变量维持在寄存器中

如果我们能够尽可能地将变量放在寄存器中，就可以提高访存的效率。由于CPU中寄存器的数量是有限的，编译器需要基于某些特征来判断哪些变量适合放在寄存器中，哪些变量适合放在内存里。有两种情况会阻止编译器将变量存在寄存器中，在编写代码时可以尽量避免。

1. 变量过多：编译器无法将全部变量都存储在寄存器中。因此寄存器需要考虑将部分暂时用不到的变量放在内存中，在需要的时候再将这个变量加载到寄存器中，这种现象称为寄存器溢出(register spilling)。

2. 指针别名：如果存在指向标量A的指针B，那么我们可以通过直接修改A或者通过指针B来修改A的值。寄存器不会将A放在寄存器中，因为通过指针对其进行的修改将会丢失。

移除无关运算

在本部分，编译器的目标是尽可能的移除循环中无用的部分。

有些计算并不需要，在编译的过程中，编译器会尽可能的忽略掉不会执行的代码，也即所谓的死代码消除(dead code elimination)。如下所示：

void add(int* a, int* b) {     (*a)++;     if (b) (*b)++; } for (int i = 0; i < n; i++) {     add(&a[i], nullptr); }​

在编译器进行内联以后，由于传给add函数的参数int *b始终为nullptr，所以编译器可以直接移除掉这部分的判断：

for (int i = 0; i < n; i++)      (*a)++;

循环不变量(Loop invariant computation)是指在循环中需要，但是不需要每次都在循环中计算的部分。例如如下的代码：

for (int i = 0; i < n; i++) {     switch (operation) {         case ADD: a[i]+= x * x; break;         case SUB: a[i]-= x * x; break;     } }

这个循环中，operation和x都是循环无关变量，因为他们不会随着循环的发生而改变。在某些情况下编译器会自动计算出x*x的值，从而减少重复运算。但若编译器偏向保守则不会做该优化，需要用户手动优化。

而对于switch控制流，编译器会尝试对不同的控制流创建循环，这种转换成为循环分裂(loop unswitching)。在编译器无法进行准确的判断控制流时，编译器往往偏向保守，需要用户手动优化。

auto x_2 = x * x; if (operation == ADD) {     for (int i = 0; i < n; i++)         a[i] += x_2; } else if (operation == SUB) {     for (int i = 0; i < n; i++)         a[i] -= x_2; }

迭代器相关变量是依赖于迭代器变量的值。如下所示：

for (int i = 0; i < n; i++) {     auto min_val = a[i];     if (i != 0) min_val = std::min(a[i - 1], min_val);      if (i != (n - 1)) min_val = std::min(a[i + 1], min_val);     b[i] = min_val; }

两个if判断条件都不依赖于循环中的数据。因此，我们可以将它们移出循环并进行特殊判断。编译器很少进行这种优化，需要用户手动优化。

b[0] = std::min(a[0], a[1]); for (int i = 1; i < n - 1; i++) {     auto min_val = a[i];     min_val = std::min(a[i - 1], min_val);     min_val = std::min(a[i + 1], min_val);     b[i] = min_val; } b[n - 1] = std::min(a[n - 2], a[n - 1]);

循环展开

当如下的循环迭代次数非常少的时候，循环操作本身的开销和循环内部操作的开销可能是一致的，在这种情况下，我们需要进行循环展开操作。

for (int i = 0; i < n; i++) {     index = i / 2;     b_val = load(b + index);     store(a + i, b_val); }

在这种情况下，我们提高了循环内部的工作量，相对减少了循环操作的开销。

for (int i = 0; i < n; ) {     index = i / 2;     b_val = load(b + index);     store(a + i, b_val);     i++;     index = i / 2;     b_val = load(b + index);     store(a + i, b_val);     i++;     index = i / 2;     b_val = load(b + index);     store(a + i, b_val);     i++;     index = i / 2;     b_val = load(b + index);     store(a + i, b_val);     i++; }

展开有两种好处，一是可以减少开销，二是可以让我们进行一些额外的优化。例如在上面的例子中，i/2和(i+1)/2在i是偶数的情况下一致，就可以删除一些不必要的负载。在进行优化后，我们只需要进行两个load操作，而原来需要四次load操作。

for (int i = 0; i < n; ) {     index = i / 2;     b_val = load(b + index);     store(a + i, b_val);     i++;     store(a + i, b_val); // b_val与上面的计算相同     i++;     index = i / 2;     b_val = load(b + index);     store(a + i, b_val);     i++;     store(a + i, b_val); // b_val与上面的计算相同     i++; }

但是循环展开也增加了内存子系统的负载，特别是指令缓存和指令解码单元。当循环内部过大的时候，会出现较多的缓存垃圾，这会降低指令的取指译码速度，因此编译器在循环展开的时候会比较保守，需要用户自行权衡循环大小与展开程度。此外也要注意，手动循环展开可能会阻碍其他的优化，可以将这部分工作交给更专业的编译器去做。例如我们可以通过!DIR$ UNROLL [(n)]或!DIR$ UNROLL [=n]让ifort进行n倍循环展开。

本次仅介绍了代码实现调优中的浮点运算和循环优化，还有内存优化和计算优化，下篇将继续介绍

这篇关于高性能计算应用优化之代码实现调优(一)的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---