PostgreSQL Logical Replication Benchmark Suite


 TL;DR
可以。这里先把范围严格限定为一个独立的 PostgreSQL 逻辑复制 Benchmark Suite,不包含 pg_replication_trace,也不依赖任何自研 PostgreSQL Extension。
难度 中等

可以。这里先把范围严格限定为一个独立的 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 性能测试工具。


文章作者: growdu
版权声明: 本博客所有文章除特別声明外,均采用 CC BY 4.0 许可协议。转载请注明来源 growdu !
这篇还发到了
今日头条 drafted
  目录