可以。这里先把范围严格限定为一个独立的 PostgreSQL 逻辑复制 Benchmark Suite,不包含 pg_replication_trace,也不依赖任何自研 PostgreSQL Extension。
目标就是先回答一个纯粹的问题:
PostgreSQL 18 原生逻辑复制,在不同数据规模、事务规模、并发度、DML 类型、网络条件和 Subscriber 负载下,到底能达到多少复制吞吐,以及瓶颈在哪里。
建议项目名称:
pg-repl-bench
版本:
v1.0
PostgreSQL 18
1. 项目目标
Benchmark Suite 主要实现四个目标。
目标一:测量逻辑复制吞吐
WAL generation rate
Send rate
Receive rate
Apply rate
End-to-End rate
目标二:测量复制延迟
Replication Lag
Apply Lag
Catch-up Time
目标三:定位性能瓶颈
不需要修改 PostgreSQL 源码,利用原生统计接口和 OS 指标判断:
Publisher CPU
Publisher IO
Logical Replication
Network
Subscriber CPU
Subscriber IO
Subscriber Lock
目标四:建立可重复的性能基线
支持:
PG18 → PG18
不同 workload
不同并发
不同事务大小
不同网络
不同硬件
并输出标准化结果,方便横向比较。
2. 非目标
第一版明确不做:
❌ pg_replication_trace
❌ PostgreSQL 内核修改
❌ Logical Decoding 插件
❌ WAL 内部 hook
❌ 单表内部 Decode Trace
❌ Transaction → Relation 精确追踪
❌ 自定义 Apply Worker
也就是说:
只使用 PostgreSQL 官方提供的 SQL/统计视图 + pgbench + Linux 标准工具。
3. 总体架构
pg-repl-bench
│
┌───────────────┼───────────────┐
│ │ │
▼ ▼ ▼
Environment Workload Metrics
Manager Manager Collector
│ │ │
▼ ▼ ▼
PostgreSQL pgbench PostgreSQL SQL
Publisher SQL OS Metrics
│ │
│ Logical Replication │
▼ │
PostgreSQL │
Subscriber │
│ │
└───────────────┬───────────────┘
▼
Result Analyzer
│
┌─────────┼─────────┐
▼ ▼ ▼
CSV JSON Report
4. 技术选型
建议非常简单:
| 模块 | 技术 |
|---|---|
| Controller | Python 3 |
| Workload | pgbench + SQL |
| Database | PostgreSQL 18 |
| Environment | Docker Compose |
| Metrics | SQL + /proc |
| Network | Linux tc |
| Result | JSON + CSV |
| Analysis | Python |
| Chart | Matplotlib |
| Report | Markdown + HTML |
第一版不需要 Prometheus/Grafana。
因为 Benchmark 的重点是:
一次测试 → 一组确定结果 → 可重复 → 可比较。
5. 部署模式
支持两种模式。
Mode A:单机
┌─────────────────────────────┐
│ Host │
│ │
│ Publisher │
│ PostgreSQL 18 │
│ │
│ Subscriber │
│ PostgreSQL 18 │
│ │
│ pg-repl-bench │
└─────────────────────────────┘
适合:
- 开发
- 功能验证
- 基准测试
- CI
Mode B:双机
更推荐用于正式性能测试:
Machine A Machine B
Publisher Subscriber
PostgreSQL 18 PostgreSQL 18
│ ▲
│ │
└────────── Network ───────────────┘
│
1/10 Gbps
适合:
- 网络吞吐测试
- CPU 对比
- IO 对比
- Walsender 性能
- Apply 性能
6. 测试生命周期
每个 Benchmark Case 都严格遵循:
Prepare
↓
Initialize
↓
Create Publication
↓
Create Subscription
↓
Initial Sync
↓
Baseline
↓
Start Metrics
↓
Start Workload
↓
Collect
↓
Workload Finished
↓
Wait Catch-up
↓
Verify
↓
Calculate
↓
Generate Report
↓
Cleanup
这样可以保证每个 Case 的测试环境一致。
7. PostgreSQL 初始化
Publisher:
CREATE DATABASE replbench;
配置:
wal_level = logical
max_replication_slots = ...
max_wal_senders = ...
创建:
CREATE PUBLICATION bench_pub
FOR TABLE ...;
Subscriber:
CREATE SUBSCRIPTION bench_sub
CONNECTION '...'
PUBLICATION bench_pub;
8. 测试数据模型
第一版建议统一使用一张标准表:
CREATE TABLE bench_t (
id BIGINT PRIMARY KEY,
payload TEXT,
created_at TIMESTAMPTZ,
updated_at TIMESTAMPTZ
);
这样可以控制:
row size
primary key
update
delete
insert
9. Row Size 控制
测试:
100 B
512 B
1 KB
4 KB
16 KB
64 KB
例如:
repeat('x', 1024)
控制 payload。
10. Transaction Size
测试:
1 row
10 rows
100 rows
1,000 rows
10,000 rows
100,000 rows
1,000,000 rows
这是整个 Benchmark 非常重要的维度。
因为:
1 row / transaction
和:
100,000 rows / transaction
对逻辑复制的行为差异很大。
11. Workload 类型
第一版定义:
W01 INSERT
W02 UPDATE
W03 DELETE
W04 MIXED
W01 INSERT
INSERT INTO bench_t
SELECT
g,
repeat('x', :payload_size),
now(),
now()
FROM generate_series(...);
W02 UPDATE
UPDATE bench_t
SET
payload = repeat('y', :payload_size),
updated_at = now()
WHERE id BETWEEN :start AND :end;
W03 DELETE
DELETE FROM bench_t
WHERE id BETWEEN :start AND :end;
W04 MIXED
默认:
INSERT 40%
UPDATE 40%
DELETE 20%
12. pgbench 的作用
这里需要特别明确:
pgbench是 Workload Generator,不是 Logical Replication Benchmark 本身。
它负责制造稳定的数据库负载:
pgbench
↓
DML
↓
WAL
↓
Logical Replication
Benchmark Suite 再测:
WAL
Send
Receive
Apply
Lag
13. Benchmark Matrix
第一版建议做 6 个维度。
DML Type
Row Size
Transaction Size
Concurrency
Table Count
Network
14. 第一组:DML Benchmark
| Case | Operation |
|---|---|
| B01 | INSERT |
| B02 | UPDATE |
| B03 | DELETE |
| B04 | MIXED |
15. 第二组:Row Size Benchmark
固定:
32 clients
100 rows/transaction
分别测试:
100 B
512 B
1 KB
4 KB
16 KB
64 KB
目标:
Row Size
↓
WAL Rate
↓
Replication Rate
16. 第三组:Transaction Benchmark
固定:
row size = 1 KB
测试:
1
10
100
1K
10K
100K
最终分析:
Transaction Size
↓
TPS
↓
WAL MB/s
↓
Apply MB/s
17. 第四组:Concurrency Benchmark
固定:
1 KB
100 rows/transaction
测试:
1
2
4
8
16
32
64
128
寻找:
Logical Replication 的吞吐饱和点。
例如:
Clients Apply MB/s
1 20
2 40
4 75
8 130
16 210
32 280
64 285
128 280
那么:
32 clients
附近就是一个重要拐点。
18. 第五组:Multi-Table Benchmark
测试:
1 table
10 tables
100 tables
例如:
table_001
table_002
...
table_100
Publication:
CREATE PUBLICATION bench_pub
FOR TABLE table_001, table_002, ...;
Workload:
每张表均匀产生 DML
目的:
测试逻辑复制处理大量 relation 时的性能变化。
19. 第六组:Network Benchmark
这是针对你之前 walsender → epoll_pwait 问题最重要的测试组。
利用:
tc
人为控制:
100 Mbps
500 Mbps
1 Gbps
5 Gbps
10 Gbps
再增加:
10 ms latency
50 ms latency
100 ms latency
观察:
WAL Rate
Send Rate
Receive Rate
Apply Rate
Replication Lag
Walsender wait_event
20. 第七组:Subscriber Bottleneck
Subscriber 增加索引:
0 index
1 index
5 indexes
10 indexes
20 indexes
测试:
Apply Rate
CPU
IO
Lag
目的:
Publisher
│
│ 500 MB/s
▼
Subscriber
│
│ 100 MB/s
▼
Apply
验证 Apply 是否成为瓶颈。
21. 第八组:Lock Benchmark
Subscriber:
BEGIN;
UPDATE bench_t
SET payload = 'lock'
WHERE id = 1;
不提交。
Publisher:
UPDATE bench_t
SET payload = 'replication'
WHERE id = 1;
然后采集:
SELECT
pid,
wait_event_type,
wait_event,
state
FROM pg_stat_activity;
验证:
Apply Worker
↓
Lock
↓
Replication Lag ↑
22. 核心 Metrics
这是整个 Suite 的核心。
Publisher
每秒:
SELECT
clock_timestamp(),
pg_current_wal_lsn();
以及:
SELECT
pid,
state,
wait_event_type,
wait_event,
sent_lsn,
write_lsn,
flush_lsn,
replay_lsn
FROM pg_stat_replication;
23. Subscriber Metrics
每秒:
SELECT
subname,
pid,
relid,
received_lsn,
latest_end_lsn,
latest_end_time
FROM pg_stat_subscription;
同时:
SELECT *
FROM pg_stat_subscription_stats;
24. Replication Slot Metrics
Publisher:
SELECT
slot_name,
active,
restart_lsn,
confirmed_flush_lsn,
wal_status
FROM pg_replication_slots;
关注:
confirmed_flush_lsn
25. OS Metrics
每秒采集:
CPU
Memory
Disk Read
Disk Write
IOPS
Network RX
Network TX
Load
不依赖 Prometheus。
Linux:
/proc/stat
/proc/meminfo
/proc/diskstats
/proc/net/dev
26. 最核心的 Rate 算法
WAL Rate
Δpg_current_wal_lsn()
---------------------
Δtime
Send Rate
Δsent_lsn
---------
Δtime
Receive Rate
Δreceived_lsn
-------------
Δtime
Apply Rate
原生 PostgreSQL 下,建议同时采用两种定义:
LSN-based
根据 Subscriber 的复制位置估算:
ΔLSN / Δtime
Data-based
通过 workload 已知的:
rows
bytes
transactions
计算:
applied rows / elapsed time
最终两个指标同时报告。
27. End-to-End Throughput
定义:
Workload Start
↓
第一次产生 change
↓
...
↓
Subscriber 完成 Apply
最终:
E2E throughput =
successfully applied logical data
/
E2E elapsed time
28. Replication Lag
建议同时报告:
LSN Lag
Time Lag
LSN:
pg_wal_lsn_diff(
pg_current_wal_lsn(),
replay_lsn
)
时间:
latest_end_time
29. Bottleneck 判断
第一版不做复杂 AI,只做规则判断。
Decode/WAL
WAL Rate 高
Send Rate 明显低
CPU 高
→ Publisher/Decoding 疑似瓶颈。
Network
Send Rate ≈ Network bandwidth
Walsender waiting
Receive Rate ≈ Send Rate
→ Network 疑似瓶颈。
Apply
Receive Rate >> Apply Rate
Subscriber CPU/IO 高
→ Apply 疑似瓶颈。
Lock
Apply Worker
wait_event_type = Lock
→ Lock bottleneck。
30. Benchmark 配置文件
统一使用 YAML。
例如:
name: insert_1k_100txn
database:
publisher: publisher
subscriber: subscriber
workload:
type: insert
row_size: 1024
rows_per_transaction: 100
clients: 32
duration: 300
replication:
publication: bench_pub
subscription: bench_sub
monitor:
interval: 1
network:
bandwidth: unlimited
repeat: 3
31. Scenario 配置
例如:
scenarios/
├── B01_insert.yaml
├── B02_update.yaml
├── B03_delete.yaml
├── B04_mixed.yaml
├── B05_row_size.yaml
├── B06_transaction_size.yaml
├── B07_concurrency.yaml
├── B08_multitable.yaml
├── B09_network.yaml
├── B10_apply.yaml
└── B11_lock.yaml
32. Controller
Python Controller 负责:
环境初始化
数据库初始化
Publication
Subscription
Workload
Metrics
Cleanup
CLI:
./bench prepare
./bench run B01
./bench run B01 --repeat 3
./bench run-all
./bench report
33. 目录结构
建议最终:
pg-repl-bench/
│
├── README.md
├── Makefile
├── requirements.txt
│
├── config/
│ ├── database.yaml
│ └── benchmark.yaml
│
├── workloads/
│ ├── insert.sql
│ ├── update.sql
│ ├── delete.sql
│ └── mixed.sql
│
├── scenarios/
│ ├── B01_insert.yaml
│ ├── B02_update.yaml
│ ├── B03_delete.yaml
│ ├── B04_mixed.yaml
│ ├── B05_row_size.yaml
│ ├── B06_transaction.yaml
│ ├── B07_concurrency.yaml
│ ├── B08_multitable.yaml
│ ├── B09_network.yaml
│ ├── B10_apply.yaml
│ └── B11_lock.yaml
│
├── controller/
│ ├── cli.py
│ ├── environment.py
│ ├── database.py
│ ├── workload.py
│ └── runner.py
│
├── monitor/
│ ├── publisher.py
│ ├── subscriber.py
│ ├── replication.py
│ └── system.py
│
├── analysis/
│ ├── lsn.py
│ ├── rate.py
│ ├── lag.py
│ └── bottleneck.py
│
├── docker/
│ ├── publisher/
│ └── subscriber/
│
├── results/
│
└── reports/
34. Result 数据模型
每次测试保存:
results/
└── 20260903/
└── B01/
├── metadata.json
├── publisher.csv
├── subscriber.csv
├── system.csv
├── workload.csv
└── summary.json
35. metadata.json
记录环境:
{
"postgres_version": "18",
"os": "Ubuntu 24.04",
"kernel": "...",
"cpu": 32,
"memory_gb": 64,
"publisher": "...",
"subscriber": "...",
"row_size": 1024,
"transaction_size": 100,
"clients": 32,
"duration": 300
}
36. summary.json
最终结果:
{
"case": "B01",
"tps": 12500,
"wal_mb_s": 320,
"send_mb_s": 315,
"receive_mb_s": 313,
"apply_mb_s": 305,
"rows_s": 298000,
"average_lag_ms": 125,
"p99_lag_ms": 380,
"publisher_cpu": 72,
"subscriber_cpu": 81,
"bottleneck": "APPLY"
}
37. 最终报告
每个 Case 自动生成:
B01 INSERT 1KB
Environment
--------------------------------
CPU 32
Memory 64 GB
PostgreSQL 18
Workload
--------------------------------
Clients 32
Row Size 1 KB
Transaction 100
Duration 300s
Performance
--------------------------------
TPS 12,500
WAL 320 MB/s
Send 315 MB/s
Receive 313 MB/s
Apply 305 MB/s
Replication
--------------------------------
Average Lag 125 ms
P99 Lag 380 ms
Resource
--------------------------------
Publisher CPU 72%
Subscriber CPU 81%
Bottleneck
--------------------------------
APPLY
38. 三张核心图
每个测试至少输出三个图。
图 1:Replication Throughput
Time
│
│ Apply
│ ─────────────
│
│ Receive
│ ───────────────
│
└────────────────────
图 2:LSN Progress
LSN
│
│ Apply
│ /
│ /
│ / Receive
│ /
│ / Send
│ /
└────────────────── Time
图 3:Replication Lag
Lag
│ /\
│ / \
│____/ \________
│
└────────────────── Time
39. 测试重复策略
单个 Case 不允许只跑一次。
建议:
Warmup: 60 sec
正式测试: 300 sec
Repeat: 3~5 次
最终:
mean
median
min
max
stddev
尤其 TPS 和 Apply Rate。
40. Benchmark 的公平性要求
如果比较:
PostgreSQL 17
vs
PostgreSQL 18
必须固定:
CPU
Memory
Disk
Network
Dataset
Row Size
Transaction Size
Concurrency
Duration
PostgreSQL Configuration
唯一变化:
PostgreSQL Version
否则测试没有太大意义。
41. 第一版建议的完整 Test Matrix
不要一开始就做上百个测试。
先定义:
┌─────────────┐
│ PostgreSQL18│
└──────┬──────┘
│
┌────────────┼────────────┐
▼ ▼ ▼
DML TXN Row
│ │ │
INSERT 1/100/1K 100B/1K/10K
UPDATE 10K/100K
DELETE
MIXED
│
├──────────────┐
▼ ▼
Concurrency Network
1/4/8/16/32 100M/1G/10G
/64/128
第一阶段大约 30~50 个 Case 就足够。
42. 最重要的 11 个基础 Case
我建议把下面 11 个作为 v1.0 Acceptance Test:
| ID | 场景 | 目的 |
|---|---|---|
| B01 | INSERT 1KB | 基准 |
| B02 | UPDATE 1KB | UPDATE 性能 |
| B03 | DELETE | DELETE 性能 |
| B04 | Mixed | 综合负载 |
| B05 | Small Transaction | 小事务 |
| B06 | Large Transaction | 大事务 |
| B07 | Row Size | 行大小影响 |
| B08 | Concurrency | 并发扩展 |
| B09 | Multi Table | 多表 |
| B10 | Network Limit | 网络瓶颈 |
| B11 | Subscriber Lock | Apply/Lock |
43. 一个非常重要的设计原则
这个 Benchmark Suite 不要试图测“内部 Decode MB/s”。
因为在不修改 PostgreSQL、不增加 extension 的前提下,原生接口并不能准确提供:
Logical Decode:
xxx MB/s
因此 v1.0 应该严格定义:
WAL Generation Rate
Send Rate
Receive Rate
Apply Rate
而不是伪造一个:
Decode Rate
这是保证 Benchmark 数据可信的关键。
44. 最终的指标体系
因此整个 Benchmark Suite 最终形成:
pg-repl-bench
│
┌───────────┴───────────┐
│ │
Workload Metrics Replication Metrics
│ │
▼ ▼
TPS WAL MB/s
Latency Send MB/s
Receive MB/s
Apply MB/s
Lag
Catch-up Time
│ │
└───────────┬───────────┘
▼
System Metrics
│
┌───────────┼───────────┐
▼ ▼ ▼
CPU IO Network
│
▼
Bottleneck
│
▼
Report
45. 最终定位
这个版本的 pg-repl-bench 应该是一个纯黑盒 Benchmark:
PostgreSQL 18
│
不修改源码
│
┌────────┴────────┐
▼ ▼
Publisher Subscriber
│ │
└──── Logical ────┘
Replication
│
▼
pg-repl-bench
│
▼
Performance
Report
它先建立一套可信的 PostgreSQL 18 原生逻辑复制性能基线。
后续如果开发 pg_replication_trace,则可以变成:
pg-repl-bench
│
┌────────────┴────────────┐
▼ ▼
Native Metrics PRT Metrics
│ │
▼ ▼
“复制有多快” “为什么这么快/慢”
这两个项目解耦后,Benchmark Suite 本身即使永远不开发 pg_replication_trace,也仍然是一个完整、可独立使用的 PostgreSQL Logical Replication 性能测试工具。