MIME-Version: 1.0
References: 
 <CABPTF7XiwbA38OZBj5Y2F-q+fZ=03YFN9iFnb_406F4SfE-f4w@mail.gmail.com>
 <CABPTF7WcZ4_xvPeBh9Ws3_AJ3u67gHdHSAmE5Pp+0pDppY=ZvA@mail.gmail.com>
In-Reply-To: 
 <CABPTF7WcZ4_xvPeBh9Ws3_AJ3u67gHdHSAmE5Pp+0pDppY=ZvA@mail.gmail.com>
From: Xuneng Zhou <xunengzhou@gmail.com>
Date: Tue, 16 Dec 2025 18:52:13 +0800
Message-ID: 
 <CABPTF7Vty_fsJLpj6=Xn5MM5PXiV_n=XeN87S+7JhSmROYwCAA@mail.gmail.com>
Subject: Re: Optimize SnapBuild by maintaining committed.xip in sorted order
To: pgsql-hackers <pgsql-hackers@lists.postgresql.org>
Cc: Masahiko Sawada <sawada.mshk@gmail.com>
Content-Type: multipart/mixed; boundary="00000000000010628306460f8660"
Archived-At: 
 <https://www.postgresql.org/message-id/CABPTF7Vty_fsJLpj6%3DXn5MM5PXiV_n%3DXeN87S%2B7JhSmROYwCAA%40mail.gmail.com>
Precedence: bulk

--00000000000010628306460f8660
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

Hi,

On Tue, Dec 16, 2025 at 6:20=E2=80=AFPM Xuneng Zhou <xunengzhou@gmail.com> =
wrote:
>
> Hi,
>
> On Fri, Nov 7, 2025 at 12:55=E2=80=AFPM Xuneng Zhou <xunengzhou@gmail.com=
> wrote:
> >
> > Hi hackers,
> >
> > I'd like to propose an optimization for logical decoding's snapshot bui=
lding
> > mechanism that eliminates repeated sorting overhead once a replication =
slot
> > reaches the CONSISTENT state.
> >
> > 1) Problem
> >
> > Currently, SnapBuildBuildSnapshot() sorts the entire committed.xip arra=
y on
> > every call using qsort(). Once a logical decoding slot reaches CONSISTE=
NT
> > state, snapshots are built frequently=E2=80=94after every catalog-modif=
ying transaction
> > commit. This repeated O(n log n) sorting becomes a performance bottlene=
ck as
> > the committed transaction array grows.
> >
> > The existing code even has a TODO comment acknowledging this inefficien=
cy:
> > "TODO: It's unclear whether that reasoning has much merit. Every time w=
e add
> > something here after becoming consistent will also require distributing=
 a
> > snapshot."
> >
> > 2) Proposed Solution
> >
> > Maintain sorted order via batch merge on each commit:
> >
> > 1. Collect all relevant XIDs (including subtransactions) into a batch a=
rray
> > 2. Sort the batch: O(m log m) where m is typically small (1 + nsubxacts=
)
> > 3. Merge into the global array: O(n + m) via reverse in-place merge
> >
> > While per-commit cost increases from O(m) to O(m log m + n), this is of=
fset by
> > eliminating O(n log n) sorts at each snapshot build. Since CONSISTENT s=
tate
> > builds snapshots after each catalog-modifying commit, the amortized cos=
t is
> > significantly lower.
> >
> > 3) Performance Impact
> >
> > Expected improvements in CONSISTENT state:
> > - Eliminates O(n log n) qsort on every snapshot build
> > - Replaces with O(m log m + n) merge per commit
> > - For typical cases where m << n and snapshots are frequent, this is a =
win
> >
> >
> > The benchmark results for this patch are shown below.
> >
> > 4) Configuration
> >
> > shared_buffers =3D '4GB'
> > wal_level =3D logical
> > max_replication_slots =3D 10
> > max_wal_senders =3D 10
> > log_min_messages =3D warning
> > max_connections =3D 600
> > autovacuum =3D off
> > checkpoint_timeout =3D 15min
> > max_wal_size =3D 4GB
> >
> >
> > 5) Workloads
> >
> > # Workload 1: DDL - High frequency, small commits
> > create_ddl_workload() {
> >   local ROOT=3D"$1"
> >   cat >"$ROOT/ddl.sql" <<'SQL'
> > -- High-frequency small catalog commits
> > -- Each commit triggers SnapBuildBuildSnapshot
> > DO $$
> > DECLARE
> >   tbl text :=3D format('temp_%s_%s',
> >                      current_setting('application_name', true),
> >                      floor(random()*1e9)::int);
> > BEGIN
> >   EXECUTE format('CREATE TEMP TABLE %I (id int, data text) ON COMMIT
> > DROP', tbl);
> >   EXECUTE format('INSERT INTO %I VALUES (1, ''x'')', tbl);
> >   EXECUTE format('SELECT * FROM %I', tbl);
> > END$$;
> > SQL
> > }
> >
> > # Workload 2: MIXED - mix of DDL and DML, 50%-50%
> > create_mixed_workload() {
> >   local ROOT=3D"$1"
> >   cat >"$ROOT/mixed_ddl.sql" <<'SQL'
> > -- DDL workload (catalog changes)
> > DO $$
> > DECLARE
> >   tbl text :=3D format('t_%s_%s',
> >                      current_setting('application_name', true),
> >                      floor(random()*1e9)::int);
> > BEGIN
> >   EXECUTE format('CREATE TABLE %I (id int, data text) ON COMMIT DROP', =
tbl);
> >   EXECUTE format('INSERT INTO %I VALUES (1, ''x'')', tbl);
> > END$$;
> >
> > SQL
> >   cat >"$ROOT/mixed_dml.sql" <<'SQL'
> > -- DML workload (no catalog changes)
> > INSERT INTO app_data (id, data)
> > VALUES (floor(random()*1e6)::int, repeat('x', 100))
> > ON CONFLICT (id) DO UPDATE SET data =3D repeat('y', 100);
> > SQL
> > }
> >
> > # Workload 3: CONTROL - Pure DML, no catalog changes
> > create_control_workload() {
> >   local ROOT=3D"$1"
> >   cat >"$ROOT/control.sql" <<'SQL'
> >
> > -- Pure DML, no catalog changes
> > -- Should show no difference between baseline and patched
> > INSERT INTO control_data (id, data)
> > VALUES (floor(random()*1e6)::int, repeat('x', 100))
> > ON CONFLICT (id) DO UPDATE SET data =3D repeat('y', 100);
> > SQL
> > }
> >
> >
> > 6) Test strategy
> >
> > Clients: 100 concurrent connections per workload
> > Duration: 40 seconds per run
> > Repetitions: 1 run per workload type
> > Replication:  Logical replication slot using `test_decoding` plugin
> > with `EXPORT_SNAPSHOT=3Dtrue`
> >
> > Workload Types:
> > 1. DDL - Pure catalog churn (temp table create/drop)
> > 2. Mixed- 50% DDL + 50% DML (workload)
> > 3. Control - Pure DML (no catalog changes)
> >
> > Measurement:
> > - Metrics captured from pg_stat_replication_slots before/after each run
> > - Primary metrics: total_txns (transactions decoded) and total_bytes
> > (data volume)
> > - Compared baseline (vanilla PostgreSQL) vs patched (sorted
> > committed.xip optimization)
> >
> >
> > 7) Performance results
> >
> > DDL Workload: +235% Decoder Improvement
> > Decoder throughput:  713.76 =E2=86=92 2396.52 txns/sec  (+235%)
> > Throughput (MB/s):   672.67 =E2=86=92 1747.22 MB/s     (+159%)
> > Decode efficiency:   9.46% =E2=86=92 33.29%             (+23.83 points)
> >
> > Mixed Workload: No Change
> > Decoder throughput:  2751.10 =E2=86=92 2730.00 txns/sec  (0%)
> > Decode efficiency:   40.47% =E2=86=92 40.47%             (unchanged)
> >
> > We can see that the qsort overhead in SnapBuild has been eliminated in
> > the flamegraphs in the mixed workload. However, the performance
> > improvement was not observed as in the DDL workload. My guess is that,
> > for DML workloads, ReorderBufferApplyChange has become the new
> > hotspot.
> >
> > DML Workload: No Change
> > Decoder throughput:  3062.57 =E2=86=92 3066.37 txns/sec  (0%)
> > Decode efficiency:   49.97% =E2=86=92 49.97%             (unchanged)
> >
> > =3D=3D=3D Workload: ddl =3D=3D=3D
> > Client commits/sec:
> >   Baseline:  7545.76 commits/sec
> >   Patched:   7198.21 commits/sec
> >
> > Decoder throughput (from pg_stat_replication_slots):
> >   Baseline:  713.76 txns/sec  (672.67 MB/s)
> >   Patched:   2396.52 txns/sec  (1747.22 MB/s)
> >
> > Transaction efficiency (decoded vs committed):
> >   Baseline:  309376 committed  =E2=86=92  29264 decoded  (9.46%)
> >   Patched:   302325 committed  =E2=86=92  100654 decoded  (33.29%)
> >
> > Total decoded (all reps):
> >   Baseline:  29264 txns  (27579.53 MB)
> >   Patched:   100654 txns  (73383.10 MB)
> >
> >   Decoder improvement: +235.00% (txns/sec)
> >   Decoder improvement: +159.00% (MB/s)
> >   Efficiency improvement: +23.83% points (more transactions decoded
> > per committed)
> >
> > =3D=3D=3D Workload: mixed =3D=3D=3D
> > Client commits/sec:
> >   Baseline:  6797.50 commits/sec
> >   Patched:   6745.26 commits/sec
> >
> > Decoder throughput (from pg_stat_replication_slots):
> >   Baseline:  2751.10 txns/sec  (210.35 MB/s)
> >   Patched:   2730.00 txns/sec  (205.64 MB/s)
> >
> > Transaction efficiency (decoded vs committed):
> >   Baseline:  285495 committed  =E2=86=92  115546 decoded  (40.47%)
> >   Patched:   283301 committed  =E2=86=92  114660 decoded  (40.47%)
> >
> > Total decoded (all reps):
> >   Baseline:  115546 txns  (8834.71 MB)
> >   Patched:   114660 txns  (8636.96 MB)
> >
> >   =E2=89=88  Decoder unchanged: 0.00% (txns/sec)
> >
> > =3D=3D=3D Workload: DML =3D=3D=3D
> > Client commits/sec:
> >   Baseline:  6129.24 commits/sec
> >   Patched:   6136.93 commits/sec
> >
> > Decoder throughput (from pg_stat_replication_slots):
> >   Baseline:  3062.57 txns/sec  (0.26 MB/s)
> >   Patched:   3066.37 txns/sec  (0.26 MB/s)
> >
> > Transaction efficiency (decoded vs committed):
> >   Baseline:  257428 committed  =E2=86=92  128628 decoded  (49.97%)
> >   Patched:   251614 committed  =E2=86=92  125721 decoded  (49.97%)
> >
> > Total decoded (all reps):
> >   Baseline:  128628 txns  (10.98 MB)
> >   Patched:   125721 txns  (10.69 MB)
> >
> >   =E2=89=88  Decoder unchanged: 0.00% (txns/sec)
> >
> > 8) Potential regression
> >
> > The potential regression point could be before the slot reaches the
> > CONSISTENT state, particularly when building_full_snapshot is set to
> > true. In this phase, all transactions including those that don=E2=80=99=
t
> > modify the catalog =E2=80=94 must be added to the committed.xip array. =
These
> > XIDs don=E2=80=99t require later snapshot builds or sorting, so the
> > batch-insert logic increases the per-insert cost from O(1) to O(m + n)
> > without providing a direct benefit.
> >
> > However, the impact of this regression could be limited. The system
> > remains in the pre-CONSISTENT phase only briefly during initial
> > snapshot building, and the building_full_snapshot =3D true case is rare=
,
> > mainly used when creating replication slots with the EXPORT_SNAPSHOT
> > option.
> >
> > Once the slot becomes CONSISTENT, only catalog-modifying transactions
> > are tracked in committed.xip, and the patch reduces overall
> > snapshot-building overhead by eliminating repeated full-array sorts.
> >
> > We could also adopt a two-phase approach =E2=80=94 keeping the current
> > behavior before reaching the CONSISTENT state and maintaining a sorted
> > array only after that point. This would preserve the performance
> > benefits while avoiding potential regressions. However, it would
> > introduce additional complexity and potential risks in handling the
> > state transitions.
> >
> > if (builder->state < SNAPBUILD_CONSISTENT)
> > {
> > /* ensure that only commits after this are getting replayed */
> > if (builder->start_decoding_at <=3D lsn)
> > builder->start_decoding_at =3D lsn + 1;
> >
> > /*
> > * If building an exportable snapshot, force xid to be tracked, even
> > * if the transaction didn't modify the catalog.
> > */
> > if (builder->building_full_snapshot)
> > {
> > needs_timetravel =3D true;
> > }
> > }
>
> After some consideration, a two-phase sorting strategy seems feasible
> to implement in a relatively straightforward manner. So it's done in
> v2. I also plan to run benchmarks to evaluate potential regressions of
> the original =E2=80=9Csort-at-all-stages=E2=80=9D approach of v1.
>
> > 9) Additional benefit
> > With this patch applied, we can optimize the SnapBuildPurgeOlderTxn to =
use
> > two binary searchs rather than interating and copying to find the inter=
val
> > to keep in the sorted commited.xip array. [1]
> >
> > Feedbacks welcomed.
> >
> > [1] https://www.postgresql.org/message-id/flat/CABPTF7V9gcpTLrOY0fG4Yon=
toHjVg8YrbmiH4XB_5PT6K56xhg%40mail.gmail.com
>
> V2 fixes several issues in v1, including a potential memory leak, type
> inconsistencies, and applies pgindent to the files.
>

V3 fixes a critical issue where the snapshot->xip array in
SnapBuildBuildSnapshot might not be sorted before reaching the
consistent state. Sorry for the noise here.

--=20
Best,
Xuneng

--00000000000010628306460f8660
Content-Type: application/octet-stream;
	name="v3-0001-Optimize-SnapBuild-by-maintaining-committed.xip-i.patch"
Content-Disposition: attachment;
	filename="v3-0001-Optimize-SnapBuild-by-maintaining-committed.xip-i.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mj8gnijj0>
X-Attachment-Id: f_mj8gnijj0
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--00000000000010628306460f8660--