agora inbox for pgsql-hackers@postgresql.orghelp / color / mirror / Atom feed
[PATCH v3 05/17] Prepare freeze tuples in heap_page_prune() 11+ messages / 1 participants [nested] [flat]
* [PATCH v3 05/17] Prepare freeze tuples in heap_page_prune() @ 2024-01-07 16:18 Melanie Plageman <melanieplageman@gmail.com> 0 siblings, 0 replies; 11+ messages in thread From: Melanie Plageman @ 2024-01-07 16:18 UTC (permalink / raw) In order to combine the freeze and prune records, we must determine which tuples are freezable before actually executing pruning. All of the page modifications should be made in the same critical section along with emitting the combined WAL. Determine whether or not tuples should or must be frozen and whether or not the page will be all frozen as a consequence during pruning. --- src/backend/access/heap/pruneheap.c | 78 ++++++++++++++++++++++++++-- src/backend/access/heap/vacuumlazy.c | 68 ++++++------------------ src/include/access/heapam.h | 12 +++++ 3 files changed, 101 insertions(+), 57 deletions(-) diff --git a/src/backend/access/heap/pruneheap.c b/src/backend/access/heap/pruneheap.c index 42fd4a74845..6bd8400b33b 100644 --- a/src/backend/access/heap/pruneheap.c +++ b/src/backend/access/heap/pruneheap.c @@ -62,6 +62,9 @@ static HTSV_Result heap_prune_satisfies_vacuum(PruneState *prstate, static int heap_prune_chain(Buffer buffer, OffsetNumber rootoffnum, PruneState *prstate, PruneResult *presult); + +static void prune_prepare_freeze_tuple(Page page, OffsetNumber offnum, + HeapPageFreeze *pagefrz, PruneResult *presult); static void heap_prune_record_prunable(PruneState *prstate, TransactionId xid); static void heap_prune_record_redirect(PruneState *prstate, OffsetNumber offnum, OffsetNumber rdoffnum); @@ -155,7 +158,7 @@ heap_page_prune_opt(Relation relation, Buffer buffer) * not the relation has indexes, since we cannot safely determine * that during on-access pruning with the current implementation. */ - heap_page_prune(relation, buffer, vistest, false, + heap_page_prune(relation, buffer, vistest, false, NULL, &presult, NULL); /* @@ -218,6 +221,9 @@ prune_freeze_xmin_is_removable(GlobalVisState *visstate, TransactionId xmin) * mark_unused_now indicates whether or not dead items can be set LP_UNUSED during * pruning. * + * pagefrz contains both input and output parameters used if the caller is + * interested in potentially freezing tuples on the page. + * * off_loc is the offset location required by the caller to use in error * callback. * @@ -229,6 +235,7 @@ void heap_page_prune(Relation relation, Buffer buffer, GlobalVisState *vistest, bool mark_unused_now, + HeapPageFreeze *pagefrz, PruneResult *presult, OffsetNumber *off_loc) { @@ -264,6 +271,7 @@ heap_page_prune(Relation relation, Buffer buffer, */ presult->ndeleted = 0; presult->nnewlpdead = 0; + presult->nfrozen = 0; /* * Keep track of whether or not the page is all_visible in case the caller @@ -410,6 +418,15 @@ heap_page_prune(Relation relation, Buffer buffer, */ presult->all_visible_except_removable = presult->all_visible; + /* + * We will update the VM after pruning, collecting LP_DEAD items, and + * freezing tuples. Keep track of whether or not the page is all_visible + * and all_frozen and use this information to update the VM. all_visible + * implies lpdead_items == 0, but don't trust all_frozen result unless + * all_visible is also set to true. + */ + presult->all_frozen = true; + /* Scan the page */ for (offnum = FirstOffsetNumber; offnum <= maxoff; @@ -417,14 +434,18 @@ heap_page_prune(Relation relation, Buffer buffer, { ItemId itemid; - /* Ignore items already processed as part of an earlier chain */ - if (prstate.marked[offnum]) - continue; - /* see preceding loop */ if (off_loc) *off_loc = offnum; + if (pagefrz) + prune_prepare_freeze_tuple(page, offnum, + pagefrz, presult); + + /* Ignore items already processed as part of an earlier chain */ + if (prstate.marked[offnum]) + continue; + /* Nothing to do if slot is empty */ itemid = PageGetItemId(page, offnum); if (!ItemIdIsUsed(itemid)) @@ -867,6 +888,53 @@ heap_prune_chain(Buffer buffer, OffsetNumber rootoffnum, return ndeleted; } +/* + * While pruning, before actually executing pruning and updating the line + * pointers, we may consider freezing tuples referred to by LP_NORMAL line + * pointers whose visibility status is not HEAPTUPLE_DEAD. That is to say, we + * want to consider freezing normal tuples which will not be removed. +*/ +static void +prune_prepare_freeze_tuple(Page page, OffsetNumber offnum, + HeapPageFreeze *pagefrz, + PruneResult *presult) +{ + bool totally_frozen; + HeapTupleHeader htup; + ItemId itemid; + + Assert(pagefrz); + + itemid = PageGetItemId(page, offnum); + + if (!ItemIdIsNormal(itemid)) + return; + + /* We do not consider freezing tuples which will be removed. */ + if (presult->htsv[offnum] == HEAPTUPLE_DEAD || + presult->htsv[offnum] == -1) + return; + + htup = (HeapTupleHeader) PageGetItem(page, itemid); + + /* Tuple with storage -- consider need to freeze */ + if ((heap_prepare_freeze_tuple(htup, pagefrz, + &presult->frozen[presult->nfrozen], + &totally_frozen))) + { + /* Save prepared freeze plan for later */ + presult->frozen[presult->nfrozen++].offset = offnum; + } + + /* + * If any tuple isn't either totally frozen already or eligible to become + * totally frozen (according to its freeze plan), then the page definitely + * cannot be set all-frozen in the visibility map later on + */ + if (!totally_frozen) + presult->all_frozen = false; +} + /* Record lowest soon-prunable XID */ static void heap_prune_record_prunable(PruneState *prstate, TransactionId xid) diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c index 06e0e841582..4187c998d25 100644 --- a/src/backend/access/heap/vacuumlazy.c +++ b/src/backend/access/heap/vacuumlazy.c @@ -1416,16 +1416,13 @@ lazy_scan_prune(LVRelState *vacrel, maxoff; ItemId itemid; PruneResult presult; - int tuples_frozen, - lpdead_items, + int lpdead_items, live_tuples, recently_dead_tuples; HeapPageFreeze pagefrz; bool hastup = false; - bool all_frozen; int64 fpi_before = pgWalUsage.wal_fpi; OffsetNumber deadoffsets[MaxHeapTuplesPerPage]; - HeapTupleFreeze frozen[MaxHeapTuplesPerPage]; Assert(BufferGetBlockNumber(buf) == blkno); @@ -1443,7 +1440,6 @@ lazy_scan_prune(LVRelState *vacrel, pagefrz.NoFreezePageRelfrozenXid = vacrel->NewRelfrozenXid; pagefrz.NoFreezePageRelminMxid = vacrel->NewRelminMxid; pagefrz.cutoffs = &vacrel->cutoffs; - tuples_frozen = 0; lpdead_items = 0; live_tuples = 0; recently_dead_tuples = 0; @@ -1461,31 +1457,20 @@ lazy_scan_prune(LVRelState *vacrel, * false otherwise. */ heap_page_prune(rel, buf, vacrel->vistest, vacrel->nindexes == 0, - &presult, &vacrel->offnum); + &pagefrz, &presult, &vacrel->offnum); /* * Now scan the page to collect LP_DEAD items and check for tuples * requiring freezing among remaining tuples with storage. We will update * the VM after collecting LP_DEAD items and freezing tuples. Pruning will - * have determined whether or not the page is all_visible. Keep track of - * whether or not the page is all_frozen and use this information to - * update the VM. all_visible implies lpdead_items == 0, but don't trust - * all_frozen result unless all_visible is also set to true. + * have determined whether or not the page is all_visible and able to + * become all_frozen. * */ - all_frozen = true; - - /* - * Now scan the page to collect LP_DEAD items and update the variables set - * just above. - */ for (offnum = FirstOffsetNumber; offnum <= maxoff; offnum = OffsetNumberNext(offnum)) { - HeapTupleHeader htup; - bool totally_frozen; - /* * Set the offset number so that we can display it along with any * error that occurred while processing this tuple. @@ -1521,8 +1506,6 @@ lazy_scan_prune(LVRelState *vacrel, Assert(ItemIdIsNormal(itemid)); - htup = (HeapTupleHeader) PageGetItem(page, itemid); - /* * The criteria for counting a tuple as live in this block need to * match what analyze.c's acquire_sample_rows() does, otherwise VACUUM @@ -1587,29 +1570,8 @@ lazy_scan_prune(LVRelState *vacrel, hastup = true; /* page makes rel truncation unsafe */ - /* Tuple with storage -- consider need to freeze */ - if (heap_prepare_freeze_tuple(htup, &pagefrz, - &frozen[tuples_frozen], &totally_frozen)) - { - /* Save prepared freeze plan for later */ - frozen[tuples_frozen++].offset = offnum; - } - - /* - * If any tuple isn't either totally frozen already or eligible to - * become totally frozen (according to its freeze plan), then the page - * definitely cannot be set all-frozen in the visibility map later on - */ - if (!totally_frozen) - all_frozen = false; } - /* - * We have now divided every item on the page into either an LP_DEAD item - * that will need to be vacuumed in indexes later, or a LP_NORMAL tuple - * that remains and needs to be considered for freezing now (LP_UNUSED and - * LP_REDIRECT items also remain, but are of no further interest to us). - */ vacrel->offnum = InvalidOffsetNumber; /* @@ -1618,8 +1580,8 @@ 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 || tuples_frozen == 0 || - (presult.all_visible_except_removable && all_frozen && + if (pagefrz.freeze_required || presult.nfrozen == 0 || + (presult.all_visible_except_removable && presult.all_frozen && fpi_before != pgWalUsage.wal_fpi)) { /* @@ -1629,7 +1591,7 @@ lazy_scan_prune(LVRelState *vacrel, vacrel->NewRelfrozenXid = pagefrz.FreezePageRelfrozenXid; vacrel->NewRelminMxid = pagefrz.FreezePageRelminMxid; - if (tuples_frozen == 0) + if (presult.nfrozen == 0) { /* * We have no freeze plans to execute, so there's no added cost @@ -1657,7 +1619,7 @@ lazy_scan_prune(LVRelState *vacrel, * once we're done with it. Otherwise we generate a conservative * cutoff by stepping back from OldestXmin. */ - if (presult.all_visible_except_removable && all_frozen) + if (presult.all_visible_except_removable && presult.all_frozen) { /* Using same cutoff when setting VM is now unnecessary */ snapshotConflictHorizon = presult.frz_conflict_horizon; @@ -1673,7 +1635,7 @@ lazy_scan_prune(LVRelState *vacrel, /* Execute all freeze plans for page as a single atomic action */ heap_freeze_execute_prepared(vacrel->rel, buf, snapshotConflictHorizon, - frozen, tuples_frozen); + presult.frozen, presult.nfrozen); } } else @@ -1684,8 +1646,8 @@ lazy_scan_prune(LVRelState *vacrel, */ vacrel->NewRelfrozenXid = pagefrz.NoFreezePageRelfrozenXid; vacrel->NewRelminMxid = pagefrz.NoFreezePageRelminMxid; - all_frozen = false; - tuples_frozen = 0; /* avoid miscounts in instrumentation */ + presult.all_frozen = false; + presult.nfrozen = 0; /* avoid miscounts in instrumentation */ } /* @@ -1708,6 +1670,8 @@ lazy_scan_prune(LVRelState *vacrel, &debug_cutoff, &debug_all_frozen)) Assert(false); + Assert(presult.all_frozen == debug_all_frozen); + Assert(!TransactionIdIsValid(debug_cutoff) || debug_cutoff == presult.frz_conflict_horizon); } @@ -1738,7 +1702,7 @@ lazy_scan_prune(LVRelState *vacrel, /* Finally, add page-local counts to whole-VACUUM counts */ vacrel->tuples_deleted += presult.ndeleted; - vacrel->tuples_frozen += tuples_frozen; + vacrel->tuples_frozen += presult.nfrozen; vacrel->lpdead_items += lpdead_items; vacrel->live_tuples += live_tuples; vacrel->recently_dead_tuples += recently_dead_tuples; @@ -1761,7 +1725,7 @@ lazy_scan_prune(LVRelState *vacrel, { uint8 flags = VISIBILITYMAP_ALL_VISIBLE; - if (all_frozen) + if (presult.all_frozen) { Assert(!TransactionIdIsValid(presult.frz_conflict_horizon)); flags |= VISIBILITYMAP_ALL_FROZEN; @@ -1832,7 +1796,7 @@ lazy_scan_prune(LVRelState *vacrel, * true, so we must check both all_visible and all_frozen. */ else if (all_visible_according_to_vm && presult.all_visible && - all_frozen && !VM_ALL_FROZEN(vacrel->rel, blkno, &vmbuffer)) + presult.all_frozen && !VM_ALL_FROZEN(vacrel->rel, blkno, &vmbuffer)) { /* * Avoid relying on all_visible_according_to_vm as a proxy for the diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h index 297ba03bf09..2339abfd28a 100644 --- a/src/include/access/heapam.h +++ b/src/include/access/heapam.h @@ -201,6 +201,11 @@ typedef struct PruneResult int nnewlpdead; /* Number of newly LP_DEAD items */ bool all_visible; /* Whether or not the page is all visible */ bool all_visible_except_removable; + /* Whether or not the page can be set all frozen in the VM */ + bool all_frozen; + + /* Number of newly frozen tuples */ + int nfrozen; TransactionId frz_conflict_horizon; /* Newest xmin on the page */ /* @@ -213,6 +218,12 @@ typedef struct PruneResult * 1. Otherwise every access would need to subtract 1. */ int8 htsv[MaxHeapTuplesPerPage + 1]; + + + /* + * One entry for every tuple that we may freeze. + */ + HeapTupleFreeze frozen[MaxHeapTuplesPerPage]; } PruneResult; /* @@ -324,6 +335,7 @@ extern void heap_page_prune_opt(Relation relation, Buffer buffer); extern void heap_page_prune(Relation relation, Buffer buffer, struct GlobalVisState *vistest, bool mark_unused_now, + HeapPageFreeze *pagefrz, PruneResult *presult, OffsetNumber *off_loc); extern void heap_page_prune_execute(Buffer buffer, -- 2.40.1 --racicctn4wry6xe5 Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v3-0006-lazy_scan_prune-reorder-freeze-execution-logic.patch" ^ permalink raw reply [nested|flat] 11+ messages in thread
* [PATCH v2 05/17] Prepare freeze tuples in heap_page_prune() @ 2024-01-07 16:18 Melanie Plageman <melanieplageman@gmail.com> 0 siblings, 0 replies; 11+ messages in thread From: Melanie Plageman @ 2024-01-07 16:18 UTC (permalink / raw) In order to combine the freeze and prune records, we must determine which tuples are freezable before actually executing pruning. All of the page modifications should be made in the same critical section along with emitting the combined WAL. Determine whether or not tuples should or must be frozen and whether or not the page will be all frozen as a consequence during pruning. --- src/backend/access/heap/pruneheap.c | 78 ++++++++++++++++++++++++++-- src/backend/access/heap/vacuumlazy.c | 68 ++++++------------------ src/include/access/heapam.h | 13 +++++ 3 files changed, 102 insertions(+), 57 deletions(-) diff --git a/src/backend/access/heap/pruneheap.c b/src/backend/access/heap/pruneheap.c index b3a7ce06699..44a5c0a917b 100644 --- a/src/backend/access/heap/pruneheap.c +++ b/src/backend/access/heap/pruneheap.c @@ -62,6 +62,9 @@ static HTSV_Result heap_prune_satisfies_vacuum(PruneState *prstate, static int heap_prune_chain(Buffer buffer, OffsetNumber rootoffnum, PruneState *prstate, PruneResult *presult); + +static void prune_prepare_freeze_tuple(Page page, OffsetNumber offnum, + HeapPageFreeze *pagefrz, PruneResult *presult); static void heap_prune_record_prunable(PruneState *prstate, TransactionId xid); static void heap_prune_record_redirect(PruneState *prstate, OffsetNumber offnum, OffsetNumber rdoffnum); @@ -155,7 +158,7 @@ heap_page_prune_opt(Relation relation, Buffer buffer) * not the relation has indexes, since we cannot safely determine * that during on-access pruning with the current implementation. */ - heap_page_prune(relation, buffer, vistest, false, + heap_page_prune(relation, buffer, vistest, false, NULL, &presult, NULL); /* @@ -204,6 +207,9 @@ heap_page_prune_opt(Relation relation, Buffer buffer) * mark_unused_now indicates whether or not dead items can be set LP_UNUSED during * pruning. * + * pagefrz contains both input and output parameters used if the caller is + * interested in potentially freezing tuples on the page. + * * off_loc is the offset location required by the caller to use in error * callback. * @@ -215,6 +221,7 @@ void heap_page_prune(Relation relation, Buffer buffer, GlobalVisState *vistest, bool mark_unused_now, + HeapPageFreeze *pagefrz, PruneResult *presult, OffsetNumber *off_loc) { @@ -250,6 +257,7 @@ heap_page_prune(Relation relation, Buffer buffer, */ presult->ndeleted = 0; presult->nnewlpdead = 0; + presult->nfrozen = 0; /* * Keep track of whether or not the page is all_visible in case the caller @@ -396,6 +404,15 @@ heap_page_prune(Relation relation, Buffer buffer, */ presult->all_visible_except_removable = presult->all_visible; + /* + * We will update the VM after pruning, collecting LP_DEAD items, and + * freezing tuples. Keep track of whether or not the page is all_visible + * and all_frozen and use this information to update the VM. all_visible + * implies lpdead_items == 0, but don't trust all_frozen result unless + * all_visible is also set to true. + */ + presult->all_frozen = true; + /* Scan the page */ for (offnum = FirstOffsetNumber; offnum <= maxoff; @@ -403,14 +420,18 @@ heap_page_prune(Relation relation, Buffer buffer, { ItemId itemid; - /* Ignore items already processed as part of an earlier chain */ - if (prstate.marked[offnum]) - continue; - /* see preceding loop */ if (off_loc) *off_loc = offnum; + if (pagefrz) + prune_prepare_freeze_tuple(page, offnum, + pagefrz, presult); + + /* Ignore items already processed as part of an earlier chain */ + if (prstate.marked[offnum]) + continue; + /* Nothing to do if slot is empty */ itemid = PageGetItemId(page, offnum); if (!ItemIdIsUsed(itemid)) @@ -853,6 +874,53 @@ heap_prune_chain(Buffer buffer, OffsetNumber rootoffnum, return ndeleted; } +/* + * While pruning, before actually executing pruning and updating the line + * pointers, we may consider freezing tuples referred to by LP_NORMAL line + * pointers whose visibility status is not HEAPTUPLE_DEAD. That is to say, we + * want to consider freezing normal tuples which will not be removed. +*/ +static void +prune_prepare_freeze_tuple(Page page, OffsetNumber offnum, + HeapPageFreeze *pagefrz, + PruneResult *presult) +{ + bool totally_frozen; + HeapTupleHeader htup; + ItemId itemid; + + Assert(pagefrz); + + itemid = PageGetItemId(page, offnum); + + if (!ItemIdIsNormal(itemid)) + return; + + /* We do not consider freezing tuples which will be removed. */ + if (presult->htsv[offnum] == HEAPTUPLE_DEAD || + presult->htsv[offnum] == -1) + return; + + htup = (HeapTupleHeader) PageGetItem(page, itemid); + + /* Tuple with storage -- consider need to freeze */ + if ((heap_prepare_freeze_tuple(htup, pagefrz, + &presult->frozen[presult->nfrozen], + &totally_frozen))) + { + /* Save prepared freeze plan for later */ + presult->frozen[presult->nfrozen++].offset = offnum; + } + + /* + * If any tuple isn't either totally frozen already or eligible to become + * totally frozen (according to its freeze plan), then the page definitely + * cannot be set all-frozen in the visibility map later on + */ + if (!totally_frozen) + presult->all_frozen = false; +} + /* Record lowest soon-prunable XID */ static void heap_prune_record_prunable(PruneState *prstate, TransactionId xid) diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c index 06e0e841582..4187c998d25 100644 --- a/src/backend/access/heap/vacuumlazy.c +++ b/src/backend/access/heap/vacuumlazy.c @@ -1416,16 +1416,13 @@ lazy_scan_prune(LVRelState *vacrel, maxoff; ItemId itemid; PruneResult presult; - int tuples_frozen, - lpdead_items, + int lpdead_items, live_tuples, recently_dead_tuples; HeapPageFreeze pagefrz; bool hastup = false; - bool all_frozen; int64 fpi_before = pgWalUsage.wal_fpi; OffsetNumber deadoffsets[MaxHeapTuplesPerPage]; - HeapTupleFreeze frozen[MaxHeapTuplesPerPage]; Assert(BufferGetBlockNumber(buf) == blkno); @@ -1443,7 +1440,6 @@ lazy_scan_prune(LVRelState *vacrel, pagefrz.NoFreezePageRelfrozenXid = vacrel->NewRelfrozenXid; pagefrz.NoFreezePageRelminMxid = vacrel->NewRelminMxid; pagefrz.cutoffs = &vacrel->cutoffs; - tuples_frozen = 0; lpdead_items = 0; live_tuples = 0; recently_dead_tuples = 0; @@ -1461,31 +1457,20 @@ lazy_scan_prune(LVRelState *vacrel, * false otherwise. */ heap_page_prune(rel, buf, vacrel->vistest, vacrel->nindexes == 0, - &presult, &vacrel->offnum); + &pagefrz, &presult, &vacrel->offnum); /* * Now scan the page to collect LP_DEAD items and check for tuples * requiring freezing among remaining tuples with storage. We will update * the VM after collecting LP_DEAD items and freezing tuples. Pruning will - * have determined whether or not the page is all_visible. Keep track of - * whether or not the page is all_frozen and use this information to - * update the VM. all_visible implies lpdead_items == 0, but don't trust - * all_frozen result unless all_visible is also set to true. + * have determined whether or not the page is all_visible and able to + * become all_frozen. * */ - all_frozen = true; - - /* - * Now scan the page to collect LP_DEAD items and update the variables set - * just above. - */ for (offnum = FirstOffsetNumber; offnum <= maxoff; offnum = OffsetNumberNext(offnum)) { - HeapTupleHeader htup; - bool totally_frozen; - /* * Set the offset number so that we can display it along with any * error that occurred while processing this tuple. @@ -1521,8 +1506,6 @@ lazy_scan_prune(LVRelState *vacrel, Assert(ItemIdIsNormal(itemid)); - htup = (HeapTupleHeader) PageGetItem(page, itemid); - /* * The criteria for counting a tuple as live in this block need to * match what analyze.c's acquire_sample_rows() does, otherwise VACUUM @@ -1587,29 +1570,8 @@ lazy_scan_prune(LVRelState *vacrel, hastup = true; /* page makes rel truncation unsafe */ - /* Tuple with storage -- consider need to freeze */ - if (heap_prepare_freeze_tuple(htup, &pagefrz, - &frozen[tuples_frozen], &totally_frozen)) - { - /* Save prepared freeze plan for later */ - frozen[tuples_frozen++].offset = offnum; - } - - /* - * If any tuple isn't either totally frozen already or eligible to - * become totally frozen (according to its freeze plan), then the page - * definitely cannot be set all-frozen in the visibility map later on - */ - if (!totally_frozen) - all_frozen = false; } - /* - * We have now divided every item on the page into either an LP_DEAD item - * that will need to be vacuumed in indexes later, or a LP_NORMAL tuple - * that remains and needs to be considered for freezing now (LP_UNUSED and - * LP_REDIRECT items also remain, but are of no further interest to us). - */ vacrel->offnum = InvalidOffsetNumber; /* @@ -1618,8 +1580,8 @@ 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 || tuples_frozen == 0 || - (presult.all_visible_except_removable && all_frozen && + if (pagefrz.freeze_required || presult.nfrozen == 0 || + (presult.all_visible_except_removable && presult.all_frozen && fpi_before != pgWalUsage.wal_fpi)) { /* @@ -1629,7 +1591,7 @@ lazy_scan_prune(LVRelState *vacrel, vacrel->NewRelfrozenXid = pagefrz.FreezePageRelfrozenXid; vacrel->NewRelminMxid = pagefrz.FreezePageRelminMxid; - if (tuples_frozen == 0) + if (presult.nfrozen == 0) { /* * We have no freeze plans to execute, so there's no added cost @@ -1657,7 +1619,7 @@ lazy_scan_prune(LVRelState *vacrel, * once we're done with it. Otherwise we generate a conservative * cutoff by stepping back from OldestXmin. */ - if (presult.all_visible_except_removable && all_frozen) + if (presult.all_visible_except_removable && presult.all_frozen) { /* Using same cutoff when setting VM is now unnecessary */ snapshotConflictHorizon = presult.frz_conflict_horizon; @@ -1673,7 +1635,7 @@ lazy_scan_prune(LVRelState *vacrel, /* Execute all freeze plans for page as a single atomic action */ heap_freeze_execute_prepared(vacrel->rel, buf, snapshotConflictHorizon, - frozen, tuples_frozen); + presult.frozen, presult.nfrozen); } } else @@ -1684,8 +1646,8 @@ lazy_scan_prune(LVRelState *vacrel, */ vacrel->NewRelfrozenXid = pagefrz.NoFreezePageRelfrozenXid; vacrel->NewRelminMxid = pagefrz.NoFreezePageRelminMxid; - all_frozen = false; - tuples_frozen = 0; /* avoid miscounts in instrumentation */ + presult.all_frozen = false; + presult.nfrozen = 0; /* avoid miscounts in instrumentation */ } /* @@ -1708,6 +1670,8 @@ lazy_scan_prune(LVRelState *vacrel, &debug_cutoff, &debug_all_frozen)) Assert(false); + Assert(presult.all_frozen == debug_all_frozen); + Assert(!TransactionIdIsValid(debug_cutoff) || debug_cutoff == presult.frz_conflict_horizon); } @@ -1738,7 +1702,7 @@ lazy_scan_prune(LVRelState *vacrel, /* Finally, add page-local counts to whole-VACUUM counts */ vacrel->tuples_deleted += presult.ndeleted; - vacrel->tuples_frozen += tuples_frozen; + vacrel->tuples_frozen += presult.nfrozen; vacrel->lpdead_items += lpdead_items; vacrel->live_tuples += live_tuples; vacrel->recently_dead_tuples += recently_dead_tuples; @@ -1761,7 +1725,7 @@ lazy_scan_prune(LVRelState *vacrel, { uint8 flags = VISIBILITYMAP_ALL_VISIBLE; - if (all_frozen) + if (presult.all_frozen) { Assert(!TransactionIdIsValid(presult.frz_conflict_horizon)); flags |= VISIBILITYMAP_ALL_FROZEN; @@ -1832,7 +1796,7 @@ lazy_scan_prune(LVRelState *vacrel, * true, so we must check both all_visible and all_frozen. */ else if (all_visible_according_to_vm && presult.all_visible && - all_frozen && !VM_ALL_FROZEN(vacrel->rel, blkno, &vmbuffer)) + presult.all_frozen && !VM_ALL_FROZEN(vacrel->rel, blkno, &vmbuffer)) { /* * Avoid relying on all_visible_according_to_vm as a proxy for the diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h index 6823ab8b658..bea35afc4bd 100644 --- a/src/include/access/heapam.h +++ b/src/include/access/heapam.h @@ -212,7 +212,19 @@ typedef struct PruneResult * 1. Otherwise every access would need to subtract 1. */ int8 htsv[MaxHeapTuplesPerPage + 1]; + bool all_visible_except_removable; + + /* Whether or not the page can be set all frozen in the VM */ + bool all_frozen; + + /* Number of newly frozen tuples */ + int nfrozen; + + /* + * One entry for every tuple that we may freeze. + */ + HeapTupleFreeze frozen[MaxHeapTuplesPerPage]; } PruneResult; /* @@ -324,6 +336,7 @@ extern void heap_page_prune_opt(Relation relation, Buffer buffer); extern void heap_page_prune(Relation relation, Buffer buffer, struct GlobalVisState *vistest, bool mark_unused_now, + HeapPageFreeze *pagefrz, PruneResult *presult, OffsetNumber *off_loc); extern void heap_page_prune_execute(Buffer buffer, -- 2.40.1 --rdqtp5puvxqotfdw Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v2-0006-lazy_scan_prune-reorder-freeze-execution-logic.patch" ^ permalink raw reply [nested|flat] 11+ messages in thread
* [PATCH v2 05/17] Prepare freeze tuples in heap_page_prune() @ 2024-01-07 16:18 Melanie Plageman <melanieplageman@gmail.com> 0 siblings, 0 replies; 11+ messages in thread From: Melanie Plageman @ 2024-01-07 16:18 UTC (permalink / raw) In order to combine the freeze and prune records, we must determine which tuples are freezable before actually executing pruning. All of the page modifications should be made in the same critical section along with emitting the combined WAL. Determine whether or not tuples should or must be frozen and whether or not the page will be all frozen as a consequence during pruning. --- src/backend/access/heap/pruneheap.c | 78 ++++++++++++++++++++++++++-- src/backend/access/heap/vacuumlazy.c | 68 ++++++------------------ src/include/access/heapam.h | 13 +++++ 3 files changed, 102 insertions(+), 57 deletions(-) diff --git a/src/backend/access/heap/pruneheap.c b/src/backend/access/heap/pruneheap.c index b3a7ce06699..44a5c0a917b 100644 --- a/src/backend/access/heap/pruneheap.c +++ b/src/backend/access/heap/pruneheap.c @@ -62,6 +62,9 @@ static HTSV_Result heap_prune_satisfies_vacuum(PruneState *prstate, static int heap_prune_chain(Buffer buffer, OffsetNumber rootoffnum, PruneState *prstate, PruneResult *presult); + +static void prune_prepare_freeze_tuple(Page page, OffsetNumber offnum, + HeapPageFreeze *pagefrz, PruneResult *presult); static void heap_prune_record_prunable(PruneState *prstate, TransactionId xid); static void heap_prune_record_redirect(PruneState *prstate, OffsetNumber offnum, OffsetNumber rdoffnum); @@ -155,7 +158,7 @@ heap_page_prune_opt(Relation relation, Buffer buffer) * not the relation has indexes, since we cannot safely determine * that during on-access pruning with the current implementation. */ - heap_page_prune(relation, buffer, vistest, false, + heap_page_prune(relation, buffer, vistest, false, NULL, &presult, NULL); /* @@ -204,6 +207,9 @@ heap_page_prune_opt(Relation relation, Buffer buffer) * mark_unused_now indicates whether or not dead items can be set LP_UNUSED during * pruning. * + * pagefrz contains both input and output parameters used if the caller is + * interested in potentially freezing tuples on the page. + * * off_loc is the offset location required by the caller to use in error * callback. * @@ -215,6 +221,7 @@ void heap_page_prune(Relation relation, Buffer buffer, GlobalVisState *vistest, bool mark_unused_now, + HeapPageFreeze *pagefrz, PruneResult *presult, OffsetNumber *off_loc) { @@ -250,6 +257,7 @@ heap_page_prune(Relation relation, Buffer buffer, */ presult->ndeleted = 0; presult->nnewlpdead = 0; + presult->nfrozen = 0; /* * Keep track of whether or not the page is all_visible in case the caller @@ -396,6 +404,15 @@ heap_page_prune(Relation relation, Buffer buffer, */ presult->all_visible_except_removable = presult->all_visible; + /* + * We will update the VM after pruning, collecting LP_DEAD items, and + * freezing tuples. Keep track of whether or not the page is all_visible + * and all_frozen and use this information to update the VM. all_visible + * implies lpdead_items == 0, but don't trust all_frozen result unless + * all_visible is also set to true. + */ + presult->all_frozen = true; + /* Scan the page */ for (offnum = FirstOffsetNumber; offnum <= maxoff; @@ -403,14 +420,18 @@ heap_page_prune(Relation relation, Buffer buffer, { ItemId itemid; - /* Ignore items already processed as part of an earlier chain */ - if (prstate.marked[offnum]) - continue; - /* see preceding loop */ if (off_loc) *off_loc = offnum; + if (pagefrz) + prune_prepare_freeze_tuple(page, offnum, + pagefrz, presult); + + /* Ignore items already processed as part of an earlier chain */ + if (prstate.marked[offnum]) + continue; + /* Nothing to do if slot is empty */ itemid = PageGetItemId(page, offnum); if (!ItemIdIsUsed(itemid)) @@ -853,6 +874,53 @@ heap_prune_chain(Buffer buffer, OffsetNumber rootoffnum, return ndeleted; } +/* + * While pruning, before actually executing pruning and updating the line + * pointers, we may consider freezing tuples referred to by LP_NORMAL line + * pointers whose visibility status is not HEAPTUPLE_DEAD. That is to say, we + * want to consider freezing normal tuples which will not be removed. +*/ +static void +prune_prepare_freeze_tuple(Page page, OffsetNumber offnum, + HeapPageFreeze *pagefrz, + PruneResult *presult) +{ + bool totally_frozen; + HeapTupleHeader htup; + ItemId itemid; + + Assert(pagefrz); + + itemid = PageGetItemId(page, offnum); + + if (!ItemIdIsNormal(itemid)) + return; + + /* We do not consider freezing tuples which will be removed. */ + if (presult->htsv[offnum] == HEAPTUPLE_DEAD || + presult->htsv[offnum] == -1) + return; + + htup = (HeapTupleHeader) PageGetItem(page, itemid); + + /* Tuple with storage -- consider need to freeze */ + if ((heap_prepare_freeze_tuple(htup, pagefrz, + &presult->frozen[presult->nfrozen], + &totally_frozen))) + { + /* Save prepared freeze plan for later */ + presult->frozen[presult->nfrozen++].offset = offnum; + } + + /* + * If any tuple isn't either totally frozen already or eligible to become + * totally frozen (according to its freeze plan), then the page definitely + * cannot be set all-frozen in the visibility map later on + */ + if (!totally_frozen) + presult->all_frozen = false; +} + /* Record lowest soon-prunable XID */ static void heap_prune_record_prunable(PruneState *prstate, TransactionId xid) diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c index 06e0e841582..4187c998d25 100644 --- a/src/backend/access/heap/vacuumlazy.c +++ b/src/backend/access/heap/vacuumlazy.c @@ -1416,16 +1416,13 @@ lazy_scan_prune(LVRelState *vacrel, maxoff; ItemId itemid; PruneResult presult; - int tuples_frozen, - lpdead_items, + int lpdead_items, live_tuples, recently_dead_tuples; HeapPageFreeze pagefrz; bool hastup = false; - bool all_frozen; int64 fpi_before = pgWalUsage.wal_fpi; OffsetNumber deadoffsets[MaxHeapTuplesPerPage]; - HeapTupleFreeze frozen[MaxHeapTuplesPerPage]; Assert(BufferGetBlockNumber(buf) == blkno); @@ -1443,7 +1440,6 @@ lazy_scan_prune(LVRelState *vacrel, pagefrz.NoFreezePageRelfrozenXid = vacrel->NewRelfrozenXid; pagefrz.NoFreezePageRelminMxid = vacrel->NewRelminMxid; pagefrz.cutoffs = &vacrel->cutoffs; - tuples_frozen = 0; lpdead_items = 0; live_tuples = 0; recently_dead_tuples = 0; @@ -1461,31 +1457,20 @@ lazy_scan_prune(LVRelState *vacrel, * false otherwise. */ heap_page_prune(rel, buf, vacrel->vistest, vacrel->nindexes == 0, - &presult, &vacrel->offnum); + &pagefrz, &presult, &vacrel->offnum); /* * Now scan the page to collect LP_DEAD items and check for tuples * requiring freezing among remaining tuples with storage. We will update * the VM after collecting LP_DEAD items and freezing tuples. Pruning will - * have determined whether or not the page is all_visible. Keep track of - * whether or not the page is all_frozen and use this information to - * update the VM. all_visible implies lpdead_items == 0, but don't trust - * all_frozen result unless all_visible is also set to true. + * have determined whether or not the page is all_visible and able to + * become all_frozen. * */ - all_frozen = true; - - /* - * Now scan the page to collect LP_DEAD items and update the variables set - * just above. - */ for (offnum = FirstOffsetNumber; offnum <= maxoff; offnum = OffsetNumberNext(offnum)) { - HeapTupleHeader htup; - bool totally_frozen; - /* * Set the offset number so that we can display it along with any * error that occurred while processing this tuple. @@ -1521,8 +1506,6 @@ lazy_scan_prune(LVRelState *vacrel, Assert(ItemIdIsNormal(itemid)); - htup = (HeapTupleHeader) PageGetItem(page, itemid); - /* * The criteria for counting a tuple as live in this block need to * match what analyze.c's acquire_sample_rows() does, otherwise VACUUM @@ -1587,29 +1570,8 @@ lazy_scan_prune(LVRelState *vacrel, hastup = true; /* page makes rel truncation unsafe */ - /* Tuple with storage -- consider need to freeze */ - if (heap_prepare_freeze_tuple(htup, &pagefrz, - &frozen[tuples_frozen], &totally_frozen)) - { - /* Save prepared freeze plan for later */ - frozen[tuples_frozen++].offset = offnum; - } - - /* - * If any tuple isn't either totally frozen already or eligible to - * become totally frozen (according to its freeze plan), then the page - * definitely cannot be set all-frozen in the visibility map later on - */ - if (!totally_frozen) - all_frozen = false; } - /* - * We have now divided every item on the page into either an LP_DEAD item - * that will need to be vacuumed in indexes later, or a LP_NORMAL tuple - * that remains and needs to be considered for freezing now (LP_UNUSED and - * LP_REDIRECT items also remain, but are of no further interest to us). - */ vacrel->offnum = InvalidOffsetNumber; /* @@ -1618,8 +1580,8 @@ 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 || tuples_frozen == 0 || - (presult.all_visible_except_removable && all_frozen && + if (pagefrz.freeze_required || presult.nfrozen == 0 || + (presult.all_visible_except_removable && presult.all_frozen && fpi_before != pgWalUsage.wal_fpi)) { /* @@ -1629,7 +1591,7 @@ lazy_scan_prune(LVRelState *vacrel, vacrel->NewRelfrozenXid = pagefrz.FreezePageRelfrozenXid; vacrel->NewRelminMxid = pagefrz.FreezePageRelminMxid; - if (tuples_frozen == 0) + if (presult.nfrozen == 0) { /* * We have no freeze plans to execute, so there's no added cost @@ -1657,7 +1619,7 @@ lazy_scan_prune(LVRelState *vacrel, * once we're done with it. Otherwise we generate a conservative * cutoff by stepping back from OldestXmin. */ - if (presult.all_visible_except_removable && all_frozen) + if (presult.all_visible_except_removable && presult.all_frozen) { /* Using same cutoff when setting VM is now unnecessary */ snapshotConflictHorizon = presult.frz_conflict_horizon; @@ -1673,7 +1635,7 @@ lazy_scan_prune(LVRelState *vacrel, /* Execute all freeze plans for page as a single atomic action */ heap_freeze_execute_prepared(vacrel->rel, buf, snapshotConflictHorizon, - frozen, tuples_frozen); + presult.frozen, presult.nfrozen); } } else @@ -1684,8 +1646,8 @@ lazy_scan_prune(LVRelState *vacrel, */ vacrel->NewRelfrozenXid = pagefrz.NoFreezePageRelfrozenXid; vacrel->NewRelminMxid = pagefrz.NoFreezePageRelminMxid; - all_frozen = false; - tuples_frozen = 0; /* avoid miscounts in instrumentation */ + presult.all_frozen = false; + presult.nfrozen = 0; /* avoid miscounts in instrumentation */ } /* @@ -1708,6 +1670,8 @@ lazy_scan_prune(LVRelState *vacrel, &debug_cutoff, &debug_all_frozen)) Assert(false); + Assert(presult.all_frozen == debug_all_frozen); + Assert(!TransactionIdIsValid(debug_cutoff) || debug_cutoff == presult.frz_conflict_horizon); } @@ -1738,7 +1702,7 @@ lazy_scan_prune(LVRelState *vacrel, /* Finally, add page-local counts to whole-VACUUM counts */ vacrel->tuples_deleted += presult.ndeleted; - vacrel->tuples_frozen += tuples_frozen; + vacrel->tuples_frozen += presult.nfrozen; vacrel->lpdead_items += lpdead_items; vacrel->live_tuples += live_tuples; vacrel->recently_dead_tuples += recently_dead_tuples; @@ -1761,7 +1725,7 @@ lazy_scan_prune(LVRelState *vacrel, { uint8 flags = VISIBILITYMAP_ALL_VISIBLE; - if (all_frozen) + if (presult.all_frozen) { Assert(!TransactionIdIsValid(presult.frz_conflict_horizon)); flags |= VISIBILITYMAP_ALL_FROZEN; @@ -1832,7 +1796,7 @@ lazy_scan_prune(LVRelState *vacrel, * true, so we must check both all_visible and all_frozen. */ else if (all_visible_according_to_vm && presult.all_visible && - all_frozen && !VM_ALL_FROZEN(vacrel->rel, blkno, &vmbuffer)) + presult.all_frozen && !VM_ALL_FROZEN(vacrel->rel, blkno, &vmbuffer)) { /* * Avoid relying on all_visible_according_to_vm as a proxy for the diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h index 6823ab8b658..bea35afc4bd 100644 --- a/src/include/access/heapam.h +++ b/src/include/access/heapam.h @@ -212,7 +212,19 @@ typedef struct PruneResult * 1. Otherwise every access would need to subtract 1. */ int8 htsv[MaxHeapTuplesPerPage + 1]; + bool all_visible_except_removable; + + /* Whether or not the page can be set all frozen in the VM */ + bool all_frozen; + + /* Number of newly frozen tuples */ + int nfrozen; + + /* + * One entry for every tuple that we may freeze. + */ + HeapTupleFreeze frozen[MaxHeapTuplesPerPage]; } PruneResult; /* @@ -324,6 +336,7 @@ extern void heap_page_prune_opt(Relation relation, Buffer buffer); extern void heap_page_prune(Relation relation, Buffer buffer, struct GlobalVisState *vistest, bool mark_unused_now, + HeapPageFreeze *pagefrz, PruneResult *presult, OffsetNumber *off_loc); extern void heap_page_prune_execute(Buffer buffer, -- 2.40.1 --rdqtp5puvxqotfdw Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v2-0006-lazy_scan_prune-reorder-freeze-execution-logic.patch" ^ permalink raw reply [nested|flat] 11+ messages in thread
* [PATCH v3 05/17] Prepare freeze tuples in heap_page_prune() @ 2024-01-07 16:18 Melanie Plageman <melanieplageman@gmail.com> 0 siblings, 0 replies; 11+ messages in thread From: Melanie Plageman @ 2024-01-07 16:18 UTC (permalink / raw) In order to combine the freeze and prune records, we must determine which tuples are freezable before actually executing pruning. All of the page modifications should be made in the same critical section along with emitting the combined WAL. Determine whether or not tuples should or must be frozen and whether or not the page will be all frozen as a consequence during pruning. --- src/backend/access/heap/pruneheap.c | 78 ++++++++++++++++++++++++++-- src/backend/access/heap/vacuumlazy.c | 68 ++++++------------------ src/include/access/heapam.h | 12 +++++ 3 files changed, 101 insertions(+), 57 deletions(-) diff --git a/src/backend/access/heap/pruneheap.c b/src/backend/access/heap/pruneheap.c index 42fd4a74845..6bd8400b33b 100644 --- a/src/backend/access/heap/pruneheap.c +++ b/src/backend/access/heap/pruneheap.c @@ -62,6 +62,9 @@ static HTSV_Result heap_prune_satisfies_vacuum(PruneState *prstate, static int heap_prune_chain(Buffer buffer, OffsetNumber rootoffnum, PruneState *prstate, PruneResult *presult); + +static void prune_prepare_freeze_tuple(Page page, OffsetNumber offnum, + HeapPageFreeze *pagefrz, PruneResult *presult); static void heap_prune_record_prunable(PruneState *prstate, TransactionId xid); static void heap_prune_record_redirect(PruneState *prstate, OffsetNumber offnum, OffsetNumber rdoffnum); @@ -155,7 +158,7 @@ heap_page_prune_opt(Relation relation, Buffer buffer) * not the relation has indexes, since we cannot safely determine * that during on-access pruning with the current implementation. */ - heap_page_prune(relation, buffer, vistest, false, + heap_page_prune(relation, buffer, vistest, false, NULL, &presult, NULL); /* @@ -218,6 +221,9 @@ prune_freeze_xmin_is_removable(GlobalVisState *visstate, TransactionId xmin) * mark_unused_now indicates whether or not dead items can be set LP_UNUSED during * pruning. * + * pagefrz contains both input and output parameters used if the caller is + * interested in potentially freezing tuples on the page. + * * off_loc is the offset location required by the caller to use in error * callback. * @@ -229,6 +235,7 @@ void heap_page_prune(Relation relation, Buffer buffer, GlobalVisState *vistest, bool mark_unused_now, + HeapPageFreeze *pagefrz, PruneResult *presult, OffsetNumber *off_loc) { @@ -264,6 +271,7 @@ heap_page_prune(Relation relation, Buffer buffer, */ presult->ndeleted = 0; presult->nnewlpdead = 0; + presult->nfrozen = 0; /* * Keep track of whether or not the page is all_visible in case the caller @@ -410,6 +418,15 @@ heap_page_prune(Relation relation, Buffer buffer, */ presult->all_visible_except_removable = presult->all_visible; + /* + * We will update the VM after pruning, collecting LP_DEAD items, and + * freezing tuples. Keep track of whether or not the page is all_visible + * and all_frozen and use this information to update the VM. all_visible + * implies lpdead_items == 0, but don't trust all_frozen result unless + * all_visible is also set to true. + */ + presult->all_frozen = true; + /* Scan the page */ for (offnum = FirstOffsetNumber; offnum <= maxoff; @@ -417,14 +434,18 @@ heap_page_prune(Relation relation, Buffer buffer, { ItemId itemid; - /* Ignore items already processed as part of an earlier chain */ - if (prstate.marked[offnum]) - continue; - /* see preceding loop */ if (off_loc) *off_loc = offnum; + if (pagefrz) + prune_prepare_freeze_tuple(page, offnum, + pagefrz, presult); + + /* Ignore items already processed as part of an earlier chain */ + if (prstate.marked[offnum]) + continue; + /* Nothing to do if slot is empty */ itemid = PageGetItemId(page, offnum); if (!ItemIdIsUsed(itemid)) @@ -867,6 +888,53 @@ heap_prune_chain(Buffer buffer, OffsetNumber rootoffnum, return ndeleted; } +/* + * While pruning, before actually executing pruning and updating the line + * pointers, we may consider freezing tuples referred to by LP_NORMAL line + * pointers whose visibility status is not HEAPTUPLE_DEAD. That is to say, we + * want to consider freezing normal tuples which will not be removed. +*/ +static void +prune_prepare_freeze_tuple(Page page, OffsetNumber offnum, + HeapPageFreeze *pagefrz, + PruneResult *presult) +{ + bool totally_frozen; + HeapTupleHeader htup; + ItemId itemid; + + Assert(pagefrz); + + itemid = PageGetItemId(page, offnum); + + if (!ItemIdIsNormal(itemid)) + return; + + /* We do not consider freezing tuples which will be removed. */ + if (presult->htsv[offnum] == HEAPTUPLE_DEAD || + presult->htsv[offnum] == -1) + return; + + htup = (HeapTupleHeader) PageGetItem(page, itemid); + + /* Tuple with storage -- consider need to freeze */ + if ((heap_prepare_freeze_tuple(htup, pagefrz, + &presult->frozen[presult->nfrozen], + &totally_frozen))) + { + /* Save prepared freeze plan for later */ + presult->frozen[presult->nfrozen++].offset = offnum; + } + + /* + * If any tuple isn't either totally frozen already or eligible to become + * totally frozen (according to its freeze plan), then the page definitely + * cannot be set all-frozen in the visibility map later on + */ + if (!totally_frozen) + presult->all_frozen = false; +} + /* Record lowest soon-prunable XID */ static void heap_prune_record_prunable(PruneState *prstate, TransactionId xid) diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c index 06e0e841582..4187c998d25 100644 --- a/src/backend/access/heap/vacuumlazy.c +++ b/src/backend/access/heap/vacuumlazy.c @@ -1416,16 +1416,13 @@ lazy_scan_prune(LVRelState *vacrel, maxoff; ItemId itemid; PruneResult presult; - int tuples_frozen, - lpdead_items, + int lpdead_items, live_tuples, recently_dead_tuples; HeapPageFreeze pagefrz; bool hastup = false; - bool all_frozen; int64 fpi_before = pgWalUsage.wal_fpi; OffsetNumber deadoffsets[MaxHeapTuplesPerPage]; - HeapTupleFreeze frozen[MaxHeapTuplesPerPage]; Assert(BufferGetBlockNumber(buf) == blkno); @@ -1443,7 +1440,6 @@ lazy_scan_prune(LVRelState *vacrel, pagefrz.NoFreezePageRelfrozenXid = vacrel->NewRelfrozenXid; pagefrz.NoFreezePageRelminMxid = vacrel->NewRelminMxid; pagefrz.cutoffs = &vacrel->cutoffs; - tuples_frozen = 0; lpdead_items = 0; live_tuples = 0; recently_dead_tuples = 0; @@ -1461,31 +1457,20 @@ lazy_scan_prune(LVRelState *vacrel, * false otherwise. */ heap_page_prune(rel, buf, vacrel->vistest, vacrel->nindexes == 0, - &presult, &vacrel->offnum); + &pagefrz, &presult, &vacrel->offnum); /* * Now scan the page to collect LP_DEAD items and check for tuples * requiring freezing among remaining tuples with storage. We will update * the VM after collecting LP_DEAD items and freezing tuples. Pruning will - * have determined whether or not the page is all_visible. Keep track of - * whether or not the page is all_frozen and use this information to - * update the VM. all_visible implies lpdead_items == 0, but don't trust - * all_frozen result unless all_visible is also set to true. + * have determined whether or not the page is all_visible and able to + * become all_frozen. * */ - all_frozen = true; - - /* - * Now scan the page to collect LP_DEAD items and update the variables set - * just above. - */ for (offnum = FirstOffsetNumber; offnum <= maxoff; offnum = OffsetNumberNext(offnum)) { - HeapTupleHeader htup; - bool totally_frozen; - /* * Set the offset number so that we can display it along with any * error that occurred while processing this tuple. @@ -1521,8 +1506,6 @@ lazy_scan_prune(LVRelState *vacrel, Assert(ItemIdIsNormal(itemid)); - htup = (HeapTupleHeader) PageGetItem(page, itemid); - /* * The criteria for counting a tuple as live in this block need to * match what analyze.c's acquire_sample_rows() does, otherwise VACUUM @@ -1587,29 +1570,8 @@ lazy_scan_prune(LVRelState *vacrel, hastup = true; /* page makes rel truncation unsafe */ - /* Tuple with storage -- consider need to freeze */ - if (heap_prepare_freeze_tuple(htup, &pagefrz, - &frozen[tuples_frozen], &totally_frozen)) - { - /* Save prepared freeze plan for later */ - frozen[tuples_frozen++].offset = offnum; - } - - /* - * If any tuple isn't either totally frozen already or eligible to - * become totally frozen (according to its freeze plan), then the page - * definitely cannot be set all-frozen in the visibility map later on - */ - if (!totally_frozen) - all_frozen = false; } - /* - * We have now divided every item on the page into either an LP_DEAD item - * that will need to be vacuumed in indexes later, or a LP_NORMAL tuple - * that remains and needs to be considered for freezing now (LP_UNUSED and - * LP_REDIRECT items also remain, but are of no further interest to us). - */ vacrel->offnum = InvalidOffsetNumber; /* @@ -1618,8 +1580,8 @@ 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 || tuples_frozen == 0 || - (presult.all_visible_except_removable && all_frozen && + if (pagefrz.freeze_required || presult.nfrozen == 0 || + (presult.all_visible_except_removable && presult.all_frozen && fpi_before != pgWalUsage.wal_fpi)) { /* @@ -1629,7 +1591,7 @@ lazy_scan_prune(LVRelState *vacrel, vacrel->NewRelfrozenXid = pagefrz.FreezePageRelfrozenXid; vacrel->NewRelminMxid = pagefrz.FreezePageRelminMxid; - if (tuples_frozen == 0) + if (presult.nfrozen == 0) { /* * We have no freeze plans to execute, so there's no added cost @@ -1657,7 +1619,7 @@ lazy_scan_prune(LVRelState *vacrel, * once we're done with it. Otherwise we generate a conservative * cutoff by stepping back from OldestXmin. */ - if (presult.all_visible_except_removable && all_frozen) + if (presult.all_visible_except_removable && presult.all_frozen) { /* Using same cutoff when setting VM is now unnecessary */ snapshotConflictHorizon = presult.frz_conflict_horizon; @@ -1673,7 +1635,7 @@ lazy_scan_prune(LVRelState *vacrel, /* Execute all freeze plans for page as a single atomic action */ heap_freeze_execute_prepared(vacrel->rel, buf, snapshotConflictHorizon, - frozen, tuples_frozen); + presult.frozen, presult.nfrozen); } } else @@ -1684,8 +1646,8 @@ lazy_scan_prune(LVRelState *vacrel, */ vacrel->NewRelfrozenXid = pagefrz.NoFreezePageRelfrozenXid; vacrel->NewRelminMxid = pagefrz.NoFreezePageRelminMxid; - all_frozen = false; - tuples_frozen = 0; /* avoid miscounts in instrumentation */ + presult.all_frozen = false; + presult.nfrozen = 0; /* avoid miscounts in instrumentation */ } /* @@ -1708,6 +1670,8 @@ lazy_scan_prune(LVRelState *vacrel, &debug_cutoff, &debug_all_frozen)) Assert(false); + Assert(presult.all_frozen == debug_all_frozen); + Assert(!TransactionIdIsValid(debug_cutoff) || debug_cutoff == presult.frz_conflict_horizon); } @@ -1738,7 +1702,7 @@ lazy_scan_prune(LVRelState *vacrel, /* Finally, add page-local counts to whole-VACUUM counts */ vacrel->tuples_deleted += presult.ndeleted; - vacrel->tuples_frozen += tuples_frozen; + vacrel->tuples_frozen += presult.nfrozen; vacrel->lpdead_items += lpdead_items; vacrel->live_tuples += live_tuples; vacrel->recently_dead_tuples += recently_dead_tuples; @@ -1761,7 +1725,7 @@ lazy_scan_prune(LVRelState *vacrel, { uint8 flags = VISIBILITYMAP_ALL_VISIBLE; - if (all_frozen) + if (presult.all_frozen) { Assert(!TransactionIdIsValid(presult.frz_conflict_horizon)); flags |= VISIBILITYMAP_ALL_FROZEN; @@ -1832,7 +1796,7 @@ lazy_scan_prune(LVRelState *vacrel, * true, so we must check both all_visible and all_frozen. */ else if (all_visible_according_to_vm && presult.all_visible && - all_frozen && !VM_ALL_FROZEN(vacrel->rel, blkno, &vmbuffer)) + presult.all_frozen && !VM_ALL_FROZEN(vacrel->rel, blkno, &vmbuffer)) { /* * Avoid relying on all_visible_according_to_vm as a proxy for the diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h index 297ba03bf09..2339abfd28a 100644 --- a/src/include/access/heapam.h +++ b/src/include/access/heapam.h @@ -201,6 +201,11 @@ typedef struct PruneResult int nnewlpdead; /* Number of newly LP_DEAD items */ bool all_visible; /* Whether or not the page is all visible */ bool all_visible_except_removable; + /* Whether or not the page can be set all frozen in the VM */ + bool all_frozen; + + /* Number of newly frozen tuples */ + int nfrozen; TransactionId frz_conflict_horizon; /* Newest xmin on the page */ /* @@ -213,6 +218,12 @@ typedef struct PruneResult * 1. Otherwise every access would need to subtract 1. */ int8 htsv[MaxHeapTuplesPerPage + 1]; + + + /* + * One entry for every tuple that we may freeze. + */ + HeapTupleFreeze frozen[MaxHeapTuplesPerPage]; } PruneResult; /* @@ -324,6 +335,7 @@ extern void heap_page_prune_opt(Relation relation, Buffer buffer); extern void heap_page_prune(Relation relation, Buffer buffer, struct GlobalVisState *vistest, bool mark_unused_now, + HeapPageFreeze *pagefrz, PruneResult *presult, OffsetNumber *off_loc); extern void heap_page_prune_execute(Buffer buffer, -- 2.40.1 --racicctn4wry6xe5 Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v3-0006-lazy_scan_prune-reorder-freeze-execution-logic.patch" ^ permalink raw reply [nested|flat] 11+ messages in thread
* [PATCH v4 07/19] Prepare freeze tuples in heap_page_prune() @ 2024-03-19 00:01 Melanie Plageman <melanieplageman@gmail.com> 0 siblings, 0 replies; 11+ messages in thread From: Melanie Plageman @ 2024-03-19 00:01 UTC (permalink / raw) In order to combine the freeze and prune records, we must determine which tuples are freezable before actually executing pruning. All of the page modifications should be made in the same critical section along with emitting the combined WAL. Determine whether or not tuples should or must be frozen and whether or not the page will be all frozen as a consequence during pruning. --- src/backend/access/heap/pruneheap.c | 41 +++++++++++++++-- src/backend/access/heap/vacuumlazy.c | 68 +++++++--------------------- src/include/access/heapam.h | 12 +++++ 3 files changed, 66 insertions(+), 55 deletions(-) diff --git a/src/backend/access/heap/pruneheap.c b/src/backend/access/heap/pruneheap.c index bd30296ef1a..afc5ea5e0e7 100644 --- a/src/backend/access/heap/pruneheap.c +++ b/src/backend/access/heap/pruneheap.c @@ -153,7 +153,7 @@ heap_page_prune_opt(Relation relation, Buffer buffer) * not the relation has indexes, since we cannot safely determine * that during on-access pruning with the current implementation. */ - heap_page_prune(relation, buffer, vistest, false, + heap_page_prune(relation, buffer, vistest, false, NULL, &presult, NULL); /* @@ -206,6 +206,9 @@ heap_page_prune_opt(Relation relation, Buffer buffer) * mark_unused_now indicates whether or not dead items can be set LP_UNUSED * during pruning. * + * pagefrz contains both input and output parameters used if the caller is + * interested in potentially freezing tuples on the page. + * * presult contains output parameters needed by callers such as the number of * tuples removed and the number of line pointers newly marked LP_DEAD. * heap_page_prune() is responsible for initializing it. @@ -217,6 +220,7 @@ void heap_page_prune(Relation relation, Buffer buffer, GlobalVisState *vistest, bool mark_unused_now, + HeapPageFreeze *pagefrz, PruneResult *presult, OffsetNumber *off_loc) { @@ -247,11 +251,16 @@ heap_page_prune(Relation relation, Buffer buffer, presult->ndeleted = 0; presult->nnewlpdead = 0; + presult->nfrozen = 0; /* - * Keep track of whether or not the page is all_visible in case the caller - * wants to use this information to update the VM. + * Caller will update the VM after pruning, collecting LP_DEAD items, and + * freezing tuples. Keep track of whether or not the page is all_visible + * and all_frozen and use this information to update the VM. all_visible + * implies lpdead_items == 0, but don't trust all_frozen result unless + * all_visible is also set to true. */ + presult->all_frozen = true; presult->all_visible = true; /* for recovery conflicts */ presult->frz_conflict_horizon = InvalidTransactionId; @@ -381,6 +390,32 @@ heap_page_prune(Relation relation, Buffer buffer, elog(ERROR, "unexpected HeapTupleSatisfiesVacuum result"); break; } + + /* + * Consider freezing any normal tuples which will not be removed + */ + if (presult->htsv[offnum] != HEAPTUPLE_DEAD && pagefrz) + { + bool totally_frozen; + + /* Tuple with storage -- consider need to freeze */ + if ((heap_prepare_freeze_tuple(htup, pagefrz, + &presult->frozen[presult->nfrozen], + &totally_frozen))) + { + /* Save prepared freeze plan for later */ + presult->frozen[presult->nfrozen++].offset = offnum; + } + + /* + * If any tuple isn't either totally frozen already or eligible to + * become totally frozen (according to its freeze plan), then the + * page definitely cannot be set all-frozen in the visibility map + * later on + */ + if (!totally_frozen) + presult->all_frozen = false; + } } /* diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c index 06e0e841582..4187c998d25 100644 --- a/src/backend/access/heap/vacuumlazy.c +++ b/src/backend/access/heap/vacuumlazy.c @@ -1416,16 +1416,13 @@ lazy_scan_prune(LVRelState *vacrel, maxoff; ItemId itemid; PruneResult presult; - int tuples_frozen, - lpdead_items, + int lpdead_items, live_tuples, recently_dead_tuples; HeapPageFreeze pagefrz; bool hastup = false; - bool all_frozen; int64 fpi_before = pgWalUsage.wal_fpi; OffsetNumber deadoffsets[MaxHeapTuplesPerPage]; - HeapTupleFreeze frozen[MaxHeapTuplesPerPage]; Assert(BufferGetBlockNumber(buf) == blkno); @@ -1443,7 +1440,6 @@ lazy_scan_prune(LVRelState *vacrel, pagefrz.NoFreezePageRelfrozenXid = vacrel->NewRelfrozenXid; pagefrz.NoFreezePageRelminMxid = vacrel->NewRelminMxid; pagefrz.cutoffs = &vacrel->cutoffs; - tuples_frozen = 0; lpdead_items = 0; live_tuples = 0; recently_dead_tuples = 0; @@ -1461,31 +1457,20 @@ lazy_scan_prune(LVRelState *vacrel, * false otherwise. */ heap_page_prune(rel, buf, vacrel->vistest, vacrel->nindexes == 0, - &presult, &vacrel->offnum); + &pagefrz, &presult, &vacrel->offnum); /* * Now scan the page to collect LP_DEAD items and check for tuples * requiring freezing among remaining tuples with storage. We will update * the VM after collecting LP_DEAD items and freezing tuples. Pruning will - * have determined whether or not the page is all_visible. Keep track of - * whether or not the page is all_frozen and use this information to - * update the VM. all_visible implies lpdead_items == 0, but don't trust - * all_frozen result unless all_visible is also set to true. + * have determined whether or not the page is all_visible and able to + * become all_frozen. * */ - all_frozen = true; - - /* - * Now scan the page to collect LP_DEAD items and update the variables set - * just above. - */ for (offnum = FirstOffsetNumber; offnum <= maxoff; offnum = OffsetNumberNext(offnum)) { - HeapTupleHeader htup; - bool totally_frozen; - /* * Set the offset number so that we can display it along with any * error that occurred while processing this tuple. @@ -1521,8 +1506,6 @@ lazy_scan_prune(LVRelState *vacrel, Assert(ItemIdIsNormal(itemid)); - htup = (HeapTupleHeader) PageGetItem(page, itemid); - /* * The criteria for counting a tuple as live in this block need to * match what analyze.c's acquire_sample_rows() does, otherwise VACUUM @@ -1587,29 +1570,8 @@ lazy_scan_prune(LVRelState *vacrel, hastup = true; /* page makes rel truncation unsafe */ - /* Tuple with storage -- consider need to freeze */ - if (heap_prepare_freeze_tuple(htup, &pagefrz, - &frozen[tuples_frozen], &totally_frozen)) - { - /* Save prepared freeze plan for later */ - frozen[tuples_frozen++].offset = offnum; - } - - /* - * If any tuple isn't either totally frozen already or eligible to - * become totally frozen (according to its freeze plan), then the page - * definitely cannot be set all-frozen in the visibility map later on - */ - if (!totally_frozen) - all_frozen = false; } - /* - * We have now divided every item on the page into either an LP_DEAD item - * that will need to be vacuumed in indexes later, or a LP_NORMAL tuple - * that remains and needs to be considered for freezing now (LP_UNUSED and - * LP_REDIRECT items also remain, but are of no further interest to us). - */ vacrel->offnum = InvalidOffsetNumber; /* @@ -1618,8 +1580,8 @@ 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 || tuples_frozen == 0 || - (presult.all_visible_except_removable && all_frozen && + if (pagefrz.freeze_required || presult.nfrozen == 0 || + (presult.all_visible_except_removable && presult.all_frozen && fpi_before != pgWalUsage.wal_fpi)) { /* @@ -1629,7 +1591,7 @@ lazy_scan_prune(LVRelState *vacrel, vacrel->NewRelfrozenXid = pagefrz.FreezePageRelfrozenXid; vacrel->NewRelminMxid = pagefrz.FreezePageRelminMxid; - if (tuples_frozen == 0) + if (presult.nfrozen == 0) { /* * We have no freeze plans to execute, so there's no added cost @@ -1657,7 +1619,7 @@ lazy_scan_prune(LVRelState *vacrel, * once we're done with it. Otherwise we generate a conservative * cutoff by stepping back from OldestXmin. */ - if (presult.all_visible_except_removable && all_frozen) + if (presult.all_visible_except_removable && presult.all_frozen) { /* Using same cutoff when setting VM is now unnecessary */ snapshotConflictHorizon = presult.frz_conflict_horizon; @@ -1673,7 +1635,7 @@ lazy_scan_prune(LVRelState *vacrel, /* Execute all freeze plans for page as a single atomic action */ heap_freeze_execute_prepared(vacrel->rel, buf, snapshotConflictHorizon, - frozen, tuples_frozen); + presult.frozen, presult.nfrozen); } } else @@ -1684,8 +1646,8 @@ lazy_scan_prune(LVRelState *vacrel, */ vacrel->NewRelfrozenXid = pagefrz.NoFreezePageRelfrozenXid; vacrel->NewRelminMxid = pagefrz.NoFreezePageRelminMxid; - all_frozen = false; - tuples_frozen = 0; /* avoid miscounts in instrumentation */ + presult.all_frozen = false; + presult.nfrozen = 0; /* avoid miscounts in instrumentation */ } /* @@ -1708,6 +1670,8 @@ lazy_scan_prune(LVRelState *vacrel, &debug_cutoff, &debug_all_frozen)) Assert(false); + Assert(presult.all_frozen == debug_all_frozen); + Assert(!TransactionIdIsValid(debug_cutoff) || debug_cutoff == presult.frz_conflict_horizon); } @@ -1738,7 +1702,7 @@ lazy_scan_prune(LVRelState *vacrel, /* Finally, add page-local counts to whole-VACUUM counts */ vacrel->tuples_deleted += presult.ndeleted; - vacrel->tuples_frozen += tuples_frozen; + vacrel->tuples_frozen += presult.nfrozen; vacrel->lpdead_items += lpdead_items; vacrel->live_tuples += live_tuples; vacrel->recently_dead_tuples += recently_dead_tuples; @@ -1761,7 +1725,7 @@ lazy_scan_prune(LVRelState *vacrel, { uint8 flags = VISIBILITYMAP_ALL_VISIBLE; - if (all_frozen) + if (presult.all_frozen) { Assert(!TransactionIdIsValid(presult.frz_conflict_horizon)); flags |= VISIBILITYMAP_ALL_FROZEN; @@ -1832,7 +1796,7 @@ lazy_scan_prune(LVRelState *vacrel, * true, so we must check both all_visible and all_frozen. */ else if (all_visible_according_to_vm && presult.all_visible && - all_frozen && !VM_ALL_FROZEN(vacrel->rel, blkno, &vmbuffer)) + presult.all_frozen && !VM_ALL_FROZEN(vacrel->rel, blkno, &vmbuffer)) { /* * Avoid relying on all_visible_according_to_vm as a proxy for the diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h index 297ba03bf09..2339abfd28a 100644 --- a/src/include/access/heapam.h +++ b/src/include/access/heapam.h @@ -201,6 +201,11 @@ typedef struct PruneResult int nnewlpdead; /* Number of newly LP_DEAD items */ bool all_visible; /* Whether or not the page is all visible */ bool all_visible_except_removable; + /* Whether or not the page can be set all frozen in the VM */ + bool all_frozen; + + /* Number of newly frozen tuples */ + int nfrozen; TransactionId frz_conflict_horizon; /* Newest xmin on the page */ /* @@ -213,6 +218,12 @@ typedef struct PruneResult * 1. Otherwise every access would need to subtract 1. */ int8 htsv[MaxHeapTuplesPerPage + 1]; + + + /* + * One entry for every tuple that we may freeze. + */ + HeapTupleFreeze frozen[MaxHeapTuplesPerPage]; } PruneResult; /* @@ -324,6 +335,7 @@ extern void heap_page_prune_opt(Relation relation, Buffer buffer); extern void heap_page_prune(Relation relation, Buffer buffer, struct GlobalVisState *vistest, bool mark_unused_now, + HeapPageFreeze *pagefrz, PruneResult *presult, OffsetNumber *off_loc); extern void heap_page_prune_execute(Buffer buffer, -- 2.40.1 --tez7m2a73jtztiij Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v4-0008-lazy_scan_prune-reorder-freeze-execution-logic.patch" ^ permalink raw reply [nested|flat] 11+ messages in thread
* [PATCH v4 07/19] Prepare freeze tuples in heap_page_prune() @ 2024-03-19 00:01 Melanie Plageman <melanieplageman@gmail.com> 0 siblings, 0 replies; 11+ messages in thread From: Melanie Plageman @ 2024-03-19 00:01 UTC (permalink / raw) In order to combine the freeze and prune records, we must determine which tuples are freezable before actually executing pruning. All of the page modifications should be made in the same critical section along with emitting the combined WAL. Determine whether or not tuples should or must be frozen and whether or not the page will be all frozen as a consequence during pruning. --- src/backend/access/heap/pruneheap.c | 41 +++++++++++++++-- src/backend/access/heap/vacuumlazy.c | 68 +++++++--------------------- src/include/access/heapam.h | 12 +++++ 3 files changed, 66 insertions(+), 55 deletions(-) diff --git a/src/backend/access/heap/pruneheap.c b/src/backend/access/heap/pruneheap.c index bd30296ef1a..afc5ea5e0e7 100644 --- a/src/backend/access/heap/pruneheap.c +++ b/src/backend/access/heap/pruneheap.c @@ -153,7 +153,7 @@ heap_page_prune_opt(Relation relation, Buffer buffer) * not the relation has indexes, since we cannot safely determine * that during on-access pruning with the current implementation. */ - heap_page_prune(relation, buffer, vistest, false, + heap_page_prune(relation, buffer, vistest, false, NULL, &presult, NULL); /* @@ -206,6 +206,9 @@ heap_page_prune_opt(Relation relation, Buffer buffer) * mark_unused_now indicates whether or not dead items can be set LP_UNUSED * during pruning. * + * pagefrz contains both input and output parameters used if the caller is + * interested in potentially freezing tuples on the page. + * * presult contains output parameters needed by callers such as the number of * tuples removed and the number of line pointers newly marked LP_DEAD. * heap_page_prune() is responsible for initializing it. @@ -217,6 +220,7 @@ void heap_page_prune(Relation relation, Buffer buffer, GlobalVisState *vistest, bool mark_unused_now, + HeapPageFreeze *pagefrz, PruneResult *presult, OffsetNumber *off_loc) { @@ -247,11 +251,16 @@ heap_page_prune(Relation relation, Buffer buffer, presult->ndeleted = 0; presult->nnewlpdead = 0; + presult->nfrozen = 0; /* - * Keep track of whether or not the page is all_visible in case the caller - * wants to use this information to update the VM. + * Caller will update the VM after pruning, collecting LP_DEAD items, and + * freezing tuples. Keep track of whether or not the page is all_visible + * and all_frozen and use this information to update the VM. all_visible + * implies lpdead_items == 0, but don't trust all_frozen result unless + * all_visible is also set to true. */ + presult->all_frozen = true; presult->all_visible = true; /* for recovery conflicts */ presult->frz_conflict_horizon = InvalidTransactionId; @@ -381,6 +390,32 @@ heap_page_prune(Relation relation, Buffer buffer, elog(ERROR, "unexpected HeapTupleSatisfiesVacuum result"); break; } + + /* + * Consider freezing any normal tuples which will not be removed + */ + if (presult->htsv[offnum] != HEAPTUPLE_DEAD && pagefrz) + { + bool totally_frozen; + + /* Tuple with storage -- consider need to freeze */ + if ((heap_prepare_freeze_tuple(htup, pagefrz, + &presult->frozen[presult->nfrozen], + &totally_frozen))) + { + /* Save prepared freeze plan for later */ + presult->frozen[presult->nfrozen++].offset = offnum; + } + + /* + * If any tuple isn't either totally frozen already or eligible to + * become totally frozen (according to its freeze plan), then the + * page definitely cannot be set all-frozen in the visibility map + * later on + */ + if (!totally_frozen) + presult->all_frozen = false; + } } /* diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c index 06e0e841582..4187c998d25 100644 --- a/src/backend/access/heap/vacuumlazy.c +++ b/src/backend/access/heap/vacuumlazy.c @@ -1416,16 +1416,13 @@ lazy_scan_prune(LVRelState *vacrel, maxoff; ItemId itemid; PruneResult presult; - int tuples_frozen, - lpdead_items, + int lpdead_items, live_tuples, recently_dead_tuples; HeapPageFreeze pagefrz; bool hastup = false; - bool all_frozen; int64 fpi_before = pgWalUsage.wal_fpi; OffsetNumber deadoffsets[MaxHeapTuplesPerPage]; - HeapTupleFreeze frozen[MaxHeapTuplesPerPage]; Assert(BufferGetBlockNumber(buf) == blkno); @@ -1443,7 +1440,6 @@ lazy_scan_prune(LVRelState *vacrel, pagefrz.NoFreezePageRelfrozenXid = vacrel->NewRelfrozenXid; pagefrz.NoFreezePageRelminMxid = vacrel->NewRelminMxid; pagefrz.cutoffs = &vacrel->cutoffs; - tuples_frozen = 0; lpdead_items = 0; live_tuples = 0; recently_dead_tuples = 0; @@ -1461,31 +1457,20 @@ lazy_scan_prune(LVRelState *vacrel, * false otherwise. */ heap_page_prune(rel, buf, vacrel->vistest, vacrel->nindexes == 0, - &presult, &vacrel->offnum); + &pagefrz, &presult, &vacrel->offnum); /* * Now scan the page to collect LP_DEAD items and check for tuples * requiring freezing among remaining tuples with storage. We will update * the VM after collecting LP_DEAD items and freezing tuples. Pruning will - * have determined whether or not the page is all_visible. Keep track of - * whether or not the page is all_frozen and use this information to - * update the VM. all_visible implies lpdead_items == 0, but don't trust - * all_frozen result unless all_visible is also set to true. + * have determined whether or not the page is all_visible and able to + * become all_frozen. * */ - all_frozen = true; - - /* - * Now scan the page to collect LP_DEAD items and update the variables set - * just above. - */ for (offnum = FirstOffsetNumber; offnum <= maxoff; offnum = OffsetNumberNext(offnum)) { - HeapTupleHeader htup; - bool totally_frozen; - /* * Set the offset number so that we can display it along with any * error that occurred while processing this tuple. @@ -1521,8 +1506,6 @@ lazy_scan_prune(LVRelState *vacrel, Assert(ItemIdIsNormal(itemid)); - htup = (HeapTupleHeader) PageGetItem(page, itemid); - /* * The criteria for counting a tuple as live in this block need to * match what analyze.c's acquire_sample_rows() does, otherwise VACUUM @@ -1587,29 +1570,8 @@ lazy_scan_prune(LVRelState *vacrel, hastup = true; /* page makes rel truncation unsafe */ - /* Tuple with storage -- consider need to freeze */ - if (heap_prepare_freeze_tuple(htup, &pagefrz, - &frozen[tuples_frozen], &totally_frozen)) - { - /* Save prepared freeze plan for later */ - frozen[tuples_frozen++].offset = offnum; - } - - /* - * If any tuple isn't either totally frozen already or eligible to - * become totally frozen (according to its freeze plan), then the page - * definitely cannot be set all-frozen in the visibility map later on - */ - if (!totally_frozen) - all_frozen = false; } - /* - * We have now divided every item on the page into either an LP_DEAD item - * that will need to be vacuumed in indexes later, or a LP_NORMAL tuple - * that remains and needs to be considered for freezing now (LP_UNUSED and - * LP_REDIRECT items also remain, but are of no further interest to us). - */ vacrel->offnum = InvalidOffsetNumber; /* @@ -1618,8 +1580,8 @@ 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 || tuples_frozen == 0 || - (presult.all_visible_except_removable && all_frozen && + if (pagefrz.freeze_required || presult.nfrozen == 0 || + (presult.all_visible_except_removable && presult.all_frozen && fpi_before != pgWalUsage.wal_fpi)) { /* @@ -1629,7 +1591,7 @@ lazy_scan_prune(LVRelState *vacrel, vacrel->NewRelfrozenXid = pagefrz.FreezePageRelfrozenXid; vacrel->NewRelminMxid = pagefrz.FreezePageRelminMxid; - if (tuples_frozen == 0) + if (presult.nfrozen == 0) { /* * We have no freeze plans to execute, so there's no added cost @@ -1657,7 +1619,7 @@ lazy_scan_prune(LVRelState *vacrel, * once we're done with it. Otherwise we generate a conservative * cutoff by stepping back from OldestXmin. */ - if (presult.all_visible_except_removable && all_frozen) + if (presult.all_visible_except_removable && presult.all_frozen) { /* Using same cutoff when setting VM is now unnecessary */ snapshotConflictHorizon = presult.frz_conflict_horizon; @@ -1673,7 +1635,7 @@ lazy_scan_prune(LVRelState *vacrel, /* Execute all freeze plans for page as a single atomic action */ heap_freeze_execute_prepared(vacrel->rel, buf, snapshotConflictHorizon, - frozen, tuples_frozen); + presult.frozen, presult.nfrozen); } } else @@ -1684,8 +1646,8 @@ lazy_scan_prune(LVRelState *vacrel, */ vacrel->NewRelfrozenXid = pagefrz.NoFreezePageRelfrozenXid; vacrel->NewRelminMxid = pagefrz.NoFreezePageRelminMxid; - all_frozen = false; - tuples_frozen = 0; /* avoid miscounts in instrumentation */ + presult.all_frozen = false; + presult.nfrozen = 0; /* avoid miscounts in instrumentation */ } /* @@ -1708,6 +1670,8 @@ lazy_scan_prune(LVRelState *vacrel, &debug_cutoff, &debug_all_frozen)) Assert(false); + Assert(presult.all_frozen == debug_all_frozen); + Assert(!TransactionIdIsValid(debug_cutoff) || debug_cutoff == presult.frz_conflict_horizon); } @@ -1738,7 +1702,7 @@ lazy_scan_prune(LVRelState *vacrel, /* Finally, add page-local counts to whole-VACUUM counts */ vacrel->tuples_deleted += presult.ndeleted; - vacrel->tuples_frozen += tuples_frozen; + vacrel->tuples_frozen += presult.nfrozen; vacrel->lpdead_items += lpdead_items; vacrel->live_tuples += live_tuples; vacrel->recently_dead_tuples += recently_dead_tuples; @@ -1761,7 +1725,7 @@ lazy_scan_prune(LVRelState *vacrel, { uint8 flags = VISIBILITYMAP_ALL_VISIBLE; - if (all_frozen) + if (presult.all_frozen) { Assert(!TransactionIdIsValid(presult.frz_conflict_horizon)); flags |= VISIBILITYMAP_ALL_FROZEN; @@ -1832,7 +1796,7 @@ lazy_scan_prune(LVRelState *vacrel, * true, so we must check both all_visible and all_frozen. */ else if (all_visible_according_to_vm && presult.all_visible && - all_frozen && !VM_ALL_FROZEN(vacrel->rel, blkno, &vmbuffer)) + presult.all_frozen && !VM_ALL_FROZEN(vacrel->rel, blkno, &vmbuffer)) { /* * Avoid relying on all_visible_according_to_vm as a proxy for the diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h index 297ba03bf09..2339abfd28a 100644 --- a/src/include/access/heapam.h +++ b/src/include/access/heapam.h @@ -201,6 +201,11 @@ typedef struct PruneResult int nnewlpdead; /* Number of newly LP_DEAD items */ bool all_visible; /* Whether or not the page is all visible */ bool all_visible_except_removable; + /* Whether or not the page can be set all frozen in the VM */ + bool all_frozen; + + /* Number of newly frozen tuples */ + int nfrozen; TransactionId frz_conflict_horizon; /* Newest xmin on the page */ /* @@ -213,6 +218,12 @@ typedef struct PruneResult * 1. Otherwise every access would need to subtract 1. */ int8 htsv[MaxHeapTuplesPerPage + 1]; + + + /* + * One entry for every tuple that we may freeze. + */ + HeapTupleFreeze frozen[MaxHeapTuplesPerPage]; } PruneResult; /* @@ -324,6 +335,7 @@ extern void heap_page_prune_opt(Relation relation, Buffer buffer); extern void heap_page_prune(Relation relation, Buffer buffer, struct GlobalVisState *vistest, bool mark_unused_now, + HeapPageFreeze *pagefrz, PruneResult *presult, OffsetNumber *off_loc); extern void heap_page_prune_execute(Buffer buffer, -- 2.40.1 --tez7m2a73jtztiij Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v4-0008-lazy_scan_prune-reorder-freeze-execution-logic.patch" ^ permalink raw reply [nested|flat] 11+ messages in thread
* [PATCH v7 06/16] Prepare freeze tuples in heap_page_prune() @ 2024-03-25 23:23 Melanie Plageman <melanieplageman@gmail.com> 0 siblings, 0 replies; 11+ messages in thread From: Melanie Plageman @ 2024-03-25 23:23 UTC (permalink / raw) In order to combine the freeze and prune records, we must determine which tuples are freezable before actually executing pruning. All of the page modifications should be made in the same critical section along with emitting the combined WAL. Determine whether or not tuples should or must be frozen and whether or not the page will be all frozen as a consequence during pruning. --- src/backend/access/heap/pruneheap.c | 41 +++++++++++++++-- src/backend/access/heap/vacuumlazy.c | 68 ++++++---------------------- src/include/access/heapam.h | 12 +++++ 3 files changed, 64 insertions(+), 57 deletions(-) diff --git a/src/backend/access/heap/pruneheap.c b/src/backend/access/heap/pruneheap.c index 5776ae84f4d..457650ab651 100644 --- a/src/backend/access/heap/pruneheap.c +++ b/src/backend/access/heap/pruneheap.c @@ -153,7 +153,7 @@ heap_page_prune_opt(Relation relation, Buffer buffer) * not the relation has indexes, since we cannot safely determine * that during on-access pruning with the current implementation. */ - heap_page_prune(relation, buffer, vistest, false, + heap_page_prune(relation, buffer, vistest, false, NULL, &presult, PRUNE_ON_ACCESS, NULL); /* @@ -201,6 +201,9 @@ heap_page_prune_opt(Relation relation, Buffer buffer) * mark_unused_now indicates whether or not dead items can be set LP_UNUSED * during pruning. * + * pagefrz contains both input and output parameters used if the caller is + * interested in potentially freezing tuples on the page. + * * presult contains output parameters needed by callers such as the number of * tuples removed and the number of line pointers newly marked LP_DEAD. * heap_page_prune() is responsible for initializing it. @@ -215,6 +218,7 @@ void heap_page_prune(Relation relation, Buffer buffer, GlobalVisState *vistest, bool mark_unused_now, + HeapPageFreeze *pagefrz, PruneResult *presult, PruneReason reason, OffsetNumber *off_loc) @@ -250,11 +254,16 @@ heap_page_prune(Relation relation, Buffer buffer, */ presult->ndeleted = 0; presult->nnewlpdead = 0; + presult->nfrozen = 0; /* - * Keep track of whether or not the page is all_visible in case the caller - * wants to use this information to update the VM. + * Caller will update the VM after pruning, collecting LP_DEAD items, and + * freezing tuples. Keep track of whether or not the page is all_visible + * and all_frozen and use this information to update the VM. all_visible + * implies lpdead_items == 0, but don't trust all_frozen result unless + * all_visible is also set to true. */ + presult->all_frozen = true; presult->all_visible = true; /* for recovery conflicts */ presult->visibility_cutoff_xid = InvalidTransactionId; @@ -388,6 +397,32 @@ heap_page_prune(Relation relation, Buffer buffer, elog(ERROR, "unexpected HeapTupleSatisfiesVacuum result"); break; } + + /* + * Consider freezing any normal tuples which will not be removed + */ + if (presult->htsv[offnum] != HEAPTUPLE_DEAD && pagefrz) + { + bool totally_frozen; + + /* Tuple with storage -- consider need to freeze */ + if ((heap_prepare_freeze_tuple(htup, pagefrz, + &presult->frozen[presult->nfrozen], + &totally_frozen))) + { + /* Save prepared freeze plan for later */ + presult->frozen[presult->nfrozen++].offset = offnum; + } + + /* + * If any tuple isn't either totally frozen already or eligible to + * become totally frozen (according to its freeze plan), then the + * page definitely cannot be set all-frozen in the visibility map + * later on + */ + if (!totally_frozen) + presult->all_frozen = false; + } } /* diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c index 1b060124a3f..2a3cc5c7cd3 100644 --- a/src/backend/access/heap/vacuumlazy.c +++ b/src/backend/access/heap/vacuumlazy.c @@ -1416,16 +1416,13 @@ lazy_scan_prune(LVRelState *vacrel, maxoff; ItemId itemid; PruneResult presult; - int tuples_frozen, - lpdead_items, + int lpdead_items, live_tuples, recently_dead_tuples; HeapPageFreeze pagefrz; bool hastup = false; - bool all_frozen; int64 fpi_before = pgWalUsage.wal_fpi; OffsetNumber deadoffsets[MaxHeapTuplesPerPage]; - HeapTupleFreeze frozen[MaxHeapTuplesPerPage]; Assert(BufferGetBlockNumber(buf) == blkno); @@ -1443,7 +1440,6 @@ lazy_scan_prune(LVRelState *vacrel, pagefrz.NoFreezePageRelfrozenXid = vacrel->NewRelfrozenXid; pagefrz.NoFreezePageRelminMxid = vacrel->NewRelminMxid; pagefrz.cutoffs = &vacrel->cutoffs; - tuples_frozen = 0; lpdead_items = 0; live_tuples = 0; recently_dead_tuples = 0; @@ -1460,21 +1456,9 @@ lazy_scan_prune(LVRelState *vacrel, * items LP_UNUSED, so mark_unused_now should be true if no indexes and * false otherwise. */ - heap_page_prune(rel, buf, vacrel->vistest, vacrel->nindexes == 0, + heap_page_prune(rel, buf, vacrel->vistest, vacrel->nindexes == 0, &pagefrz, &presult, PRUNE_VACUUM_SCAN, &vacrel->offnum); - /* - * Now scan the page to collect LP_DEAD items and check for tuples - * requiring freezing among remaining tuples with storage. We will update - * the VM after collecting LP_DEAD items and freezing tuples. Pruning will - * have determined whether or not the page is all_visible. Keep track of - * whether or not the page is all_frozen and use this information to - * update the VM. all_visible implies lpdead_items == 0, but don't trust - * all_frozen result unless all_visible is also set to true. - * - */ - all_frozen = true; - /* * Now scan the page to collect LP_DEAD items and update the variables set * just above. @@ -1483,9 +1467,6 @@ lazy_scan_prune(LVRelState *vacrel, offnum <= maxoff; offnum = OffsetNumberNext(offnum)) { - HeapTupleHeader htup; - bool totally_frozen; - /* * Set the offset number so that we can display it along with any * error that occurred while processing this tuple. @@ -1521,8 +1502,6 @@ lazy_scan_prune(LVRelState *vacrel, Assert(ItemIdIsNormal(itemid)); - htup = (HeapTupleHeader) PageGetItem(page, itemid); - /* * The criteria for counting a tuple as live in this block need to * match what analyze.c's acquire_sample_rows() does, otherwise VACUUM @@ -1587,29 +1566,8 @@ lazy_scan_prune(LVRelState *vacrel, hastup = true; /* page makes rel truncation unsafe */ - /* Tuple with storage -- consider need to freeze */ - if (heap_prepare_freeze_tuple(htup, &pagefrz, - &frozen[tuples_frozen], &totally_frozen)) - { - /* Save prepared freeze plan for later */ - frozen[tuples_frozen++].offset = offnum; - } - - /* - * If any tuple isn't either totally frozen already or eligible to - * become totally frozen (according to its freeze plan), then the page - * definitely cannot be set all-frozen in the visibility map later on - */ - if (!totally_frozen) - all_frozen = false; } - /* - * We have now divided every item on the page into either an LP_DEAD item - * that will need to be vacuumed in indexes later, or a LP_NORMAL tuple - * that remains and needs to be considered for freezing now (LP_UNUSED and - * LP_REDIRECT items also remain, but are of no further interest to us). - */ vacrel->offnum = InvalidOffsetNumber; /* @@ -1618,8 +1576,8 @@ 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 || tuples_frozen == 0 || - (presult.all_visible_except_removable && all_frozen && + if (pagefrz.freeze_required || presult.nfrozen == 0 || + (presult.all_visible_except_removable && presult.all_frozen && fpi_before != pgWalUsage.wal_fpi)) { /* @@ -1629,7 +1587,7 @@ lazy_scan_prune(LVRelState *vacrel, vacrel->NewRelfrozenXid = pagefrz.FreezePageRelfrozenXid; vacrel->NewRelminMxid = pagefrz.FreezePageRelminMxid; - if (tuples_frozen == 0) + if (presult.nfrozen == 0) { /* * We have no freeze plans to execute, so there's no added cost @@ -1657,7 +1615,7 @@ lazy_scan_prune(LVRelState *vacrel, * once we're done with it. Otherwise we generate a conservative * cutoff by stepping back from OldestXmin. */ - if (presult.all_visible_except_removable && all_frozen) + if (presult.all_visible_except_removable && presult.all_frozen) { /* Using same cutoff when setting VM is now unnecessary */ snapshotConflictHorizon = presult.visibility_cutoff_xid; @@ -1673,7 +1631,7 @@ lazy_scan_prune(LVRelState *vacrel, /* Execute all freeze plans for page as a single atomic action */ heap_freeze_execute_prepared(vacrel->rel, buf, snapshotConflictHorizon, - frozen, tuples_frozen); + presult.frozen, presult.nfrozen); } } else @@ -1684,8 +1642,8 @@ lazy_scan_prune(LVRelState *vacrel, */ vacrel->NewRelfrozenXid = pagefrz.NoFreezePageRelfrozenXid; vacrel->NewRelminMxid = pagefrz.NoFreezePageRelminMxid; - all_frozen = false; - tuples_frozen = 0; /* avoid miscounts in instrumentation */ + presult.all_frozen = false; + presult.nfrozen = 0; /* avoid miscounts in instrumentation */ } /* @@ -1708,6 +1666,8 @@ lazy_scan_prune(LVRelState *vacrel, &debug_cutoff, &debug_all_frozen)) Assert(false); + Assert(presult.all_frozen == debug_all_frozen); + Assert(!TransactionIdIsValid(debug_cutoff) || debug_cutoff == presult.visibility_cutoff_xid); } @@ -1738,7 +1698,7 @@ lazy_scan_prune(LVRelState *vacrel, /* Finally, add page-local counts to whole-VACUUM counts */ vacrel->tuples_deleted += presult.ndeleted; - vacrel->tuples_frozen += tuples_frozen; + vacrel->tuples_frozen += presult.nfrozen; vacrel->lpdead_items += lpdead_items; vacrel->live_tuples += live_tuples; vacrel->recently_dead_tuples += recently_dead_tuples; @@ -1761,7 +1721,7 @@ lazy_scan_prune(LVRelState *vacrel, { uint8 flags = VISIBILITYMAP_ALL_VISIBLE; - if (all_frozen) + if (presult.all_frozen) { Assert(!TransactionIdIsValid(presult.visibility_cutoff_xid)); flags |= VISIBILITYMAP_ALL_FROZEN; @@ -1832,7 +1792,7 @@ lazy_scan_prune(LVRelState *vacrel, * true, so we must check both all_visible and all_frozen. */ else if (all_visible_according_to_vm && presult.all_visible && - all_frozen && !VM_ALL_FROZEN(vacrel->rel, blkno, &vmbuffer)) + presult.all_frozen && !VM_ALL_FROZEN(vacrel->rel, blkno, &vmbuffer)) { /* * Avoid relying on all_visible_according_to_vm as a proxy for the diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h index 3f510e8e197..59c81f38e51 100644 --- a/src/include/access/heapam.h +++ b/src/include/access/heapam.h @@ -219,6 +219,9 @@ typedef struct PruneResult * page. */ bool all_visible_except_removable; + + /* Whether or not the page can be set all-frozen in the VM */ + bool all_frozen; TransactionId visibility_cutoff_xid; /* Newest xmin on the page */ /* @@ -231,6 +234,14 @@ typedef struct PruneResult * 1. Otherwise every access would need to subtract 1. */ int8 htsv[MaxHeapTuplesPerPage + 1]; + + /* Number of tuples we may freeze */ + int nfrozen; + + /* + * One entry for every tuple that we may freeze. + */ + HeapTupleFreeze frozen[MaxHeapTuplesPerPage]; } PruneResult; /* 'reason' codes for heap_page_prune() */ @@ -350,6 +361,7 @@ extern void heap_page_prune_opt(Relation relation, Buffer buffer); extern void heap_page_prune(Relation relation, Buffer buffer, struct GlobalVisState *vistest, bool mark_unused_now, + HeapPageFreeze *pagefrz, PruneResult *presult, PruneReason reason, OffsetNumber *off_loc); -- 2.40.1 --ck6erxojvlx23byk Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v7-0007-lazy_scan_prune-reorder-freeze-execution-logic.patch" ^ permalink raw reply [nested|flat] 11+ messages in thread
* [PATCH v9 06/21] Prepare freeze tuples in heap_page_prune() @ 2024-03-25 23:23 Melanie Plageman <melanieplageman@gmail.com> 0 siblings, 0 replies; 11+ messages in thread From: Melanie Plageman @ 2024-03-25 23:23 UTC (permalink / raw) In order to combine the freeze and prune records, we must determine which tuples are freezable before actually executing pruning. All of the page modifications should be made in the same critical section along with emitting the combined WAL. Determine whether or not tuples should or must be frozen and whether or not the page will be all frozen as a consequence during pruning. --- src/backend/access/heap/pruneheap.c | 41 +++++++++++++++-- src/backend/access/heap/vacuumlazy.c | 68 ++++++---------------------- src/include/access/heapam.h | 12 +++++ 3 files changed, 64 insertions(+), 57 deletions(-) diff --git a/src/backend/access/heap/pruneheap.c b/src/backend/access/heap/pruneheap.c index 52513fcdc90..eb09713311b 100644 --- a/src/backend/access/heap/pruneheap.c +++ b/src/backend/access/heap/pruneheap.c @@ -153,7 +153,7 @@ heap_page_prune_opt(Relation relation, Buffer buffer) * not the relation has indexes, since we cannot safely determine * that during on-access pruning with the current implementation. */ - heap_page_prune(relation, buffer, vistest, false, + heap_page_prune(relation, buffer, vistest, false, NULL, &presult, PRUNE_ON_ACCESS, NULL); /* @@ -201,6 +201,9 @@ heap_page_prune_opt(Relation relation, Buffer buffer) * mark_unused_now indicates whether or not dead items can be set LP_UNUSED * during pruning. * + * pagefrz contains both input and output parameters used if the caller is + * interested in potentially freezing tuples on the page. + * * presult contains output parameters needed by callers such as the number of * tuples removed and the number of line pointers newly marked LP_DEAD. * heap_page_prune() is responsible for initializing it. @@ -215,6 +218,7 @@ void heap_page_prune(Relation relation, Buffer buffer, GlobalVisState *vistest, bool mark_unused_now, + HeapPageFreeze *pagefrz, PruneResult *presult, PruneReason reason, OffsetNumber *off_loc) @@ -250,11 +254,16 @@ heap_page_prune(Relation relation, Buffer buffer, */ presult->ndeleted = 0; presult->nnewlpdead = 0; + presult->nfrozen = 0; /* - * Keep track of whether or not the page is all_visible in case the caller - * wants to use this information to update the VM. + * Caller will update the VM after pruning, collecting LP_DEAD items, and + * freezing tuples. Keep track of whether or not the page is all_visible + * and all_frozen and use this information to update the VM. all_visible + * implies lpdead_items == 0, but don't trust all_frozen result unless + * all_visible is also set to true. */ + presult->all_frozen = true; presult->all_visible = true; /* for recovery conflicts */ presult->visibility_cutoff_xid = InvalidTransactionId; @@ -388,6 +397,32 @@ heap_page_prune(Relation relation, Buffer buffer, elog(ERROR, "unexpected HeapTupleSatisfiesVacuum result"); break; } + + /* + * Consider freezing any normal tuples which will not be removed + */ + if (presult->htsv[offnum] != HEAPTUPLE_DEAD && pagefrz) + { + bool totally_frozen; + + /* Tuple with storage -- consider need to freeze */ + if ((heap_prepare_freeze_tuple(htup, pagefrz, + &presult->frozen[presult->nfrozen], + &totally_frozen))) + { + /* Save prepared freeze plan for later */ + presult->frozen[presult->nfrozen++].offset = offnum; + } + + /* + * If any tuple isn't either totally frozen already or eligible to + * become totally frozen (according to its freeze plan), then the + * page definitely cannot be set all-frozen in the visibility map + * later on + */ + if (!totally_frozen) + presult->all_frozen = false; + } } /* diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c index 1b060124a3f..2a3cc5c7cd3 100644 --- a/src/backend/access/heap/vacuumlazy.c +++ b/src/backend/access/heap/vacuumlazy.c @@ -1416,16 +1416,13 @@ lazy_scan_prune(LVRelState *vacrel, maxoff; ItemId itemid; PruneResult presult; - int tuples_frozen, - lpdead_items, + int lpdead_items, live_tuples, recently_dead_tuples; HeapPageFreeze pagefrz; bool hastup = false; - bool all_frozen; int64 fpi_before = pgWalUsage.wal_fpi; OffsetNumber deadoffsets[MaxHeapTuplesPerPage]; - HeapTupleFreeze frozen[MaxHeapTuplesPerPage]; Assert(BufferGetBlockNumber(buf) == blkno); @@ -1443,7 +1440,6 @@ lazy_scan_prune(LVRelState *vacrel, pagefrz.NoFreezePageRelfrozenXid = vacrel->NewRelfrozenXid; pagefrz.NoFreezePageRelminMxid = vacrel->NewRelminMxid; pagefrz.cutoffs = &vacrel->cutoffs; - tuples_frozen = 0; lpdead_items = 0; live_tuples = 0; recently_dead_tuples = 0; @@ -1460,21 +1456,9 @@ lazy_scan_prune(LVRelState *vacrel, * items LP_UNUSED, so mark_unused_now should be true if no indexes and * false otherwise. */ - heap_page_prune(rel, buf, vacrel->vistest, vacrel->nindexes == 0, + heap_page_prune(rel, buf, vacrel->vistest, vacrel->nindexes == 0, &pagefrz, &presult, PRUNE_VACUUM_SCAN, &vacrel->offnum); - /* - * Now scan the page to collect LP_DEAD items and check for tuples - * requiring freezing among remaining tuples with storage. We will update - * the VM after collecting LP_DEAD items and freezing tuples. Pruning will - * have determined whether or not the page is all_visible. Keep track of - * whether or not the page is all_frozen and use this information to - * update the VM. all_visible implies lpdead_items == 0, but don't trust - * all_frozen result unless all_visible is also set to true. - * - */ - all_frozen = true; - /* * Now scan the page to collect LP_DEAD items and update the variables set * just above. @@ -1483,9 +1467,6 @@ lazy_scan_prune(LVRelState *vacrel, offnum <= maxoff; offnum = OffsetNumberNext(offnum)) { - HeapTupleHeader htup; - bool totally_frozen; - /* * Set the offset number so that we can display it along with any * error that occurred while processing this tuple. @@ -1521,8 +1502,6 @@ lazy_scan_prune(LVRelState *vacrel, Assert(ItemIdIsNormal(itemid)); - htup = (HeapTupleHeader) PageGetItem(page, itemid); - /* * The criteria for counting a tuple as live in this block need to * match what analyze.c's acquire_sample_rows() does, otherwise VACUUM @@ -1587,29 +1566,8 @@ lazy_scan_prune(LVRelState *vacrel, hastup = true; /* page makes rel truncation unsafe */ - /* Tuple with storage -- consider need to freeze */ - if (heap_prepare_freeze_tuple(htup, &pagefrz, - &frozen[tuples_frozen], &totally_frozen)) - { - /* Save prepared freeze plan for later */ - frozen[tuples_frozen++].offset = offnum; - } - - /* - * If any tuple isn't either totally frozen already or eligible to - * become totally frozen (according to its freeze plan), then the page - * definitely cannot be set all-frozen in the visibility map later on - */ - if (!totally_frozen) - all_frozen = false; } - /* - * We have now divided every item on the page into either an LP_DEAD item - * that will need to be vacuumed in indexes later, or a LP_NORMAL tuple - * that remains and needs to be considered for freezing now (LP_UNUSED and - * LP_REDIRECT items also remain, but are of no further interest to us). - */ vacrel->offnum = InvalidOffsetNumber; /* @@ -1618,8 +1576,8 @@ 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 || tuples_frozen == 0 || - (presult.all_visible_except_removable && all_frozen && + if (pagefrz.freeze_required || presult.nfrozen == 0 || + (presult.all_visible_except_removable && presult.all_frozen && fpi_before != pgWalUsage.wal_fpi)) { /* @@ -1629,7 +1587,7 @@ lazy_scan_prune(LVRelState *vacrel, vacrel->NewRelfrozenXid = pagefrz.FreezePageRelfrozenXid; vacrel->NewRelminMxid = pagefrz.FreezePageRelminMxid; - if (tuples_frozen == 0) + if (presult.nfrozen == 0) { /* * We have no freeze plans to execute, so there's no added cost @@ -1657,7 +1615,7 @@ lazy_scan_prune(LVRelState *vacrel, * once we're done with it. Otherwise we generate a conservative * cutoff by stepping back from OldestXmin. */ - if (presult.all_visible_except_removable && all_frozen) + if (presult.all_visible_except_removable && presult.all_frozen) { /* Using same cutoff when setting VM is now unnecessary */ snapshotConflictHorizon = presult.visibility_cutoff_xid; @@ -1673,7 +1631,7 @@ lazy_scan_prune(LVRelState *vacrel, /* Execute all freeze plans for page as a single atomic action */ heap_freeze_execute_prepared(vacrel->rel, buf, snapshotConflictHorizon, - frozen, tuples_frozen); + presult.frozen, presult.nfrozen); } } else @@ -1684,8 +1642,8 @@ lazy_scan_prune(LVRelState *vacrel, */ vacrel->NewRelfrozenXid = pagefrz.NoFreezePageRelfrozenXid; vacrel->NewRelminMxid = pagefrz.NoFreezePageRelminMxid; - all_frozen = false; - tuples_frozen = 0; /* avoid miscounts in instrumentation */ + presult.all_frozen = false; + presult.nfrozen = 0; /* avoid miscounts in instrumentation */ } /* @@ -1708,6 +1666,8 @@ lazy_scan_prune(LVRelState *vacrel, &debug_cutoff, &debug_all_frozen)) Assert(false); + Assert(presult.all_frozen == debug_all_frozen); + Assert(!TransactionIdIsValid(debug_cutoff) || debug_cutoff == presult.visibility_cutoff_xid); } @@ -1738,7 +1698,7 @@ lazy_scan_prune(LVRelState *vacrel, /* Finally, add page-local counts to whole-VACUUM counts */ vacrel->tuples_deleted += presult.ndeleted; - vacrel->tuples_frozen += tuples_frozen; + vacrel->tuples_frozen += presult.nfrozen; vacrel->lpdead_items += lpdead_items; vacrel->live_tuples += live_tuples; vacrel->recently_dead_tuples += recently_dead_tuples; @@ -1761,7 +1721,7 @@ lazy_scan_prune(LVRelState *vacrel, { uint8 flags = VISIBILITYMAP_ALL_VISIBLE; - if (all_frozen) + if (presult.all_frozen) { Assert(!TransactionIdIsValid(presult.visibility_cutoff_xid)); flags |= VISIBILITYMAP_ALL_FROZEN; @@ -1832,7 +1792,7 @@ lazy_scan_prune(LVRelState *vacrel, * true, so we must check both all_visible and all_frozen. */ else if (all_visible_according_to_vm && presult.all_visible && - all_frozen && !VM_ALL_FROZEN(vacrel->rel, blkno, &vmbuffer)) + presult.all_frozen && !VM_ALL_FROZEN(vacrel->rel, blkno, &vmbuffer)) { /* * Avoid relying on all_visible_according_to_vm as a proxy for the diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h index 689427e2512..9d047621ea5 100644 --- a/src/include/access/heapam.h +++ b/src/include/access/heapam.h @@ -219,6 +219,9 @@ typedef struct PruneResult * page. */ bool all_visible_except_removable; + + /* Whether or not the page can be set all-frozen in the VM */ + bool all_frozen; TransactionId visibility_cutoff_xid; /* Newest xmin on the page */ /* @@ -231,6 +234,14 @@ typedef struct PruneResult * 1. Otherwise every access would need to subtract 1. */ int8 htsv[MaxHeapTuplesPerPage + 1]; + + /* Number of tuples we may freeze */ + int nfrozen; + + /* + * One entry for every tuple that we may freeze. + */ + HeapTupleFreeze frozen[MaxHeapTuplesPerPage]; } PruneResult; /* 'reason' codes for heap_page_prune() */ @@ -353,6 +364,7 @@ extern void heap_page_prune_opt(Relation relation, Buffer buffer); extern void heap_page_prune(Relation relation, Buffer buffer, struct GlobalVisState *vistest, bool mark_unused_now, + HeapPageFreeze *pagefrz, PruneResult *presult, PruneReason reason, OffsetNumber *off_loc); -- 2.40.1 --caj67xgx3lukmr5f Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v9-0007-lazy_scan_prune-reorder-freeze-execution-logic.patch" ^ permalink raw reply [nested|flat] 11+ messages in thread
* [PATCH v7 06/16] Prepare freeze tuples in heap_page_prune() @ 2024-03-25 23:23 Melanie Plageman <melanieplageman@gmail.com> 0 siblings, 0 replies; 11+ messages in thread From: Melanie Plageman @ 2024-03-25 23:23 UTC (permalink / raw) In order to combine the freeze and prune records, we must determine which tuples are freezable before actually executing pruning. All of the page modifications should be made in the same critical section along with emitting the combined WAL. Determine whether or not tuples should or must be frozen and whether or not the page will be all frozen as a consequence during pruning. --- src/backend/access/heap/pruneheap.c | 41 +++++++++++++++-- src/backend/access/heap/vacuumlazy.c | 68 ++++++---------------------- src/include/access/heapam.h | 12 +++++ 3 files changed, 64 insertions(+), 57 deletions(-) diff --git a/src/backend/access/heap/pruneheap.c b/src/backend/access/heap/pruneheap.c index 5776ae84f4d..457650ab651 100644 --- a/src/backend/access/heap/pruneheap.c +++ b/src/backend/access/heap/pruneheap.c @@ -153,7 +153,7 @@ heap_page_prune_opt(Relation relation, Buffer buffer) * not the relation has indexes, since we cannot safely determine * that during on-access pruning with the current implementation. */ - heap_page_prune(relation, buffer, vistest, false, + heap_page_prune(relation, buffer, vistest, false, NULL, &presult, PRUNE_ON_ACCESS, NULL); /* @@ -201,6 +201,9 @@ heap_page_prune_opt(Relation relation, Buffer buffer) * mark_unused_now indicates whether or not dead items can be set LP_UNUSED * during pruning. * + * pagefrz contains both input and output parameters used if the caller is + * interested in potentially freezing tuples on the page. + * * presult contains output parameters needed by callers such as the number of * tuples removed and the number of line pointers newly marked LP_DEAD. * heap_page_prune() is responsible for initializing it. @@ -215,6 +218,7 @@ void heap_page_prune(Relation relation, Buffer buffer, GlobalVisState *vistest, bool mark_unused_now, + HeapPageFreeze *pagefrz, PruneResult *presult, PruneReason reason, OffsetNumber *off_loc) @@ -250,11 +254,16 @@ heap_page_prune(Relation relation, Buffer buffer, */ presult->ndeleted = 0; presult->nnewlpdead = 0; + presult->nfrozen = 0; /* - * Keep track of whether or not the page is all_visible in case the caller - * wants to use this information to update the VM. + * Caller will update the VM after pruning, collecting LP_DEAD items, and + * freezing tuples. Keep track of whether or not the page is all_visible + * and all_frozen and use this information to update the VM. all_visible + * implies lpdead_items == 0, but don't trust all_frozen result unless + * all_visible is also set to true. */ + presult->all_frozen = true; presult->all_visible = true; /* for recovery conflicts */ presult->visibility_cutoff_xid = InvalidTransactionId; @@ -388,6 +397,32 @@ heap_page_prune(Relation relation, Buffer buffer, elog(ERROR, "unexpected HeapTupleSatisfiesVacuum result"); break; } + + /* + * Consider freezing any normal tuples which will not be removed + */ + if (presult->htsv[offnum] != HEAPTUPLE_DEAD && pagefrz) + { + bool totally_frozen; + + /* Tuple with storage -- consider need to freeze */ + if ((heap_prepare_freeze_tuple(htup, pagefrz, + &presult->frozen[presult->nfrozen], + &totally_frozen))) + { + /* Save prepared freeze plan for later */ + presult->frozen[presult->nfrozen++].offset = offnum; + } + + /* + * If any tuple isn't either totally frozen already or eligible to + * become totally frozen (according to its freeze plan), then the + * page definitely cannot be set all-frozen in the visibility map + * later on + */ + if (!totally_frozen) + presult->all_frozen = false; + } } /* diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c index 1b060124a3f..2a3cc5c7cd3 100644 --- a/src/backend/access/heap/vacuumlazy.c +++ b/src/backend/access/heap/vacuumlazy.c @@ -1416,16 +1416,13 @@ lazy_scan_prune(LVRelState *vacrel, maxoff; ItemId itemid; PruneResult presult; - int tuples_frozen, - lpdead_items, + int lpdead_items, live_tuples, recently_dead_tuples; HeapPageFreeze pagefrz; bool hastup = false; - bool all_frozen; int64 fpi_before = pgWalUsage.wal_fpi; OffsetNumber deadoffsets[MaxHeapTuplesPerPage]; - HeapTupleFreeze frozen[MaxHeapTuplesPerPage]; Assert(BufferGetBlockNumber(buf) == blkno); @@ -1443,7 +1440,6 @@ lazy_scan_prune(LVRelState *vacrel, pagefrz.NoFreezePageRelfrozenXid = vacrel->NewRelfrozenXid; pagefrz.NoFreezePageRelminMxid = vacrel->NewRelminMxid; pagefrz.cutoffs = &vacrel->cutoffs; - tuples_frozen = 0; lpdead_items = 0; live_tuples = 0; recently_dead_tuples = 0; @@ -1460,21 +1456,9 @@ lazy_scan_prune(LVRelState *vacrel, * items LP_UNUSED, so mark_unused_now should be true if no indexes and * false otherwise. */ - heap_page_prune(rel, buf, vacrel->vistest, vacrel->nindexes == 0, + heap_page_prune(rel, buf, vacrel->vistest, vacrel->nindexes == 0, &pagefrz, &presult, PRUNE_VACUUM_SCAN, &vacrel->offnum); - /* - * Now scan the page to collect LP_DEAD items and check for tuples - * requiring freezing among remaining tuples with storage. We will update - * the VM after collecting LP_DEAD items and freezing tuples. Pruning will - * have determined whether or not the page is all_visible. Keep track of - * whether or not the page is all_frozen and use this information to - * update the VM. all_visible implies lpdead_items == 0, but don't trust - * all_frozen result unless all_visible is also set to true. - * - */ - all_frozen = true; - /* * Now scan the page to collect LP_DEAD items and update the variables set * just above. @@ -1483,9 +1467,6 @@ lazy_scan_prune(LVRelState *vacrel, offnum <= maxoff; offnum = OffsetNumberNext(offnum)) { - HeapTupleHeader htup; - bool totally_frozen; - /* * Set the offset number so that we can display it along with any * error that occurred while processing this tuple. @@ -1521,8 +1502,6 @@ lazy_scan_prune(LVRelState *vacrel, Assert(ItemIdIsNormal(itemid)); - htup = (HeapTupleHeader) PageGetItem(page, itemid); - /* * The criteria for counting a tuple as live in this block need to * match what analyze.c's acquire_sample_rows() does, otherwise VACUUM @@ -1587,29 +1566,8 @@ lazy_scan_prune(LVRelState *vacrel, hastup = true; /* page makes rel truncation unsafe */ - /* Tuple with storage -- consider need to freeze */ - if (heap_prepare_freeze_tuple(htup, &pagefrz, - &frozen[tuples_frozen], &totally_frozen)) - { - /* Save prepared freeze plan for later */ - frozen[tuples_frozen++].offset = offnum; - } - - /* - * If any tuple isn't either totally frozen already or eligible to - * become totally frozen (according to its freeze plan), then the page - * definitely cannot be set all-frozen in the visibility map later on - */ - if (!totally_frozen) - all_frozen = false; } - /* - * We have now divided every item on the page into either an LP_DEAD item - * that will need to be vacuumed in indexes later, or a LP_NORMAL tuple - * that remains and needs to be considered for freezing now (LP_UNUSED and - * LP_REDIRECT items also remain, but are of no further interest to us). - */ vacrel->offnum = InvalidOffsetNumber; /* @@ -1618,8 +1576,8 @@ 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 || tuples_frozen == 0 || - (presult.all_visible_except_removable && all_frozen && + if (pagefrz.freeze_required || presult.nfrozen == 0 || + (presult.all_visible_except_removable && presult.all_frozen && fpi_before != pgWalUsage.wal_fpi)) { /* @@ -1629,7 +1587,7 @@ lazy_scan_prune(LVRelState *vacrel, vacrel->NewRelfrozenXid = pagefrz.FreezePageRelfrozenXid; vacrel->NewRelminMxid = pagefrz.FreezePageRelminMxid; - if (tuples_frozen == 0) + if (presult.nfrozen == 0) { /* * We have no freeze plans to execute, so there's no added cost @@ -1657,7 +1615,7 @@ lazy_scan_prune(LVRelState *vacrel, * once we're done with it. Otherwise we generate a conservative * cutoff by stepping back from OldestXmin. */ - if (presult.all_visible_except_removable && all_frozen) + if (presult.all_visible_except_removable && presult.all_frozen) { /* Using same cutoff when setting VM is now unnecessary */ snapshotConflictHorizon = presult.visibility_cutoff_xid; @@ -1673,7 +1631,7 @@ lazy_scan_prune(LVRelState *vacrel, /* Execute all freeze plans for page as a single atomic action */ heap_freeze_execute_prepared(vacrel->rel, buf, snapshotConflictHorizon, - frozen, tuples_frozen); + presult.frozen, presult.nfrozen); } } else @@ -1684,8 +1642,8 @@ lazy_scan_prune(LVRelState *vacrel, */ vacrel->NewRelfrozenXid = pagefrz.NoFreezePageRelfrozenXid; vacrel->NewRelminMxid = pagefrz.NoFreezePageRelminMxid; - all_frozen = false; - tuples_frozen = 0; /* avoid miscounts in instrumentation */ + presult.all_frozen = false; + presult.nfrozen = 0; /* avoid miscounts in instrumentation */ } /* @@ -1708,6 +1666,8 @@ lazy_scan_prune(LVRelState *vacrel, &debug_cutoff, &debug_all_frozen)) Assert(false); + Assert(presult.all_frozen == debug_all_frozen); + Assert(!TransactionIdIsValid(debug_cutoff) || debug_cutoff == presult.visibility_cutoff_xid); } @@ -1738,7 +1698,7 @@ lazy_scan_prune(LVRelState *vacrel, /* Finally, add page-local counts to whole-VACUUM counts */ vacrel->tuples_deleted += presult.ndeleted; - vacrel->tuples_frozen += tuples_frozen; + vacrel->tuples_frozen += presult.nfrozen; vacrel->lpdead_items += lpdead_items; vacrel->live_tuples += live_tuples; vacrel->recently_dead_tuples += recently_dead_tuples; @@ -1761,7 +1721,7 @@ lazy_scan_prune(LVRelState *vacrel, { uint8 flags = VISIBILITYMAP_ALL_VISIBLE; - if (all_frozen) + if (presult.all_frozen) { Assert(!TransactionIdIsValid(presult.visibility_cutoff_xid)); flags |= VISIBILITYMAP_ALL_FROZEN; @@ -1832,7 +1792,7 @@ lazy_scan_prune(LVRelState *vacrel, * true, so we must check both all_visible and all_frozen. */ else if (all_visible_according_to_vm && presult.all_visible && - all_frozen && !VM_ALL_FROZEN(vacrel->rel, blkno, &vmbuffer)) + presult.all_frozen && !VM_ALL_FROZEN(vacrel->rel, blkno, &vmbuffer)) { /* * Avoid relying on all_visible_according_to_vm as a proxy for the diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h index 3f510e8e197..59c81f38e51 100644 --- a/src/include/access/heapam.h +++ b/src/include/access/heapam.h @@ -219,6 +219,9 @@ typedef struct PruneResult * page. */ bool all_visible_except_removable; + + /* Whether or not the page can be set all-frozen in the VM */ + bool all_frozen; TransactionId visibility_cutoff_xid; /* Newest xmin on the page */ /* @@ -231,6 +234,14 @@ typedef struct PruneResult * 1. Otherwise every access would need to subtract 1. */ int8 htsv[MaxHeapTuplesPerPage + 1]; + + /* Number of tuples we may freeze */ + int nfrozen; + + /* + * One entry for every tuple that we may freeze. + */ + HeapTupleFreeze frozen[MaxHeapTuplesPerPage]; } PruneResult; /* 'reason' codes for heap_page_prune() */ @@ -350,6 +361,7 @@ extern void heap_page_prune_opt(Relation relation, Buffer buffer); extern void heap_page_prune(Relation relation, Buffer buffer, struct GlobalVisState *vistest, bool mark_unused_now, + HeapPageFreeze *pagefrz, PruneResult *presult, PruneReason reason, OffsetNumber *off_loc); -- 2.40.1 --ck6erxojvlx23byk Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v7-0007-lazy_scan_prune-reorder-freeze-execution-logic.patch" ^ permalink raw reply [nested|flat] 11+ messages in thread
* [PATCH v9 06/21] Prepare freeze tuples in heap_page_prune() @ 2024-03-25 23:23 Melanie Plageman <melanieplageman@gmail.com> 0 siblings, 0 replies; 11+ messages in thread From: Melanie Plageman @ 2024-03-25 23:23 UTC (permalink / raw) In order to combine the freeze and prune records, we must determine which tuples are freezable before actually executing pruning. All of the page modifications should be made in the same critical section along with emitting the combined WAL. Determine whether or not tuples should or must be frozen and whether or not the page will be all frozen as a consequence during pruning. --- src/backend/access/heap/pruneheap.c | 41 +++++++++++++++-- src/backend/access/heap/vacuumlazy.c | 68 ++++++---------------------- src/include/access/heapam.h | 12 +++++ 3 files changed, 64 insertions(+), 57 deletions(-) diff --git a/src/backend/access/heap/pruneheap.c b/src/backend/access/heap/pruneheap.c index 52513fcdc90..eb09713311b 100644 --- a/src/backend/access/heap/pruneheap.c +++ b/src/backend/access/heap/pruneheap.c @@ -153,7 +153,7 @@ heap_page_prune_opt(Relation relation, Buffer buffer) * not the relation has indexes, since we cannot safely determine * that during on-access pruning with the current implementation. */ - heap_page_prune(relation, buffer, vistest, false, + heap_page_prune(relation, buffer, vistest, false, NULL, &presult, PRUNE_ON_ACCESS, NULL); /* @@ -201,6 +201,9 @@ heap_page_prune_opt(Relation relation, Buffer buffer) * mark_unused_now indicates whether or not dead items can be set LP_UNUSED * during pruning. * + * pagefrz contains both input and output parameters used if the caller is + * interested in potentially freezing tuples on the page. + * * presult contains output parameters needed by callers such as the number of * tuples removed and the number of line pointers newly marked LP_DEAD. * heap_page_prune() is responsible for initializing it. @@ -215,6 +218,7 @@ void heap_page_prune(Relation relation, Buffer buffer, GlobalVisState *vistest, bool mark_unused_now, + HeapPageFreeze *pagefrz, PruneResult *presult, PruneReason reason, OffsetNumber *off_loc) @@ -250,11 +254,16 @@ heap_page_prune(Relation relation, Buffer buffer, */ presult->ndeleted = 0; presult->nnewlpdead = 0; + presult->nfrozen = 0; /* - * Keep track of whether or not the page is all_visible in case the caller - * wants to use this information to update the VM. + * Caller will update the VM after pruning, collecting LP_DEAD items, and + * freezing tuples. Keep track of whether or not the page is all_visible + * and all_frozen and use this information to update the VM. all_visible + * implies lpdead_items == 0, but don't trust all_frozen result unless + * all_visible is also set to true. */ + presult->all_frozen = true; presult->all_visible = true; /* for recovery conflicts */ presult->visibility_cutoff_xid = InvalidTransactionId; @@ -388,6 +397,32 @@ heap_page_prune(Relation relation, Buffer buffer, elog(ERROR, "unexpected HeapTupleSatisfiesVacuum result"); break; } + + /* + * Consider freezing any normal tuples which will not be removed + */ + if (presult->htsv[offnum] != HEAPTUPLE_DEAD && pagefrz) + { + bool totally_frozen; + + /* Tuple with storage -- consider need to freeze */ + if ((heap_prepare_freeze_tuple(htup, pagefrz, + &presult->frozen[presult->nfrozen], + &totally_frozen))) + { + /* Save prepared freeze plan for later */ + presult->frozen[presult->nfrozen++].offset = offnum; + } + + /* + * If any tuple isn't either totally frozen already or eligible to + * become totally frozen (according to its freeze plan), then the + * page definitely cannot be set all-frozen in the visibility map + * later on + */ + if (!totally_frozen) + presult->all_frozen = false; + } } /* diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c index 1b060124a3f..2a3cc5c7cd3 100644 --- a/src/backend/access/heap/vacuumlazy.c +++ b/src/backend/access/heap/vacuumlazy.c @@ -1416,16 +1416,13 @@ lazy_scan_prune(LVRelState *vacrel, maxoff; ItemId itemid; PruneResult presult; - int tuples_frozen, - lpdead_items, + int lpdead_items, live_tuples, recently_dead_tuples; HeapPageFreeze pagefrz; bool hastup = false; - bool all_frozen; int64 fpi_before = pgWalUsage.wal_fpi; OffsetNumber deadoffsets[MaxHeapTuplesPerPage]; - HeapTupleFreeze frozen[MaxHeapTuplesPerPage]; Assert(BufferGetBlockNumber(buf) == blkno); @@ -1443,7 +1440,6 @@ lazy_scan_prune(LVRelState *vacrel, pagefrz.NoFreezePageRelfrozenXid = vacrel->NewRelfrozenXid; pagefrz.NoFreezePageRelminMxid = vacrel->NewRelminMxid; pagefrz.cutoffs = &vacrel->cutoffs; - tuples_frozen = 0; lpdead_items = 0; live_tuples = 0; recently_dead_tuples = 0; @@ -1460,21 +1456,9 @@ lazy_scan_prune(LVRelState *vacrel, * items LP_UNUSED, so mark_unused_now should be true if no indexes and * false otherwise. */ - heap_page_prune(rel, buf, vacrel->vistest, vacrel->nindexes == 0, + heap_page_prune(rel, buf, vacrel->vistest, vacrel->nindexes == 0, &pagefrz, &presult, PRUNE_VACUUM_SCAN, &vacrel->offnum); - /* - * Now scan the page to collect LP_DEAD items and check for tuples - * requiring freezing among remaining tuples with storage. We will update - * the VM after collecting LP_DEAD items and freezing tuples. Pruning will - * have determined whether or not the page is all_visible. Keep track of - * whether or not the page is all_frozen and use this information to - * update the VM. all_visible implies lpdead_items == 0, but don't trust - * all_frozen result unless all_visible is also set to true. - * - */ - all_frozen = true; - /* * Now scan the page to collect LP_DEAD items and update the variables set * just above. @@ -1483,9 +1467,6 @@ lazy_scan_prune(LVRelState *vacrel, offnum <= maxoff; offnum = OffsetNumberNext(offnum)) { - HeapTupleHeader htup; - bool totally_frozen; - /* * Set the offset number so that we can display it along with any * error that occurred while processing this tuple. @@ -1521,8 +1502,6 @@ lazy_scan_prune(LVRelState *vacrel, Assert(ItemIdIsNormal(itemid)); - htup = (HeapTupleHeader) PageGetItem(page, itemid); - /* * The criteria for counting a tuple as live in this block need to * match what analyze.c's acquire_sample_rows() does, otherwise VACUUM @@ -1587,29 +1566,8 @@ lazy_scan_prune(LVRelState *vacrel, hastup = true; /* page makes rel truncation unsafe */ - /* Tuple with storage -- consider need to freeze */ - if (heap_prepare_freeze_tuple(htup, &pagefrz, - &frozen[tuples_frozen], &totally_frozen)) - { - /* Save prepared freeze plan for later */ - frozen[tuples_frozen++].offset = offnum; - } - - /* - * If any tuple isn't either totally frozen already or eligible to - * become totally frozen (according to its freeze plan), then the page - * definitely cannot be set all-frozen in the visibility map later on - */ - if (!totally_frozen) - all_frozen = false; } - /* - * We have now divided every item on the page into either an LP_DEAD item - * that will need to be vacuumed in indexes later, or a LP_NORMAL tuple - * that remains and needs to be considered for freezing now (LP_UNUSED and - * LP_REDIRECT items also remain, but are of no further interest to us). - */ vacrel->offnum = InvalidOffsetNumber; /* @@ -1618,8 +1576,8 @@ 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 || tuples_frozen == 0 || - (presult.all_visible_except_removable && all_frozen && + if (pagefrz.freeze_required || presult.nfrozen == 0 || + (presult.all_visible_except_removable && presult.all_frozen && fpi_before != pgWalUsage.wal_fpi)) { /* @@ -1629,7 +1587,7 @@ lazy_scan_prune(LVRelState *vacrel, vacrel->NewRelfrozenXid = pagefrz.FreezePageRelfrozenXid; vacrel->NewRelminMxid = pagefrz.FreezePageRelminMxid; - if (tuples_frozen == 0) + if (presult.nfrozen == 0) { /* * We have no freeze plans to execute, so there's no added cost @@ -1657,7 +1615,7 @@ lazy_scan_prune(LVRelState *vacrel, * once we're done with it. Otherwise we generate a conservative * cutoff by stepping back from OldestXmin. */ - if (presult.all_visible_except_removable && all_frozen) + if (presult.all_visible_except_removable && presult.all_frozen) { /* Using same cutoff when setting VM is now unnecessary */ snapshotConflictHorizon = presult.visibility_cutoff_xid; @@ -1673,7 +1631,7 @@ lazy_scan_prune(LVRelState *vacrel, /* Execute all freeze plans for page as a single atomic action */ heap_freeze_execute_prepared(vacrel->rel, buf, snapshotConflictHorizon, - frozen, tuples_frozen); + presult.frozen, presult.nfrozen); } } else @@ -1684,8 +1642,8 @@ lazy_scan_prune(LVRelState *vacrel, */ vacrel->NewRelfrozenXid = pagefrz.NoFreezePageRelfrozenXid; vacrel->NewRelminMxid = pagefrz.NoFreezePageRelminMxid; - all_frozen = false; - tuples_frozen = 0; /* avoid miscounts in instrumentation */ + presult.all_frozen = false; + presult.nfrozen = 0; /* avoid miscounts in instrumentation */ } /* @@ -1708,6 +1666,8 @@ lazy_scan_prune(LVRelState *vacrel, &debug_cutoff, &debug_all_frozen)) Assert(false); + Assert(presult.all_frozen == debug_all_frozen); + Assert(!TransactionIdIsValid(debug_cutoff) || debug_cutoff == presult.visibility_cutoff_xid); } @@ -1738,7 +1698,7 @@ lazy_scan_prune(LVRelState *vacrel, /* Finally, add page-local counts to whole-VACUUM counts */ vacrel->tuples_deleted += presult.ndeleted; - vacrel->tuples_frozen += tuples_frozen; + vacrel->tuples_frozen += presult.nfrozen; vacrel->lpdead_items += lpdead_items; vacrel->live_tuples += live_tuples; vacrel->recently_dead_tuples += recently_dead_tuples; @@ -1761,7 +1721,7 @@ lazy_scan_prune(LVRelState *vacrel, { uint8 flags = VISIBILITYMAP_ALL_VISIBLE; - if (all_frozen) + if (presult.all_frozen) { Assert(!TransactionIdIsValid(presult.visibility_cutoff_xid)); flags |= VISIBILITYMAP_ALL_FROZEN; @@ -1832,7 +1792,7 @@ lazy_scan_prune(LVRelState *vacrel, * true, so we must check both all_visible and all_frozen. */ else if (all_visible_according_to_vm && presult.all_visible && - all_frozen && !VM_ALL_FROZEN(vacrel->rel, blkno, &vmbuffer)) + presult.all_frozen && !VM_ALL_FROZEN(vacrel->rel, blkno, &vmbuffer)) { /* * Avoid relying on all_visible_according_to_vm as a proxy for the diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h index 689427e2512..9d047621ea5 100644 --- a/src/include/access/heapam.h +++ b/src/include/access/heapam.h @@ -219,6 +219,9 @@ typedef struct PruneResult * page. */ bool all_visible_except_removable; + + /* Whether or not the page can be set all-frozen in the VM */ + bool all_frozen; TransactionId visibility_cutoff_xid; /* Newest xmin on the page */ /* @@ -231,6 +234,14 @@ typedef struct PruneResult * 1. Otherwise every access would need to subtract 1. */ int8 htsv[MaxHeapTuplesPerPage + 1]; + + /* Number of tuples we may freeze */ + int nfrozen; + + /* + * One entry for every tuple that we may freeze. + */ + HeapTupleFreeze frozen[MaxHeapTuplesPerPage]; } PruneResult; /* 'reason' codes for heap_page_prune() */ @@ -353,6 +364,7 @@ extern void heap_page_prune_opt(Relation relation, Buffer buffer); extern void heap_page_prune(Relation relation, Buffer buffer, struct GlobalVisState *vistest, bool mark_unused_now, + HeapPageFreeze *pagefrz, PruneResult *presult, PruneReason reason, OffsetNumber *off_loc); -- 2.40.1 --caj67xgx3lukmr5f Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v9-0007-lazy_scan_prune-reorder-freeze-execution-logic.patch" ^ permalink raw reply [nested|flat] 11+ messages in thread
* [PATCH v10 07/10] Prepare freeze tuples in heap_page_prune() @ 2024-03-30 01:22 Melanie Plageman <melanieplageman@gmail.com> 0 siblings, 0 replies; 11+ messages in thread From: Melanie Plageman @ 2024-03-30 01:22 UTC (permalink / raw) In order to combine the freeze and prune records, we must determine which tuples are freezable before actually executing pruning. All of the page modifications should be made in the same critical section along with emitting the combined WAL. Determine whether or not tuples should or must be frozen and whether or not the page will be all frozen as a consequence during pruning. --- src/backend/access/heap/heapam.c | 6 +-- src/backend/access/heap/pruneheap.c | 64 +++++++++++++++++++++----- src/backend/access/heap/vacuumlazy.c | 67 ++++++++++------------------ src/include/access/heapam.h | 25 ++++++++++- 4 files changed, 103 insertions(+), 59 deletions(-) diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c index 2f6527df0d..f8fddce03b 100644 --- a/src/backend/access/heap/heapam.c +++ b/src/backend/access/heap/heapam.c @@ -6475,10 +6475,10 @@ FreezeMultiXactId(MultiXactId multi, uint16 t_infomask, */ bool heap_prepare_freeze_tuple(HeapTupleHeader tuple, - const struct VacuumCutoffs *cutoffs, HeapPageFreeze *pagefrz, HeapTupleFreeze *frz, bool *totally_frozen) { + const struct VacuumCutoffs *cutoffs = pagefrz->cutoffs; bool xmin_already_frozen = false, xmax_already_frozen = false; bool freeze_xmin = false, @@ -6889,9 +6889,9 @@ heap_freeze_tuple(HeapTupleHeader tuple, pagefrz.FreezePageRelminMxid = MultiXactCutoff; pagefrz.NoFreezePageRelfrozenXid = FreezeLimit; pagefrz.NoFreezePageRelminMxid = MultiXactCutoff; + pagefrz.cutoffs = &cutoffs; - do_freeze = heap_prepare_freeze_tuple(tuple, &cutoffs, - &pagefrz, &frz, &totally_frozen); + do_freeze = heap_prepare_freeze_tuple(tuple, &pagefrz, &frz, &totally_frozen); /* * Note that because this is not a WAL-logged operation, we don't need to diff --git a/src/backend/access/heap/pruneheap.c b/src/backend/access/heap/pruneheap.c index 20d5ad7b80..be06699523 100644 --- a/src/backend/access/heap/pruneheap.c +++ b/src/backend/access/heap/pruneheap.c @@ -17,6 +17,7 @@ #include "access/heapam.h" #include "access/heapam_xlog.h" #include "access/htup_details.h" +#include "access/multixact.h" #include "access/transam.h" #include "access/xlog.h" #include "access/xloginsert.h" @@ -75,7 +76,7 @@ static HTSV_Result heap_prune_satisfies_vacuum(PruneState *prstate, static void heap_prune_chain(Buffer buffer, OffsetNumber rootoffnum, int8 *htsv, - PruneState *prstate); + PruneState *prstate, PruneResult *presult); static void heap_prune_record_prunable(PruneState *prstate, TransactionId xid); static void heap_prune_record_redirect(PruneState *prstate, OffsetNumber offnum, OffsetNumber rdoffnum, bool was_normal); @@ -83,7 +84,7 @@ static void heap_prune_record_dead(PruneState *prstate, OffsetNumber offnum, boo static void heap_prune_record_dead_or_unused(PruneState *prstate, OffsetNumber offnum, bool was_normal); static void heap_prune_record_unused(PruneState *prstate, OffsetNumber offnum, bool was_normal); -static void heap_prune_record_unchanged(Page page, int8 *htsv, PruneState *prstate, OffsetNumber offnum); +static void heap_prune_record_unchanged(Page page, int8 *htsv, PruneState *prstate, PruneResult *presult, OffsetNumber offnum); static void heap_prune_record_unchanged_lp_dead(PruneState *prstate, OffsetNumber offnum); static void heap_prune_record_unchanged_lp_redirect(PruneState *prstate, OffsetNumber offnum); @@ -167,6 +168,13 @@ heap_page_prune_opt(Relation relation, Buffer buffer) { PruneResult presult; + presult.pagefrz.freeze_required = false; + presult.pagefrz.FreezePageRelfrozenXid = InvalidTransactionId; + presult.pagefrz.FreezePageRelminMxid = InvalidMultiXactId; + presult.pagefrz.NoFreezePageRelfrozenXid = InvalidTransactionId; + presult.pagefrz.NoFreezePageRelminMxid = InvalidMultiXactId; + presult.pagefrz.cutoffs = NULL; + /* * For now, do not set PRUNE_DO_MARK_UNUSED_NOW regardless of * whether or not the relation has indexes, since we cannot safely @@ -266,6 +274,16 @@ heap_page_prune(Relation relation, Buffer buffer, prstate.nchain_members = 0; prstate.nchain_candidates = 0; + /* + * If we will prepare to freeze tuples, consider that it might be possible + * to set the page all-frozen in the visibility map. + */ + if (prstate.actions & PRUNE_DO_TRY_FREEZE) + presult->all_frozen = true; + else + presult->all_frozen = false; + + /* * presult->htsv is not initialized here because all ntuple spots in the * array will be set either to a valid HTSV_Result value or -1. @@ -273,6 +291,8 @@ heap_page_prune(Relation relation, Buffer buffer, presult->ndeleted = 0; presult->nnewlpdead = 0; + presult->nfrozen = 0; + maxoff = PageGetMaxOffsetNumber(page); tup.t_tableOid = RelationGetRelid(relation); @@ -384,7 +404,7 @@ heap_page_prune(Relation relation, Buffer buffer, *off_loc = offnum; /* Process this item or chain of items */ - heap_prune_chain(buffer, offnum, presult->htsv, &prstate); + heap_prune_chain(buffer, offnum, presult->htsv, &prstate, presult); } /* @@ -454,7 +474,7 @@ heap_page_prune(Relation relation, Buffer buffer, * marked by heap_prune_chain() and heap_prune_record_unchanged() will * return immediately. */ - heap_prune_record_unchanged(page, presult->htsv, &prstate, offnum); + heap_prune_record_unchanged(page, presult->htsv, &prstate, presult, offnum); } /* We should now have processed every tuple exactly once */ @@ -597,7 +617,7 @@ heap_prune_satisfies_vacuum(PruneState *prstate, HeapTuple tup, Buffer buffer) */ static void heap_prune_chain(Buffer buffer, OffsetNumber rootoffnum, - int8 *htsv, PruneState *prstate) + int8 *htsv, PruneState *prstate, PruneResult *presult) { Page page = (Page) BufferGetPage(buffer); ItemId rootlp = PageGetItemId(page, rootoffnum); @@ -764,7 +784,7 @@ process_chains: /* the rest of tuples in the chain are normal, unchanged tuples */ for (; i < nchain; i++) - heap_prune_record_unchanged(page, htsv, prstate, chainitems[i]); + heap_prune_record_unchanged(page, htsv, prstate, presult, chainitems[i]); } else if (ndeadchain == nchain) { @@ -796,7 +816,7 @@ process_chains: /* the rest of tuples in the chain are normal, unchanged tuples */ for (int i = ndeadchain; i < nchain; i++) - heap_prune_record_unchanged(page, htsv, prstate, chainitems[i]); + heap_prune_record_unchanged(page, htsv, prstate, presult, chainitems[i]); } } @@ -910,9 +930,10 @@ heap_prune_record_unused(PruneState *prstate, OffsetNumber offnum, bool was_norm * Record LP_NORMAL line pointer that is left unchanged. */ static void -heap_prune_record_unchanged(Page page, int8 *htsv, PruneState *prstate, OffsetNumber offnum) +heap_prune_record_unchanged(Page page, int8 *htsv, PruneState *prstate, + PruneResult *presult, OffsetNumber offnum) { - HeapTupleHeader htup; + HeapTupleHeader htup = (HeapTupleHeader) PageGetItem(page, PageGetItemId(page, offnum)); Assert(!prstate->marked[offnum]); prstate->marked[offnum] = true; @@ -933,8 +954,6 @@ heap_prune_record_unchanged(Page page, int8 *htsv, PruneState *prstate, OffsetNu case HEAPTUPLE_RECENTLY_DEAD: case HEAPTUPLE_DELETE_IN_PROGRESS: - htup = (HeapTupleHeader) PageGetItem(page, PageGetItemId(page, offnum)); - /* * This tuple may soon become DEAD. Update the hint field so that * the page is reconsidered for pruning in future. @@ -953,6 +972,29 @@ heap_prune_record_unchanged(Page page, int8 *htsv, PruneState *prstate, OffsetNu elog(ERROR, "unexpected HeapTupleSatisfiesVacuum result %d", htsv[offnum]); break; } + + /* Consider freezing any normal tuples which will not be removed */ + if (prstate->actions & PRUNE_DO_TRY_FREEZE) + { + /* Tuple with storage -- consider need to freeze */ + bool totally_frozen; + + if ((heap_prepare_freeze_tuple(htup, &presult->pagefrz, + &presult->frozen[presult->nfrozen], + &totally_frozen))) + { + /* Save prepared freeze plan for later */ + presult->frozen[presult->nfrozen++].offset = offnum; + } + + /* + * If any tuple isn't either totally frozen already or eligible to + * become totally frozen (according to its freeze plan), then the page + * definitely cannot be set all-frozen in the visibility map later on + */ + if (!totally_frozen) + presult->all_frozen = false; + } } diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c index 880a218cb4..679c6a866e 100644 --- a/src/backend/access/heap/vacuumlazy.c +++ b/src/backend/access/heap/vacuumlazy.c @@ -1416,19 +1416,15 @@ lazy_scan_prune(LVRelState *vacrel, maxoff; ItemId itemid; PruneResult presult; - int tuples_frozen, - lpdead_items, + int lpdead_items, live_tuples, recently_dead_tuples; - HeapPageFreeze pagefrz; bool hastup = false; - bool all_visible, - all_frozen; + bool all_visible; TransactionId visibility_cutoff_xid; uint8 actions = 0; int64 fpi_before = pgWalUsage.wal_fpi; OffsetNumber deadoffsets[MaxHeapTuplesPerPage]; - HeapTupleFreeze frozen[MaxHeapTuplesPerPage]; Assert(BufferGetBlockNumber(buf) == blkno); @@ -1440,12 +1436,12 @@ lazy_scan_prune(LVRelState *vacrel, maxoff = PageGetMaxOffsetNumber(page); /* Initialize (or reset) page-level state */ - pagefrz.freeze_required = false; - pagefrz.FreezePageRelfrozenXid = vacrel->NewRelfrozenXid; - pagefrz.FreezePageRelminMxid = vacrel->NewRelminMxid; - pagefrz.NoFreezePageRelfrozenXid = vacrel->NewRelfrozenXid; - pagefrz.NoFreezePageRelminMxid = vacrel->NewRelminMxid; - tuples_frozen = 0; + presult.pagefrz.freeze_required = false; + presult.pagefrz.FreezePageRelfrozenXid = vacrel->NewRelfrozenXid; + presult.pagefrz.FreezePageRelminMxid = vacrel->NewRelminMxid; + presult.pagefrz.NoFreezePageRelfrozenXid = vacrel->NewRelfrozenXid; + presult.pagefrz.NoFreezePageRelminMxid = vacrel->NewRelminMxid; + presult.pagefrz.cutoffs = &vacrel->cutoffs; lpdead_items = 0; live_tuples = 0; recently_dead_tuples = 0; @@ -1462,6 +1458,7 @@ lazy_scan_prune(LVRelState *vacrel, * items LP_UNUSED, so PRUNE_DO_MARK_UNUSED_NOW should be set if no * indexes and unset otherwise. */ + actions |= PRUNE_DO_TRY_FREEZE; if (vacrel->nindexes == 0) actions |= PRUNE_DO_MARK_UNUSED_NOW; @@ -1479,7 +1476,6 @@ lazy_scan_prune(LVRelState *vacrel, * Also keep track of the visibility cutoff xid for recovery conflicts. */ all_visible = true; - all_frozen = true; visibility_cutoff_xid = InvalidTransactionId; /* @@ -1491,7 +1487,6 @@ lazy_scan_prune(LVRelState *vacrel, offnum = OffsetNumberNext(offnum)) { HeapTupleHeader htup; - bool totally_frozen; /* * Set the offset number so that we can display it along with any @@ -1638,22 +1633,6 @@ lazy_scan_prune(LVRelState *vacrel, } hastup = true; /* page makes rel truncation unsafe */ - - /* Tuple with storage -- consider need to freeze */ - if (heap_prepare_freeze_tuple(htup, &vacrel->cutoffs, &pagefrz, - &frozen[tuples_frozen], &totally_frozen)) - { - /* Save prepared freeze plan for later */ - frozen[tuples_frozen++].offset = offnum; - } - - /* - * If any tuple isn't either totally frozen already or eligible to - * become totally frozen (according to its freeze plan), then the page - * definitely cannot be set all-frozen in the visibility map later on - */ - if (!totally_frozen) - all_frozen = false; } /* @@ -1670,18 +1649,18 @@ 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 || tuples_frozen == 0 || - (all_visible && all_frozen && + if (presult.pagefrz.freeze_required || presult.nfrozen == 0 || + (all_visible && presult.all_frozen && fpi_before != pgWalUsage.wal_fpi)) { /* * 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. */ - vacrel->NewRelfrozenXid = pagefrz.FreezePageRelfrozenXid; - vacrel->NewRelminMxid = pagefrz.FreezePageRelminMxid; + vacrel->NewRelfrozenXid = presult.pagefrz.FreezePageRelfrozenXid; + vacrel->NewRelminMxid = presult.pagefrz.FreezePageRelminMxid; - if (tuples_frozen == 0) + if (presult.nfrozen == 0) { /* * We have no freeze plans to execute, so there's no added cost @@ -1709,7 +1688,7 @@ lazy_scan_prune(LVRelState *vacrel, * once we're done with it. Otherwise we generate a conservative * cutoff by stepping back from OldestXmin. */ - if (all_visible && all_frozen) + if (all_visible && presult.all_frozen) { /* Using same cutoff when setting VM is now unnecessary */ snapshotConflictHorizon = visibility_cutoff_xid; @@ -1725,7 +1704,7 @@ lazy_scan_prune(LVRelState *vacrel, /* Execute all freeze plans for page as a single atomic action */ heap_freeze_execute_prepared(vacrel->rel, buf, snapshotConflictHorizon, - frozen, tuples_frozen); + presult.frozen, presult.nfrozen); } } else @@ -1734,10 +1713,10 @@ lazy_scan_prune(LVRelState *vacrel, * Page requires "no freeze" processing. It might be set all-visible * in the visibility map, but it can never be set all-frozen. */ - vacrel->NewRelfrozenXid = pagefrz.NoFreezePageRelfrozenXid; - vacrel->NewRelminMxid = pagefrz.NoFreezePageRelminMxid; - all_frozen = false; - tuples_frozen = 0; /* avoid miscounts in instrumentation */ + vacrel->NewRelfrozenXid = presult.pagefrz.NoFreezePageRelfrozenXid; + vacrel->NewRelminMxid = presult.pagefrz.NoFreezePageRelminMxid; + presult.all_frozen = false; + presult.nfrozen = 0; /* avoid miscounts in instrumentation */ } /* @@ -1801,7 +1780,7 @@ lazy_scan_prune(LVRelState *vacrel, /* Finally, add page-local counts to whole-VACUUM counts */ vacrel->tuples_deleted += presult.ndeleted; - vacrel->tuples_frozen += tuples_frozen; + vacrel->tuples_frozen += presult.nfrozen; vacrel->lpdead_items += lpdead_items; vacrel->live_tuples += live_tuples; vacrel->recently_dead_tuples += recently_dead_tuples; @@ -1824,7 +1803,7 @@ lazy_scan_prune(LVRelState *vacrel, { uint8 flags = VISIBILITYMAP_ALL_VISIBLE; - if (all_frozen) + if (presult.all_frozen) { Assert(!TransactionIdIsValid(visibility_cutoff_xid)); flags |= VISIBILITYMAP_ALL_FROZEN; @@ -1895,7 +1874,7 @@ lazy_scan_prune(LVRelState *vacrel, * true, so we must check both all_visible and all_frozen. */ else if (all_visible_according_to_vm && all_visible && - all_frozen && !VM_ALL_FROZEN(vacrel->rel, blkno, &vmbuffer)) + presult.all_frozen && !VM_ALL_FROZEN(vacrel->rel, blkno, &vmbuffer)) { /* * Avoid relying on all_visible_according_to_vm as a proxy for the diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h index b5c711e790..a7f5f19916 100644 --- a/src/include/access/heapam.h +++ b/src/include/access/heapam.h @@ -189,6 +189,7 @@ typedef struct HeapPageFreeze TransactionId NoFreezePageRelfrozenXid; MultiXactId NoFreezePageRelminMxid; + struct VacuumCutoffs *cutoffs; } HeapPageFreeze; /* @@ -202,6 +203,15 @@ typedef struct HeapPageFreeze */ #define PRUNE_DO_MARK_UNUSED_NOW (1 << 1) +/* + * Prepare to freeze if advantageous or required and try to advance + * relfrozenxid and relminmxid. To attempt freezing, we will need to determine + * if the page is all frozen. So, if this action is set, we will also inform + * the caller if the page is all-visible and/or all-frozen and calculate a + * snapshot conflict horizon for updating the visibility map. + */ +#define PRUNE_DO_TRY_FREEZE (1 << 2) + /* * Per-page state returned from pruning */ @@ -220,6 +230,20 @@ typedef struct PruneResult * 1. Otherwise every access would need to subtract 1. */ int8 htsv[MaxHeapTuplesPerPage + 1]; + + /* + * Prepare to freeze in heap_page_prune(). lazy_scan_prune() will use the + * returned freeze plans to execute freezing. + */ + HeapPageFreeze pagefrz; + + /* + * Whether or not the page can be set all-frozen in the visibility map. + * This is only set if the PRUNE_DO_TRY_FREEZE action flag is set. + */ + bool all_frozen; + int nfrozen; + HeapTupleFreeze frozen[MaxHeapTuplesPerPage]; } PruneResult; /* 'reason' codes for heap_page_prune() */ @@ -314,7 +338,6 @@ extern TM_Result heap_lock_tuple(Relation relation, ItemPointer tid, extern void heap_inplace_update(Relation relation, HeapTuple tuple); extern bool heap_prepare_freeze_tuple(HeapTupleHeader tuple, - const struct VacuumCutoffs *cutoffs, HeapPageFreeze *pagefrz, HeapTupleFreeze *frz, bool *totally_frozen); extern void heap_freeze_execute_prepared(Relation rel, Buffer buffer, -- 2.40.1 --nehniapdxqvkrsct Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v10-0008-Set-hastup-in-heap_page_prune.patch" ^ permalink raw reply [nested|flat] 11+ messages in thread
end of thread, other threads:[~2024-03-30 01:22 UTC | newest] Thread overview: 11+ messages (download: mbox mbox.gz follow: Atom feed) -- links below jump to the message on this page -- 2024-01-07 16:18 [PATCH v2 05/17] Prepare freeze tuples in heap_page_prune() Melanie Plageman <melanieplageman@gmail.com> 2024-01-07 16:18 [PATCH v3 05/17] Prepare freeze tuples in heap_page_prune() Melanie Plageman <melanieplageman@gmail.com> 2024-01-07 16:18 [PATCH v2 05/17] Prepare freeze tuples in heap_page_prune() Melanie Plageman <melanieplageman@gmail.com> 2024-01-07 16:18 [PATCH v3 05/17] Prepare freeze tuples in heap_page_prune() Melanie Plageman <melanieplageman@gmail.com> 2024-03-19 00:01 [PATCH v4 07/19] Prepare freeze tuples in heap_page_prune() Melanie Plageman <melanieplageman@gmail.com> 2024-03-19 00:01 [PATCH v4 07/19] Prepare freeze tuples in heap_page_prune() Melanie Plageman <melanieplageman@gmail.com> 2024-03-25 23:23 [PATCH v7 06/16] Prepare freeze tuples in heap_page_prune() Melanie Plageman <melanieplageman@gmail.com> 2024-03-25 23:23 [PATCH v9 06/21] Prepare freeze tuples in heap_page_prune() Melanie Plageman <melanieplageman@gmail.com> 2024-03-25 23:23 [PATCH v7 06/16] Prepare freeze tuples in heap_page_prune() Melanie Plageman <melanieplageman@gmail.com> 2024-03-25 23:23 [PATCH v9 06/21] Prepare freeze tuples in heap_page_prune() Melanie Plageman <melanieplageman@gmail.com> 2024-03-30 01:22 [PATCH v10 07/10] Prepare freeze tuples in heap_page_prune() Melanie Plageman <melanieplageman@gmail.com>
This inbox is served by agora; see mirroring instructions for how to clone and mirror all data and code used for this inbox