From 1bb0bdd4e1337fe95b34bedaac255285144a3329 Mon Sep 17 00:00:00 2001 From: Melanie Plageman Date: Sun, 7 Jan 2024 14:50:12 -0500 Subject: [PATCH v3 06/17] lazy_scan_prune reorder freeze execution logic To combine the prune and freeze records, freezing must be done before a pruning WAL record is emitted. We will move the freeze execution into heap_page_prune() in future commits. lazy_scan_prune() currently executes freezing, updates vacrel->NewRelfrozenXid and vacrel->NewRelminMxid, and resets the snapshotConflictHorizon that the visibility map update record may use in the same block of if statements. This commit starts reordering that logic so that the freeze execution can be separated from the other updates which should not be done in pruning. It also adds a helper calculating freeze snapshot conflict horizon. This will be useful when the freeze execution is moved into pruning because not all callers of heap_page_prune() have access to VacuumCutoffs. --- src/backend/access/heap/vacuumlazy.c | 112 ++++++++++++++++----------- 1 file changed, 67 insertions(+), 45 deletions(-) diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c index 4187c998d25..abbb7ab3ada 100644 --- a/src/backend/access/heap/vacuumlazy.c +++ b/src/backend/access/heap/vacuumlazy.c @@ -269,6 +269,8 @@ static void update_vacuum_error_info(LVRelState *vacrel, static void restore_vacuum_error_info(LVRelState *vacrel, const LVSavedErrInfo *saved_vacrel); +static TransactionId heap_frz_conflict_horizon(PruneResult *presult, + HeapPageFreeze *pagefrz); /* * heap_vacuum_rel() -- perform VACUUM for one heap relation @@ -1373,6 +1375,33 @@ lazy_scan_new_or_empty(LVRelState *vacrel, Buffer buf, BlockNumber blkno, return false; } +/* + * Determine the snapshotConflictHorizon for freezing. Must only be called + * after pruning and determining if the page is freezable. + */ +static TransactionId +heap_frz_conflict_horizon(PruneResult *presult, HeapPageFreeze *pagefrz) +{ + TransactionId result; + + /* + * We can use frz_conflict_horizon 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 (presult->all_visible_except_removable && presult->all_frozen) + result = presult->frz_conflict_horizon; + else + { + /* Avoids false conflicts when hot_standby_feedback in use */ + result = pagefrz->cutoffs->OldestXmin; + TransactionIdRetreat(result); + } + + return result; +} + /* * lazy_scan_prune() -- lazy_scan_heap() pruning and freezing. * @@ -1421,6 +1450,7 @@ lazy_scan_prune(LVRelState *vacrel, recently_dead_tuples; HeapPageFreeze pagefrz; bool hastup = false; + bool do_freeze; int64 fpi_before = pgWalUsage.wal_fpi; OffsetNumber deadoffsets[MaxHeapTuplesPerPage]; @@ -1580,10 +1610,15 @@ lazy_scan_prune(LVRelState *vacrel, * freeze when pruning generated an FPI, if doing so means that we set the * page all-frozen afterwards (might not happen until final heap pass). */ - if (pagefrz.freeze_required || presult.nfrozen == 0 || + do_freeze = pagefrz.freeze_required || (presult.all_visible_except_removable && presult.all_frozen && - fpi_before != pgWalUsage.wal_fpi)) + presult.nfrozen > 0 && + fpi_before != pgWalUsage.wal_fpi); + + if (do_freeze) { + TransactionId snapshotConflictHorizon; + /* * We're freezing the page. Our final NewRelfrozenXid doesn't need to * be affected by the XIDs that are just about to be frozen anyway. @@ -1591,52 +1626,39 @@ lazy_scan_prune(LVRelState *vacrel, vacrel->NewRelfrozenXid = pagefrz.FreezePageRelfrozenXid; vacrel->NewRelminMxid = pagefrz.FreezePageRelminMxid; - if (presult.nfrozen == 0) - { - /* - * We have no freeze plans to execute, so there's no added cost - * from following the freeze path. That's why it was chosen. This - * is important in the case where the page only contains totally - * frozen tuples at this point (perhaps only following pruning). - * Such pages can be marked all-frozen in the VM by our caller, - * even though none of its tuples were newly frozen here (note - * that the "no freeze" path never sets pages all-frozen). - * - * We never increment the frozen_pages instrumentation counter - * here, since it only counts pages with newly frozen tuples - * (don't confuse that with pages newly set all-frozen in VM). - */ - } - else - { - TransactionId snapshotConflictHorizon; + vacrel->frozen_pages++; - vacrel->frozen_pages++; + snapshotConflictHorizon = heap_frz_conflict_horizon(&presult, &pagefrz); - /* - * We can use frz_conflict_horizon 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 (presult.all_visible_except_removable && presult.all_frozen) - { - /* Using same cutoff when setting VM is now unnecessary */ - snapshotConflictHorizon = presult.frz_conflict_horizon; - presult.frz_conflict_horizon = InvalidTransactionId; - } - else - { - /* Avoids false conflicts when hot_standby_feedback in use */ - snapshotConflictHorizon = vacrel->cutoffs.OldestXmin; - TransactionIdRetreat(snapshotConflictHorizon); - } + /* Using same cutoff when setting VM is now unnecessary */ + if (presult.all_visible_except_removable && presult.all_frozen) + presult.frz_conflict_horizon = InvalidTransactionId; - /* Execute all freeze plans for page as a single atomic action */ - heap_freeze_execute_prepared(vacrel->rel, buf, - snapshotConflictHorizon, - presult.frozen, presult.nfrozen); - } + /* Execute all freeze plans for page as a single atomic action */ + heap_freeze_execute_prepared(vacrel->rel, buf, + snapshotConflictHorizon, + presult.frozen, presult.nfrozen); + } + else if (presult.all_frozen && presult.nfrozen == 0) + { + /* Page should be all visible except to-be-removed tuples */ + Assert(presult.all_visible_except_removable); + + /* + * We have no freeze plans to execute, so there's no added cost from + * following the freeze path. That's why it was chosen. This is + * important in the case where the page only contains totally frozen + * tuples at this point (perhaps only following pruning). Such pages + * can be marked all-frozen in the VM by our caller, even though none + * of its tuples were newly frozen here (note that the "no freeze" + * path never sets pages all-frozen). + * + * We never increment the frozen_pages instrumentation counter here, + * since it only counts pages with newly frozen tuples (don't confuse + * that with pages newly set all-frozen in VM). + */ + vacrel->NewRelfrozenXid = pagefrz.FreezePageRelfrozenXid; + vacrel->NewRelminMxid = pagefrz.FreezePageRelminMxid; } else { -- 2.40.1