在<性能工具-Perfetto-调度轨迹抓取(3)>介绍了通过perfetto轻松的抓取系统的调度轨迹，本文介绍一个更产品和的办法，通过perfetto sdk来抓取你想要的信息

# 下载sdk
perfetto分为C和C++版本，我们可以直接下载即可

C版本的
```
https://github.com/google/perfetto/releases/download/v54.0/perfetto-c-sdk-src.zip
```
C++版本的
```
https://github.com/google/perfetto/releases/download/v54.0/perfetto-cpp-sdk-src.zip
```
本文基于C版本介绍

当然我们也可以直接基于perfetto 的github仓库来抽取sdk
```
https://github.com/google/perfetto/tree/main/include
```

# 编译构建
我们直接可以编译perfetto给我的示例程序

首先将sdk链接到example处
```
ln -s $(pwd)/../../../c-sdk sdk
```
然后修改一下CMakeLists.txt的配置
```
diff --git a/examples/sdk/CMakeLists.txt b/examples/sdk/CMakeLists.txt
index 00508dc34e..1e90607c25 100644
--- a/examples/sdk/CMakeLists.txt
+++ b/examples/sdk/CMakeLists.txt
@@ -22,8 +22,8 @@ find_package(Threads)

 # Define a static library for Perfetto. In this example, we expect the SDK
 # (perfetto.cc and perfetto.h) to live in the top level sdk/ directory.
-include_directories(../../sdk)
-add_library(perfetto STATIC ../../sdk/perfetto.cc)
+include_directories(sdk)
+add_library(perfetto STATIC sdk/perfetto.cc)

 # Link the library to the main executables.
 add_executable(example example.cc trace_categories.cc)
```
直接编译
```
# cmake -B build && cmake --build build
-- Configuring done (0.0s)
-- Generating done (0.0s)
-- Build files have been written to: /root/claude/perfetto/examples/sdk/build
[  6%] Building CXX object CMakeFiles/perfetto.dir/sdk/perfetto.cc.o
/root/claude/perfetto/examples/sdk/sdk/perfetto.cc:49545:13: warning: #pragma system_header ignored outside include file
49545 | #pragma GCC system_header
      |             ^~~~~~~~~~~~~
[ 13%] Linking CXX static library libperfetto.a
[ 13%] Built target perfetto
[ 20%] Building CXX object CMakeFiles/example.dir/example.cc.o
[ 26%] Building CXX object CMakeFiles/example.dir/trace_categories.cc.o
[ 33%] Linking CXX executable example
[ 33%] Built target example
[ 40%] Building CXX object CMakeFiles/example_system_wide.dir/example_system_wide.cc.o
[ 46%] Building CXX object CMakeFiles/example_system_wide.dir/trace_categories.cc.o
[ 53%] Linking CXX executable example_system_wide
[ 53%] Built target example_system_wide
[ 60%] Building CXX object CMakeFiles/example_custom_data_source.dir/example_custom_data_source.cc.o
[ 66%] Linking CXX executable example_custom_data_source
[ 66%] Built target example_custom_data_source
[ 73%] Building CXX object CMakeFiles/example_console.dir/example_console.cc.o
[ 80%] Building CXX object CMakeFiles/example_console.dir/trace_categories.cc.o
[ 86%] Linking CXX executable example_console
[ 86%] Built target example_console
[ 93%] Building CXX object CMakeFiles/example_startup_trace.dir/example_startup_trace.cc.o
[100%] Linking CXX executable example_startup_trace
[100%] Built target example_startup_trace
```
编译完成了有四个产物，如下
```
example  example_console  example_custom_data_source  example_startup_trace  example_system_wide
```
解释如下
| 二进制 | 后端 | 输出文件 | 适用场景 |
|---|---|---|---|
| `example` | kInProcess | `example.pftrace` | 基础示例，学习 SDK 基本用法 |
| `example_console` | kInProcess | 无（输出到终端） | 调试，直接在终端看事件流 |
| `example_custom_data_source` | kInProcess | `example_custom_data_source.pftrace` | 自定义数据源格式 |
| `example_startup_trace` | kSystem | `example_startup_trace.pftrace` | 采集进程启动早期事件 |
| `example_system_wide` | kSystem | 无（由外部 perfetto CLI 写入） | 结合 ftrace/heap 做系统级分析 |

下面逐一介绍这些examples的功能

# example程序
这是最基础的示例，直接在代码中嵌入 trace 并输出到 pftrace文件上，其核心代码如下
```
#include "trace_categories.h"

void InitializePerfetto() {
  perfetto::TracingInitArgs args;
  args.backends = perfetto::kInProcessBackend;  // 进程内 tracing
  perfetto::Tracing::Initialize(args);
  perfetto::TrackEvent::Register();
}

std::unique_ptr<perfetto::TracingSession> StartTracing() {
  perfetto::TraceConfig cfg;
  cfg.add_buffers()->set_size_kb(1024);
  auto* ds_cfg = cfg.add_data_sources()->mutable_config();
  ds_cfg->set_name("track_event");

  auto session = perfetto::Tracing::NewTrace();
  session->Setup(cfg);
  session->StartBlocking();
  return session;
}

void StopTracing(std::unique_ptr<perfetto::TracingSession> session) {
  perfetto::TrackEvent::Flush();
  session->StopBlocking();
  std::vector<char> data = session->ReadTraceBlocking();
  std::ofstream("example.pftrace", std::ios::binary).write(data.data(), data.size());
}

int main() {
  InitializePerfetto();
  auto session = StartTracing();

  TRACE_EVENT("rendering", "DrawPlayer", "player_number", 1);
  std::this_thread::sleep_for(std::chrono::milliseconds(100));
  TRACE_COUNTER("rendering", "Framerate", 120);

  StopTracing(std::move(session));
}
```
首先通过 `perfetto::Tracing::Initialize`和 `perfetto::TrackEvent::Register` 注册，其通过TRACE_EVENT和TRACE_COUNTER获取了trace，然后输出为`example.pftrace`。下面演示一下
```
# ./example
[923.099]       perfetto.cc:64891 Configured tracing session 1, #sources:1, duration:0 ms, #buffers:1, total buffer size:1024 KB, total sessions:1, uid:0 session name: ""
[925.102]           example.cc:80 Trace written in example.pftrace file. To read this trace in text form, run `./tools/traceconv text example.pftrace`
```
此时我们打开example.pftrace文件

![](http://192.168.31.100/static/img/8b7c133d7b8aa2498b810278555772c9.image.webp)

# example_console程序
这个程序不会生成pftrace文件，而是直接打印在console上，其核心代码如下
```
void InitializePerfetto() {
  perfetto::TracingInitArgs args;
  args.backends = perfetto::kInProcessBackend;
  perfetto::Tracing::Initialize(args);
  perfetto::TrackEvent::Register();
  perfetto::ConsoleInterceptor::Register();  // 注册控制台拦截器
}
```
现在运行如下
```
# ./example_console
[018.957]       perfetto.cc:64891 Configured tracing session 1, #sources:1, duration:0 ms, #buffers:1, total buffer size:1024 KB, total sessions:1, uid:0 session name: ""
[  0.000]   example_console rende DrawGame {
[  0.000]   example_console rende -  DrawPlayer {(player_number:1)
[  0.501]   example_console rende -  } DrawPlayer +500ms
[  0.501]   example_console rende -  DrawPlayer {(player_number:2)
[  1.001]   example_console rende -  } DrawPlayer +500ms
[  1.001]   example_console rende } DrawGame +1000ms
```

# example_custom_data_source 程序
如果我们在定制开发的时候，perfetto提供的track_event数据不满足要求，那么可以自定义数据，自定义数据源可以发任意 protobuf 数据，只要你自己定义 schema。 然后自行由第三方程序解析。

开始演示

运行测试程序
```
# ./example_custom_data_source
[076.202]       perfetto.cc:64891 Configured tracing session 1, #sources:1, duration:0 ms, #buffers:1, total buffer size:1024 KB, total sessions:1, uid:0 session name: ""
[076.203] ustom_data_source.cc:99 Trace written in example_custom_data_source.pftrace file. To read this trace in text form, run `./tools/traceconv text example_custom_data_source.pftrace`
```
注意，此时example_custom_data_source.pftrace并不能被perfetto解析，这个用作第三方程序自定义解析

我们可以将其转换成格式化的txt文件显示，如下
```
# ./traceconv text example_custom_data_source.pftrace
packet {
  timestamp: 2394076202757473
  trusted_uid: 0
  trusted_packet_sequence_id: 1
  service_event {
    tracing_disabled: true
  }
}
......
```
这是protobuf的格式包

# example_startup_trace程序
这个程序用来采集**进程启动早期**的事件（在 TracingSession 建立之前），特别适合分析 init 阶段性能问题。

我们看看其核心代码
```cpp
void InitializePerfetto() {
  perfetto::TracingInitArgs args;
  args.backends = perfetto::kSystemBackend;  // 必须用系统后端
  perfetto::Tracing::Initialize(args);

  perfetto::DataSourceDescriptor dsd;
  dsd.set_name("com.example.startup_trace");
  MyDataSource::Register(dsd);
}

// 在 TracingSession 创建前写入事件
void StartStartupTracing() {
  perfetto::Tracing::SetupStartupTracingOpts args;
  args.backend = perfetto::kSystemBackend;
  perfetto::Tracing::SetupStartupTracingBlocking(GetTraceConfig(), args);
}

int main() {
  InitializePerfetto();
  StartStartupTracing();  // 在 session 创建前调用

  // 这些事件在 session 建立前就写入
  CustomDataSource::Trace([](auto& ctx) {
    ctx.NewTracePacket()->set_timestamp(41);
  });

  auto session = StartTracing();
  // session 建立后的事件
  CustomDataSource::Trace([](auto& ctx) {
    ctx.NewTracePacket()->set_timestamp(42);
  });
}
```
这里`StartStartupTracing`会在程序启动前写入事件

下面开始演示
```
# mkdir -p /run/perfetto
# traced --background
# ./example_startup_trace
[409.984] le_startup_trace.cc:102 Trace written in example_startup_trace.pftrace file. To read this trace in text form, run `./tools/traceconv text example_startup_trace.pftrace`
# traceconv text example_startup_trace.pftrace
```
我们看到startup事件
```
  packet {
    for_testing {
      str: "Startup Event"
    }
    trusted_packet_sequence_id: 2
    trusted_pid: 1137362
  }
  ---
  packet {
    for_testing {
      str: "Main Event"
    }
    trusted_packet_sequence_id: 2
    trusted_pid: 1137362
  }
```

  - Startup Event — 在 TracingSession 建立前写入
  - Main Event — 在 TracingSession 建立后写入

  两个事件都正确记录，证明 startup tracing 功能正常。

# example_system_wide程序
对于perfetto的分析，我们通常需要按照事件触发的方式，这也就意味着并不需要对程序的event进行常开，那example_system_wide程序的作用就是默认不采集，但是一直监听等待traced守护进程的事件，如果traced的事件触发，那么就会随着系统级的ftrace一同采集。这样的好处如下
* 降低cpu开销
* 按照特定事件触发
* 减少采集数据的大小
* 更精准的提供数据

下面开始演示

我们需要提供一个支持track_event的data source，如下
```
buffers {
  size_kb: 63488
}

# ============================================================
# Data Source 1: Ftrace CPU 调度事件
# ============================================================
data_sources {
  config {
    name: "linux.ftrace"
    ftrace_config {
      ftrace_events: "sched/sched_switch"
      ftrace_events: "sched/sched_wakeup"
      buffer_size_kb: 16384
    }
  }
}

# ============================================================
# Data Source 2: Track Event（接收 example_system_wide 的事件）
# ============================================================
data_sources {
  config {
    name: "track_event"
  }
}

# ============================================================
# Trace 配置
# ============================================================
duration_ms: 10000
write_into_file: true
flush_timeout_ms: 30000
```
然后我们通过tracebox触发一次调度轨迹的trace事件，如下
```
./perfetto --txt -c /tmp/config_with_track_event.pbtx -o /tmp/example.pftrace
```

根据上面的分析，example_system_wide会默认阻塞，等待系统级的trace进行触发，我们运行它
```
# ./example_system_wide
[499.783] ample_system_wide.cc:78 Waiting for tracing to start...
```
此时我们可以看到 ftrace 和 track_event 混合的日志信息

![image.png](/static/img/a3af136bec4a11461f993cc584cc5894.image.webp)

同时，我们也可以通过perfetto命令查看到启动了哪些data source，很明显trace_event是打开的
```
# ./perfetto --query --long
PRODUCER PROCESSES CONNECTED:

ID     PID      UID      FLAGS  NAME                                       SDK
==     ===      ===      =====  ====                                       ===
1      1156509  0               perfetto.traced_probes                     Perfetto v54.0-7616314b3 (7616314b391aa5fe69aa57705216c40727eb0160)

```

# 个人技巧分享

## 1. 缓冲区大小估算

- **经验法则**：每秒约 1-10 MB 的 trace 数据（取决于开启的数据源）
- 开启 ftrace 调度事件：约 2-5 MB/s
- 加上 ATrace：额外 0.5-2 MB/s
- **建议**：至少设置 64 MB（`size_kb: 65536`），复杂场景使用 128-256 MB

## 2. 多缓冲区策略

将高频和低频数据源分配到不同缓冲区：

```protobuf
# 高频：ftrace 事件
buffers { size_kb: 131072 fill_policy: RING_BUFFER }
# 低频：进程统计
buffers { size_kb: 8192 fill_policy: RING_BUFFER }
```

## 3. 长时间追踪

使用 `write_into_file` 配合较小的缓冲区可以追踪数小时：

```protobuf
write_into_file: true
file_write_period_ms: 2500
max_file_size_bytes: 2147483648  # 2GB 上限
buffers { size_kb: 32768 fill_policy: RING_BUFFER }
```

# 总结
本文详细的演示了perfetto的sdk的使用办法，在高性能的程序调试过程中，经常需要支持在perfetto上埋点然后触发采集，这样能够准确有效的定位核心性能问题。

perfetto的使用非常简单，只要心里记住他们是生产者消费者模型即可。我们配好自己的data sourc(生产者)，配好自己的输出方式(消费者)就能高效的使用perfetto了

现在我们知道了perfetto灵活可变的采集方式，接下来我们聚焦在可视化上的分析角度继续演示


性能工具-Perfetto(4)-通过SDK抓取信息

上一篇文章介绍了perfetto的基本原理，本文开始实操

为了考虑到广泛性使用，本文基于标准linux平台实操，实际上可用将其迁移到android，chrome，linux等各种环境中。
# 获取二进制
```
https://github.com/google/perfetto/releases/tag/v54.0
```
直接下载对应平台编译的二进制即可

以linux平台为例
```
wget https://github.com/google/perfetto/releases/download/v54.0/linux-amd64.zip
```
# 抓取办法
主要有四种办法
* perfetto命令抓取
* tracebox命令抓取
* 内置sdk抓取
* peretto ui在线抓取

## perfetto命令抓取
perfetto抓取需要traced进程开启
```
# mkdir -p /run/perfetto
# ./traced --background
1087619
```
我们现在要测试ftrace的数据，所以需要打开ftrace的data source，如下
```
# traced_probes --background
```
此时我们看看data source是否正常打开
```
# ./perfetto --query --long

PRODUCER PROCESSES CONNECTED:

ID     PID      UID      FLAGS  NAME                                       SDK
==     ===      ===      =====  ====                                       ===
1      1092517  0               perfetto.traced_probes                     Perfetto v54.0-7616314b3 (7616314b391aa5fe69aa57705216c40727eb0160)

DATA SOURCES REGISTERED:

NAME                                     PRODUCER                     DETAILS
===                                      ========                     ========
linux.frozen_ftrace                      perfetto.traced_probes (1)
linux.ftrace                             perfetto.traced_probes (1)
linux.inode_file_map                     perfetto.traced_probes (1)
linux.process_stats                      perfetto.traced_probes (1)
linux.sys_stats                          perfetto.traced_probes (1)
linux.sysfs_power                        perfetto.traced_probes (1)
linux.system_info                        perfetto.traced_probes (1)
perfetto.metatrace                       perfetto.traced_probes (1)
```
根据上一个文章 <性能工具-Perfetto-数据处理(2)> 可以知道，我们需要这个data source，且正常打开了，所以接下来就可以直接抓取数据

```
./perfetto -t 10s -b 32mb sched/sched_switch sched/sched_wakeup -o /tmp/sched.pftrace
[940.327]    perfetto_cmd.cc:1136 Connected to the Perfetto traced service, TTL: 10s
[950.405]    perfetto_cmd.cc:1293 Wrote 1166644 bytes into /tmp/sched.pftrace
```

等10s，我们可以获取到文件，然后在 `https://ui.perfetto.dev/` 中查看

![image.png](/static/img/52999e31ba926453564b8ee69f24d4d2.image.webp)

可以看到，我们成功获取到了整个系统的调度信息。接下来就可以更详细的分析调度问题了。

## tracebox命令抓取

`tracebox` 是 Perfetto 提供的单文件工具，打包了 `traced`、`traced_probes`、`perfetto` ，这样我们启动一次调试就不需要启动 三个程序了，这对新手来说使用更加轻松，这里也演示一下

在使用tracebox之前，我们需要准备一下data source的描述，也就是pbtx文件，如下
```
buffers {
  size_kb: 16384
}

# ============================================================
# Data Source: Ftrace CPU 调度事件
# ============================================================
data_sources {
  config {
    name: "linux.ftrace"
    ftrace_config {
      # 调度事件
      ftrace_events: "sched/sched_switch"
      ftrace_events: "sched/sched_wakeup"

      buffer_size_kb: 16384
    }
  }
}

# ============================================================
# Trace 配置
# ============================================================
duration_ms: 30000
write_into_file: true
flush_timeout_ms: 30000
flush_period_ms: 604800000
```
然后用tracebox加载即可
```bash
# ./tracebox --txt -c /tmp/docs/config_linux_ftrace_sched.pbtx -o /tmp/sched.pftrace
[110.638]          service.cc:267 Started traced, listening on @traced-p-1108237 @traced-c-1108237
[110.679]           probes.cc:103 Starting traced_probes service
[110.680]  probes_producer.cc:397 Connected to the service
[110.685]   perf_producer.cc:1324 Connected to the service
[110.686]    perfetto_cmd.cc:1136 Connected to the Perfetto traced service, TTL: 30s
[110.686] ng_service_impl.cc:1368 Configured tracing session 1, #sources:1, duration:30000 ms, #buffers:1, total buffer size:16384 KB, total sessions:1, uid:0 session name: ""
[110.720]  probes_producer.cc:141 Ftrace setup (target_buf=1)
[110.720]          tracefs.cc:636 disabled ftrace in /sys/kernel/tracing/
[110.803]          tracefs.cc:633 enabled ftrace in /sys/kernel/tracing/
```
同样，tracebox可以一行命令直接抓到调度轨迹

![image.png](/static/img/f9266fd19bf3ca45610c59baff0a70a9.image.webp)

## Perfetto UI 在线调试
步骤如下

1. 打开浏览器访问 [https://ui.perfetto.dev](https://ui.perfetto.dev)
2. 点击左侧菜单 **"Record new trace"**
3. 选择目标设备和传输方式：
   - **WebUSB**：直接通过 USB 连接 Android 设备
   - **ADB over WebSocket**：通过 adb 转发
   - **Chrome**：追踪 Chrome 浏览器本身

4. 配置数据源：
5. 设置缓冲区大小和追踪时长
6. 点击红色录制按钮开始追踪
7. 操作你的应用，复现性能问题
8. 追踪完成后自动在 UI 中打开分析

# 总结
本文通过perfetto和tracebox两种方式演示了调度轨迹的抓取，同时也说明了perfetto ui在线调试的办法。但是遗留了一个sdk方式埋点抓数据的方式，这个在下一篇文章介绍。

perfetto是非常方便系统性分析问题的核心工具，掌握其使用的意义非常重要

# 参考资料
- [Quickstart: Record traces on Android](https://perfetto.dev/docs/quickstart/android-tracing)
- [Recording system traces with Perfetto](https://perfetto.dev/docs/getting-started/system-tracing)
- [Trace configuration](https://perfetto.dev/docs/concepts/config)
- [TraceConfig Proto Reference](https://perfetto.dev/docs/reference/trace-config-proto)


性能工具-Perfetto(3)-调度轨迹抓取

在演示perfetto之前，需要介绍一下perfetto的数据处理过程，这样就能够清晰的了解如何抓取trace。

# 整体介绍
Perfetto 通过生产者消费者模型来抓取数据，其设计的架构可以分为三个层次（消费者/Tracing 服务/生产者）：

![image.png](/static/img/20bb75c5245139288d5395830e748375.image.webp)

* 消费者：trace_processor_shell或perfetto ui
* tracing服务： traced
* 生产者： 自定义的data source

# Producer（数据生产者）
## 概念
Producer 是追踪数据的来源，每个 Producer 可以注册一个或多个 **Data Source**（数据源）。Producer 通过 UNIX socket 连接到 `traced` 服务，并在追踪会话期间将数据直接写入共享内存缓冲区。

## 内置traced_probes
`traced_probes` 是 Perfetto 最重要的内置 Producer，负责采集系统级数据：

| 数据源名称 | 功能 | 采集方式 |
|-----------|------|---------|
| `linux.ftrace` | 内核 ftrace 事件 | 读取 tracefs |
| `linux.sys_stats` | 系统统计信息 | 读取 /proc/stat 等 |
| `linux.process_stats` | 进程统计信息 | 读取 /proc/[pid]/stat |
| `linux.system_info` | 系统信息 | 读取 /proc/cpuinfo 等 |

例如

![image.png](/static/img/2455ba696fdf6bcd8e3408adcd2b8f19.image.webp)

## 外部data source
通过配置data source可以自定义一个数据源，例如

![image.png](/static/img/624d2e74ade130606c14030c03df9bd5.image.webp)

## 共享内存机制

Producer 与 traced 之间的数据传输使用了**共享内存缓冲区（Shared Memory Buffer, SMB）**：

![image.png](/static/img/b38dfb9b211444a11c418b3afb5a44c8.image.webp)

**工作流程：**

1. Producer 连接到 traced 后，traced 分配一块共享内存
2. Producer 的每个线程在共享内存中申请一个 **Chunk**（数据块）
3. Producer 使用 **ProtoZero** 库直接在 Chunk 上序列化 protobuf 数据
4. 当 Chunk 写满后，Producer 通过 IPC 通知 traced 进行提交
5. traced 将数据从共享内存拷贝到追踪缓冲区

这种设计的优势：
- **零拷贝序列化**：数据直接写入共享内存，避免额外的内存拷贝
- **线程安全**：每个线程独立操作自己的 Chunk
- **低延迟**：无需内核态切换（相比 ftrace 的 trace_marker 方式）

# Consumer（数据消费者）

## 概念

Consumer 是追踪会话的发起者和控制者，负责：
- 定义 `TraceConfig`（追踪配置）
- 启动和停止追踪会话
- 读取最终的 trace 数据

## 常见 Consumer
例如有如下消费者
* perfetto二进制
   ```bash
   perfetto -c config.pbtx --txt -o trace.perfetto-trace
   ```
* perfetto ui 在线调试
* record_android_trace 工具
* Android Framework `TraceManager` 系统服务

# Tracing Service（traced）

## 核心职责

`traced` 是整个追踪系统的中枢，主要职责包括：

## 1. 会话管理（Session Manager）

管理追踪会话的完整生命周期：

![image.png](/static/img/86323b12b48810ed630e981638f798a7.image.webp)


## 2. 缓冲区管理（Buffer Manager）

traced 管理两种缓冲区：

- **共享内存缓冲区（SMB）**：Producer 与 traced 之间的数据通道
- **追踪缓冲区（Trace Buffer）**：存储最终 trace 数据的内存区域

追踪缓冲区支持两种填充策略：

```protobuf
buffers {
  size_kb: 65536
  fill_policy: RING_BUFFER    # 环形缓冲，覆盖旧数据
  # fill_policy: DISCARD      # 满了就丢弃新数据
}
```

## 3. 配置分发（Config Dispatcher）

traced 收到 `TraceConfig` 后，将其中的 `DataSourceConfig` 分发给对应的 Producer：

```protobuf
data_sources {
  config {
    name: "linux.ftrace"          # 路由到 traced_probes
    target_buffer: 0
    ftrace_config {
      ftrace_events: "sched/sched_switch"
    }
  }
}

data_sources {
  config {
    name: "track_event"           # 路由到 SDK Producer
    target_buffer: 1
  }
}
```

注意：traced **不解码** DataSourceConfig 的内容，只是将原始二进制 blob 转发给匹配的 Producer。这意味着可以引入新的数据源而不需要修改 traced。

## 数据流详解

## 完整数据流路径

![image.png](/static/img/abfe7f286aa88f0ac7e246d6debb9f5d.image.webp)

## 多缓冲区路由

不同数据源可以路由到不同的缓冲区，避免高频数据源挤占低频数据源的空间：

```protobuf
# 缓冲区 0：高频数据（ftrace），需要较大空间
buffers { size_kb: 131072 fill_policy: RING_BUFFER }

# 缓冲区 1：低频数据（进程统计），较小空间即可
buffers { size_kb: 8192 fill_policy: RING_BUFFER }

data_sources {
  config {
    name: "linux.ftrace"
    target_buffer: 0          # 路由到缓冲区 0
    ftrace_config { ... }
  }
}

data_sources {
  config {
    name: "linux.process_stats"
    target_buffer: 1          # 路由到缓冲区 1
    process_stats_config { ... }
  }
}
```

## 长时间追踪（Long Traces）

对于需要长时间追踪的场景，Perfetto 支持 `write_into_file` 模式：

```protobuf
write_into_file: true
file_write_period_ms: 5000    # 每 5 秒刷新一次

buffers {
  size_kb: 16384              # 只需容纳两次刷新间隔的数据
  fill_policy: RING_BUFFER
}
```

在这种模式下：
- traced 定期将缓冲区数据排空到输出文件
- 缓冲区只需足够容纳两次写入间隔的数据
- 可以记录数小时甚至数天的 trace

## 进程内模式 vs 系统模式

Perfetto SDK 支持两种运行模式：

### 系统模式（System Mode）

![image.png](/static/img/39be5ccf4b90fac4662ff8004987148e.image.webp)

- Producer 通过 UNIX socket 连接到系统 traced
- 可以与系统级数据（ftrace、procfs）一起采集
- 适合 Android/Linux 系统级追踪

### 进程内模式（In-Process Mode）

![image.png](/static/img/309349d112c93aeb4791eb900f5f64e1.image.webp)

- 追踪服务在应用内的专用线程上运行
- 不依赖系统 traced
- 适合跨平台或独立应用的追踪
- 相同的 API，只是初始化配置不同

## perfetto设计机制

1. **服务化解耦**：Producer 和 Consumer 通过 traced 解耦，可独立演进
2. **零拷贝设计**：共享内存 + ProtoZero 实现极低开销
3. **可扩展性**：新数据源通过 Producer 注册机制无缝接入
4. **灵活配置**：protobuf 化的配置支持动态能力发现和数据源配置
5. **多缓冲区**：避免不同频率数据源的相互干扰
6. **双模式支持**：系统模式和进程内模式覆盖不同场景

## 总结
Perfetto 的 Producer-Consumer 架构是其高性能和灵活性的基石。通过共享内存和 ProtoZero 序列化实现极低开销，通过服务化架构实现组件解耦和可扩展性。理解这套架构，是深入使用和定制 Perfetto 的前提。

在下一篇文章中，我们将实战演示如何在 Android 设备上抓取 Perfetto trace，涵盖命令行、UI 以及编程方式的完整操作流程。

## 参考资料

- [Perfetto 官方文档 - 架构概述](https://perfetto.dev/docs/)
- [Trace Processor 架构设计](https://perfetto.dev/docs/design-docs/trace-processor-architecture)
- [Perfetto Tracing SDK](https://perfetto.dev/docs/instrumentation/tracing-sdk)


ION 的 dma-buf 集成机制深度解析

ION System Heap 与 CMA Heap 深度解析