From 1a47cee03394ef70f5f70a1a93648be2369611ee Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sat, 25 Jul 2026 06:37:21 +0000
Subject: [PATCH 1/3] notify-bench: harness isolating the NOTIFY commit lock
 (fork-local)

Adds the benchmark harness, raw results and measurement instrumentation
used to characterize the cluster-wide lock that PreCommit_Notify()
takes.  Fork-local; not proposed for upstream in this form.

The central difficulty is that comparing INSERT against INSERT+NOTIFY
measures the lock plus the SLRU queue insert, the utility statement and
an extra round trip.  The instrumentation patch resolves this by making
the identical binary skip only LockSharedObject() when PG_NOTIFY_NOLOCK
is set in the postmaster environment, so the two arms differ by that one
call.  With synchronous_commit=on and zero listeners, removing it takes
throughput from 1,027 to 7,893 TPS at 16 clients and from 1,055 to
12,369 at 64 -- recovering essentially all of the gap to a NOTIFY-free
workload up to 16 clients and 74% of it at 64.  This shows the SLRU
NotifyQueueLock does not simply become the next bottleneck.

Stated without reference to this disk: the wait-event data shows both
arms with one fsync in flight, but the control queues ~21 backends
behind it while NOTIFY queues none, because they are stuck a step
earlier.  Group-commit batch factor ~21 versus exactly 1.

The README documents the harness's known defects rather than hiding
them, including one that invalidates the "interested listener" results
and whose bias favours the conclusion the harness was built to test:
psql reading from a fifo never calls PQconsumeInput, so those listeners
jam in ClientWrite instead of draining.  scripts/checkjam.sh
demonstrates it.  Those numbers are retracted; the uninterested-listener
results are unaffected.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01M3RLizCyeXBBFJdBHGDvKW
---
 notify-bench/README.md                        | 139 ++++++++++++++++++
 ...UREMENT-ONLY-skip-notify-commit-lock.patch |  33 +++++
 notify-bench/results/ab_lock.csv              |  39 +++++
 notify-bench/results/master.csv               |  31 ++++
 notify-bench/results/master.listeners.csv     |   8 +
 notify-bench/results/master.listeners2.csv    |   9 ++
 notify-bench/results/master.waits.csv         | 107 ++++++++++++++
 notify-bench/results/pg18.listeners2.csv      |   9 ++
 notify-bench/results/pg18.waits.csv           | 101 +++++++++++++
 notify-bench/results/pg18.writers.csv         |  29 ++++
 notify-bench/scripts/ab_lock.sh               | 117 +++++++++++++++
 notify-bench/scripts/checkjam.sh              |  49 ++++++
 notify-bench/scripts/listeners.sh             |  73 +++++++++
 notify-bench/scripts/verify.sh                |  53 +++++++
 notify-bench/scripts/writers.sh               |  78 ++++++++++
 15 files changed, 875 insertions(+)
 create mode 100644 notify-bench/README.md
 create mode 100644 notify-bench/instrumentation/0001-MEASUREMENT-ONLY-skip-notify-commit-lock.patch
 create mode 100644 notify-bench/results/ab_lock.csv
 create mode 100644 notify-bench/results/master.csv
 create mode 100644 notify-bench/results/master.listeners.csv
 create mode 100644 notify-bench/results/master.listeners2.csv
 create mode 100644 notify-bench/results/master.waits.csv
 create mode 100644 notify-bench/results/pg18.listeners2.csv
 create mode 100644 notify-bench/results/pg18.waits.csv
 create mode 100644 notify-bench/results/pg18.writers.csv
 create mode 100644 notify-bench/scripts/ab_lock.sh
 create mode 100644 notify-bench/scripts/checkjam.sh
 create mode 100644 notify-bench/scripts/listeners.sh
 create mode 100644 notify-bench/scripts/verify.sh
 create mode 100644 notify-bench/scripts/writers.sh

diff --git a/notify-bench/README.md b/notify-bench/README.md
new file mode 100644
index 0000000000000..298698d6023fe
--- /dev/null
+++ b/notify-bench/README.md
@@ -0,0 +1,139 @@
+# notify-bench — measuring the LISTEN/NOTIFY commit lock
+
+Fork-local benchmark harness for the cluster-wide heavyweight lock that
+`PreCommit_Notify()` takes at `src/backend/commands/async.c:1309`:
+
+```c
+LockSharedObject(DatabaseRelationId, InvalidOid, 0, AccessExclusiveLock);
+```
+
+Because `LockSharedObject()` builds the locktag with dbid `InvalidOid`, this lock is
+cluster-wide (all databases). It is released at
+`ResourceOwnerRelease(RESOURCE_RELEASE_LOCKS)` (`xact.c:2480`), i.e. **after**
+`RecordTransactionCommit()` (`:2407`, containing `XLogFlush()` at `:1544` and
+`SyncRepWaitForLSN()` at `:1599`) and **after** `ProcArrayEndTransaction()` (`:2431`).
+Notifying transactions therefore cannot group-commit with one another.
+
+Context, full analysis and discussion: issue #82 in this fork.
+
+> **This directory is fork-local.** It is not proposed for upstream inclusion in this
+> form. The instrumentation patch is a measurement device and is deliberately unsafe.
+
+## Headline result: the lock, isolated
+
+The problem with comparing `INSERT` against `INSERT; NOTIFY` is that the delta contains
+the lock *plus* the SLRU queue insert, the utility statement, and an extra client round
+trip. To isolate the lock, `instrumentation/0001-MEASUREMENT-ONLY-skip-notify-commit-lock.patch`
+makes the identical binary skip **only** that one call when `PG_NOTIFY_NOLOCK` is set in
+the postmaster environment.
+
+`synchronous_commit=on`, zero listeners, 3 reps of 10 s, median [min–max]:
+
+| clients | control | NOTIFY (lock) | NOTIFY (no lock) | gap recovered |
+|--:|--:|--:|--:|--:|
+| 1  | 824 [794–835] | 790 [618–844] | 733 [695–778] | — (no gap at c=1) |
+| 4  | 2,059 [1946–2075] | 1,033 [934–1051] | 2,177 [2115–2300] | 111% |
+| 16 | 7,811 [7430–8006] | 1,027 [911–1074] | 7,893 [7606–8290] | 101% |
+| 64 | 16,307 [16044–16469] | 1,055 [979–1135] | 12,369 [11077–12973] | 74% |
+
+Lock-removal speedup: 2.1x (4 clients), 7.7x (16), 11.7x (64). Arm separation is
+asserted by the harness: 72 `Lock`/`object` wait samples in the lock arm, **0** in the
+no-lock arm. A run where that check fails to separate is void.
+
+This answers the open question from the 2025 pgsql-hackers thread — whether
+`NotifyQueueLock` would simply become the next bottleneck. It does not: it is a short
+LWLock around the SLRU insert and never spans the fsync. At 64 clients the residual
+(NotifyQueueLock + SLRU + one extra round trip) is ~26% of the gap.
+
+### The mechanism, stated hardware-independently
+
+From `results/master.waits.csv`, both arms show exactly one backend in `IO`/`WalSync` at
+any instant — one fsync in flight. The difference is who is queued behind it:
+
+| | `Lock`/`object` | `LWLock`/`WALWrite` | `IO`/`WalSync` |
+|---|--:|--:|--:|
+| NOTIFY, 32 clients | 610 | **0** | 18 |
+| control, 32 clients | 0 | **373** | 18 |
+
+Control queues ~21 backends per in-flight fsync — group commit working. NOTIFY queues
+**zero**, because everyone is stuck one step earlier on the heavyweight lock.
+**Group-commit batch factor ~21 versus exactly 1.** Throughput ratios on any particular
+disk are a consequence of that; this statement is the portable one.
+
+## Scripts
+
+All run as an unprivileged user; PostgreSQL refuses to start as root.
+
+```
+scripts/writers.sh   <PGBIN> <PGDATA> <PORT> <LABEL> <OUTDIR> [initdb]
+scripts/listeners.sh <PGBIN> <PGDATA> <PORT> <LABEL> <OUTDIR>
+scripts/ab_lock.sh   <PGBIN> <PGDATA> <PORT> <OUTDIR>          # needs instrumented build
+scripts/verify.sh                                              # arm-separation smoke test
+scripts/checkjam.sh                                            # demonstrates the defect in D1 below
+```
+
+`ab_lock.sh` is the one that matters. `writers.sh` and `listeners.sh` are the earlier,
+weaker harness, kept because the published numbers in issue #82 §3 came from them and the
+raw data should stay auditable.
+
+## Builds used
+
+Same repo, same container, `./configure --prefix=... --without-readline --without-zlib --without-icu`:
+
+- `master` — `13b7a8a` (20devel), i.e. **with** the v19 fix `282b1cde`
+- `v18` — `REL_18_BETA1`, i.e. **before** it
+- instrumented — `13b7a8a` plus the patch in `instrumentation/`
+
+## Known defects — read before citing any number here
+
+These were found by adversarial review and are documented rather than quietly fixed,
+because several published numbers depend on them.
+
+**D1 — the "interested listener" measurements are invalid and are retracted.**
+`listeners.sh` starts listeners as `psql -f <fifo>`. A psql blocked reading a fifo never
+calls `PQconsumeInput`, so it never collects notifications; the backend fills the socket
+buffer and parks in `ClientWrite`, stopping draining. On master a jammed listener latches
+`wakeupPending` and is then skipped forever by `SignalBackends()`; on v18 there is no such
+flag and it is signalled on every notifying commit. **The defect flatters master and
+punishes v18** — the direction of the bias favours the conclusion the harness was built to
+test. `scripts/checkjam.sh` demonstrates it: 50 of 50 listeners in `Client`/`ClientWrite`
+for the whole run. Any future listener work needs a real libpq client looping on
+`PQconsumeInput`/`PQnotifies`, plus a `received ≈ sent × listeners` assertion.
+The *uninterested* listener numbers are unaffected — those listeners receive nothing and
+never jam.
+
+**D2 — single samples in `writers.sh`/`listeners.sh`.** `master.listeners.csv` and
+`master.listeners2.csv` are two runs of the same configuration; the 500-interested cell
+differs by 7,380% (386 vs 28,881) because an earlier cleanup bug leaked 169 sessions.
+Only `ab_lock.csv` has repetitions.
+
+**D3 — the `synchronous_commit=off` rows are noise.** Cross-comparing the control arm
+between builds (identical code path) shows up to 31% disagreement, and `master.csv` has
+NOTIFY *beating* the control at 8 clients. Noise floor ~50%. Do not quote a ratio.
+
+**D4 — 4 vCPU box, pgbench and up to 500 listener processes co-resident with the server.**
+Everything at ≥8 clients is CPU-oversubscribed. The listener runs are at 125 listeners per
+core and will not reproduce at realistic ratios. The NOTIFY `synchronous_commit=on` rows
+are the least affected — at ~1,000 TPS with 96% of backends parked on a lock, the box is
+idle.
+
+**D5 — no latency percentiles** (only pgbench's mean), **no sync-rep configuration**
+despite the claim that sync rep worsens the effect, **no `pg_test_fsync`** to establish
+that the ~1 ms fsync is genuinely durable, and **different pgbench binaries** between the
+master and v18 arms in `writers.sh`.
+
+**D6 — `bigserial primary key`** puts a sequence and a monotonic rightmost btree page in
+both arms, capping the control ceiling — i.e. the numerator of every ratio.
+
+## Before publishing any of this
+
+Fix D1, D2 and D4 first. Then: a machine with ≥32 cores, pgbench and listeners on separate
+hosts, ≥5 runs per cell with medians and bootstrap CIs on every published ratio, 30 s
+warmup discarded plus ≥60 s measured, latency p50/p90/p99, `pg_test_fsync` output, a
+synchronous standby with `netem` RTT sweep, and a `commit_delay` sweep (it should help the
+control and do nothing for NOTIFY — a knob that provably moves one arm and not the other
+is clean mechanistic evidence).
+
+The single cleanest confirmation available: WAL fsyncs per commit from `pg_stat_io`
+(`object='wal'`, `context='normal'`), which should be pinned at **1.00 for NOTIFY at every
+concurrency** while the control falls toward ~0.05 at 64 clients.
diff --git a/notify-bench/instrumentation/0001-MEASUREMENT-ONLY-skip-notify-commit-lock.patch b/notify-bench/instrumentation/0001-MEASUREMENT-ONLY-skip-notify-commit-lock.patch
new file mode 100644
index 0000000000000..54512d507da77
--- /dev/null
+++ b/notify-bench/instrumentation/0001-MEASUREMENT-ONLY-skip-notify-commit-lock.patch
@@ -0,0 +1,33 @@
+diff --git a/src/backend/commands/async.c b/src/backend/commands/async.c
+index 2799f989..bbcebf36 100644
+--- a/src/backend/commands/async.c
++++ b/src/backend/commands/async.c
+@@ -1306,8 +1306,26 @@ PreCommit_Notify(void)
+ 		 * (Historical note: before PG 9.0, a similar lock on "database 0" was
+ 		 * used by the flatfiles mechanism.)
+ 		 */
+-		LockSharedObject(DatabaseRelationId, InvalidOid, 0,
+-						 AccessExclusiveLock);
++		/*
++		 * MEASUREMENT HACK -- NOT A PATCH PROPOSAL.
++		 *
++		 * Setting PG_NOTIFY_NOLOCK in the postmaster's environment skips the
++		 * serializing lock entirely.  This BREAKS the commit-order guarantee
++		 * and must never be used for anything but benchmarking: it exists so
++		 * that the identical binary can be measured with and without the
++		 * lock, isolating the lock's cost from every other cost NOTIFY adds
++		 * (XID assignment, SLRU writes, extra WAL, signalling).
++		 */
++		{
++			static int	skip_commit_lock = -1;
++
++			if (skip_commit_lock < 0)
++				skip_commit_lock = (getenv("PG_NOTIFY_NOLOCK") != NULL) ? 1 : 0;
++
++			if (!skip_commit_lock)
++				LockSharedObject(DatabaseRelationId, InvalidOid, 0,
++								 AccessExclusiveLock);
++		}
+ 
+ 		/*
+ 		 * For the direct advancement optimization in SignalBackends(), we
diff --git a/notify-bench/results/ab_lock.csv b/notify-bench/results/ab_lock.csv
new file mode 100644
index 0000000000000..d78513a8084cb
--- /dev/null
+++ b/notify-bench/results/ab_lock.csv
@@ -0,0 +1,39 @@
+workload,clients,rep,tps,latency_ms
+verify,lock,lock_object_samples,72
+control,1,1,793.747637,1.260
+notify_lock,1,1,617.689105,1.619
+control,1,2,823.616542,1.214
+notify_lock,1,2,789.701872,1.266
+control,1,3,835.146151,1.197
+notify_lock,1,3,843.828178,1.185
+control,4,1,2075.229962,1.927
+notify_lock,4,1,1032.757037,3.873
+control,4,2,1945.620218,2.056
+notify_lock,4,2,934.017819,4.283
+control,4,3,2059.100874,1.943
+notify_lock,4,3,1050.942403,3.806
+control,16,1,8006.320200,1.998
+notify_lock,16,1,1027.453880,15.572
+control,16,2,7430.209383,2.153
+notify_lock,16,2,910.817275,17.567
+control,16,3,7811.229830,2.048
+notify_lock,16,3,1073.621073,14.903
+control,64,1,16306.741669,3.925
+notify_lock,64,1,979.219803,65.358
+control,64,2,16044.000089,3.989
+notify_lock,64,2,1134.623215,56.406
+control,64,3,16468.864107,3.886
+notify_lock,64,3,1054.764243,60.677
+verify,nolock,lock_object_samples,0
+notify_nolock,1,1,733.369743,1.364
+notify_nolock,1,2,778.117574,1.285
+notify_nolock,1,3,695.217283,1.438
+notify_nolock,4,1,2300.381597,1.739
+notify_nolock,4,2,2115.097629,1.891
+notify_nolock,4,3,2176.567336,1.838
+notify_nolock,16,1,7892.530900,2.027
+notify_nolock,16,2,8289.748970,1.930
+notify_nolock,16,3,7605.807062,2.104
+notify_nolock,64,1,12368.686711,5.174
+notify_nolock,64,2,11076.615228,5.778
+notify_nolock,64,3,12972.550910,4.933
diff --git a/notify-bench/results/master.csv b/notify-bench/results/master.csv
new file mode 100644
index 0000000000000..93ab1764de5f9
--- /dev/null
+++ b/notify-bench/results/master.csv
@@ -0,0 +1,31 @@
+label,workload,sync_commit,listeners,clients,tps
+master,control,on,0,1,842.067097
+master,notify,on,0,1,731.288758
+master,control,on,0,2,1106.784023
+master,notify,on,0,2,1020.163226
+master,control,on,0,4,2224.208631
+master,notify,on,0,4,1147.291070
+master,control,on,0,8,3933.750804
+master,notify,on,0,8,1041.803620
+master,control,on,0,16,8239.746124
+master,notify,on,0,16,1034.046709
+master,control,on,0,32,11908.811583
+master,notify,on,0,32,931.657407
+master,control,on,0,64,16396.707752
+master,notify,on,0,64,950.531704
+master,control,off,0,1,5542.203443
+master,notify,off,0,1,4319.135678
+master,control,off,0,2,12313.310414
+master,notify,off,0,2,9253.081777
+master,control,off,0,4,43066.010812
+master,notify,off,0,4,19932.094058
+master,control,off,0,8,36010.788431
+master,notify,off,0,8,38149.919649
+master,control,off,0,16,41475.449337
+master,notify,off,0,16,22137.605751
+master,control,off,0,32,39624.212166
+master,notify,off,0,32,14169.157032
+master,control,off,0,64,35494.949721
+master,notify,off,0,64,12259.627559
+master,notify_uninterested,off,0,8,23908.553292
+master,notify_uninterested,off,50,8,19035.989019
diff --git a/notify-bench/results/master.listeners.csv b/notify-bench/results/master.listeners.csv
new file mode 100644
index 0000000000000..7c06f69d24f93
--- /dev/null
+++ b/notify-bench/results/master.listeners.csv
@@ -0,0 +1,8 @@
+label,workload,listeners_requested,sessions_live,clients,tps
+master,notify_uninterested,0,1,8,24521.495368
+master,notify_uninterested,50,51,8,19186.899494
+master,notify_uninterested,200,201,8,11720.226938
+master,notify_uninterested,500,501,8,8028.999061
+master,notify_interested,50,51,8,37042.417853
+master,notify_interested,200,201,8,37122.099701
+master,notify_interested,500,670,8,386.099710
diff --git a/notify-bench/results/master.listeners2.csv b/notify-bench/results/master.listeners2.csv
new file mode 100644
index 0000000000000..2f33d2f43e2d1
--- /dev/null
+++ b/notify-bench/results/master.listeners2.csv
@@ -0,0 +1,9 @@
+label,workload,listeners_requested,sessions_live,clients,tps
+master,notify_uninterested,0,1,8,24963.705698
+master,notify_uninterested,50,51,8,19465.589984
+master,notify_uninterested,200,201,8,11820.281611
+master,notify_uninterested,500,501,8,9313.276028
+master,notify_interested,0,1,8,33955.603557
+master,notify_interested,50,51,8,35988.892674
+master,notify_interested,200,201,8,34268.001568
+master,notify_interested,500,501,8,28880.879102
diff --git a/notify-bench/results/master.waits.csv b/notify-bench/results/master.waits.csv
new file mode 100644
index 0000000000000..3344c9e271847
--- /dev/null
+++ b/notify-bench/results/master.waits.csv
@@ -0,0 +1,107 @@
+notify32,IO,WalSync,1
+notify32,Lock,object,31
+notify32,IO,WalSync,1
+notify32,Lock,object,31
+notify32,IO,WalSync,1
+notify32,Lock,object,31
+notify32,IO,WalSync,1
+notify32,Lock,object,31
+notify32,IO,WalSync,1
+notify32,Lock,object,30
+notify32,CPU,-,1
+notify32,Client,ClientRead,1
+notify32,Lock,object,30
+notify32,IO,WalSync,1
+notify32,Lock,object,30
+notify32,IO,WalSync,1
+notify32,Lock,object,30
+notify32,IO,WalSync,1
+notify32,Lock,object,30
+notify32,IO,WalSync,1
+notify32,Lock,object,31
+notify32,IO,WalSync,1
+notify32,Lock,object,31
+notify32,IO,WalSync,1
+notify32,Lock,object,31
+notify32,IO,WalSync,1
+notify32,Lock,object,30
+notify32,IO,WalSync,1
+notify32,Lock,object,30
+notify32,CPU,-,1
+notify32,IO,WalSync,1
+notify32,Lock,object,30
+notify32,CPU,-,1
+notify32,IO,WalWrite,1
+notify32,Lock,object,30
+notify32,IO,WalSync,1
+notify32,Lock,object,31
+notify32,IO,WalSync,1
+notify32,Lock,object,30
+notify32,IO,WalSync,1
+notify32,Lock,object,31
+notify32,IO,WalSync,1
+notify32,Lock,object,31
+control32,Buffer,BufferExclusive,1
+control32,CPU,-,1
+control32,Client,ClientRead,5
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,10
+control32,Client,ClientRead,1
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,17
+control32,CPU,-,2
+control32,Client,ClientRead,4
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,20
+control32,Client,ClientRead,4
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,8
+control32,CPU,-,1
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,30
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,19
+control32,CPU,-,4
+control32,Client,ClientRead,1
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,20
+control32,CPU,-,1
+control32,LWLock,WALWrite,31
+control32,CPU,-,1
+control32,LWLock,WALWrite,24
+control32,Client,ClientRead,1
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,15
+control32,Client,ClientRead,1
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,21
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,7
+control32,CPU,-,1
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,27
+control32,CPU,-,1
+control32,Client,ClientRead,2
+control32,IO,WalSync,1
+control32,LWLock,WALInsert,5
+control32,LWLock,WALWrite,6
+control32,CPU,-,4
+control32,Client,ClientRead,11
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,14
+control32,Client,ClientRead,1
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,19
+control32,CPU,-,1
+control32,Client,ClientRead,1
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,11
+control32,CPU,-,1
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,25
+control32,CPU,-,1
+control32,Client,ClientRead,1
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,18
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,31
diff --git a/notify-bench/results/pg18.listeners2.csv b/notify-bench/results/pg18.listeners2.csv
new file mode 100644
index 0000000000000..9e1547af66fbb
--- /dev/null
+++ b/notify-bench/results/pg18.listeners2.csv
@@ -0,0 +1,9 @@
+label,workload,listeners_requested,sessions_live,clients,tps
+pg18,notify_uninterested,0,1,8,26475.993718
+pg18,notify_uninterested,50,51,8,4278.651793
+pg18,notify_uninterested,200,201,8,1044.264183
+pg18,notify_uninterested,500,501,8,385.337067
+pg18,notify_interested,0,1,8,39025.640128
+pg18,notify_interested,50,51,8,4697.860987
+pg18,notify_interested,200,201,8,1251.098088
+pg18,notify_interested,500,501,8,491.201190
diff --git a/notify-bench/results/pg18.waits.csv b/notify-bench/results/pg18.waits.csv
new file mode 100644
index 0000000000000..fb842c0805da5
--- /dev/null
+++ b/notify-bench/results/pg18.waits.csv
@@ -0,0 +1,101 @@
+notify32,CPU,-,1
+notify32,Lock,object,31
+notify32,CPU,-,1
+notify32,IO,WalSync,1
+notify32,Lock,object,30
+notify32,IO,WalSync,1
+notify32,Lock,object,30
+notify32,IO,WalSync,1
+notify32,Lock,object,30
+notify32,IO,WalSync,1
+notify32,Lock,object,31
+notify32,IO,WalSync,1
+notify32,Lock,object,30
+notify32,IO,WalSync,1
+notify32,Lock,object,31
+notify32,CPU,-,1
+notify32,IO,WalSync,1
+notify32,Lock,object,30
+notify32,IO,WalSync,1
+notify32,Lock,object,30
+notify32,IO,WalSync,1
+notify32,Lock,object,31
+notify32,IO,WalSync,1
+notify32,Lock,object,31
+notify32,Client,ClientRead,1
+notify32,IO,WalSync,1
+notify32,Lock,object,30
+notify32,CPU,-,1
+notify32,Lock,object,29
+notify32,IO,WalSync,1
+notify32,Lock,object,31
+notify32,IO,WalSync,1
+notify32,Lock,object,31
+notify32,IO,WalSync,1
+notify32,Lock,object,31
+notify32,IO,WalSync,1
+notify32,Lock,object,31
+notify32,IO,WalSync,1
+notify32,Lock,object,31
+notify32,Client,ClientRead,1
+notify32,IO,WalWrite,1
+notify32,Lock,object,30
+notify32,Client,ClientRead,1
+notify32,IO,WalSync,1
+notify32,Lock,object,30
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,31
+control32,CPU,-,2
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,23
+control32,CPU,-,1
+control32,LWLock,WALWrite,31
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,27
+control32,Client,ClientRead,1
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,14
+control32,CPU,-,3
+control32,Client,ClientRead,1
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,12
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,31
+control32,CPU,-,1
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,28
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,24
+control32,CPU,-,1
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,28
+control32,IO,WalInitSync,1
+control32,LWLock,WALWrite,31
+control32,CPU,-,1
+control32,Client,ClientRead,4
+control32,LWLock,WALWrite,12
+control32,CPU,-,1
+control32,Client,ClientRead,1
+control32,IO,WalSync,1
+control32,LWLock,WALInsert,3
+control32,LWLock,WALWrite,10
+control32,Client,ClientRead,2
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,19
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,28
+control32,CPU,-,2
+control32,Client,ClientRead,6
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,6
+control32,Client,ClientRead,1
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,4
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,27
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,31
+control32,CPU,-,2
+control32,Client,ClientRead,17
+control32,IO,WalSync,1
+control32,LWLock,WALWrite,10
diff --git a/notify-bench/results/pg18.writers.csv b/notify-bench/results/pg18.writers.csv
new file mode 100644
index 0000000000000..85dc203d3f95d
--- /dev/null
+++ b/notify-bench/results/pg18.writers.csv
@@ -0,0 +1,29 @@
+label,workload,sync_commit,listeners,clients,tps
+pg18,control,on,0,1,764.132481
+pg18,notify,on,0,1,615.101107
+pg18,control,on,0,2,996.720685
+pg18,notify,on,0,2,998.192526
+pg18,control,on,0,4,1999.333389
+pg18,notify,on,0,4,1035.925071
+pg18,control,on,0,8,4199.390351
+pg18,notify,on,0,8,1021.020323
+pg18,control,on,0,16,7926.101922
+pg18,notify,on,0,16,989.232522
+pg18,control,on,0,32,11982.054706
+pg18,notify,on,0,32,900.939021
+pg18,control,on,0,64,16937.448497
+pg18,notify,on,0,64,906.057529
+pg18,control,off,0,1,5537.431426
+pg18,notify,off,0,1,4402.078509
+pg18,control,off,0,2,12185.103436
+pg18,notify,off,0,2,8848.930137
+pg18,control,off,0,4,32816.302574
+pg18,notify,off,0,4,30162.108965
+pg18,control,off,0,8,45237.475428
+pg18,notify,off,0,8,30133.721985
+pg18,control,off,0,16,41116.911323
+pg18,notify,off,0,16,22328.862784
+pg18,control,off,0,32,44543.541500
+pg18,notify,off,0,32,14663.683928
+pg18,control,off,0,64,34886.894299
+pg18,notify,off,0,64,12815.283571
diff --git a/notify-bench/scripts/ab_lock.sh b/notify-bench/scripts/ab_lock.sh
new file mode 100644
index 0000000000000..fffedc827a66b
--- /dev/null
+++ b/notify-bench/scripts/ab_lock.sh
@@ -0,0 +1,117 @@
+#!/bin/bash
+# A/B test isolating the NOTIFY commit lock.
+#
+# Same binary throughout. The instrumented build skips
+# LockSharedObject() in PreCommit_Notify() iff PG_NOTIFY_NOLOCK is set in the
+# postmaster environment, so the ONLY difference between the "notify" and
+# "notify_nolock" arms is that one lock. Everything else NOTIFY costs
+# (XID assignment, SLRU writes, extra WAL, signalling) is present in both.
+#
+# NOTE: the nolock arm breaks the commit-order guarantee. It is a measurement
+# device, not a proposed behaviour.
+#
+# usage: ab_lock.sh <PGBIN> <PGDATA> <PORT> <OUTDIR>
+set -u
+PGBIN=$1; PGDATA=$2; PORT=$3; OUT=$4
+export PATH=$PGBIN:$PATH
+export PGPORT=$PORT PGHOST=/tmp PGDATABASE=bench
+DUR=${DUR:-10}
+REPS=${REPS:-3}
+CLIENTS=${CLIENTS:-"1 4 16 64"}
+RES=$OUT/ab_lock.csv
+mkdir -p "$OUT"
+
+start_server() {   # $1 = "lock" | "nolock"
+  pg_ctl -D "$PGDATA" -m immediate -w stop >/dev/null 2>&1
+  if [ "$1" = nolock ]; then
+    PG_NOTIFY_NOLOCK=1 pg_ctl -D "$PGDATA" -l "$OUT/ab.pglog" -w start >/dev/null 2>&1
+  else
+    unset PG_NOTIFY_NOLOCK
+    pg_ctl -D "$PGDATA" -l "$OUT/ab.pglog" -w start >/dev/null 2>&1
+  fi
+  psql -U postgres -q -c "alter system set synchronous_commit='on'" -c "select pg_reload_conf()" >/dev/null 2>&1
+}
+
+init() {
+  rm -rf "$PGDATA"
+  initdb -D "$PGDATA" -U postgres --no-sync -A trust >/dev/null 2>&1
+  cat >> "$PGDATA/postgresql.conf" <<EOF
+port = $PORT
+unix_socket_directories = '/tmp'
+listen_addresses = ''
+shared_buffers = 2GB
+max_connections = 1000
+max_wal_size = 16GB
+checkpoint_timeout = 60min
+autovacuum = off
+fsync = on
+synchronous_commit = on
+log_min_messages = warning
+EOF
+  pg_ctl -D "$PGDATA" -l "$OUT/ab.pglog" -w start >/dev/null 2>&1
+  createdb -U postgres bench 2>/dev/null
+  psql -U postgres -q -c "create table t(id bigserial primary key, v int, pad text)" 2>/dev/null
+}
+
+cat > /tmp/ab_control.sql <<'EOF'
+\set c random(1, 1000000)
+BEGIN;
+INSERT INTO t (v, pad) VALUES (:c, 'abcdefghij');
+END;
+EOF
+cat > /tmp/ab_notify.sql <<'EOF'
+\set c random(1, 1000000)
+BEGIN;
+INSERT INTO t (v, pad) VALUES (:c, 'abcdefghij');
+NOTIFY hotchan, 'payload';
+END;
+EOF
+
+# verify the env switch is actually in effect: with the lock, concurrent
+# notifiers must show Lock/object waits; without it, they must not.
+verify_arm() {   # $1 = expected arm
+  ( pgbench -U postgres -n -f /tmp/ab_notify.sql -c 16 -j 4 -T 6 bench >/dev/null 2>&1 ) &
+  local bp=$! n=0
+  sleep 2
+  for i in 1 2 3 4 5; do
+    n=$((n + $(psql -U postgres -tAc "select count(*) from pg_stat_activity where wait_event_type='Lock' and wait_event='object'" 2>/dev/null)))
+    sleep 0.3
+  done
+  wait $bp
+  echo "verify,$1,lock_object_samples,$n" | tee -a "$RES"
+}
+
+run() {   # $1 script, $2 clients, $3 tag, $4 rep
+  local o tps lat
+  o=$(pgbench -U postgres -n -f "$1" -c "$2" -j "$(( $2 > 4 ? 4 : $2 ))" -T "$DUR" bench 2>/dev/null)
+  tps=$(echo "$o" | grep -E '^tps' | head -1 | sed -E 's/tps = ([0-9.]+).*/\1/')
+  lat=$(echo "$o" | grep -E 'latency average' | head -1 | sed -E 's/.*= ([0-9.]+) ms.*/\1/')
+  echo "$3,$2,$4,${tps:-ERR},${lat:-ERR}" | tee -a "$RES"
+}
+
+echo "workload,clients,rep,tps,latency_ms" > "$RES"
+init
+
+# ---- arm 1: stock behaviour (lock present)
+start_server lock
+verify_arm lock
+pgbench -U postgres -n -f /tmp/ab_notify.sql -c 8 -j 4 -T 5 bench >/dev/null 2>&1   # warmup
+for c in $CLIENTS; do
+  for r in $(seq 1 $REPS); do
+    run /tmp/ab_control.sql "$c" control "$r"
+    run /tmp/ab_notify.sql  "$c" notify_lock "$r"
+  done
+done
+
+# ---- arm 2: identical binary, lock skipped
+start_server nolock
+verify_arm nolock
+pgbench -U postgres -n -f /tmp/ab_notify.sql -c 8 -j 4 -T 5 bench >/dev/null 2>&1   # warmup
+for c in $CLIENTS; do
+  for r in $(seq 1 $REPS); do
+    run /tmp/ab_notify.sql "$c" notify_nolock "$r"
+  done
+done
+
+pg_ctl -D "$PGDATA" -m immediate -w stop >/dev/null 2>&1
+echo "DONE ab_lock"
diff --git a/notify-bench/scripts/checkjam.sh b/notify-bench/scripts/checkjam.sh
new file mode 100644
index 0000000000000..25fa6bc2a9367
--- /dev/null
+++ b/notify-bench/scripts/checkjam.sh
@@ -0,0 +1,49 @@
+#!/bin/bash
+# Does a psql listener reading from a FIFO actually drain notifications,
+# or does it jam in ClientWrite once the socket buffer fills?
+set -u
+export PATH=/home/user/pg-master/bin:$PATH
+export PGHOST=/tmp PGPORT=55432 PGDATABASE=bench
+D=/home/pgbench/data-master
+
+pg_ctl -D $D -m immediate -w stop >/dev/null 2>&1
+pg_ctl -D $D -l /home/pgbench/jam.log -w start >/dev/null 2>&1
+psql -U postgres -q -c "create table if not exists t(id bigserial primary key, v int, pad text)" >/dev/null 2>&1
+
+for i in $(seq 1 50); do
+  mkfifo /tmp/jf.$i 2>/dev/null
+  ( psql -U postgres -q -f /tmp/jf.$i >/dev/null 2>&1 ) &
+  ( echo "LISTEN hotchan;"; exec sleep 100000 ) > /tmp/jf.$i &
+done
+sleep 4
+echo "listeners connected: $(psql -U postgres -tAc "select count(*) from pg_stat_activity where backend_type='client backend'")"
+
+cat > /tmp/jam.sql <<'EOF'
+\set c random(1, 1000000)
+BEGIN;
+INSERT INTO t (v, pad) VALUES (:c, 'abcdefghij');
+NOTIFY hotchan, 'payload';
+END;
+EOF
+
+( pgbench -U postgres -n -f /tmp/jam.sql -c 8 -j 4 -T 12 bench >/tmp/jam.out 2>&1 ) &
+bp=$!
+sleep 3
+echo "--- listener backend wait events during sustained notify load ---"
+for s in 1 2 3; do
+  psql -U postgres -tAF'|' -c "
+    select coalesce(wait_event_type,'CPU'), coalesce(wait_event,'-'), state, count(*)
+    from pg_stat_activity
+    where backend_type='client backend' and query like 'LISTEN%'
+    group by 1,2,3 order by 4 desc"
+  sleep 2
+done
+echo "--- queue usage (tail pinned?) ---"
+psql -U postgres -tAc "select pg_notification_queue_usage()"
+wait $bp
+grep -E '^tps' /tmp/jam.out
+
+pkill -u "$(id -un)" psql 2>/dev/null
+pkill -u "$(id -un)" -f "sleep 100000" 2>/dev/null
+rm -f /tmp/jf.* 2>/dev/null
+pg_ctl -D $D -m immediate -w stop >/dev/null 2>&1
diff --git a/notify-bench/scripts/listeners.sh b/notify-bench/scripts/listeners.sh
new file mode 100644
index 0000000000000..a2d4dc3ec0ddd
--- /dev/null
+++ b/notify-bench/scripts/listeners.sh
@@ -0,0 +1,73 @@
+#!/bin/bash
+# Listener-scaling test v2 — hard reset (server restart) between configurations
+# usage: listeners2.sh <PGBIN> <PGDATA> <PORT> <LABEL> <OUTDIR>
+set -u
+PGBIN=$1; PGDATA=$2; PORT=$3; LABEL=$4; OUT=$5
+export PATH=$PGBIN:$PATH
+export PGPORT=$PORT PGHOST=/tmp PGDATABASE=bench
+DUR=${DUR:-8}
+RES=$OUT/$LABEL.listeners2.csv
+
+reset_server() {
+  pkill -u "$(id -un)" psql 2>/dev/null
+  pkill -u "$(id -un)" -f "sleep 100000" 2>/dev/null
+  pg_ctl -D "$PGDATA" -m immediate -w stop >/dev/null 2>&1
+  rm -f /tmp/lfifo.* 2>/dev/null
+  pg_ctl -D "$PGDATA" -l "$OUT/$LABEL.pglog" -w start >/dev/null 2>&1
+  psql -U postgres -q -c "alter system set synchronous_commit='off'" -c "select pg_reload_conf()" >/dev/null 2>&1
+}
+
+start_listeners() {   # $1 = count, $2 = hot|spread
+  local n=$1 mode=$2 ch
+  for i in $(seq 1 "$n"); do
+    if [ "$mode" = hot ]; then ch=hotchan; else ch="idle$i"; fi
+    mkfifo "/tmp/lfifo.$i" 2>/dev/null
+    ( psql -U postgres -q -f "/tmp/lfifo.$i" >/dev/null 2>&1 ) &
+    ( echo "LISTEN $ch;"; exec sleep 100000 ) > "/tmp/lfifo.$i" &
+  done
+  sleep 5
+}
+
+run() {   # $1 script, $2 clients, $3 tag, $4 listeners
+  local live tps
+  live=$(psql -U postgres -tAc "select count(*) from pg_stat_activity where backend_type='client backend'" 2>/dev/null)
+  tps=$(pgbench -U postgres -n -f "$1" -c "$2" -j 4 -T "$DUR" bench 2>/dev/null \
+        | grep -E '^tps' | head -1 | sed -E 's/tps = ([0-9.]+).*/\1/')
+  echo "$LABEL,$3,$4,$live,$2,${tps:-ERR}" | tee -a "$RES"
+}
+
+reset_server
+psql -U postgres -q -c "create table if not exists t(id bigserial primary key, v int, pad text)" >/dev/null 2>&1
+
+cat > /tmp/nr_$LABEL.sql <<'EOF'
+\set c random(1, 1000000)
+\set ch random(1, 1000)
+BEGIN;
+INSERT INTO t (v, pad) VALUES (:c, 'abcdefghij');
+SELECT pg_notify('cold' || :ch, 'payload');
+END;
+EOF
+cat > /tmp/nh_$LABEL.sql <<'EOF'
+\set c random(1, 1000000)
+BEGIN;
+INSERT INTO t (v, pad) VALUES (:c, 'abcdefghij');
+NOTIFY hotchan, 'payload';
+END;
+EOF
+
+echo "label,workload,listeners_requested,sessions_live,clients,tps" > "$RES"
+
+for L in 0 50 200 500; do
+  reset_server
+  [ "$L" -gt 0 ] && start_listeners "$L" spread
+  run /tmp/nr_$LABEL.sql 8 notify_uninterested "$L"
+done
+
+for L in 0 50 200 500; do
+  reset_server
+  [ "$L" -gt 0 ] && start_listeners "$L" hot
+  run /tmp/nh_$LABEL.sql 8 notify_interested "$L"
+done
+
+reset_server
+echo "DONE $LABEL listeners2"
diff --git a/notify-bench/scripts/verify.sh b/notify-bench/scripts/verify.sh
new file mode 100644
index 0000000000000..deaa873751d36
--- /dev/null
+++ b/notify-bench/scripts/verify.sh
@@ -0,0 +1,53 @@
+#!/bin/bash
+# Verify the PG_NOTIFY_NOLOCK switch separates the two arms.
+set -u
+export PATH=/home/user/pg-nolock-inst/bin:$PATH
+export PGHOST=/tmp PGPORT=55434 PGDATABASE=bench
+D=/home/pgbench/data-nolock
+
+rm -rf $D
+initdb -D $D -U postgres --no-sync -A trust >/dev/null 2>&1
+cat >> $D/postgresql.conf <<EOF
+port = 55434
+unix_socket_directories = '/tmp'
+listen_addresses = ''
+shared_buffers = 1GB
+max_connections = 200
+fsync = on
+synchronous_commit = on
+log_min_messages = warning
+EOF
+
+cat > /tmp/vn.sql <<'EOF'
+\set c random(1, 1000000)
+BEGIN;
+INSERT INTO t (v, pad) VALUES (:c, 'abcdefghij');
+NOTIFY hotchan, 'payload';
+END;
+EOF
+
+for arm in lock nolock; do
+  pg_ctl -D $D -m immediate -w stop >/dev/null 2>&1
+  if [ "$arm" = nolock ]; then
+    PG_NOTIFY_NOLOCK=1 pg_ctl -D $D -l /home/pgbench/nolock.log -w start >/dev/null 2>&1
+  else
+    pg_ctl -D $D -l /home/pgbench/nolock.log -w start >/dev/null 2>&1
+  fi
+  createdb -U postgres bench 2>/dev/null
+  psql -U postgres -q -c "create table if not exists t(id bigserial primary key, v int, pad text)" >/dev/null 2>&1
+
+  ( pgbench -U postgres -n -f /tmp/vn.sql -c 16 -j 4 -T 6 bench > /tmp/out.$arm 2>&1 ) &
+  bp=$!
+  sleep 2
+  n=0
+  for i in 1 2 3 4 5; do
+    c=$(psql -U postgres -tAc "select count(*) from pg_stat_activity where wait_event_type = 'Lock' and wait_event = 'object'" 2>/dev/null)
+    c=${c:-0}
+    n=$((n + c))
+    sleep 0.4
+  done
+  wait $bp
+  printf 'ARM=%-7s lock_object_samples=%-4s %s\n' "$arm" "$n" "$(grep -E '^tps' /tmp/out.$arm | head -1)"
+done
+
+pg_ctl -D $D -m immediate -w stop >/dev/null 2>&1
diff --git a/notify-bench/scripts/writers.sh b/notify-bench/scripts/writers.sh
new file mode 100644
index 0000000000000..146c96c637568
--- /dev/null
+++ b/notify-bench/scripts/writers.sh
@@ -0,0 +1,78 @@
+#!/bin/bash
+# Writer-side test: control vs notify with ZERO listeners (isolates the commit lock)
+# usage: writers.sh <PGBIN> <PGDATA> <PORT> <LABEL> <OUTDIR> [initdb]
+set -u
+PGBIN=$1; PGDATA=$2; PORT=$3; LABEL=$4; OUT=$5; DOINIT=${6:-no}
+export PATH=$PGBIN:$PATH
+export PGPORT=$PORT PGHOST=/tmp PGDATABASE=bench
+DUR=${DUR:-8}
+RES=$OUT/$LABEL.writers.csv
+mkdir -p "$OUT"
+
+if [ "$DOINIT" = initdb ]; then
+  rm -rf "$PGDATA"
+  initdb -D "$PGDATA" -U postgres --no-sync -A trust >/dev/null 2>&1
+  cat >> "$PGDATA/postgresql.conf" <<EOF
+port = $PORT
+unix_socket_directories = '/tmp'
+listen_addresses = ''
+shared_buffers = 2GB
+max_connections = 1000
+max_wal_size = 8GB
+checkpoint_timeout = 30min
+autovacuum = off
+fsync = on
+log_min_messages = warning
+EOF
+  pg_ctl -D "$PGDATA" -l "$OUT/$LABEL.pglog" -w start >/dev/null 2>&1
+  createdb -U postgres bench 2>/dev/null
+  psql -U postgres -q -c "create table t(id bigserial primary key, v int, pad text)" 2>/dev/null
+else
+  pg_ctl -D "$PGDATA" status >/dev/null 2>&1 || pg_ctl -D "$PGDATA" -l "$OUT/$LABEL.pglog" -w start >/dev/null 2>&1
+fi
+
+cat > /tmp/c_$LABEL.sql <<'EOF'
+\set c random(1, 1000000)
+BEGIN;
+INSERT INTO t (v, pad) VALUES (:c, 'abcdefghij');
+END;
+EOF
+cat > /tmp/n_$LABEL.sql <<'EOF'
+\set c random(1, 1000000)
+BEGIN;
+INSERT INTO t (v, pad) VALUES (:c, 'abcdefghij');
+NOTIFY hotchan, 'payload';
+END;
+EOF
+
+run() {  # script clients tag sc
+  local tps
+  tps=$(pgbench -U postgres -n -f "$1" -c "$2" -j "$(( $2 > 4 ? 4 : $2 ))" -T "$DUR" bench 2>/dev/null \
+        | grep -E '^tps' | head -1 | sed -E 's/tps = ([0-9.]+).*/\1/')
+  echo "$LABEL,$3,$4,0,$2,${tps:-ERR}" | tee -a "$RES"
+}
+
+echo "label,workload,sync_commit,listeners,clients,tps" > "$RES"
+for sc in on off; do
+  psql -U postgres -q -c "alter system set synchronous_commit='$sc'" -c "select pg_reload_conf()" >/dev/null
+  for c in 1 2 4 8 16 32 64; do
+    run /tmp/c_$LABEL.sql "$c" control "$sc"
+    run /tmp/n_$LABEL.sql "$c" notify  "$sc"
+  done
+done
+
+# wait-event sampling at 32 clients, sync on
+psql -U postgres -q -c "alter system set synchronous_commit='on'" -c "select pg_reload_conf()" >/dev/null
+for pair in "n_$LABEL.sql notify32" "c_$LABEL.sql control32"; do
+  set -- $pair
+  ( pgbench -U postgres -n -f "/tmp/$1" -c 32 -j 4 -T 12 bench >/dev/null 2>&1 ) &
+  bp=$!
+  sleep 2
+  for i in $(seq 1 20); do
+    psql -U postgres -tAF, -c "select '$2', coalesce(wait_event_type,'CPU'), coalesce(wait_event,'-'), count(*) from pg_stat_activity where backend_type='client backend' and pid <> pg_backend_pid() and state='active' group by 1,2,3" >> "$OUT/$LABEL.waits.csv" 2>/dev/null
+    sleep 0.4
+  done
+  wait $bp
+done
+
+echo "DONE $LABEL writers"

From 4bdbe70499a624957ee9cbf9fd5e146c47f40df0 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sat, 25 Jul 2026 06:39:11 +0000
Subject: [PATCH 2/3] notify-bench: exempt stored diffs from the whitespace
 check

Every context line of a unified diff is a space followed by the original
source line, which for this tree means a space followed by a tab.  The
stored instrumentation patch therefore trips "space before tab in
indent" and "trailing whitespace" in git diff --check, which SanityCheck
runs.

Add a directory-local .gitattributes clearing the whitespace attribute
for *.patch, mirroring what the root .gitattributes already does for
other files that legitimately contain special whitespace.  Scoped to
this directory so the upstream root file is untouched.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01M3RLizCyeXBBFJdBHGDvKW
---
 notify-bench/.gitattributes | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 notify-bench/.gitattributes

diff --git a/notify-bench/.gitattributes b/notify-bench/.gitattributes
new file mode 100644
index 0000000000000..d091436cac41a
--- /dev/null
+++ b/notify-bench/.gitattributes
@@ -0,0 +1,5 @@
+# Stored diffs legitimately contain "space before tab" and trailing whitespace:
+# every context line of a unified diff is a space followed by the original
+# (tab-indented) source line. Exempt them, as the root .gitattributes does for
+# other files containing special whitespace.
+*.patch		-whitespace

From 7ec9a7082dfe78670f21be0c670800eeb2567e5f Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sat, 25 Jul 2026 07:30:11 +0000
Subject: [PATCH 3/3] notify-bench: add prototype measurements and scripts

Adds the two prototype arms measured on top of the lock-isolation result:
the v1 shape (heavyweight lock, insertion before ProcArrayEndTransaction)
and the v2 shape (dedicated LWLock, insertion after it), together with
their harness scripts, raw CSVs and the prototype diff.

v2 reaches 16,507 TPS at 64 clients against 1,055 for stock and 16,307
for a NOTIFY-free control, with commit latency falling from 60.7ms to
3.9ms.  v1 reached only 10,965, so the placement and lock choice account
for the remaining ~50%.

The README notes what these runs cannot show: with zero listeners
nothing ever reads the queue, so they cannot detect an ordering defect,
and control cross-run variance at 64 clients is ~10%.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01M3RLizCyeXBBFJdBHGDvKW
---
 notify-bench/README.md                        |  33 ++
 ...PE-move-notify-insertion-past-commit.patch | 294 ++++++++++++++++++
 notify-bench/results/ab_altb2.csv             |  26 ++
 notify-bench/results/ab_altb_v1.csv           |  26 ++
 notify-bench/scripts/ab_altb.sh               | 107 +++++++
 notify-bench/scripts/ab_altb2.sh              | 107 +++++++
 6 files changed, 593 insertions(+)
 create mode 100644 notify-bench/instrumentation/0002-PROTOTYPE-move-notify-insertion-past-commit.patch
 create mode 100644 notify-bench/results/ab_altb2.csv
 create mode 100644 notify-bench/results/ab_altb_v1.csv
 create mode 100644 notify-bench/scripts/ab_altb.sh
 create mode 100644 notify-bench/scripts/ab_altb2.sh

diff --git a/notify-bench/README.md b/notify-bench/README.md
index 298698d6023fe..93984f96e4534 100644
--- a/notify-bench/README.md
+++ b/notify-bench/README.md
@@ -60,6 +60,37 @@ Control queues ~21 backends per in-flight fsync — group commit working. NOTIFY
 **Group-commit batch factor ~21 versus exactly 1.** Throughput ratios on any particular
 disk are a consequence of that; this statement is the portable one.
 
+## Prototypes measured
+
+Two prototypes were built on top of the isolation result above. Both are in
+`instrumentation/`, both are measurement devices rather than patch proposals.
+
+`0002-PROTOTYPE-move-notify-insertion-past-commit.patch` moves the queue insertion out of
+`PreCommit_Notify()` into a new `PostCommitInsert_Notify()` called from
+`CommitTransaction()` after `ProcArrayEndTransaction()`, serialized by a dedicated
+`NotifyQueueInsertLock` LWLock. `synchronous_commit=on`, zero listeners, 3 reps,
+median [min-max]:
+
+| clients | control | stock | v1 (heavyweight lock, pre-ProcArray) | v2 (LWLock, post-ProcArray) | no-lock |
+|--:|--:|--:|--:|--:|--:|
+| 4  | 2,059 | 1,033 | 2,130 | 2,129 [2109-2244] | 2,177 |
+| 16 | 7,811 | 1,027 | 7,767 | 8,155 [7961-8176] | 7,893 |
+| 64 | 16,307 | 1,055 | 10,965 | 16,507 [16402-16695] | 12,369 |
+
+15.7x over stock at 64 clients; commit latency 60.7 ms -> 3.9 ms, matching the
+NOTIFY-free control. Both `Lock`/`object` and `LWLock`/`NotifyQueueInsert` sampled zero
+waiters, so the insert lock is not observably contended.
+
+The v1 column is worth keeping: an earlier iteration that kept the heavyweight lock and
+inserted *before* `ProcArrayEndTransaction()` reached only 10,965 at 64 clients. Moving
+past the ProcArray removal and switching to an LWLock is worth the remaining ~50%, and
+is also what makes the ordering invariant hold trivially instead of by lock tenure.
+
+Caveats specific to these runs: control cross-run variance is ~10% at 64 clients, so the
+"v2 matches control" claim is shape, not precision; and with zero listeners **nothing ever
+reads the queue**, so these runs cannot detect an ordering defect. See #85 for the
+prototype's known gaps.
+
 ## Scripts
 
 All run as an unprivileged user; PostgreSQL refuses to start as root.
@@ -68,6 +99,8 @@ All run as an unprivileged user; PostgreSQL refuses to start as root.
 scripts/writers.sh   <PGBIN> <PGDATA> <PORT> <LABEL> <OUTDIR> [initdb]
 scripts/listeners.sh <PGBIN> <PGDATA> <PORT> <LABEL> <OUTDIR>
 scripts/ab_lock.sh   <PGBIN> <PGDATA> <PORT> <OUTDIR>          # needs instrumented build
+scripts/ab_altb.sh   <PGBIN> <PGDATA> <PORT> <OUTDIR>          # v1 prototype
+scripts/ab_altb2.sh  <PGBIN> <PGDATA> <PORT> <OUTDIR>          # v2 prototype
 scripts/verify.sh                                              # arm-separation smoke test
 scripts/checkjam.sh                                            # demonstrates the defect in D1 below
 ```
diff --git a/notify-bench/instrumentation/0002-PROTOTYPE-move-notify-insertion-past-commit.patch b/notify-bench/instrumentation/0002-PROTOTYPE-move-notify-insertion-past-commit.patch
new file mode 100644
index 0000000000000..6309b6bfbb502
--- /dev/null
+++ b/notify-bench/instrumentation/0002-PROTOTYPE-move-notify-insertion-past-commit.patch
@@ -0,0 +1,294 @@
+diff --git a/src/backend/access/transam/xact.c b/src/backend/access/transam/xact.c
+index 3a891490..b63be24d 100644
+--- a/src/backend/access/transam/xact.c
++++ b/src/backend/access/transam/xact.c
+@@ -2430,6 +2430,26 @@ CommitTransaction(void)
+ 	 */
+ 	ProcArrayEndTransaction(MyProc, latestXid);
+ 
++	/*
++	 * PROTOTYPE ("Alt B"): insert this transaction's notifications into the
++	 * queue now.  This is deliberately *after* ProcArrayEndTransaction():
++	 *
++	 * - The serializing lock is acquired after XLogFlush()/SyncRepWaitForLSN(),
++	 *   so notifying transactions no longer serialize across their own commit
++	 *   round trip and can group-commit with one another.
++	 *
++	 * - We have already left the ProcArray, so a backend queued on the insert
++	 *   lock no longer pins its xid/xmin, and so does not hold back the global
++	 *   horizon or delay the visibility of an already-durable commit.
++	 *
++	 * - Every entry is therefore inserted by a transaction that is already
++	 *   ProcArray-complete.  A listener reads the queue head before taking its
++	 *   snapshot, so it can never observe an entry whose xid is still
++	 *   in-progress: insertion-order == visibility-order holds trivially
++	 *   rather than being derived from how long the lock is held.
++	 */
++	PostCommitInsert_Notify();
++
+ 	/*
+ 	 * This is all post-commit cleanup.  Note that if an error is raised here,
+ 	 * it's too late to abort the transaction.  This should be just
+diff --git a/src/backend/commands/async.c b/src/backend/commands/async.c
+index 2799f989..53340593 100644
+--- a/src/backend/commands/async.c
++++ b/src/backend/commands/async.c
+@@ -1226,9 +1226,6 @@ PreCommit_Notify(void)
+ 	/* Queue any pending notifies (must happen after the above) */
+ 	if (pendingNotifies)
+ 	{
+-		ListCell   *nextNotify;
+-		bool		firstIteration = true;
+-
+ 		/*
+ 		 * Build list of unique channel names being notified for use by
+ 		 * SignalBackends().
+@@ -1291,75 +1288,93 @@ PreCommit_Notify(void)
+ 		(void) GetCurrentTransactionId();
+ 
+ 		/*
+-		 * Serialize writers by acquiring a special lock that we hold till
+-		 * after commit.  This ensures that queue entries appear in commit
+-		 * order, and in particular that there are never uncommitted queue
+-		 * entries ahead of committed ones, so an uncommitted transaction
+-		 * can't block delivery of deliverable notifications.
+-		 *
+-		 * We use a heavyweight lock so that it'll automatically be released
+-		 * after either commit or abort.  This also allows deadlocks to be
+-		 * detected, though really a deadlock shouldn't be possible here.
+-		 *
+-		 * The lock is on "database 0", which is pretty ugly but it doesn't
+-		 * seem worth inventing a special locktag category just for this.
+-		 * (Historical note: before PG 9.0, a similar lock on "database 0" was
+-		 * used by the flatfiles mechanism.)
++		 * PROTOTYPE ("Alt B"): the queue insertion, and the serializing lock
++		 * that used to be taken here, have moved to PostCommitInsert_Notify(),
++		 * which CommitTransaction() calls after RecordTransactionCommit().
++		 * Nothing further to do at pre-commit time.
+ 		 */
+-		LockSharedObject(DatabaseRelationId, InvalidOid, 0,
+-						 AccessExclusiveLock);
++	}
++}
+ 
+-		/*
+-		 * For the direct advancement optimization in SignalBackends(), we
+-		 * need to ensure that no other backend can insert queue entries
+-		 * between queueHeadBeforeWrite and queueHeadAfterWrite.  The
+-		 * heavyweight lock above provides this guarantee, since it serializes
+-		 * all writers.
+-		 *
+-		 * Note: if the heavyweight lock were ever removed for scalability
+-		 * reasons, we could achieve the same guarantee by holding
+-		 * NotifyQueueLock in EXCLUSIVE mode across all our insertions, rather
+-		 * than releasing and reacquiring it for each page as we do below.
+-		 */
++/*
++ * PostCommitInsert_Notify
++ *
++ *		PROTOTYPE -- NOT A PATCH PROPOSAL.  See notify-bench/README.md.
++ *
++ *		Insert this transaction's notifications into the queue, after its
++ *		commit record is durable but before it leaves the ProcArray.
++ *
++ *		The point of moving the insertion to here is that the serializing lock
++ *		is then acquired *after* XLogFlush() and SyncRepWaitForLSN(), so
++ *		notifying transactions no longer serialize across their own commit
++ *		round trip and can group-commit with one another again.
++ *
++ *		The lock is still held from here until end of transaction, so it still
++ *		spans ProcArrayEndTransaction().  That is deliberate and load-bearing:
++ *		the listener's gate is XidInMVCCSnapshot() (see
++ *		asyncQueueProcessPageEntries), so the invariant that must be preserved
++ *		is *queue insertion order == snapshot visibility order*, not commit-LSN
++ *		order.  Holding across the ProcArray removal preserves it exactly, and
++ *		also preserves the precondition that SignalBackends()'s direct-advance
++ *		optimization depends on.
++ *
++ *		KNOWN DEFECT: asyncQueueIsFull() can still ereport(ERROR) here, and we
++ *		are now past the commit point, so that error would be raised for an
++ *		already-committed transaction.  A real patch must reserve quota during
++ *		pre-commit (where failing is safe) and make this path infallible.  The
++ *		benchmark never fills the queue, so this does not affect the numbers.
++ */
++void
++PostCommitInsert_Notify(void)
++{
++	ListCell   *nextNotify;
++	bool		firstIteration = true;
+ 
+-		/* Initialize values to a safe default in case list is empty */
+-		SET_QUEUE_POS(queueHeadBeforeWrite, 0, 0);
+-		SET_QUEUE_POS(queueHeadAfterWrite, 0, 0);
++	if (!pendingNotifies)
++		return;
+ 
+-		/* Now push the notifications into the queue */
+-		nextNotify = list_head(pendingNotifies->events);
+-		while (nextNotify != NULL)
++	/*
++	 * Serialize insertions with a dedicated LWLock rather than the old
++	 * heavyweight lock.  At this point we are past the commit record, so any
++	 * ereport(ERROR) would reach RecordTransactionAbort()'s "cannot abort
++	 * transaction %u, it was already committed" PANIC.  LWLockAcquire()
++	 * allocates nothing, consults no lock table, runs no deadlock detector and
++	 * does not call AcceptInvalidationMessages(), so unlike LockSharedObject()
++	 * it cannot throw.  It is also released by LWLockReleaseAll() during error
++	 * recovery, and is not subject to the uninterruptible-wait problem that a
++	 * heavyweight lock wait has here (we are inside HOLD_INTERRUPTS()).
++	 *
++	 * Lock ordering: NotifyQueueInsertLock is taken before NotifyQueueLock,
++	 * which is taken before the SLRU bank locks.
++	 */
++	LWLockAcquire(NotifyQueueInsertLock, LW_EXCLUSIVE);
++
++	/* Initialize values to a safe default in case list is empty */
++	SET_QUEUE_POS(queueHeadBeforeWrite, 0, 0);
++	SET_QUEUE_POS(queueHeadAfterWrite, 0, 0);
++
++	nextNotify = list_head(pendingNotifies->events);
++	while (nextNotify != NULL)
++	{
++		LWLockAcquire(NotifyQueueLock, LW_EXCLUSIVE);
++		if (firstIteration)
+ 		{
+-			/*
+-			 * Add the pending notifications to the queue.  We acquire and
+-			 * release NotifyQueueLock once per page, which might be overkill
+-			 * but it does allow readers to get in while we're doing this.
+-			 *
+-			 * A full queue is very uncommon and should really not happen,
+-			 * given that we have so much space available in the SLRU pages.
+-			 * Nevertheless we need to deal with this possibility. Note that
+-			 * when we get here we are in the process of committing our
+-			 * transaction, but we have not yet committed to clog, so at this
+-			 * point in time we can still roll the transaction back.
+-			 */
+-			LWLockAcquire(NotifyQueueLock, LW_EXCLUSIVE);
+-			if (firstIteration)
+-			{
+-				queueHeadBeforeWrite = QUEUE_HEAD;
+-				firstIteration = false;
+-			}
+-			asyncQueueFillWarning();
+-			if (asyncQueueIsFull())
+-				ereport(ERROR,
+-						(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+-						 errmsg("too many notifications in the NOTIFY queue")));
+-			nextNotify = asyncQueueAddEntries(nextNotify);
+-			queueHeadAfterWrite = QUEUE_HEAD;
+-			LWLockRelease(NotifyQueueLock);
++			queueHeadBeforeWrite = QUEUE_HEAD;
++			firstIteration = false;
+ 		}
+-
+-		/* Note that we don't clear pendingNotifies; AtCommit_Notify will. */
++		asyncQueueFillWarning();
++		if (asyncQueueIsFull())
++			ereport(ERROR,
++					(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
++					 errmsg("too many notifications in the NOTIFY queue")));
++		nextNotify = asyncQueueAddEntries(nextNotify);
++		queueHeadAfterWrite = QUEUE_HEAD;
++		LWLockRelease(NotifyQueueLock);
+ 	}
++
++	LWLockRelease(NotifyQueueInsertLock);
++
++	/* Note that we don't clear pendingNotifies; AtCommit_Notify will. */
+ }
+ 
+ /*
+diff --git a/src/backend/storage/lmgr/lwlocknames.h.tmp23721 b/src/backend/storage/lmgr/lwlocknames.h.tmp23721
+new file mode 100644
+index 00000000..ff1dfaff
+--- /dev/null
++++ b/src/backend/storage/lmgr/lwlocknames.h.tmp23721
+@@ -0,0 +1,22 @@
++/* autogenerated from src/include/storage/lwlocklist.h, do not edit */
++/* there is deliberately not an #ifndef LWLOCKNAMES_H here */
++
++#define OidGenLock                       (&MainLWLockArray[2].lock)
++#define XidGenLock                       (&MainLWLockArray[3].lock)
++#define ProcArrayLock                    (&MainLWLockArray[4].lock)
++#define SInvalReadLock                   (&MainLWLockArray[5].lock)
++#define SInvalWriteLock                  (&MainLWLockArray[6].lock)
++#define WALBufMappingLock                (&MainLWLockArray[7].lock)
++#define WALWriteLock                     (&MainLWLockArray[8].lock)
++#define ControlFileLock                  (&MainLWLockArray[9].lock)
++#define MultiXactGenLock                 (&MainLWLockArray[13].lock)
++#define RelCacheInitLock                 (&MainLWLockArray[16].lock)
++#define CheckpointerCommLock             (&MainLWLockArray[17].lock)
++#define TwoPhaseStateLock                (&MainLWLockArray[18].lock)
++#define TablespaceCreateLock             (&MainLWLockArray[19].lock)
++#define BtreeVacuumLock                  (&MainLWLockArray[20].lock)
++#define AddinShmemInitLock               (&MainLWLockArray[21].lock)
++#define AutovacuumLock                   (&MainLWLockArray[22].lock)
++#define AutovacuumScheduleLock           (&MainLWLockArray[23].lock)
++#define SyncScanLock                     (&MainLWLockArray[24].lock)
++#define RelationMappingLock              (&MainLWLockArray[25].lock)
+diff --git a/src/backend/storage/lmgr/lwlocknames.h.tmp23748 b/src/backend/storage/lmgr/lwlocknames.h.tmp23748
+new file mode 100644
+index 00000000..ff1dfaff
+--- /dev/null
++++ b/src/backend/storage/lmgr/lwlocknames.h.tmp23748
+@@ -0,0 +1,22 @@
++/* autogenerated from src/include/storage/lwlocklist.h, do not edit */
++/* there is deliberately not an #ifndef LWLOCKNAMES_H here */
++
++#define OidGenLock                       (&MainLWLockArray[2].lock)
++#define XidGenLock                       (&MainLWLockArray[3].lock)
++#define ProcArrayLock                    (&MainLWLockArray[4].lock)
++#define SInvalReadLock                   (&MainLWLockArray[5].lock)
++#define SInvalWriteLock                  (&MainLWLockArray[6].lock)
++#define WALBufMappingLock                (&MainLWLockArray[7].lock)
++#define WALWriteLock                     (&MainLWLockArray[8].lock)
++#define ControlFileLock                  (&MainLWLockArray[9].lock)
++#define MultiXactGenLock                 (&MainLWLockArray[13].lock)
++#define RelCacheInitLock                 (&MainLWLockArray[16].lock)
++#define CheckpointerCommLock             (&MainLWLockArray[17].lock)
++#define TwoPhaseStateLock                (&MainLWLockArray[18].lock)
++#define TablespaceCreateLock             (&MainLWLockArray[19].lock)
++#define BtreeVacuumLock                  (&MainLWLockArray[20].lock)
++#define AddinShmemInitLock               (&MainLWLockArray[21].lock)
++#define AutovacuumLock                   (&MainLWLockArray[22].lock)
++#define AutovacuumScheduleLock           (&MainLWLockArray[23].lock)
++#define SyncScanLock                     (&MainLWLockArray[24].lock)
++#define RelationMappingLock              (&MainLWLockArray[25].lock)
+diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
+index 1016502d..03c0b242 100644
+--- a/src/backend/utils/activity/wait_event_names.txt
++++ b/src/backend/utils/activity/wait_event_names.txt
+@@ -343,6 +343,7 @@ Autovacuum	"Waiting to read or update the current state of autovacuum workers."
+ AutovacuumSchedule	"Waiting to ensure that a table selected for autovacuum still needs vacuuming."
+ SyncScan	"Waiting to select the starting location of a synchronized table scan."
+ RelationMapping	"Waiting to read or update a <filename>pg_filenode.map</filename> file (used to track the filenode assignments of certain system catalogs)."
++NotifyQueueInsert	"Waiting to insert <command>NOTIFY</command> messages into the queue at commit."
+ NotifyQueue	"Waiting to read or update <command>NOTIFY</command> messages."
+ SerializableXactHash	"Waiting to read or update information about serializable transactions."
+ SerializableFinishedList	"Waiting to access the list of finished serializable transactions."
+diff --git a/src/include/commands/async.h b/src/include/commands/async.h
+index 202e4aa5..cdd768c3 100644
+--- a/src/include/commands/async.h
++++ b/src/include/commands/async.h
+@@ -31,6 +31,7 @@ extern void Async_UnlistenAll(void);
+ 
+ /* perform (or cancel) outbound notify processing at transaction commit */
+ extern void PreCommit_Notify(void);
++extern void PostCommitInsert_Notify(void);
+ extern void AtCommit_Notify(void);
+ extern void AtAbort_Notify(void);
+ extern void AtSubCommit_Notify(void);
+diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h
+index d7eb648b..4dadda0a 100644
+--- a/src/include/storage/lwlocklist.h
++++ b/src/include/storage/lwlocklist.h
+@@ -57,7 +57,7 @@ PG_LWLOCK(22, Autovacuum)
+ PG_LWLOCK(23, AutovacuumSchedule)
+ PG_LWLOCK(24, SyncScan)
+ PG_LWLOCK(25, RelationMapping)
+-/* 26 was NotifySLRULock */
++PG_LWLOCK(26, NotifyQueueInsert)
+ PG_LWLOCK(27, NotifyQueue)
+ PG_LWLOCK(28, SerializableXactHash)
+ PG_LWLOCK(29, SerializableFinishedList)
diff --git a/notify-bench/results/ab_altb2.csv b/notify-bench/results/ab_altb2.csv
new file mode 100644
index 0000000000000..adcaf4dcfad1d
--- /dev/null
+++ b/notify-bench/results/ab_altb2.csv
@@ -0,0 +1,26 @@
+workload,clients,rep,tps,latency_ms
+verify,lock,lock_object_samples,0
+control,1,1,770.807990,1.297
+notify_altb2,1,1,724.785642,1.380
+control,1,2,828.115771,1.208
+notify_altb2,1,2,772.310827,1.295
+control,1,3,800.326532,1.249
+notify_altb2,1,3,748.212756,1.337
+control,4,1,2063.004968,1.939
+notify_altb2,4,1,2128.648626,1.879
+control,4,2,2231.139669,1.793
+notify_altb2,4,2,2244.195694,1.782
+control,4,3,2033.189933,1.967
+notify_altb2,4,3,2109.360701,1.896
+control,16,1,8037.406137,1.991
+notify_altb2,16,1,8154.699157,1.962
+control,16,2,7665.778271,2.087
+notify_altb2,16,2,8176.278119,1.957
+control,16,3,8222.530947,1.946
+notify_altb2,16,3,7961.325018,2.010
+control,64,1,18792.329397,3.406
+notify_altb2,64,1,16694.831546,3.834
+control,64,2,17942.866082,3.567
+notify_altb2,64,2,16402.186650,3.902
+control,64,3,17720.444916,3.612
+notify_altb2,64,3,16507.286991,3.877
diff --git a/notify-bench/results/ab_altb_v1.csv b/notify-bench/results/ab_altb_v1.csv
new file mode 100644
index 0000000000000..345a586d64a8f
--- /dev/null
+++ b/notify-bench/results/ab_altb_v1.csv
@@ -0,0 +1,26 @@
+workload,clients,rep,tps,latency_ms
+verify,lock,lock_object_samples,0
+control,1,1,784.805007,1.274
+notify_altb,1,1,780.816888,1.281
+control,1,2,727.123393,1.375
+notify_altb,1,2,700.566904,1.427
+control,1,3,757.047624,1.321
+notify_altb,1,3,780.356149,1.281
+control,4,1,2189.230526,1.827
+notify_altb,4,1,2150.067275,1.860
+control,4,2,2188.374842,1.828
+notify_altb,4,2,2129.757176,1.878
+control,4,3,2033.926108,1.967
+notify_altb,4,3,2022.356793,1.978
+control,16,1,7565.333147,2.115
+notify_altb,16,1,7753.741490,2.064
+control,16,2,6171.097835,2.593
+notify_altb,16,2,7816.310501,2.047
+control,16,3,7970.449902,2.007
+notify_altb,16,3,7766.940551,2.060
+control,64,1,15257.634866,4.195
+notify_altb,64,1,11445.308027,5.592
+control,64,2,15047.548192,4.253
+notify_altb,64,2,10688.442603,5.988
+control,64,3,15657.592086,4.087
+notify_altb,64,3,10964.564136,5.837
diff --git a/notify-bench/scripts/ab_altb.sh b/notify-bench/scripts/ab_altb.sh
new file mode 100644
index 0000000000000..ad95a6404599c
--- /dev/null
+++ b/notify-bench/scripts/ab_altb.sh
@@ -0,0 +1,107 @@
+#!/bin/bash
+# A/B test isolating the NOTIFY commit lock.
+#
+# Same binary throughout. The instrumented build skips
+# LockSharedObject() in PreCommit_Notify() iff PG_NOTIFY_NOLOCK is set in the
+# postmaster environment, so the ONLY difference between the "notify" and
+# "notify_nolock" arms is that one lock. Everything else NOTIFY costs
+# (XID assignment, SLRU writes, extra WAL, signalling) is present in both.
+#
+# NOTE: the nolock arm breaks the commit-order guarantee. It is a measurement
+# device, not a proposed behaviour.
+#
+# usage: ab_lock.sh <PGBIN> <PGDATA> <PORT> <OUTDIR>
+set -u
+PGBIN=$1; PGDATA=$2; PORT=$3; OUT=$4
+export PATH=$PGBIN:$PATH
+export PGPORT=$PORT PGHOST=/tmp PGDATABASE=bench
+DUR=${DUR:-10}
+REPS=${REPS:-3}
+CLIENTS=${CLIENTS:-"1 4 16 64"}
+RES=$OUT/ab_altb.csv
+mkdir -p "$OUT"
+
+start_server() {   # $1 = "lock" | "nolock"
+  pg_ctl -D "$PGDATA" -m immediate -w stop >/dev/null 2>&1
+  if [ "$1" = nolock ]; then
+    PG_NOTIFY_NOLOCK=1 pg_ctl -D "$PGDATA" -l "$OUT/ab.pglog" -w start >/dev/null 2>&1
+  else
+    unset PG_NOTIFY_NOLOCK
+    pg_ctl -D "$PGDATA" -l "$OUT/ab.pglog" -w start >/dev/null 2>&1
+  fi
+  psql -U postgres -q -c "alter system set synchronous_commit='on'" -c "select pg_reload_conf()" >/dev/null 2>&1
+}
+
+init() {
+  rm -rf "$PGDATA"
+  initdb -D "$PGDATA" -U postgres --no-sync -A trust >/dev/null 2>&1
+  cat >> "$PGDATA/postgresql.conf" <<EOF
+port = $PORT
+unix_socket_directories = '/tmp'
+listen_addresses = ''
+shared_buffers = 2GB
+max_connections = 1000
+max_wal_size = 16GB
+checkpoint_timeout = 60min
+autovacuum = off
+fsync = on
+synchronous_commit = on
+log_min_messages = warning
+EOF
+  pg_ctl -D "$PGDATA" -l "$OUT/ab.pglog" -w start >/dev/null 2>&1
+  createdb -U postgres bench 2>/dev/null
+  psql -U postgres -q -c "create table t(id bigserial primary key, v int, pad text)" 2>/dev/null
+}
+
+cat > /tmp/ab_control.sql <<'EOF'
+\set c random(1, 1000000)
+BEGIN;
+INSERT INTO t (v, pad) VALUES (:c, 'abcdefghij');
+END;
+EOF
+cat > /tmp/ab_notify.sql <<'EOF'
+\set c random(1, 1000000)
+BEGIN;
+INSERT INTO t (v, pad) VALUES (:c, 'abcdefghij');
+NOTIFY hotchan, 'payload';
+END;
+EOF
+
+# verify the env switch is actually in effect: with the lock, concurrent
+# notifiers must show Lock/object waits; without it, they must not.
+verify_arm() {   # $1 = expected arm
+  ( pgbench -U postgres -n -f /tmp/ab_notify.sql -c 16 -j 4 -T 6 bench >/dev/null 2>&1 ) &
+  local bp=$! n=0
+  sleep 2
+  for i in 1 2 3 4 5; do
+    n=$((n + $(psql -U postgres -tAc "select count(*) from pg_stat_activity where wait_event_type='Lock' and wait_event='object'" 2>/dev/null)))
+    sleep 0.3
+  done
+  wait $bp
+  echo "verify,$1,lock_object_samples,$n" | tee -a "$RES"
+}
+
+run() {   # $1 script, $2 clients, $3 tag, $4 rep
+  local o tps lat
+  o=$(pgbench -U postgres -n -f "$1" -c "$2" -j "$(( $2 > 4 ? 4 : $2 ))" -T "$DUR" bench 2>/dev/null)
+  tps=$(echo "$o" | grep -E '^tps' | head -1 | sed -E 's/tps = ([0-9.]+).*/\1/')
+  lat=$(echo "$o" | grep -E 'latency average' | head -1 | sed -E 's/.*= ([0-9.]+) ms.*/\1/')
+  echo "$3,$2,$4,${tps:-ERR},${lat:-ERR}" | tee -a "$RES"
+}
+
+echo "workload,clients,rep,tps,latency_ms" > "$RES"
+init
+
+# ---- arm 1: stock behaviour (lock present)
+start_server lock
+verify_arm lock
+pgbench -U postgres -n -f /tmp/ab_notify.sql -c 8 -j 4 -T 5 bench >/dev/null 2>&1   # warmup
+for c in $CLIENTS; do
+  for r in $(seq 1 $REPS); do
+    run /tmp/ab_control.sql "$c" control "$r"
+    run /tmp/ab_notify.sql  "$c" notify_altb "$r"
+  done
+done
+
+pg_ctl -D "$PGDATA" -m immediate -w stop >/dev/null 2>&1
+echo "DONE ab_altb"
diff --git a/notify-bench/scripts/ab_altb2.sh b/notify-bench/scripts/ab_altb2.sh
new file mode 100644
index 0000000000000..861ac2c2a47b9
--- /dev/null
+++ b/notify-bench/scripts/ab_altb2.sh
@@ -0,0 +1,107 @@
+#!/bin/bash
+# A/B test isolating the NOTIFY commit lock.
+#
+# Same binary throughout. The instrumented build skips
+# LockSharedObject() in PreCommit_Notify() iff PG_NOTIFY_NOLOCK is set in the
+# postmaster environment, so the ONLY difference between the "notify" and
+# "notify_nolock" arms is that one lock. Everything else NOTIFY costs
+# (XID assignment, SLRU writes, extra WAL, signalling) is present in both.
+#
+# NOTE: the nolock arm breaks the commit-order guarantee. It is a measurement
+# device, not a proposed behaviour.
+#
+# usage: ab_lock.sh <PGBIN> <PGDATA> <PORT> <OUTDIR>
+set -u
+PGBIN=$1; PGDATA=$2; PORT=$3; OUT=$4
+export PATH=$PGBIN:$PATH
+export PGPORT=$PORT PGHOST=/tmp PGDATABASE=bench
+DUR=${DUR:-10}
+REPS=${REPS:-3}
+CLIENTS=${CLIENTS:-"1 4 16 64"}
+RES=$OUT/ab_altb2.csv
+mkdir -p "$OUT"
+
+start_server() {   # $1 = "lock" | "nolock"
+  pg_ctl -D "$PGDATA" -m immediate -w stop >/dev/null 2>&1
+  if [ "$1" = nolock ]; then
+    PG_NOTIFY_NOLOCK=1 pg_ctl -D "$PGDATA" -l "$OUT/ab.pglog" -w start >/dev/null 2>&1
+  else
+    unset PG_NOTIFY_NOLOCK
+    pg_ctl -D "$PGDATA" -l "$OUT/ab.pglog" -w start >/dev/null 2>&1
+  fi
+  psql -U postgres -q -c "alter system set synchronous_commit='on'" -c "select pg_reload_conf()" >/dev/null 2>&1
+}
+
+init() {
+  rm -rf "$PGDATA"
+  initdb -D "$PGDATA" -U postgres --no-sync -A trust >/dev/null 2>&1
+  cat >> "$PGDATA/postgresql.conf" <<EOF
+port = $PORT
+unix_socket_directories = '/tmp'
+listen_addresses = ''
+shared_buffers = 2GB
+max_connections = 1000
+max_wal_size = 16GB
+checkpoint_timeout = 60min
+autovacuum = off
+fsync = on
+synchronous_commit = on
+log_min_messages = warning
+EOF
+  pg_ctl -D "$PGDATA" -l "$OUT/ab.pglog" -w start >/dev/null 2>&1
+  createdb -U postgres bench 2>/dev/null
+  psql -U postgres -q -c "create table t(id bigserial primary key, v int, pad text)" 2>/dev/null
+}
+
+cat > /tmp/ab_control.sql <<'EOF'
+\set c random(1, 1000000)
+BEGIN;
+INSERT INTO t (v, pad) VALUES (:c, 'abcdefghij');
+END;
+EOF
+cat > /tmp/ab_notify.sql <<'EOF'
+\set c random(1, 1000000)
+BEGIN;
+INSERT INTO t (v, pad) VALUES (:c, 'abcdefghij');
+NOTIFY hotchan, 'payload';
+END;
+EOF
+
+# verify the env switch is actually in effect: with the lock, concurrent
+# notifiers must show Lock/object waits; without it, they must not.
+verify_arm() {   # $1 = expected arm
+  ( pgbench -U postgres -n -f /tmp/ab_notify.sql -c 16 -j 4 -T 6 bench >/dev/null 2>&1 ) &
+  local bp=$! n=0
+  sleep 2
+  for i in 1 2 3 4 5; do
+    n=$((n + $(psql -U postgres -tAc "select count(*) from pg_stat_activity where (wait_event_type='Lock' and wait_event='object') or wait_event='NotifyQueueInsert'" 2>/dev/null)))
+    sleep 0.3
+  done
+  wait $bp
+  echo "verify,$1,lock_object_samples,$n" | tee -a "$RES"
+}
+
+run() {   # $1 script, $2 clients, $3 tag, $4 rep
+  local o tps lat
+  o=$(pgbench -U postgres -n -f "$1" -c "$2" -j "$(( $2 > 4 ? 4 : $2 ))" -T "$DUR" bench 2>/dev/null)
+  tps=$(echo "$o" | grep -E '^tps' | head -1 | sed -E 's/tps = ([0-9.]+).*/\1/')
+  lat=$(echo "$o" | grep -E 'latency average' | head -1 | sed -E 's/.*= ([0-9.]+) ms.*/\1/')
+  echo "$3,$2,$4,${tps:-ERR},${lat:-ERR}" | tee -a "$RES"
+}
+
+echo "workload,clients,rep,tps,latency_ms" > "$RES"
+init
+
+# ---- arm 1: stock behaviour (lock present)
+start_server lock
+verify_arm lock
+pgbench -U postgres -n -f /tmp/ab_notify.sql -c 8 -j 4 -T 5 bench >/dev/null 2>&1   # warmup
+for c in $CLIENTS; do
+  for r in $(seq 1 $REPS); do
+    run /tmp/ab_control.sql "$c" control "$r"
+    run /tmp/ab_notify.sql  "$c" notify_altb2 "$r"
+  done
+done
+
+pg_ctl -D "$PGDATA" -m immediate -w stop >/dev/null 2>&1
+echo "DONE ab_altb2"