强度削弱优化及算术优化

整数变量与操作符运算效率表

运算类型	强度等级	典型CPU周期	关键说明和优化
加法(+)、减法(-)、位操作（&、	、^、<<、>>等）	1（最弱）	~1
乘法(*)	2（中等）	~3 - 4	硬件优化程度高，速度较快；编译器会自动优化简单场景，无需过度手动干预。
除法(/)、取模(%)（无符号整数）	3（较强）	~40 - 80	无符号整数的除法/取模相对有符号整数更快；高频循环中应避免使用，可依赖编译器将“常量除法”优化为乘法+移位操作。
除法(/)、取模(%)（有符号整数）	3（最强）	~40 - 80（通常比无符号略慢）	有符号整数因需处理符号位，额外增加逻辑开销，速度比无符号整数稍慢；同无符号场景，高频场景需尽量规避或依赖编译器优化。
自增(++i/i++)、自减(--i/i--)	接近1	~1（与普通加减效率相近）	与普通加减运算效率差异可忽略；需注意“i++（先取值后自增）”和“++i（先自增后取值）”的结果依赖场景，但效率本身无显著差别。

浮点变量与操作符运算效率表

运算类型	寄存器类型参考	典型CPU周期	关键说明和优化
加法(+)、减法(-)	XMM/YMM/ZMM（SSE/AVX等向量寄存器）、x87	~2 - 6	向量寄存器（SSE/AVX）支持并行处理多组浮点，效率远高于x87；优先用向量指令集，避免x87（精度高但速度慢）。
乘法(*)	XMM/YMM/ZMM（SSE/AVX等向量寄存器）、x87	~3 - 8	同加法，向量寄存器可并行乘法；需避免混合精度（如float与double混用），否则会触发精度转换开销。
除法(/)	XMM/YMM/ZMM（SSE/AVX等向量寄存器）、x87	~14 - 45	浮点除法比加减、乘法慢很多；优先使用优化的数学库（如Intel SVML），或通过编译器选项（如-ffast-math）在“精度要求宽松时”平衡速度。
精度选择（float vs double）	-	-	非向量场景下，double（8字节）与float（4字节）运算效率相近；小数组/大数组优先选float，可节省缓存空间、提升缓存命中率。

一、算术优化的两类核心方向

优化类型	核心目标	示例场景
单运算符优化（Single Operator Improvements）	替换单个低效运算符为高效实现	将整数乘法 x*4 替换为左移 x<<2、将浮点数除法 x/100.0 替换为乘法 x*0.01
表达式级优化（Expression-Level Optimizations）	优化多运算符组成的表达式，减少冗余计算	提取公共子表达式（如 (i*i)+(i*i) 优化为 temp=i*i; temp+temp）、编译期常量折叠

编译器（如 GCC、MSVS）会在启用优化（如 -O2）时自动完成部分优化（如常量折叠、简单强度降低），但仍需程序员主动优化编译器“看不到的全局逻辑”。

二、运算强度降低（Operator Strength Reduction）

“运算强度降低”是算术优化的核心技术，指将“计算复杂度高、延迟长的强运算”（如除法、浮点数乘法），替换为“复杂度低、延迟短的弱运算”（如位运算、加法）。

1. 需优先规避的“强运算”

• 浮点数运算：即使是浮点数加法，延迟也约为整数加法的 2-3 倍；浮点数乘法延迟更高（约为整数乘法的 3-5 倍）；
• 乘法（*）：整数乘法延迟约为整数加法的 4-6 倍，浮点数乘法延迟更高；
• 除法（/）与取余（%）：CPU 中除法延迟是乘法的 10-20 倍，取余运算（尤其是非 2 的幂次取余）延迟更高；
• 数学函数：如 sqrtf（平方根）、expf（指数），需通过硬件指令或近似算法优化，直接调用标准库函数延迟极高。

2. 核心优化方案：用弱运算替代强运算

（1）位运算替代整数乘法/除法（针对 2 的幂次）

最经典的强度降低技巧，利用“左移等价于乘以 2 的幂次、右移等价于除以 2 的幂次”，位运算为单周期指令：

强运算（低效）	弱运算（高效）	适用条件
x * 2	x << 1	整数 x，无符号或非负
x * 8	x << 3	整数 x，移位次数=log₂(乘数)
x / 4	x >> 2u	无符号整数 x（避免负号问题）
x % 512（取余）	x & 511u	取余基数为 2 的幂次（512=2⁹，掩码=512-1）

陷阱：

• 运算符优先级差异：x << 1 + 2 等价于 x << 3（加法优先级高于移位），需加括号 (x << 1) + 2，避免逻辑错误；
• 符号问题：有符号整数右移为“算术右移”（补符号位），可能导致结果错误，需使用 unsigned 类型或确保 x 非负。

（2）加法替代整数乘法（针对小乘数）

当乘数为小整数（如 2、3、5）时，加法延迟可能低于乘法（尤其在无位运算优化空间时）：

强运算（低效）	弱运算（高效）	原理
x * 2	x + x	加法延迟 < 乘法延迟
x * 3	x + x + x	3次加法延迟可能低于1次乘法（需基准测试验证）
x * 5	(x << 2) + x	结合位运算与加法，比 5次加法更快

注意：该优化需结合硬件特性——部分 CPU（如 Intel Skylake）的乘法指令已优化至单周期，此时加法替代可能无收益，需通过 perf 或 std::chrono 基准测试验证。

（3）浮点数除法→乘法（利用倒数）

浮点数除法延迟是乘法的 10-15 倍，“用‘乘以倒数’替代‘除以常数’”，通过编译期预计算倒数，将除法转为乘法：

// 低效：浮点数除法
float f = g / 100.0f;

// 高效：乘以预计算的倒数（编译期常量折叠）
const float inv_100 = 1.0f / 100.0f;  // 编译期计算倒数
float f = g * inv_100;

进阶优化：针对复杂常数（如 sqrtf(3.14159f)），用 static const 预计算倒数，避免运行时重复计算：

// 低效：每次调用都计算 sqrtf 和除法
void process(float* v, int n) {
  for (int i = 0; i < n; i++) {
    v[i] /= sqrtf(3.14159f);  // 运行时除法+数学函数，延迟高
  }
}

// 高效：静态常量预计算倒数
void process_optimized(float* v, int n) {
  static const float scale = 1.0f / sqrtf(3.14159f);  // 仅初始化时计算1次
  for (int i = 0; i < n; i++) {
    v[i] *= scale;  // 仅乘法，延迟低
  }
}

---

（4）整数算术替代浮点数算术（有限精度场景）

浮点数运算延迟远高于整数，书中建议在精度允许的场景（如 1-3 位小数），将浮点数转换为整数运算，通过“放大倍数”保留小数部分：

• 示例场景：美元/美分计算（1 美元=100 美分），用整数存储“美分”，避免浮点数精度丢失与高延迟；
• 转换逻辑：

// 低效：浮点数计算（存在精度丢失风险）
float price = 19.99f;     // 19美元99美分
float total = price * 5;  // 99.95 可能存储为 99.949997...

// 高效：整数计算（以美分为单位）
int price_cents = 1999;             // 1999美分 = 19.99美元
int total_cents = price_cents * 5;  // 9995美分 = 99.95美元
// 转换为美元+美分（仅在输出时处理）
int dollars = total_cents / 100;
int cents = total_cents % 100;

注意：整数除法/取余仍为低效运算，需尽量避免——例如上述场景中，若仅需输出总价，可直接格式化 total_cents 为字符串（如 sprintf(buf, "%d.%02d", total_cents/100, total_cents%100)），避免在热路径中执行除法/取余。

三、低效操作规避：针对取余（%）与类型转换

---

1. 规避取余运算（%）：用分支或位运算替代

---

（1）循环计数场景：用分支替代取余

在“循环计数+绕回”场景（如环形队列的索引更新），x = (x+1) % N 可替换为分支判断，延迟显著降低：

// 低效：取余绕回（N为任意整数）
int x = 0;
const int N = 100;  // 非2的幂次，无法用位运算替代
x = (x + 1) % N;    // 延迟高

// 高效：分支判断绕回
if (x == N - 1) {
  x = 0;
} else {
  x++;
}

// 简洁版（三元运算符，效率与分支相当）
x = (x == N - 1) ? 0 : x + 1;

---

（2）2 的幂次取余：用位运算替代

若取余基数为 2 的幂次（如 256、512），直接用“与运算（&）”替代取余，延迟降至单周期：

// 低效：取余运算
int x = 1023;
int rem = x % 256;  // 256=2⁸，结果=1023-3*256=255

// 高效：位运算（掩码=基数-1）
int rem = x & 255;  // 255=256-1，结果=255，延迟仅为取余的1/10

扩展优化：若需将整数限制在 [0, 255] 范围内，可直接强制类型转换为 unsigned char（8 位），编译器会自动优化为“与 255”操作，代码更简洁：

int x = 1023;
unsigned char rem = static_cast<unsigned char>(x);  // 结果=255，等价于x&255

2. 规避类型转换

关于类型的最佳实践

方法	说明
使用 static_cast 进行显式转换，避免隐式转换	显式转换避免C风格强制转换引发的潜在错误和隐式转换的性能损耗
关键计算中保持数据类型精度一致	混合精度可能导致额外转换指令，降低性能。
避免混合整数与浮点数运算	整型与浮点型混合需额外转换，增加计算开销。优先统一为浮点型或整型处理。
创建类型安全的API，避免混合类型调用	使用函数重载或模板设计API，强制参数类型一致，减少隐式转换风险。
优先使用SSE指令进行浮点运算（比x87更高效）	SSE/AVX向量寄存器支持并行计算，单/双精度运算效率高于x87长双精度（80位），且编译器默认在64位模式下启用。
低于32位的整数类型操作时实际使用32位指令集	处理器对小整数的运算通常提升为32位，仅在存储紧凑布局时使用（如数组元素）。
低精度整数（<32位）仅用于数据存储的紧凑布局	64位系统中，32位整数运算效率最高；16/8位类型仅在内存敏感场景（如大数组）使用，避免性能损失。
有符号与无符号整数速度相近，但无符号在避免符号检查时略快	无符号类型在除法、取模及常量除法优化中更快，但需注意溢出行为差异。有符号类型转浮点更快。
浮点下溢时启用Flush-to-Zero模式	子归一化数（Subnormal）处理耗时，通过_MM_SET_FLUSH_ZERO_MODE 禁用，提升性能。
大数组优先使用最小整数类型以优化缓存	在内存密集型场景可减少内存占用，提升数据缓存命中率。
数学函数优先使用库函数而非硬件指令	向量寄存器（SSE/AVX）的数学函数通常比x87硬件指令更快，且兼容性更好。
类型转换时避免符号扩展或零扩展的隐式行为	例如，int 转 unsigned int 时负数会被解释为大正数，需显式处理边界条件。

（1）避免 float 与 double 混合

double 运算延迟高于 float，且混合使用会触发隐式转换：

// 低效：混合 float 与 double（隐式转换）
float scale = sqrt(2.0) * 3.14159;
// 问题：
// 1. 2.0 是 double，sqrt(2.0) 返回 double；
// 2. 3.14159 是 double；
// 3. 结果需转换为 float，存在两次 double 运算+1次类型转换，延迟高。

// 高效：全 float 类型（添加 'f' 后缀）
float scale = sqrtf(2.0f) * 3.14159f;
// 优化：
// 1. 2.0f、3.14159f 是 float；
// 2. sqrtf 是 float 版本的平方根函数；
// 3. 无隐式转换，全 float 运算，延迟低。

注意：编译器会对“常量表达式”进行优化（如 sqrt(2.0f) 可能编译期计算），但仍需显式指定 float 类型——若遗漏 f 后缀，编译器可能发出“精度丢失”警告，且运行时仍可能执行 double 运算。

（2）避免 float 与 int 混合

int 与 float 混合运算会触发“整数转浮点数”操作，延迟约为 2-3 纳秒：

• 热路径中，将 int 提前转换为 float 并缓存，避免重复转换；
• 示例：

// 低效：循环内重复 int→float 转换
void compute(float* out, int* in, int n) {
  for (int i = 0; i < n; i++) {
    out[i] = in[i] * 0.5f;  // 每次循环都执行 in[i]（int）→float 转换
  }
}

// 高效：提前转换并缓存（若 in 不修改）
void compute_optimized(float* out, int* in, int n) {
  // 提前转换为 float 数组（仅执行1次转换）
  std::vector<float> in_float(n);
  for (int i = 0; i < n; i++) {
    in_float[i] = static_cast<float>(in[i]);
  }
  // 热路径：无类型转换，纯 float 运算
  for (int i = 0; i < n; i++) {
    out[i] = in_float[i] * 0.5f;
  }
}

四、表达式转换：减少冗余计算与优化结构

---

1. 公共子表达式消除（Common Subexpression Elimination, CSE）

当表达式中多次出现相同子表达式（如 i*i）时，提取为临时变量，避免重复计算：

// 低效：重复计算 i*i
float x = (i * i) + (i * i) + sqrtf(i * i);  // 3次计算 i*i

// 高效：提取公共子表达式
float temp = static_cast<float>(i * i);
float x = temp + temp + sqrtf(temp);  // 仅1次计算 i*i

陷阱：避免在表达式中直接赋值并复用临时变量（如 x = (temp = i*i) + temp）——C++ 未定义 + 运算符的求值顺序，可能导致 temp 未赋值就被使用，引发逻辑错误。

2. 代数恒等式优化：减少运算次数

优化前（冗余运算）	优化后（减少运算）	运算次数变化
a_x + a_y	a*(x + y)	2次乘法 + 1次加法 → 1次乘法 + 1次加法
-x + -y	-(x + y)	2次取负 + 1次加法 → 1次加法 + 1次取负
(a && b)		(a && c)
!a && !b	!(a

示例：AI 中的向量运算优化 在 AI 向量点积计算中，sum += a[i]*w[i] + a[i]*b[i] 可优化为 sum += a[i]*(w[i]+b[i])：

// 低效：2次乘法+1次加法
float dot_product(const float* a, const float* w, const float* b, int n) {
  float sum = 0.0f;
  for (int i = 0; i < n; i++) {
    sum += a[i] * w[i] + a[i] * b[i];  // 2次乘法
  }
  return sum;
}

// 高效：1次乘法+1次加法
float dot_product_optimized(const float* a, const float* w, const float* b,
                            int n) {
  float sum = 0.0f;
  for (int i = 0; i < n; i++) {
    sum += a[i] * (w[i] + b[i]);  // 1次乘法
  }
  return sum;
}

---

3. 编译期常量折叠（Constant Folding）

编译器会将“编译期可计算的常量表达式”提前计算，避免运行时冗余运算：

// 低效：运行时计算常量（编译器可能未优化）
const float pi = 3.14159f;
const float two_pi = pi * 2.0f;  // 若编译器未折叠，运行时执行乘法

// 高效：显式常量表达式（C++11及以上）
constexpr float pi = 3.14159f;
constexpr float two_pi = pi * 2.0f;  // 强制编译期计算，运行时无运算

扩展场景：针对复杂常量（如 sqrtf(2.0f)），用 const 而非 constexpr（sqrtf 非 constexpr 函数），但仍能触发编译期折叠：

// 编译期计算 sqrtf(2.0f)，运行时直接使用结果
static const float sqrt2 = sqrtf(2.0f);