第三章:测量性能_《C++性能优化指南》_notes

测量性能

第三章核心重难点解析

  1. 性能测量基础
    知识点
  • 必须通过实验测量性能,不能仅凭直觉
  • 90/10规则:90%时间运行10%的代码
  • 阿姆达尔定律:优化部分的时间占比决定整体提升
  • 正确性(Trueness)与精确性(Precision)的区别

代码示例(测量时钟分辨率):

cpp 复制代码
#include <iostream>
#include <chrono>

void test_clock_resolution() {
    auto t1 = std::chrono::high_resolution_clock::now();
    auto t2 = std::chrono::high_resolution_clock::now();
    
    // 连续获取时间差的最小分辨率
    auto min_resolution = t2 - t1;
    std::cout << "Clock resolution: " 
              << min_resolution.count() << " nanoseconds\n";
}

int main() {
    test_clock_resolution();
    return 0;
}
/*
编译:g++ -std=c++11 -O3 test.cpp -o test
输出示例:
Clock resolution: 21 nanoseconds
*/
  1. 高精度计时器实现
    知识点
  • 使用C++11的实现跨平台计时
  • RAII(资源获取即初始化)模式的应用
  • 避免测量误差的实践方法

代码示例(Stopwatch类):

cpp 复制代码
#include <iostream>
#include <chrono>

class Stopwatch {
    using Clock = std::chrono::high_resolution_clock;
    Clock::time_point start_;
public:
    Stopwatch() : start_(Clock::now()) {}
    
    void reset() { start_ = Clock::now(); }
    
    double elapsed() const {
        auto end = Clock::now();
        return std::chrono::duration<double>(end - start_).count();
    }
};

// 测试用例
void test_stopwatch() {
    Stopwatch sw;
    
    volatile int sum = 0;  // 防止优化
    for (int i=0; i<1000000; ++i) {
        sum += i;
    }
    
    std::cout << "Loop took " << sw.elapsed() * 1000 << " ms\n";
}

int main() {
    test_stopwatch();
    return 0;
}
/*
编译:g++ -std=c++11 -O3 test.cpp -o test
输出示例:
Loop took 2.345 ms
*/
  1. 热点代码识别
    知识点
  • 内存访问是主要瓶颈
  • 循环结构对性能的关键影响
  • 函数调用开销评估

代码示例(循环优化对比):

cpp 复制代码
#include <iostream>
#include <chrono>

// 未优化版本
int sum_array_v1(int* arr, size_t len) {
    int sum = 0;
    for (size_t i=0; i<len; ++i) {
        sum += arr[i];
    }
    return sum;
}

// 优化版本:循环展开
int sum_array_v2(int* arr, size_t len) {
    int sum = 0;
    size_t i=0;
    for (; i+3<len; i+=4) {
        sum += arr[i];
        sum += arr[i+1];
        sum += arr[i+2];
        sum += arr[i+3];
    }
    for (; i<len; ++i) {
        sum += arr[i];
    }
    return sum;
}

// 性能测试函数
template<typename Func>
void benchmark(Func f, const char* name) {
    const int SIZE = 1000000;
    int* arr = new int[SIZE];
    for(int i=0; i<SIZE; ++i) arr[i] = i;
    
    Stopwatch sw;
    volatile int result = f(arr, SIZE); // 防止优化
    double time = sw.elapsed() * 1000;
    
    std::cout << name << " time: " << time << " ms\n";
    delete[] arr;
}

int main() {
    benchmark(sum_array_v1, "Version 1");
    benchmark(sum_array_v2, "Version 2");
    return 0;
}
/*
编译:g++ -std=c++11 -O3 test.cpp -o test
输出示例:
Version 1 time: 1.254 ms
Version 2 time: 0.873 ms
*/
  1. 内存访问模式分析
    知识点
  • 缓存局部性原理
  • 顺序访问 vs 随机访问
  • 数据预取的影响

代码示例(内存访问模式对比):

cpp 复制代码
#include <iostream>
#include <chrono>
#include <vector>

const int SIZE = 10000;

// 顺序访问
void test_sequential() {
    std::vector<int> matrix(SIZE * SIZE);
    Stopwatch sw;
    
    for(int i=0; i<SIZE; ++i) {
        for(int j=0; j<SIZE; ++j) {
            matrix[i*SIZE + j] = i + j;
        }
    }
    
    std::cout << "Sequential: " << sw.elapsed() << " s\n";
}

// 随机访问
void test_random() {
    std::vector<int> matrix(SIZE * SIZE);
    Stopwatch sw;
    
    for(int i=0; i<SIZE; ++i) {
        for(int j=0; j<SIZE; ++j) {
            matrix[j*SIZE + i] = i + j; // 列优先访问
        }
    }
    
    std::cout << "Random: " << sw.elapsed() << " s\n";
}

int main() {
    test_sequential();
    test_random();
    return 0;
}
/*
编译:g++ -std=c++11 -O3 test.cpp -o test
输出示例:
Sequential: 0.456 s
Random: 1.892 s
*/

关键知识点总结

  1. 测量优先原则

    • 所有优化必须基于实际测量数据
    • 使用高精度计时器(如C++11的chrono)
    • 每个测试用例要包含足够大的数据量(百万级)
  2. 循环优化要点

    • 减少循环内部的计算(如提前计算循环边界)
    • 循环展开(但需注意指令缓存)
    • 避免在循环内调用虚函数
  3. 内存访问优化

    • 顺序访问比随机访问快5-10倍
    • 小数据优先使用栈内存(避免堆分配)
    • 使用内存局部性原理设计数据结构
  4. 工具链使用

    bash 复制代码
    g++ -S -fverbose-asm -O3 test.cpp
    
    # 使用perf工具(Linux)
    perf stat ./test
    perf record ./test
    perf report

    第三章核心内容梳理

核心知识点

  1. 性能测量基本原则(必须测量、90/10规则、阿姆达尔定律)
  2. 分析器工作原理和使用场景
  3. 时间测量方法(计时器实现、分辨率与准确性)
  4. 实验设计原则(基准测试、随机性消除)
  5. 代码热点识别技术
  6. 消除测量误差的实践方法
  7. 多线程环境下的测量挑战
  8. 不同时间测量API的特性对比
  9. 性能优化策略优先级判断
  10. 统计学方法在性能分析中的应用

多选题

  1. 关于分析器的正确描述包括:

    A) 可以准确预测代码的理论时间复杂度

    B) 能够直接显示内存泄漏的位置

    C) 适用于识别I/O密集型程序的真实瓶颈

    D) 在调试版本中可能产生误导性结果

    E) 可以自动优化热点函数的汇编指令

  2. 时间测量中可能引入系统误差的情况包括:

    A) 使用RDTSC指令直接读取CPU周期计数器

    B) 在虚拟机环境中测量纳秒级操作

    C) 测量前后调用GetTickCount()的时间差

    D) 使用C++11的high_resolution_clock

    E) 测量期间操作系统进行内存分页

  3. 符合90/10规则优化原则的做法是:

    A) 对全部代码进行循环展开

    B) 优先优化占用10%时间的核心函数

    C) 使用更高效的算法替换O(n²)实现

    D) 重写所有字符串操作为C风格

    E) 针对分析器显示的热点函数进行优化

  4. 在Windows平台可能产生准确亚微秒级时间测量的方法:

    A) QueryPerformanceCounter

    B) GetSystemTimeAsFileTime

    C) clock()

    D) GetSystemTimePreciseAsFileTime

    E) timeGetTime

  5. 消除测量误差的有效方法包括:

    A) 在测量前后添加空循环

    B) 使用统计方法计算置信区间

    C) 提高测量进程的CPU优先级

    D) 减少被测函数的代码行数

    E) 增加测试迭代次数

  6. 关于阿姆达尔定律的正确应用:

    A) 优化占比30%的模块使其快2倍,整体提升23%

    B) 优化占比90%的模块使其快10倍,整体提升9倍

    C) 同时优化多个小模块效果累加

    D) 仅适用于CPU密集型任务

    E) 指导优化资源分配优先级

  7. 多线程测量需要特别注意:

    A) 使用原子操作计数器

    B) 关闭超线程技术

    C) 绑定线程到特定核心

    D) 测量包含上下文切换时间

    E) 使用线程本地存储

  8. 正确的时间测量实践包括:

    A) 在循环外获取开始时间戳

    B) 使用volatile防止编译器优化

    C) 计算多次测量的中位数

    D) 优先选择最高分辨率时钟

    E) 忽略小于1%的时间差异

  9. 可能影响代码热点的因素:

    A) 输入数据规模

    B) CPU缓存命中率

    C) 编译器优化级别

    D) 函数调用深度

    E) 变量命名风格

  10. 有效的性能测试用例设计原则:

    A) 包含边界值输入

    B) 使用真实生产数据

    C) 固定随机数种子

    D) 测量冷热代码路径

    E) 包含异常处理分支


多选题答案及解析

  1. BD

    B) 某些分析器可以检测内存泄漏

    D) 调试版本可能使用调试内存分配器

    错误项:A-不能预测理论复杂度,E-不能自动优化

  2. BE

    B) 虚拟化层引入计时偏差

    E) 内存分页导致不可控延迟

    错误项:A-直接硬件读取准确,C-适合粗粒度测量

  3. BCE

    B) 优先核心函数

    C) 算法优化

    E) 热点函数优化

    错误项:A/D属于过度优化

  4. AD

    A) QPC高精度计时

    D) Win8+精确时间API

    错误项:B/C/E精度不足

  5. BCE

    B) 统计学方法

    C) 提高优先级

    E) 增加迭代次数

    错误项:A/D无关误差消除

  6. AE

    A) 30%模块2倍→1/(0.7+0.3/2)=1.176≈17.6%提升

    E) 指导优先级判断

    错误项:B-实际提升约9倍错误

  7. AC

    A) 原子操作保证计数准确

    C) 减少核心迁移影响

    错误项:D测量值包含无关因素

  8. ABC

    A) 避免循环内开销

    B) 防止关键代码被优化

    C) 中位数抗异常值

    错误项:D不总是最佳选择

  9. ABC

    A) 数据规模影响分支预测

    B) 缓存影响显著

    C) 优化级别改变代码结构

    错误项:E无关

  10. ACD

    A) 边界值测试

    C) 保证可重复性

    D) 完整路径覆盖

    错误项:B可能含敏感数据


设计题

  1. 高精度跨平台计时器设计
cpp 复制代码
#include <chrono>
#include <iostream>

class PrecisionTimer {
    using Clock = std::chrono::high_resolution_clock;
    Clock::time_point m_start;
public:
    PrecisionTimer() : m_start(Clock::now()) {}
    
    void reset() { m_start = Clock::now(); }
    
    template <typename Unit = std::chrono::milliseconds>
    auto elapsed() const {
        return std::chrono::duration_cast<Unit>(
            Clock::now() - m_start).count();
    }
};

// 测试用例
int main() {
    PrecisionTimer timer;
    volatile int sum = 0;  // 防止优化
    for(int i=0; i<1'000'000; ++i) sum += i;
    std::cout << "Elapsed: " 
              << timer.elapsed<std::chrono::nanoseconds>() 
              << " ns\n";
}
  1. 多线程测量同步优化
cpp 复制代码
#include <iostream>
#include <vector>
#include <thread>
#include <atomic>
#include <chrono>

void worker(std::atomic<int>& counter) {
    auto start = std::chrono::high_resolution_clock::now();
    // 模拟工作负载
    for(int i=0; i<1000; ++i) { /* dummy work */ }
    auto end = std::chrono::high_resolution_clock::now();
    counter += (end - start).count();
}

int main() {
    constexpr int threads_num = 4;
    std::vector<std::thread> threads;
    std::atomic<int> total_time{0};
    
    for(int i=0; i<threads_num; ++i)
        threads.emplace_back(worker, std::ref(total_time));
    
    for(auto& t : threads) t.join();
    
    std::cout << "Average time: " 
              << total_time/(threads_num*1000) 
              << " ns per iteration\n";
}
  1. 内存访问模式分析测试
cpp 复制代码
#include <vector>
#include <chrono>
#include <iostream>

constexpr size_t SIZE = 10'000'000;

void test_cache_effect() {
    std::vector<int> sequential(SIZE);
    std::vector<int> random(SIZE);
    
    auto fill = [](auto& vec) {
        for(size_t i=0; i<vec.size(); ++i)
            vec[i] = i;
    };
    
    fill(sequential);
    fill(random);
    
    auto time_access = [](auto& vec, const char* msg) {
        auto start = std::chrono::high_resolution_clock::now();
        volatile int sum = 0;
        for(size_t i=0; i<vec.size(); ++i)
            sum += vec[i];
        auto end = std::chrono::high_resolution_clock::now();
        std::cout << msg << ": " 
                  << (end - start).count() << " ns\n";
    };
    
    time_access(sequential, "Sequential");
    time_access(random, "Random    ");
}

int main() {
    test_cache_effect();
}
  1. 分支预测优化验证
cpp 复制代码
#include <algorithm>
#include <vector>
#include <chrono>
#include <iostream>

constexpr size_t SIZE = 10'000'000;

void test_branch_prediction() {
    std::vector<int> data(SIZE);
    std::generate(data.begin(), data.end(), []{ return rand() % 100; });
    
    // 未排序测试
    auto time_unsorted = [&data] {
        volatile int count = 0;
        auto start = std::chrono::high_resolution_clock::now();
        for(int n : data)
            if(n < 50) ++count;
        auto end = std::chrono::high_resolution_clock::now();
        return end - start;
    }();
    
    // 排序后测试
    std::sort(data.begin(), data.end());
    auto time_sorted = [&data] {
        volatile int count = 0;
        auto start = std::chrono::high_resolution_clock::now();
        for(int n : data)
            if(n < 50) ++count;
        auto end = std::chrono::high_resolution_clock::now();
        return end - start;
    }();
    
    std::cout << "Unsorted: " << time_unsorted.count() << " ns\n"
              << "Sorted  : " << time_sorted.count() << " ns\n";
}

int main() {
    test_branch_prediction();
}
  1. SIMD向量化效果验证
cpp 复制代码
#include <immintrin.h>
#include <chrono>
#include <iostream>

constexpr size_t SIZE = 16'000'000;

void test_simd() {
    alignas(32) float a[SIZE], b[SIZE], result[SIZE];
    
    auto fill = [](float* arr) {
        for(size_t i=0; i<SIZE; ++i)
            arr[i] = static_cast<float>(i);
    };
    
    fill(a);
    fill(b);
    
    auto time_std = [&] {
        auto start = std::chrono::high_resolution_clock::now();
        for(size_t i=0; i<SIZE; ++i)
            result[i] = a[i] + b[i];
        return std::chrono::high_resolution_clock::now() - start;
    }();
    
    auto time_simd = [&] {
        auto start = std::chrono::high_resolution_clock::now();
        for(size_t i=0; i<SIZE; i+=8) {
            __m256 va = _mm256_load_ps(&a[i]);
            __m256 vb = _mm256_load_ps(&b[i]);
            __m256 vres = _mm256_add_ps(va, vb);
            _mm256_store_ps(&result[i], vres);
        }
        return std::chrono::high_resolution_clock::now() - start;
    }();
    
    std::cout << "Standard: " << time_std.count() << " ns\n"
              << "SIMD    : " << time_simd.count() << " ns\n";
}

int main() {
    test_simd();
}

设计题答案要点

  1. 高精度计时器设计

    • 使用C++11 chrono库保证跨平台性
    • 模板化时间单位支持灵活输出
    • 通过volatile防止编译器过度优化
    • 测试用例展示纳秒级测量能力
  2. 多线程测量同步

    • 使用atomic保证计数安全
    • 分离线程创建与等待逻辑
    • 计算平均时间消除个体差异
    • 注意原子操作的性能影响
  3. 内存访问模式分析

    • 对比顺序访问和随机访问性能差异
    • 使用大内存块突显缓存效果
    • volatile防止循环被优化
    • 展示缓存对性能的显著影响
  4. 分支预测优化

    • 对比排序前后条件判断速度差异
    • 使用相同数据保证可比性
    • 展示现代CPU的分支预测能力
    • 验证排序对分支预测的帮助
  5. SIMD向量化验证

    • 使用AVX指令实现8路并行
    • 内存对齐保证最佳性能
    • 对比标量计算与向量化速度差异
    • 展示SIMD的潜在加速比
相关推荐
Ace'13 分钟前
每日一题之既约分数
c++
摸鱼码20 分钟前
(头歌作业—python)3.2 个人所得税计算器(project)
开发语言·python
理智的灰太狼21 分钟前
1015 Reversible Primes
数据结构·c++·算法
Dream it possible!31 分钟前
LeetCode 热题 100_杨辉三角(82_118_简单_C++)(动态规划)
c++·算法·leetcode·动态规划
狐凄33 分钟前
练习题:110
开发语言·python·算法
江湖人称菠萝包41 分钟前
侯捷 C++ 课程学习笔记:C++内存管理机制
c++·笔记
YJlio1 小时前
C盘清理技巧分享:PE & Dism++ 空间清理篇
c语言·开发语言
执笔论英雄1 小时前
【DeepSeek学C++】移动构造函数
c++
拖孩1 小时前
[特殊字符]我在 Chatterbox(话匣子)中 WebRTC 的使用-上篇(基本介绍)
开发语言·php·webrtc
鹿屿二向箔1 小时前
一些练习 C 语言的小游戏
c语言·开发语言