【System Beats！】第五章 优化程序性能

性能优化概况

• 在实际生活中，需要提升软件性能，最终目标是编写高效的代码，最大限度地利用硬件资源。
• 性能优化通常考虑以下三方面：
  • 选择恰当的算法和数据结构
  • 理解编译器的能力和局限性
  • 大规模任务下进行并行计算
• 需要在简单性和运行速度上进行权衡
• 注意避免"渐进低效率"的情况，即在小数据集上表现良好，但在实际部署后，由于数据规模增大，原本的算法或数据结构反而成为性能瓶颈。
• 许多低级别的优化往往会降低可读性和模块性，使得容易出错，并且更难以修改。
• 最好的编译器也收到妨碍优化的因素。

编译器(Compiler)

• 在代码优化中扮演直观重要角色
• 可以进行以下操作
  • 执行寄存器的分配和调度
  • 代码的重新排序和规划
  • 赘余代码的消除
• 不会引入可能引入风险的优化，即优化后得到的程序与未优化的版本有一样行为
• 大多数优化在函数内部
• 最简单的控制是指定优化级别
  • -Og是让GCC进行基本优化
  • -O1,-O2,-O3是让GCC进行更大量的优化
  • 可以提高程序性能
  • 也可能增加程序规模，使标准调试工具更难对程序进行调试
  • 正如在Attack Lab中看到的一样

普适性优化(Machine-independent)

消除循环低效率

• 这种优化也被称为代码移动
• 比较以下两段代码

int combine_1(vector<int>& nums,int x){int n=nums.size();for(int i=0;i<=n-1;i++){x+=nums[i];}return x;
}
int combine_2(vector<int>& nums,int x){for(int i=0;i<=nums.size();i++){x+=nums[i];}return x;
}

• 显然，combine_1的性能优于combine_2
• 但是，如果nums.size()有副作用，这两者可能有不同的行为

减少过程调用

• 同上，可以将内循环中调用的函数移出循环体。

消除不必要的内存调用

• 若每次都要访问内存并进行读写，程序的速度会大幅下降。
• 参考以下代码：

void combine_3(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];}return ;
}
void combine_4(vec_ptr v,data_t *dest){long i;long length=vec_length(v);data_t *data=get_vec_start(v);data_t acc=IDENT;for(i=0;i<length;i++){acc=acc OP data[i];}*data=acc;return ;
}

• 可以观察到，此时combine_4最后才把计算出的值写回，消除了不必要的内存引用。

降低运算复杂性

• 通过将复杂的运算转化为简单的运算，例如将乘除法转化为移位操作，可以降低运算的复杂性。
• 当乘法需要多个CPU时钟周期时，这种转换可以有效节省时间。

函数副作用

• 即函数修改全局程序状态的一部分
• 参考以下代码

long f();
long func1(){return f()+f()+f()+f();
}
long func2(){return 4*f();
}
long counter=0;
long f(){return counter++;
}

• 当上文中的f采用修改全局状态的定义时，则发生副作用。
• 此时，func1和func2的返回值不同。
• 可以使用内联函数替换，即用inline将一些简单函数声明为内联函数。
• 将函数调用替换为函数体。
• 当编译器为funline或-O1或更高等级时，编译器会尝试使用单文件中的函数内联，但是无法跨文件内联。
• 在使用GDB和代码剖析评估程序性能时，避免使用内联函数。

内存别名使用

• 内存别名使用：两个指针可能指向同一个内存位置
• 在只执行安全的优化中，编译器必须假设不同指针可能指向同一个内存位置
• 这造成了一个主要的妨碍优化的因素

特殊优化

• 需要考虑特定的处理器/ISA架构。

跳转/条件跳转

• 当处理器计算跳转目标地址时，编译器可以优化程序，让处理器在跳转前的阶段执行一些不相关的指令。

充分运行CPU各个算术单元

• 现代CPU的执行阶段通常包含多个算术单元。
• 在进行多周期运算（如乘法）时，可以合理安排顺序，使运算流水线化。
• 并且可以让CPU在每个周期内同时执行多个运算。

超标量CPU(Supercalar Processor)

• 可以在一个周期内发射(issue)和执行(execute)多条指令，实现指令级并行(issue位于decode和execute之间)。
• 同时，这些指令是乱序的。
• 现代处理器通常是4发射(一次发射4条指令)。
• 现代CPU通常分为指令控制单元(ICU)和执行单元(EU)
• 取指：
  • ICU从指令高速缓存中读取指令
  • 指令高速缓存是一个特殊高速存储器，包含最近访问指令。
  • ICU会在当前正在执行的指令很早之前取指。
  • 遇到分支时，ICU采用分支预测和投机执行策略。
  • 投机执行：开始取出预测分支跳到的地方的指令，对指令译码甚至执行。
  • 最终结果不会放在程序寄存器或者数据内存中，直到处理器能确定是否应该实际执行这些指令。
  • 若错误，会将状态设置为分支点的状态，开始取出和执行另一个方向的指令。
• 执行：
  • EU包含多个功能单元，例如load/store单元,整数运算器，浮点运算器和分支器等。
  • 执行单元之间可以直接交换信息，可以并行执行多条指令的不同部分。
  • 会接收分支操作，确定分支操作是否正确。
  • 若错误，则会发信号给分支单元，说预测是错误的，并指出正确的分支目的。
  • 执行单元之间使用寄存器重命名机制来避免数据冲突。
  • 寄存器重命名：类似于转发机制，会更新寄存器的操作被写入寄存器表。
  • 随后，等待它进行源的操作都是用其作为源值。
  • 若在寄存器表找不到标记，则去寄存器堆里找。
• 写回：
  • ICU中的退役单元(retirement unit)确保操作按照程序顺序执行。
  • 若一条指令的操作完成了，并且所有引起这条指令的分支点都正确，那么其可以退役(retirement)。
  • 若某个分支点预测错误，它会被清空(flushed)，丢弃所有计算出的结果。

表示程序性能

CPE(Cycle-Per-Element)

• 指的是每个元素运算所需的时钟周期数
• 总周期 \(T\) 可以表示为 \(T=n \times CPE + Overhead\)
• 其中 \(n\) 是元素数量， \(Overhead\) 是其他开销
• 单位用千兆赫，即 GHz 表示，意为每秒能执行 n*10^9条指令
• 当数据规模很大时，可以忽略常数项

功能单元的性能：

• 在本节中，以Intel Core i7 Haswell作为参考机。
• 它有八个功能单元，其中：
  • 四个功能单元可以执行整数操作（加法、移位、乘法）
  • 两个单元可以执行加载操作
  • 两个单元可以执行浮点乘法
• 主要包括以下三部分：
  • 延迟：表示完成运算所需要的总时间。
  • 发射时间：表示两个连续的同类型运算之间需要的最小时钟周期数。
  • 容量：能执行该运算的功能单元的数量。
• 例如，在参考机上，各运算的数据如下：

• 发射时间为1的运算被称为完全流水线化的(fully pipelined)。
• 容量大于1的运算是由于有多个功能单元。
• 部分指令的最小延迟(也就是CPE)超过1个周期，但是可以被流水线化。
• 例如，load/store(4周期)，整数乘法(3周期)，浮点加法（3），浮点乘法（5）都可以被流水线化。
• 因为，每个周期只占用一部分运算单元。
• 整数与浮点出发则比较复杂，且不能被流水线化（全程占用全部运算单元，发射时间=延迟）。
• 处理器吞吐量：吞吐量=每时钟周期(容量/发射时间)个操作。
• 延迟界限：任何必须按照严格顺序完成合并运算的函数所需要的最小CPE值。
• 吞吐量界限：给出CPE的最小界限，需要额外考虑加载/存储操作等等。
• 下面是上述运算的两个基本界限

处理器操作的抽象类型

• 需要使用程序的数据流表示
• 限制形成关键路径，是执行一组机器指令时所需时钟周期数的一个下界。
• 大概可以理解为，在下一次迭代前无法开始的指令，是关键路径的候选者。
• 循环访问的寄存器可以分为以下四类：
  • 只读，只用作源值，可以作为数据或计算内存地址，但不会被修改。
  • 只写：作为数据传送的目的。
  • 局部：在循环内部被修改和使用，迭代和迭代之间不相关，例如条件码寄存器。
  • 循环：既作为源值，又作为目的，一次迭代中产生的值会在另一次迭代中被用到。

循环优化

• 一种优化手段，希望突破延迟界限，使吞吐量界限成为唯一限制。
• 循环的性能由所有循环寄存器完成一次循环所需的最长时间(关键路径长度)所制约。

循环展开

• 通过增加每次迭代的元素来减少循环次数，只适用于循环控制开销大于循环内计算开销的情况。
• 在-O3或者更高优化等级时，编译器会自动展开循环。
• 例如以下代码：

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;for(i=0;i<limit;i+=2){acc=(acc OP data[i]) OP data[i+1];}for(;i<length;i++){acc=acc OP data[i];}*dest=acc;return ;
}

• 可以观察到，迭代次数减少了，但是乘法的关键路径还是不变。
• 因此，没有突破延迟限制。

循环展开-多个累计变量

• 循环分解将满足交换律和结合律的合并运算分割为多个部分
• 在最后合并结果，适用于循环内的数据相关性是主要制约因素的情况。
• 注意，浮点加和浮点乘不总是满足结合律。
• 比如以下代码：

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;for(i=0;i<limit;i+=2){acc0=acc0 OP data[i];acc1=acc1 OP data[i+1]; }for(;i<length;i++){acc0=acc0 OP data[i];}*dest=acc0 OP acc1;return ;
}

• 可以看到，此时acc0和acc1没有迭代依赖了，关键路径变短。
• 通常只有保持能够执行该操作的所有功能单元的流水线都是满的，程序才能达到吞吐量界限。
• 例如对延迟为 \(L,\) 容量为 \(C\) 的操作而言，循环展开因子需要达到 \(k \geq C \cdot L\) 。
• 并行度过大时，会导致寄存器溢出（可用寄存器不够），从而编译器将部分变量存储于内存中，降低性能。

循环展开-重新结合变换

• 在基础的循环展开中重新排列运算顺序，优先结合只读元素，减少迭代内的数据相关性。
• 比如，以下代码：

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;for(i=0;i<limit;i+=2){acc=acc OP (data[i] OP data[i+1]);}for(;i<length;i++){acc=acc OP data[i];}*data=acc;
}

• 画出数据流，可以观察到由乘法迭代引起的数据相关缩短了，关键路径也缩短了一半。

补充

SIMD(Single Instruction Multiple Data)

• Intel基于SIMD引入了SSE(Streaming SIMD Extension)指令集
• 它使用AVX向量寄存器(32字节)和GPU等独立部件进行并行计算，适用于向量加法等操作。

有关分支

• 使用条件传送操作可以有效较少分支预测错误的概率。
• 不要过分关心可预测的分支。
• 书写适合用条件传送实现的代码。

理解内存性能

• 由于加载操作的地址只依赖于循环索引，因此不会成为关键路径的一部分。
• 例如，在参考机上，由于只有两个加载单元。
• 因此，对于每个被计算的元素必须加载 \(k\) 个值的应用，不可能获得低于 \(\frac{k}{2}\) 的CPE。
• 存储单元包含一个存储缓冲区，包含已经被发射到存储单元而又没有完成的存储操作的地址和数据。
• 操作包括更新数据告诉缓存。
• 当一个加载操作发生时，它必须检查存储缓冲区中的条目，看有没有地址相匹配。
• 如果有地址相匹配，则取出相应的数据条目作为加载操作的结果。
• 只有加载操作会受存储操作结果的影响，即写/读相关(write/read dependency)。
• 意为，存储地址必须在数据被存储之前被计算出来。
• 同时，加载操作会将它的地址与所有未完成的存储操作的地址进行比较。
• 最后，还需要考虑加载地址和存储地址相同时的情况。

后记

• 又写一篇，明天还有一篇，累死了，期中季加油