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
diff --git a/notify-bench/README.md b/notify-bench/README.md
new file mode 100644
index 0000000000000..93984f96e4534
--- /dev/null
+++ b/notify-bench/README.md
@@ -0,0 +1,172 @@
+# 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.
+
+## 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.
+
+```
+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
+```
+
+`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/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/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_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"
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"