实战：性能分析工具（计时器+统计+火焰图数据）

性能分析，说白了就是回答三个问题：哪段代码慢？慢了多少？为什么慢？

我刚开始做C++性能调优时，总觉得凭直觉就能找到瓶颈。结果呢？优化了自以为很慢的地方，实际效果微乎其微。后来我学乖了——没有数据，别谈优化。

这一章，我们就手撸一个轻量级的性能分析工具。它能做三件事：

  • 计时器：精确测量代码段的执行时间
  • 统计：记录调用次数、平均耗时、最大/最小值
  • 火焰图数据：输出调用栈的采样信息，方便生成火焰图

嗯，别小看这个工具。我在项目中用过它抓出过一个隐藏了三个月的性能bug——一个看似无害的字符串拷贝，在循环里膨胀了上千倍。

1. 高精度计时器封装

C++11 提供了 std::chrono，精度足够日常使用。我个人习惯封装一个 Timer 类，方便切换时钟源。

#include <chrono>
#include <string>

class Timer {
public:
    Timer() : start_(now()) {}

    void reset() { start_ = now(); }

    // 返回毫秒数
    double elapsed_ms() const {
        auto end = now();
        return std::chrono::duration_cast<std::chrono::microseconds>(end - start_).count() / 1000.0;
    }

    // 返回微秒数
    int64_t elapsed_us() const {
        auto end = now();
        return std::chrono::duration_cast<std::chrono::microseconds>(end - start_).count();
    }

private:
    using Clock = std::chrono::high_resolution_clock;
    using TimePoint = Clock::time_point;

    static TimePoint now() { return Clock::now(); }

    TimePoint start_;
};
小提示： 高精度时钟在部分平台可能回退到系统时钟。如果你需要纳秒级精度，建议用平台相关的 API（如 Linux 的 clock_gettime）。

2. 带统计功能的计时器

光测一次不够，你得跑多次，看平均和波动。我曾经遇到一个函数，平均耗时 2ms，但偶尔飙到 200ms——这种抖动才是真正的杀手。

#include <atomic>
#include <limits>

class StatsTimer {
public:
    StatsTimer() : count_(0), total_us_(0), max_us_(0), min_us_(std::numeric_limits<int64_t>::max()) {}

    void start() {
        timer_.reset();
    }

    void stop() {
        int64_t us = timer_.elapsed_us();
        count_.fetch_add(1, std::memory_order_relaxed);
        total_us_.fetch_add(us, std::memory_order_relaxed);

        // 更新最大值和最小值（简单实现，不考虑并发竞争）
        if (us > max_us_.load()) max_us_.store(us);
        if (us < min_us_.load()) min_us_.store(us);
    }

    double avg_ms() const {
        auto c = count_.load();
        if (c == 0) return 0.0;
        return total_us_.load() / (1000.0 * c);
    }

    int64_t max_us() const { return max_us_.load(); }
    int64_t min_us() const { return min_us_.load(); }
    uint64_t count() const { return count_.load(); }

private:
    Timer timer_;
    std::atomic<uint64_t> count_;
    std::atomic<int64_t> total_us_;
    std::atomic<int64_t> max_us_;
    std::atomic<int64_t> min_us_;
};
注意： 上面的 max_us_ 和 min_us_ 在多线程下不是严格准确的。如果你需要精确的极值，请用原子比较交换（CAS）或加锁。不过对于大多数场景，这种近似已经够用了。

3. 火焰图数据采集

火焰图（Flame Graph）是 Brendan Gregg 发明的可视化工具。它的原理很简单：定期采样调用栈，统计每个函数出现的频率。

我们不需要完整的 perf 工具，只需要在关键位置手动埋点，输出采样数据。

#include <vector>
#include <string>
#include <fstream>

class FlameGraphRecorder {
public:
    explicit FlameGraphRecorder(const std::string& filename) : file_(filename) {
        if (file_.is_open()) {
            file_ << "# 火焰图采样数据\n";
            file_ << "# 格式: 函数名;调用者;耗时(us)\n";
        }
    }

    void record(const std::string& func, const std::string& caller, int64_t elapsed_us) {
        if (file_.is_open()) {
            file_ << func << ";" << caller << ";" << elapsed_us << "\n";
        }
    }

    ~FlameGraphRecorder() {
        if (file_.is_open()) {
            file_.close();
        }
    }

private:
    std::ofstream file_;
};

实际使用时，你可以在函数入口和出口处调用 record。比如：

void my_function() {
    FlameGraphRecorder recorder("flame_data.txt");
    Timer t;
    // ... 业务逻辑 ...
    recorder记录("my_function", "main", t.elapsed_us());
}

然后，用 Brendan Gregg 的 flamegraph.pl 脚本就能生成 SVG 火焰图了。

4. 整合：一个完整的性能分析器

把上面三个组件拼起来，就是一个可用的分析器。我个人习惯用 RAII 风格，让作用域自动管理计时和记录。

class ScopedProfiler {
public:
    ScopedProfiler(const std::string& func_name, const std::string& caller,
                   StatsTimer* stats, FlameGraphRecorder* flame)
        : func_name_(func_name), caller_(caller), stats_(stats), flame_(flame) {
        if (stats_) stats_->start();
    }

    ~ScopedProfiler() {
        if (stats_) {
            stats_->stop();
            if (flame_) {
                flame_->record(func_name_, caller_, stats_->max_us());
            }
        }
    }

private:
    std::string func_name_;
    std::string caller_;
    StatsTimer* stats_;
    FlameGraphRecorder* flame_;
};

用法极其简单：

void compute() {
    static StatsTimer stats;
    static FlameGraphRecorder flame("flame.txt");
    ScopedProfiler prof("compute", "main", &stats, &flame);

    // 你的计算逻辑...
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
}

int main() {
    for (int i = 0; i < 100; ++i) {
        compute();
    }
    // 输出统计结果
    std::cout << "平均耗时: " << stats.avg_ms() << " ms\n";
    return 0;
}

5. 知识体系图

下面这张图帮你理清整个工具的结构：

性能分析工具架构 高精度计时器 Timer 类 统计模块 StatsTimer 类 火焰图数据 FlameGraphRecorder ScopedProfiler（RAII 整合） 输出：控制台统计 + 火焰图数据文件 适用场景：函数级性能分析、热点定位、抖动检测

6. 避坑指南

我曾经踩过几个坑，分享给你：

  • 计时器本身的开销：如果函数执行时间只有几微秒，计时器的调用开销会污染结果。建议对极短函数采用批量测量。
  • 多线程下的统计：原子操作不是万能的。如果你需要精确的百分位数（P99），建议用线程本地存储 + 最终汇总。
  • 火焰图数据不要太多：每调用一次就写文件，I/O 会成为新瓶颈。我一般采样率控制在 100~1000 Hz。
  • 别忘了优化掉分析代码：发布版本中，用宏或编译开关把分析代码去掉。否则线上性能会受影响。
核心原则： 性能分析工具本身不能成为性能瓶颈。测量行为要尽量轻量，采样频率要合理，数据输出要异步。

7. 扩展思路

这个工具虽然简单，但已经能解决 80% 的日常性能问题。如果你想更进一步：

  • 接入 perf 或 DTrace 获取系统级采样
  • 用 libunwind 实现自动调用栈展开，不用手动埋点
  • 把火焰图数据直接输出为 JSON，配合前端可视化

嗯，工具是死的，思路是活的。你想想看，有了这些数据，你就能精准地回答「哪里慢」了。剩下的，就是动手优化。

公众号:蓝海资料掘金营，微信deep3321

← 上一章 📖 返回目录 下一章 →