From a3b91ab430e7af8b459c169181c1dc3f0f04c8bf Mon Sep 17 00:00:00 2001 From: Melanie Plageman Date: Wed, 25 Feb 2026 13:55:45 -0500 Subject: [PATCH v35 04/18] Use the newest to-be-frozen xid as the conflict horizon for freezing Previously WAL records that froze tuples used OldestXmin as the snapshot conflict horizon. However, OldestXmin is newer than the newest frozen tuple's xid. By tracking the newest to-be-frozen xid and using it as the snapshot conflict horizon instead, we end up with an older horizon that will result in fewer query cancellations on the standby. --- src/backend/access/heap/heapam.c | 16 +++++++++++ src/backend/access/heap/pruneheap.c | 44 ++++++++--------------------- src/include/access/heapam.h | 8 ++++++ 3 files changed, 36 insertions(+), 32 deletions(-) diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c index a231563f0df..76f94fdfa5b 100644 --- a/src/backend/access/heap/heapam.c +++ b/src/backend/access/heap/heapam.c @@ -6781,6 +6781,10 @@ heap_inplace_unlock(Relation relation, * NB: Caller should avoid needlessly calling heap_tuple_should_freeze when we * have already forced page-level freezing, since that might incur the same * SLRU buffer misses that we specifically intended to avoid by freezing. + * + * We won't update the FreezePageConflictXid because any lockers don't affect + * visibility on the standby, and we don't have to worry about the update XID + * because the only way it can be older than OldestXmin is if it aborted. */ static TransactionId FreezeMultiXactId(MultiXactId multi, uint16 t_infomask, @@ -7173,7 +7177,11 @@ heap_prepare_freeze_tuple(HeapTupleHeader tuple, /* Verify that xmin committed if and when freeze plan is executed */ if (freeze_xmin) + { frz->checkflags |= HEAP_FREEZE_CHECK_XMIN_COMMITTED; + if (TransactionIdFollows(xid, pagefrz->FreezePageConflictXid)) + pagefrz->FreezePageConflictXid = xid; + } } /* @@ -7192,6 +7200,9 @@ heap_prepare_freeze_tuple(HeapTupleHeader tuple, */ replace_xvac = pagefrz->freeze_required = true; + if (TransactionIdFollows(xid, pagefrz->FreezePageConflictXid)) + pagefrz->FreezePageConflictXid = xid; + /* Will set replace_xvac flags in freeze plan below */ } @@ -7316,7 +7327,11 @@ heap_prepare_freeze_tuple(HeapTupleHeader tuple, * independent of this, since the lock is released at xact end.) */ if (freeze_xmax && !HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask)) + { frz->checkflags |= HEAP_FREEZE_CHECK_XMAX_ABORTED; + if (TransactionIdFollows(xid, pagefrz->FreezePageConflictXid)) + pagefrz->FreezePageConflictXid = xid; + } } else if (!TransactionIdIsValid(xid)) { @@ -7499,6 +7514,7 @@ heap_freeze_tuple(HeapTupleHeader tuple, cutoffs.MultiXactCutoff = MultiXactCutoff; pagefrz.freeze_required = true; + pagefrz.FreezePageConflictXid = InvalidTransactionId; pagefrz.FreezePageRelfrozenXid = FreezeLimit; pagefrz.FreezePageRelminMxid = MultiXactCutoff; pagefrz.NoFreezePageRelfrozenXid = FreezeLimit; diff --git a/src/backend/access/heap/pruneheap.c b/src/backend/access/heap/pruneheap.c index fa5aa2a63f2..07868dbcc17 100644 --- a/src/backend/access/heap/pruneheap.c +++ b/src/backend/access/heap/pruneheap.c @@ -114,13 +114,6 @@ typedef struct */ HeapPageFreeze pagefrz; - /* - * The snapshot conflict horizon used when freezing tuples. The final - * snapshot conflict horizon for the record may be newer if pruning - * removes newer transaction IDs. - */ - TransactionId frz_conflict_horizon; - /*------------------------------------------------------- * Information about what was done * @@ -377,6 +370,7 @@ prune_freeze_setup(PruneFreezeParams *params, /* initialize page freezing working state */ prstate->pagefrz.freeze_required = false; + prstate->pagefrz.FreezePageConflictXid = InvalidTransactionId; if (prstate->attempt_freeze) { Assert(new_relfrozen_xid && new_relmin_mxid); @@ -407,7 +401,6 @@ prune_freeze_setup(PruneFreezeParams *params, * PruneState. */ prstate->deadoffsets = presult->deadoffsets; - prstate->frz_conflict_horizon = InvalidTransactionId; /* * Vacuum may update the VM after we're done. We can keep track of @@ -746,22 +739,8 @@ heap_page_will_freeze(bool did_tuple_hint_fpi, * critical section. */ heap_pre_freeze_checks(prstate->buffer, prstate->frozen, prstate->nfrozen); - - /* - * Calculate what the snapshot conflict horizon should be for a record - * freezing tuples. We can use the visibility_cutoff_xid as our cutoff - * for conflicts when the whole page is eligible to become all-frozen - * in the VM once we're done with it. Otherwise, we generate a - * conservative cutoff by stepping back from OldestXmin. - */ - if (prstate->set_all_frozen) - prstate->frz_conflict_horizon = prstate->visibility_cutoff_xid; - else - { - /* Avoids false conflicts when hot_standby_feedback in use */ - prstate->frz_conflict_horizon = prstate->cutoffs->OldestXmin; - TransactionIdRetreat(prstate->frz_conflict_horizon); - } + Assert(TransactionIdPrecedesOrEquals(prstate->pagefrz.FreezePageConflictXid, + prstate->cutoffs->OldestXmin)); } else if (prstate->nfrozen > 0) { @@ -886,11 +865,12 @@ heap_page_prune_and_freeze(PruneFreezeParams *params, /* * While scanning the line pointers, we did not clear * set_all_visible/set_all_frozen when encountering LP_DEAD items because - * we wanted the decision whether or not to freeze the page to be - * unaffected by the short-term presence of LP_DEAD items. These LP_DEAD - * items are effectively assumed to be LP_UNUSED items in the making. It - * doesn't matter which vacuum heap pass (initial pass or final pass) ends - * up setting the page all-frozen, as long as the ongoing VACUUM does it. + * we wanted the decision whether or not to opportunistically freeze the + * page to be unaffected by the short-term presence of LP_DEAD items. + * These LP_DEAD items are effectively assumed to be LP_UNUSED items in + * the making. It doesn't matter which vacuum heap pass (initial pass or + * final pass) ends up setting the page all-frozen, as long as the ongoing + * VACUUM does it. * * Now that we finished determining whether or not to freeze the page, * update set_all_visible and set_all_frozen so that they reflect the true @@ -953,7 +933,7 @@ heap_page_prune_and_freeze(PruneFreezeParams *params, * The snapshotConflictHorizon for the whole record should be the * most conservative of all the horizons calculated for any of the * possible modifications. If this record will prune tuples, any - * transactions on the standby older than the youngest xmax of the + * transactions on the standby older than the youngest xid of the * most recently removed tuple this record will prune will * conflict. If this record will freeze tuples, any transactions * on the standby with xids older than the youngest tuple this @@ -961,9 +941,9 @@ heap_page_prune_and_freeze(PruneFreezeParams *params, */ TransactionId conflict_xid; - if (TransactionIdFollows(prstate.frz_conflict_horizon, + if (TransactionIdFollows(prstate.pagefrz.FreezePageConflictXid, prstate.latest_xid_removed)) - conflict_xid = prstate.frz_conflict_horizon; + conflict_xid = prstate.pagefrz.FreezePageConflictXid; else conflict_xid = prstate.latest_xid_removed; diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h index 3c0961ab36b..fae79b37f0d 100644 --- a/src/include/access/heapam.h +++ b/src/include/access/heapam.h @@ -208,6 +208,14 @@ typedef struct HeapPageFreeze TransactionId FreezePageRelfrozenXid; MultiXactId FreezePageRelminMxid; + /* + * The youngest XID that will be frozen or removed during freezing. It is + * used to calculate the snapshot conflict horizon for a WAL record + * freezing tuples. Because it is only used if we do end up freezing + * tuples, there is no need for a "no freeze" version. + */ + TransactionId FreezePageConflictXid; + /* * "No freeze" NewRelfrozenXid/NewRelminMxid trackers. * -- 2.43.0