作者Alun

浅谈C++性能优化:从硬件原理到代码实践

滑动窗口、分支、缓存、查表、内存分配与并行化实战

C++性能优化硬件原理编译器优化算法优化
浅谈C++性能优化:从硬件原理到代码实践
题图

一开始写图片处理代码时,很容易把“优化”理解成把某个 if 删掉,或者把循环换成 SIMD。等真正开始测量,才会发现:有的程序慢在重复计算,有的慢在到处取数据,还有的时间花在分配内存和等待任务上。同一种改写,放到另一个输入规模里,甚至可能更慢。

这篇文章把几种常用思路放到具体问题里看:连续求和怎样避免反复累加,矩阵边界怎样移出热循环,为什么遍历方向会影响访存,以及查表、预分配、量化和并行化各自换来了什么。它们可以组合使用,但每一步都应该能说清楚少做了什么,又增加了什么成本。

先看交互演示 · 下载完整 C++17 用例 · 下载矩阵边界用例

两份文件都能独立编译。正文中的函数片段按顺序拼接,就是第一份完整用例;矩阵对照另放在文末。浏览器动画解释访问顺序和操作次数,不模拟 CPU 耗时,也不把操作次数直接换算成加速倍数。

1. 先知道时间花在哪里

比如给一批照片添加滤镜,过程可能包括读文件、解码、遍历像素、编码和写文件。若像素循环只占总时间的一小部分,即使把它优化得很快,整体等待也不会按同样比例下降。先分段计时,再选择真正值得优化的环节,往往比立即改底层代码更有效。

CPU 缓存让近期使用的数据有机会更快地再次访问;连续访问通常也更方便预取。分支预测则尝试猜测接下来执行哪条路径:预测正确时,if 不一定昂贵;预测失败时,已经推测执行的工作可能需要丢弃。具体代价取决于处理器、指令与数据,不能给加减乘除和浮点运算排一张适用于所有机器的快慢表。

另一个常见误区是把代码写得像“底层优化”就算完成。编译器可能早已把条件变成选择指令,或自动把普通循环向量化。更有价值的目标是给它一个清楚、可分析的数据流,再检查最终生成的代码与测量结果。

下面的函数用例统一使用这些头文件。require() 在结果错误时直接失败;不会因为开启 -O3 或定义 NDEBUG 而消失。

#include <algorithm>
#include <array>
#include <chrono>
#include <cmath>
#include <cstdint>
#include <iostream>
#include <numeric>
#include <random>
#include <stdexcept>
#include <string>
#include <thread>
#include <vector>
#if defined(__ARM_NEON)
#include <arm_neon.h>
#elif defined(__SSE2__)
#include <emmintrin.h>
#endif

void require(bool ok) {
    if (!ok) throw std::runtime_error("结果校验失败");
}
using Values = std::vector<std::int64_t>;

2. 滑动窗口:少算已经算过的部分

假设有数组 [1,7,3,2,4,5,8,0],要计算每个长度为五的连续窗口之和。第一项是 1+7+3+2+4=17,第二项可以重新算五个数,也可以从 17 中减去离开的 1,再加上进入的 5,得到 21。下一项继续减 7、加 8,得到 22。

朴素版本为每个窗口读取 k 个元素,总工作量随 (n-k+1)×k 增长。滑动窗口先初始化一次,之后只更新一进一出;当窗口很大时,省下的重复工作尤其明显。文章里的动画允许改变 k,逐步观察同一个元素被朴素方案重复读取几次。

Values windows_naive(const Values& a, std::size_t k) {
    if (k == 0 || k > a.size()) return {};
    Values out;
    out.reserve(a.size() - k + 1);
    for (std::size_t i = 0; i + k <= a.size(); ++i) {
        std::int64_t sum = 0;
        for (std::size_t j = i; j < i + k; ++j) sum += a[j];
        out.push_back(sum);
    }
    return out;
}
Values windows_rolling(const Values& a, std::size_t k) {
    if (k == 0 || k > a.size()) return {};
    Values out;
    out.reserve(a.size() - k + 1);
    std::int64_t sum = std::accumulate(a.begin(), a.begin() + k, std::int64_t{0});
    out.push_back(sum);
    for (std::size_t i = k; i < a.size(); ++i) {
        sum -= a[i-k];
        sum += a[i];
        out.push_back(sum);
    }
    return out;
}

这套方法需要问题允许增量更新。求和可以减去旧值,但窗口最大值不能简单地“减去离开的最大值”,那要考虑单调队列等其他结构。浮点求和还有累积误差问题:改变加法顺序不保证逐位相同,需要按数值范围定义误差容限。这里用有界整数输入与 64 位累加,并在测试中检查空数组、无效窗口和负数。

最长无重复子串也可以看成可变长度窗口。文末保留了集合维护与 last-seen 数组两种写法;两者都在线性推进窗口,差异主要在查找、删除和数据结构成本。不要把它们的比较误写成“从平方复杂度优化到线性”。

3. 减少 if:把边界与内部计算拆开

图像处理中,经常是边界像素走一套规则,内部像素走另一套规则。最直接的实现对每个像素判断“是不是首行、末行、首列、末列”。如果内部占绝大多数,可以先处理边缘,再让内部循环专心做同一种计算。

矩阵边界减一、内部加一,并用参考实现验证候选实现

本文的例子规定边界元素减一,内部元素加一。对三行四列矩阵,首尾两行全部减一,中间行只处理左右两个边界,剩下两个元素加一。角点已经属于首尾行,不能再在首尾列重复处理。

对于 R×C 且两边都至少为二的矩阵,拆分后内部有 (R-2)×(C-2) 个元素可以直接更新,不再逐个做几何边界判断。这里减少的是源代码中的边界判定,不是测出了 CPU 分支指令数。循环控制本身仍然存在,编译器也可能把原来的条件转换成其他指令。

在交互演示里,可以单步扫描一张六行八列的矩阵,观察“逐点判断”和“先边缘、后内部”两种安排。文末给出完整 C++ 对照,包含单行、单列与空矩阵测试。

为什么不把所有分支都改成算术

例如按条件选择两个值,手工写成乘零或乘一,可能导致两边表达式都计算了;如果某条路径原本很少发生,这反而增加工作。某些表达式也不能安全地同时执行,比如无效下标或零分母。

真正值得检查的是条件能否提前确定,能否把同一类工作批量处理,以及数据是否让分支难以预测。排序后处理和额外分组也有成本,不应为了删 if 先付出更大的排序代价。对于函数内联同样如此:inline 不是强制内联命令,大量展开还可能增加指令体积。

4. 内存访问:计算一样,走法可以不同

假设矩阵以一维数组按行存放:先是第一行,接着第二行。按行访问时,相邻读取地址也相邻;按列访问时,读完一个元素要跨过整行宽度才能读下一个。算的都是总和,访问顺序却完全不同。

std::int64_t sum_rows(const Values& a, std::size_t rows, std::size_t cols) {
    std::int64_t sum = 0;
    for (std::size_t r = 0; r < rows; ++r)
        for (std::size_t c = 0; c < cols; ++c) sum += a[r*cols+c];
    return sum;
}
std::int64_t sum_columns(const Values& a, std::size_t rows, std::size_t cols) {
    std::int64_t sum = 0;
    for (std::size_t c = 0; c < cols; ++c)
        for (std::size_t r = 0; r < rows; ++r) sum += a[r*cols+c];
    return sum;
}

这两个函数假设输入长度正好是 rows×cols,所有用例都满足这一条件。连续访问通常更容易利用缓存行和预取,但不是说列访问每次都必然未命中。当矩阵很小,整个工作集可能都留在缓存里;不同处理器的缓存和预取策略也会影响结果。演示只画出一维地址上的步长,不假装做了真实缓存模拟。

再往后可以考虑分块:让一小块数据在被替换出缓存前尽量多次使用。典型例子是矩阵乘法,但块大小要结合元素类型、同时活跃的数组和处理器来测,不是固定选 16 或 32 就一定最优。

数据布局也会影响访问成本。一个函数只处理所有像素的绿色通道时,交错 RGB 数据会带上另外两个通道;按通道分开存储可能更方便连续计算,但后续显示和编码又可能要求交错布局。把转换成本放进完整流程里衡量,才知道换布局有没有收益。

5. 查表:把重复的映射提前算出来

把八位通道的亮度增加一个固定值,并限制在 0~255,是一个适合解释查表的例子。每个像素都做加法与截断,或者先把全部 256 种输入的结果计算好,之后按像素值索引。

using Bytes = std::vector<std::uint8_t>;
using Table = std::array<std::uint8_t, 256>;
std::uint8_t adjusted(std::uint8_t value, int delta) {
    // 用例中的 delta 限定为 [-255, 255]。
    return static_cast<std::uint8_t>(std::clamp(int(value) + delta, 0, 255));
}
Table make_lut(int delta) {
    Table table{};
    for (std::size_t i = 0; i < table.size(); ++i)
        table[i] = adjusted(static_cast<std::uint8_t>(i), delta);
    return table;
}
Bytes brighten_direct(const Bytes& input, int delta) {
    Bytes out(input.size());
    for (std::size_t i = 0; i < input.size(); ++i) out[i] = adjusted(input[i], delta);
    return out;
}
Bytes brighten_lut(const Bytes& input, const Table& table) {
    Bytes out(input.size());
    for (std::size_t i = 0; i < input.size(); ++i) out[i] = table[input[i]];
    return out;
}

假设像素是 [0,120,250,255],偏移为 10,两种方式都应输出 [10,130,255,255]。查表没有改变输出,也没有让像素遍历消失,只是把映射计算提前完成。参数改变后,表也要重建。

简单加法很便宜,编译器还可能直接向量化,所以这份用例不保证查表比直接计算快。输入范围很小、映射复杂且反复复用时,查表才更值得试;浮点输入范围大时,建表和离散化本身就成为另一套取舍。

6. 少分配、少拷贝:先知道数据会去哪里

逐项向 std::vector 追加数据时,容量不足需要重新分配存储并搬迁已有元素。若事先知道元素个数,可以先 reserve,让追加过程避免因容量增长而重新分配。

Values collect(const Values& input, bool preallocate) {
    Values out;
    if (preallocate) out.reserve(input.size());
    for (auto value : input) out.push_back(value * value);
    return out;
}

这里把输入限制在 -100~100,避免平方或累计结果溢出。两条路径都输出平方值,但建立结果容器的方式不同。reserve 改变容量,不改变 size,所以不能 reserve(n) 后就直接写 out[i];那需要先 resize(n) 或构造 n 个元素。也不要每次追加前都 reserve(size()+1),这会破坏原本的增长策略。

函数接收 const Values&,避免为了只读输入先复制整个数组。返回结果也不要随手 std::move(out):正常返回可以利用返回值优化或移动语义,显式移动未必有帮助。循环处理中能复用缓冲区时,还可以把分配挪出每帧路径;前提是明确谁拥有数据、谁还持有引用。

预留过多空间也会占用内存。如果输出数量很难估计,容器自身的增长策略可能已经足够好。基准中的两条路径都会为结果分配内存,比较的是增长过程,不是把“完全不分配”与“分配”混为一谈。

7. 量化:用明确的误差换存储空间

有些数据允许近似表示。例如已知数值范围为 0.1~0.8,可以映射到 0~255,用一个字节保存,再按同一范围还原。与前面几种等价改写不同,量化会改变结果,所以应检查误差而不是要求逐位相等。

std::uint8_t quantize(double value) {
    if (!std::isfinite(value)) throw std::invalid_argument("输入必须有限");
    const double unit = (std::clamp(value, 0.1, 0.8) - 0.1) / 0.7;
    return static_cast<std::uint8_t>(std::lround(unit * 255.0));
}
double restore(std::uint8_t value) {
    return 0.1 + double(value) * 0.7 / 255.0;
}

区间内相邻档位相差 0.7/255,采用最近邻舍入时,理论最大绝对误差约为半个档位,即 0.001373;测试另留很小的浮点容差。0.5 对应编码约 146,还原约 0.500784。区间外输入被截断,误差就不能再用半档位描述。

若原先每个数用四字节浮点存储,量化后的原始载荷是每个数一字节;这不等于整个程序或模型文件必然缩小到四分之一。范围参数、索引、对齐和临时缓冲都可能占空间。后续算法如果每次又全部转回浮点,转换开销与峰值内存也要计算进去。

量化不是“浮点数总比整数慢”的推论。它更直接的价值是缩小数据体积、降低某些场景的传输或访存需求;是否适合计算,还要看指令支持与误差要求。

8. SIMD:一条指令处理多个独立元素

SIMD 适合让多个元素执行相同操作。下面给每个像素通道加一个常数,并饱和到 255:普通循环先做,向量实现一次处理 16 个字节,尾部不足 16 个的元素仍交给标量路径。

Bytes brighten_simd(const Bytes& input, std::uint8_t delta) {
    Bytes out(input.size());
    std::size_t i = 0;
#if defined(__ARM_NEON)
    const auto d = vdupq_n_u8(delta);
    for (; i + 16 <= input.size(); i += 16)
        vst1q_u8(out.data()+i, vqaddq_u8(vld1q_u8(input.data()+i), d));
#elif defined(__SSE2__)
    const auto d = _mm_set1_epi8(static_cast<char>(delta));
    for (; i + 16 <= input.size(); i += 16) {
        const auto value = _mm_loadu_si128(reinterpret_cast<const __m128i*>(input.data()+i));
        _mm_storeu_si128(reinterpret_cast<__m128i*>(out.data()+i), _mm_adds_epu8(value, d));
    }
#endif
    for (; i < input.size(); ++i) out[i] = adjusted(input[i], delta);
    return out;
}

这里分别使用 ARM NEON 与 x86 SSE2 的无符号饱和加法,其他平台保留标量回退。显式 SIMD 只演示正偏移,不能直接拿它处理负数。校验覆盖所有 256 个正偏移、全部字节输入和 0~65 的短长度,专门检查尾部与截断。

同样写一个循环,-O3 也可能自动生成 SIMD。因此标量源代码与显式 intrinsic 的比较,不一定等于“没有向量化”和“有向量化”的比较。想知道实际差别,应检查优化报告或汇编。不同指令集不能靠复制一份头文件就通用,运行时分派也需要额外设计。

9. 多线程与 GPU:并行前先划分工作

每个输入独立、计算量足够大时,可以把数据切成不重叠的块,让多个线程处理。下面对整数求和,每个线程写自己的局部结果,全部结束后再归并,避免大家同时修改同一个累加器。

std::int64_t parallel_sum(const Values& input, std::size_t workers) {
    if (workers == 0) throw std::invalid_argument("线程数必须为正");
    if (input.empty()) return 0;
    workers = std::min(workers, input.size());
    Values partial(workers, 0);
    std::vector<std::thread> threads;
    threads.reserve(workers);
    try {
        for (std::size_t w = 0; w < workers; ++w) {
            const auto begin = input.size() * w / workers;
            const auto end = input.size() * (w + 1) / workers;
            threads.emplace_back([&, w, begin, end] {
                std::int64_t local = 0;
                for (auto i = begin; i < end; ++i) local += input[i];
                partial[w] = local;
            });
        }
    } catch (...) {
        for (auto& thread : threads) thread.join();
        throw;
    }
    for (auto& thread : threads) thread.join();
    return std::accumulate(partial.begin(), partial.end(), std::int64_t{0});
}

线程创建、调度和归并都有成本,所以例子允许小输入也走相同路径,以便在本机观察额外成本;实际产品通常考虑任务大小门槛与线程池。线程越多不一定越快,纯求和可能先受内存带宽限制。整数范围也必须保证所有局部和及最终结果不溢出。

GPU 更适合大量规则一致的并行工作,但还要考虑上传、下载和同步。如果输入和下一步处理都留在 GPU 上,多步滤镜有机会复用已有纹理;只为了一个很短的循环把数据来回搬运,未必划算。本文不把 CPU 线程测试当成 GPU 性能证明,也不虚构没有 GPU 环境的运行结果。

10. 把这些方法真正跑起来

下面的入口和前面的函数片段组成完整程序,复制时需要全部片段,也可以直接下载。它先做正确性校验;传入 --bench 才打印本机微基准。每组跑七轮、交替两种方案的先后顺序,输出中位数和范围,避免只挑最好看的一次。

volatile std::int64_t observed = 0;

template<class F, class G>
void compare(const char* label, F first, G second) {
    std::array<double, 7> a{}, b{};
    auto measure = [](auto fn) {
        const auto start = std::chrono::steady_clock::now();
        const auto result = fn();
        const auto end = std::chrono::steady_clock::now();
        observed = result;
        return std::chrono::duration<double, std::milli>(end-start).count();
    };
    observed = first(); observed = second(); // 预热,不计入七轮
    for (std::size_t i = 0; i < a.size(); ++i) {
        if (i % 2 == 0) { a[i] = measure(first); b[i] = measure(second); }
        else { b[i] = measure(second); a[i] = measure(first); }
    }
    std::sort(a.begin(), a.end()); std::sort(b.begin(), b.end());
    std::cout << label << "\n  A median=" << a[3] << " ms [" << a.front() << "," << a.back()
              << "]\n  B median=" << b[3] << " ms [" << b.front() << "," << b.back() << "]\n";
}

template<class T>
std::int64_t checksum(const std::vector<T>& a) {
    return std::accumulate(a.begin(), a.end(), std::int64_t{0});
}

int main(int argc, char** argv) {
    std::mt19937 rng(42);
    for (std::size_t n = 0; n <= 80; ++n) {
        Values a(n);
        for (auto& value : a) value = int(rng()%201)-100;
        for (std::size_t k = 0; k <= n+1; ++k)
            require(windows_naive(a,k) == windows_rolling(a,k));
        require(collect(a,false) == collect(a,true));
        for (auto w : {1u,2u,4u}) require(parallel_sum(a,w) == checksum(a));
    }
    for (std::size_t rows = 0; rows <= 20; ++rows)
        for (std::size_t cols = 0; cols <= 20; ++cols) {
            Values a(rows*cols);
            for (auto& value : a) value = int(rng()%201)-100;
            require(sum_rows(a,rows,cols) == sum_columns(a,rows,cols));
        }
    Bytes all(256); std::iota(all.begin(), all.end(), 0);
    for (int delta = -255; delta <= 255; ++delta)
        require(brighten_direct(all,delta) == brighten_lut(all,make_lut(delta)));
    for (int delta = 0; delta <= 255; ++delta) {
        require(brighten_direct(all,delta) == brighten_simd(all,static_cast<std::uint8_t>(delta)));
        for (std::size_t n = 0; n <= 65; ++n) {
            Bytes a(n); for (auto& value : a) value = static_cast<std::uint8_t>(rng()%256);
            require(brighten_direct(a,delta) == brighten_simd(a,static_cast<std::uint8_t>(delta)));
        }
    }
    require(sum_rows({1,2,3,4,5,6},2,3) == 21);
    require(sum_columns({1,2,3,4,5,6},2,3) == 21);
    require(collect({-2,0,3},true) == Values({4,0,9}));
    for (auto n : {257u,1023u,4099u}) {
        Bytes input(n);
        for (std::size_t i = 0; i < input.size(); ++i)
            input[i] = static_cast<std::uint8_t>((i*37)%256);
        for (auto delta : {0,1,23,127,255})
            require(brighten_simd(input,static_cast<std::uint8_t>(delta)) == brighten_direct(input,delta));
    }
    bool rejected = false;
    try { parallel_sum({1},0); } catch (const std::invalid_argument&) { rejected = true; }
    require(rejected);
    double max_error = 0;
    for (int i = 0; i <= 10000; ++i) {
        const double value = 0.1 + 0.7*i/10000.0;
        max_error = std::max(max_error, std::abs(restore(quantize(value))-value));
    }
    require(max_error <= 0.7/510.0 + 1e-12);
    require(quantize(-1) == 0 && quantize(2) == 255);
    require(windows_rolling({1,7,3,2,4,5,8,0},5) == Values({17,21,22,19}));
    require(brighten_direct({0,120,250,255},10) == Bytes({10,130,255,255}));
    std::cout << "正确性校验通过:滑动窗口、遍历顺序、查表、预分配、量化、SIMD 与线程归并\n";
    std::cout << "量化最大误差=" << max_error << '\n';
#if defined(__ARM_NEON)
    std::cout << "SIMD path: ARM NEON\n";
#elif defined(__SSE2__)
    std::cout << "SIMD path: x86 SSE2\n";
#else
    std::cout << "SIMD path: scalar fallback\n";
#endif
    if (argc < 2 || std::string(argv[1]) != "--bench") return 0;
    constexpr std::size_t rows = 1024, cols = 1024;
    Values input(rows*cols);
    for (auto& value : input) value = int(rng()%201)-100;
    Bytes pixels(input.size());
    for (auto& value : pixels) value = static_cast<std::uint8_t>(rng()%256);
    const auto table = make_lut(23);
    std::cout << "n=1048576; window=64; matrix=1024x1024; threads=4; rounds=7\n";
    compare("窗口和 A=重新累加 B=增量更新", [&]{return checksum(windows_naive(input,64));}, [&]{return checksum(windows_rolling(input,64));});
    compare("遍历 A=按列 B=按行", [&]{return sum_columns(input,rows,cols);}, [&]{return sum_rows(input,rows,cols);});
    compare("亮度 A=直接计算 B=查表(不含建表)", [&]{return checksum(brighten_direct(pixels,23));}, [&]{return checksum(brighten_lut(pixels,table));});
    compare("容器 A=自动增长 B=预留容量", [&]{return checksum(collect(input,false));}, [&]{return checksum(collect(input,true));});
    compare("像素 A=普通循环 B=显式SIMD或回退", [&]{return checksum(brighten_direct(pixels,23));}, [&]{return checksum(brighten_simd(pixels,23));});
    compare("求和 A=单线程 B=四线程(含创建与归并)", [&]{return checksum(input);}, [&]{return parallel_sum(input,4);});
    std::cout << "observable checksum=" << observed << '\n';
}

复现命令与计时范围

本站仓库根目录执行:

npm run test:article
npm run test:article -- --bench

校验脚本直接从正文提取函数,分别编译完整套件与矩阵用例。校验使用 -O1 -g -fsanitize=address,undefined;基准另以 -O3 编译,不把消毒器成本计入测量。脚本打印系统、处理器、编译器和实际参数。

也可以下载后独立运行:

c++ -std=c++17 -O3 -pthread cpp-optimization.cpp -o cpp-optimization
./cpp-optimization
./cpp-optimization --bench

套件中的基准包含函数内部结果容器的分配,以及返回结果的求和检查;输入生成在计时外。查表项不含建表时间,线程项包含创建和归并。它们是明确范围的端到端小用例,不是纯指令吞吐测试。易受内存带宽影响的求和或查表也可能比对照更慢,遇到这种输出不需要“修正”成好看的数字。

编译器仍可能优化具体路径,微基准不能完全复现产品负载。不同方案的输入相同,但只有逐元素校验能检出交换位置等问题;校验和用于让结果可观察,不替代正确性检查。量化单独测误差,不混进等价比较。

一次本机运行里,有些“优化”并没有赢

下面是本轮实际运行的一个样本:Apple M1、macOS/arm64、Apple clang 21.0.0,参数 -std=c++17 -O3 -pthread,输入 1048576 个元素,窗口大小 64,矩阵 1024×1024,每项七轮。数值为毫秒中位数,仅说明这份输入和测量范围;两种方案的离散范围也会由程序打印。

对照项目 方案 A 方案 B 怎样理解
重新求窗口和 / 增量更新 6.563 3.379 减少了重复累加,但分配结果与校验仍占时间
按列 / 按行访问 1.364 0.177 同一块按行存储的数据,访问顺序影响很明显
直接亮度加法 / 查表 0.095 0.361 便宜的加法不一定值得换成表索引
自动增长 / 预留容量 1.911 1.406 本次预分配更快,但仍包含结果构建与检查
普通循环 / 显式 SIMD 0.093 0.093 手写 SIMD 没有明显优势,普通循环也可能已被优化
单线程 / 四线程求和 0.141 0.118 差距较小,应继续观察波动和不同规模

最值得注意的不是某个倍数,而是查表这一行。它确实把重复映射提前算好了,却没有在这个廉价操作上赢过编译器处理后的循环。以后换成复杂的色调映射,可以重新测;不能据此把查表一概判为无用,也不能只保留跑得更快的项目来证明“优化有效”。

11. 编译器优化:先用好现成能力

完成正确性检查后,再用发布配置测量。-O0 下的比较容易把编译器没有执行的基础优化也算成手写收益。GCC/Clang 的 -O2、-O3 会启用不同优化组合;具体内容随版本与目标变化,不能把 -O3 简单解释为“肯定最快”。更大的代码体积也可能产生代价。

循环向量化报告能帮助回答“普通循环是否已经使用 SIMD”。按编译器选择命令,不要把两套参数混用:

# Clang:查看循环向量化成功与未成功的说明
clang++ -std=c++17 -O3 -pthread -Rpass=loop-vectorize -Rpass-missed=loop-vectorize cpp-optimization.cpp -o cpp-optimization
# GCC:输出向量化诊断
g++ -std=c++17 -O3 -pthread -fopt-info-vec cpp-optimization.cpp -o cpp-optimization

-flto 让链接阶段看到更多跨文件信息,但依赖工具链支持。-march=native 可能生成只适合当前机器的指令,不应直接用于要分发到未知硬件的二进制。-ffast-math 会放宽浮点语义约束,不能为了跑分快就默认打开;对 NaN、无穷大、结合顺序等有要求的代码尤其要先确认约定。

编译器能够做的常量除法替换,也不必手写成移位。带符号数、舍入和溢出规则不一致时,所谓“位运算优化”甚至会改变结果。先保留意图清楚的表达式,发现具体热点再研究汇编。

附录:矩阵边界与最长无重复字节子串

这份独立文件保留最容易出错的边界对照。矩阵输入长度为行数乘列数,元素限定在 -1000~1000;字符串按字节而非 Unicode 字素计算。它覆盖 625 个矩阵尺寸组合和 517 个字符串样本,随机种子固定为 42。

展开完整 C++17 矩阵与字符串用例(也可直接下载)
#include <algorithm>
#include <array>
#include <chrono>
#include <cstdint>
#include <iostream>
#include <random>
#include <stdexcept>
#include <string>
#include <unordered_set>
#include <vector>

using Matrix = std::vector<int>;

void reference(Matrix& a, std::size_t rows, std::size_t cols) {
    for (std::size_t r = 0; r < rows; ++r)
        for (std::size_t c = 0; c < cols; ++c)
            a[r * cols + c] += (r == 0 || c == 0 || r == rows - 1 || c == cols - 1) ? -1 : 1;
}

void split_loops(Matrix& a, std::size_t rows, std::size_t cols) {
    if (rows == 0 || cols == 0) return;
    for (std::size_t c = 0; c < cols; ++c) --a[c];
    if (rows == 1) return;
    for (std::size_t c = 0; c < cols; ++c) --a[(rows - 1) * cols + c];
    for (std::size_t r = 1; r + 1 < rows; ++r) {
        --a[r * cols];
        if (cols == 1) continue;
        for (std::size_t c = 1; c + 1 < cols; ++c) ++a[r * cols + c];
        --a[r * cols + cols - 1];
    }
}

std::size_t unique_reference(const std::string& s) {
    std::unordered_set<unsigned char> window;
    std::size_t left = 0, best = 0;
    for (std::size_t right = 0; right < s.size(); ++right) {
        const auto ch = static_cast<unsigned char>(s[right]);
        while (window.count(ch)) window.erase(static_cast<unsigned char>(s[left++]));
        window.insert(ch);
        best = std::max(best, right - left + 1);
    }
    return best;
}

std::size_t unique_last_seen(const std::string& s) {
    std::array<std::size_t, 256> next{};
    std::size_t left = 0, best = 0;
    for (std::size_t right = 0; right < s.size(); ++right) {
        const auto ch = static_cast<unsigned char>(s[right]);
        left = std::max(left, next[ch]);
        best = std::max(best, right - left + 1);
        next[ch] = right + 1;
    }
    return best;
}

void require(bool ok) {
    if (!ok) throw std::runtime_error("结果不等价");
}

int main(int argc, char** argv) {
    std::mt19937 rng(42);
    std::size_t matrices = 0, strings = 0;
    for (std::size_t rows = 0; rows <= 24; ++rows) {
        for (std::size_t cols = 0; cols <= 24; ++cols) {
            Matrix input(rows * cols);
            for (auto& v : input) v = static_cast<int>(rng() % 2001) - 1000;
            auto expected = input, actual = input;
            reference(expected, rows, cols);
            split_loops(actual, rows, cols);
            require(actual == expected);
            ++matrices;
        }
    }
    for (const auto& s : {std::string(""), std::string("abcabcbb"), std::string("bbbbb"), std::string("pwwkew")}) {
        require(unique_reference(s) == unique_last_seen(s));
        ++strings;
    }
    require(unique_last_seen("") == 0 && unique_last_seen("abcabcbb") == 3);
    require(unique_last_seen("bbbbb") == 1 && unique_last_seen("pwwkew") == 3);
    for (std::size_t len = 0; len <= 512; ++len) {
        std::string s(len, '\0');
        for (auto& ch : s) ch = static_cast<char>(rng() % 256);
        require(unique_reference(s) == unique_last_seen(s));
        ++strings;
    }
    std::cout << "校验通过:" << matrices << " 个矩阵," << strings << " 个字节字符串\n";

    if (argc < 2 || std::string(argv[1]) != "--bench") return 0;
    constexpr std::size_t rows = 512, cols = 768, iterations = 80;
    auto measure = [&](auto fn) {
        Matrix a(rows * cols, 0);
        const auto start = std::chrono::steady_clock::now();
        for (std::size_t i = 0; i < iterations; ++i) fn(a, rows, cols);
        const auto end = std::chrono::steady_clock::now();
        std::int64_t checksum = 0;
        for (int v : a) checksum += v;
        std::cout << std::chrono::duration<double, std::milli>(end - start).count()
                  << " ms; checksum=" << checksum << '\n';
    };
    std::cout << "reference: "; measure(reference);
    std::cout << "split_loops: "; measure(split_loops);
}

矩阵基准仍使用 512×768、80 次更新,单次输出只用于快速观察。与主套件的七轮统计不同,正式比较时请交替多轮执行,并记录硬件和编译参数。这个基准不包含分配,但包含连续多次修改矩阵;不要把它与每次都创建新结果的套件项目横向比较。

最后怎样选择优化顺序

遇到慢代码时,可以按这个顺序推进:先减少重复工作,再整理数据访问与分配,随后检查热循环、编译器输出和并行机会。每完成一步,就用同样的输入核对结果,再测量实际热点。

并不需要把文章中的所有方法都用一遍。窗口求和最值得先解决的是重复累加,超大图片可能更在意内存与传输,短小任务则可能根本不值得启用线程。能解释哪个成本下降了、付出了什么代价,以及在什么规模下值得使用,比把代码写得更“像优化”更重要。

参考与修订

2026-11-04:恢复多种优化方法,增加窗口、边界和访存动画,以及可下载的 C++ 对照套件。旧版遗漏矩阵行、重复修改角点及问题不一致的示例没有恢复;现在以可执行校验约束后续修改。

看见每一步

性能优化小实验

先选一种方法,再点“下一步”或播放。颜色表示本步访问,数字与结果跟着实际算法更新;这是原理演示,操作次数不等于 CPU 耗时。

① 滑动窗口:保留上一轮的和

同一组数,左边每次重新读取整个窗口,右边只读取离开和进入的数。改变窗口大小,观察重复工作。

每次重新累加

增量更新

尚未开始

② 减少边界判断:先分区,再更新

6×8 的零矩阵,边界减一,内部加一。两边每步各处理一个元素,最后应得到同一张矩阵。

逐点判断边界

先边缘,后内部

尚未开始

③ 访存顺序:沿着地址读,还是跨行跳

同一块按行存储的 6×8 数据,编号就是线性下标。两边都求总和,比较相邻两次访问的地址间隔。

按列访问

按行访问

尚未开始

评论