From 33a35d23ae88d634cb01024295099e5d5466b1a3 Mon Sep 17 00:00:00 2001 From: Melanie Plageman Date: Mon, 15 Sep 2025 12:06:19 -0400 Subject: [PATCH v16 02/14] Assorted trivial heap_page_prune_and_freeze cleanup Group heap_page_prune_and_freeze() input parameters in a struct and clean up their documentation. Rename a member of PruneState and disambiguate some local heap_page_prune_and_freeze() variables. --- src/backend/access/heap/pruneheap.c | 114 +++++++++++++-------------- src/backend/access/heap/vacuumlazy.c | 16 ++-- src/include/access/heapam.h | 62 ++++++++++++--- src/tools/pgindent/typedefs.list | 1 + 4 files changed, 115 insertions(+), 78 deletions(-) diff --git a/src/backend/access/heap/pruneheap.c b/src/backend/access/heap/pruneheap.c index d8ea0c78f77..9ba89b1fc28 100644 --- a/src/backend/access/heap/pruneheap.c +++ b/src/backend/access/heap/pruneheap.c @@ -42,8 +42,8 @@ typedef struct /* whether or not dead items can be set LP_UNUSED during pruning */ bool mark_unused_now; /* whether to attempt freezing tuples */ - bool freeze; - struct VacuumCutoffs *cutoffs; + bool attempt_freeze; + const struct VacuumCutoffs *cutoffs; /*------------------------------------------------------- * Fields describing what to do to the page @@ -253,15 +253,23 @@ heap_page_prune_opt(Relation relation, Buffer buffer) if (PageIsFull(page) || PageGetHeapFreeSpace(page) < minfree) { OffsetNumber dummy_off_loc; + PruneFreezeParams params; PruneFreezeResult presult; + params.relation = relation; + params.buffer = buffer; + params.reason = PRUNE_ON_ACCESS; + params.vistest = vistest; + params.cutoffs = NULL; + /* * For now, pass mark_unused_now as false regardless of whether or * not the relation has indexes, since we cannot safely determine * that during on-access pruning with the current implementation. */ - heap_page_prune_and_freeze(relation, buffer, vistest, 0, - NULL, &presult, PRUNE_ON_ACCESS, &dummy_off_loc, NULL, NULL); + params.options = 0; + + heap_page_prune_and_freeze(¶ms, &presult, &dummy_off_loc, NULL, NULL); /* * Report the number of tuples reclaimed to pgstats. This is @@ -303,60 +311,43 @@ heap_page_prune_opt(Relation relation, Buffer buffer) * also need to account for a reduction in the length of the line pointer * array following array truncation by us. * - * If the HEAP_PRUNE_FREEZE option is set, we will also freeze tuples if it's - * required in order to advance relfrozenxid / relminmxid, or if it's - * considered advantageous for overall system performance to do so now. The - * 'cutoffs', 'presult', 'new_relfrozen_xid' and 'new_relmin_mxid' arguments - * are required when freezing. When HEAP_PRUNE_FREEZE option is set, we also - * set presult->all_visible and presult->all_frozen on exit, to indicate if - * the VM bits can be set. They are always set to false when the - * HEAP_PRUNE_FREEZE option is not set, because at the moment only callers - * that also freeze need that information. - * - * vistest is used to distinguish whether tuples are DEAD or RECENTLY_DEAD - * (see heap_prune_satisfies_vacuum). + * params contains the input parameters used to control freezing and pruning + * behavior. See the definition of PruneFreezeParams for more on what each + * parameter does. * - * options: - * MARK_UNUSED_NOW indicates that dead items can be set LP_UNUSED during - * pruning. - * - * FREEZE indicates that we will also freeze tuples, and will return - * 'all_visible', 'all_frozen' flags to the caller. - * - * cutoffs contains the freeze cutoffs, established by VACUUM at the beginning - * of vacuuming the relation. Required if HEAP_PRUNE_FREEZE option is set. - * cutoffs->OldestXmin is also used to determine if dead tuples are - * HEAPTUPLE_RECENTLY_DEAD or HEAPTUPLE_DEAD. + * If the HEAP_PRUNE_FREEZE option is set in params, we will freeze tuples if + * it's required in order to advance relfrozenxid / relminmxid, or if it's + * considered advantageous for overall system performance to do so now. The + * 'params.cutoffs', 'presult', 'new_relfrozen_xid' and 'new_relmin_mxid' + * arguments are required when freezing. When HEAP_PRUNE_FREEZE option is + * passed, we also set presult->all_visible and presult->all_frozen on exit, + * to indicate if the VM bits can be set. They are always set to false when + * the HEAP_PRUNE_FREEZE option is not passed, because at the moment only + * callers that also freeze need that information. * * presult contains output parameters needed by callers, such as the number of * tuples removed and the offsets of dead items on the page after pruning. * heap_page_prune_and_freeze() is responsible for initializing it. Required * by all callers. * - * reason indicates why the pruning is performed. It is included in the WAL - * record for debugging and analysis purposes, but otherwise has no effect. - * * off_loc is the offset location required by the caller to use in error * callback. * * new_relfrozen_xid and new_relmin_mxid must provided by the caller if the - * HEAP_PRUNE_FREEZE option is set. On entry, they contain the oldest XID and - * multi-XID seen on the relation so far. They will be updated with oldest - * values present on the page after pruning. After processing the whole - * relation, VACUUM can use these values as the new relfrozenxid/relminmxid - * for the relation. + * HEAP_PRUNE_FREEZE option is set in params. On entry, they contain the + * oldest XID and multi-XID seen on the relation so far. They will be updated + * with oldest values present on the page after pruning. After processing the + * whole relation, VACUUM can use these values as the new + * relfrozenxid/relminmxid for the relation. */ void -heap_page_prune_and_freeze(Relation relation, Buffer buffer, - GlobalVisState *vistest, - int options, - struct VacuumCutoffs *cutoffs, +heap_page_prune_and_freeze(PruneFreezeParams *params, PruneFreezeResult *presult, - PruneReason reason, OffsetNumber *off_loc, TransactionId *new_relfrozen_xid, MultiXactId *new_relmin_mxid) { + Buffer buffer = params->buffer; Page page = BufferGetPage(buffer); BlockNumber blockno = BufferGetBlockNumber(buffer); OffsetNumber offnum, @@ -365,15 +356,16 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer, HeapTupleData tup; bool do_freeze; bool do_prune; - bool do_hint; - bool hint_bit_fpi; + bool do_hint_prune; + bool did_tuple_hint_fpi; int64 fpi_before = pgWalUsage.wal_fpi; /* Copy parameters to prstate */ - prstate.vistest = vistest; - prstate.mark_unused_now = (options & HEAP_PAGE_PRUNE_MARK_UNUSED_NOW) != 0; - prstate.freeze = (options & HEAP_PAGE_PRUNE_FREEZE) != 0; - prstate.cutoffs = cutoffs; + prstate.vistest = params->vistest; + prstate.mark_unused_now = + (params->options & HEAP_PAGE_PRUNE_MARK_UNUSED_NOW) != 0; + prstate.attempt_freeze = (params->options & HEAP_PAGE_PRUNE_FREEZE) != 0; + prstate.cutoffs = params->cutoffs; /* * Our strategy is to scan the page and make lists of items to change, @@ -394,7 +386,7 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer, /* initialize page freezing working state */ prstate.pagefrz.freeze_required = false; - if (prstate.freeze) + if (prstate.attempt_freeze) { Assert(new_relfrozen_xid && new_relmin_mxid); prstate.pagefrz.FreezePageRelfrozenXid = *new_relfrozen_xid; @@ -441,7 +433,7 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer, * function, when we return the value to the caller, so that the caller * doesn't set the VM bit incorrectly. */ - if (prstate.freeze) + if (prstate.attempt_freeze) { prstate.all_visible = true; prstate.all_frozen = true; @@ -467,7 +459,7 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer, prstate.visibility_cutoff_xid = InvalidTransactionId; maxoff = PageGetMaxOffsetNumber(page); - tup.t_tableOid = RelationGetRelid(relation); + tup.t_tableOid = RelationGetRelid(params->relation); /* * Determine HTSV for all tuples, and queue them up for processing as HOT @@ -555,7 +547,7 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer, * If checksums are enabled, heap_prune_satisfies_vacuum() may have caused * an FPI to be emitted. */ - hint_bit_fpi = fpi_before != pgWalUsage.wal_fpi; + did_tuple_hint_fpi = fpi_before != pgWalUsage.wal_fpi; /* * Process HOT chains. @@ -663,7 +655,7 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer, * pd_prune_xid field or the page was marked full, we will update the hint * bit. */ - do_hint = ((PageHeader) page)->pd_prune_xid != prstate.new_prune_xid || + do_hint_prune = ((PageHeader) page)->pd_prune_xid != prstate.new_prune_xid || PageIsFull(page); /* @@ -671,7 +663,7 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer, * plans we prepared, or not. */ do_freeze = false; - if (prstate.freeze) + if (prstate.attempt_freeze) { if (prstate.pagefrz.freeze_required) { @@ -702,16 +694,16 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer, * Freezing would make the page all-frozen. Have already * emitted an FPI or will do so anyway? */ - if (RelationNeedsWAL(relation)) + if (RelationNeedsWAL(params->relation)) { - if (hint_bit_fpi) + if (did_tuple_hint_fpi) do_freeze = true; else if (do_prune) { if (XLogCheckBufferNeedsBackup(buffer)) do_freeze = true; } - else if (do_hint) + else if (do_hint_prune) { if (XLogHintBitIsNeeded() && XLogCheckBufferNeedsBackup(buffer)) do_freeze = true; @@ -753,7 +745,7 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer, /* Any error while applying the changes is critical */ START_CRIT_SECTION(); - if (do_hint) + if (do_hint_prune) { /* * Update the page's pd_prune_xid field to either zero, or the lowest @@ -796,7 +788,7 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer, /* * Emit a WAL XLOG_HEAP2_PRUNE* record showing what we did */ - if (RelationNeedsWAL(relation)) + if (RelationNeedsWAL(params->relation)) { /* * The snapshotConflictHorizon for the whole record should be the @@ -834,9 +826,9 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer, else conflict_xid = prstate.latest_xid_removed; - log_heap_prune_and_freeze(relation, buffer, + log_heap_prune_and_freeze(params->relation, buffer, conflict_xid, - true, reason, + true, params->reason, prstate.frozen, prstate.nfrozen, prstate.redirected, prstate.nredirected, prstate.nowdead, prstate.ndead, @@ -894,7 +886,7 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer, presult->lpdead_items = prstate.lpdead_items; /* the presult->deadoffsets array was already filled in */ - if (prstate.freeze) + if (prstate.attempt_freeze) { if (presult->nfrozen > 0) { @@ -1476,7 +1468,7 @@ heap_prune_record_unchanged_lp_normal(Page page, PruneState *prstate, OffsetNumb } /* Consider freezing any normal tuples which will not be removed */ - if (prstate->freeze) + if (prstate->attempt_freeze) { bool totally_frozen; diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c index ab6938d1da1..6125f157709 100644 --- a/src/backend/access/heap/vacuumlazy.c +++ b/src/backend/access/heap/vacuumlazy.c @@ -1951,10 +1951,16 @@ lazy_scan_prune(LVRelState *vacrel, { Relation rel = vacrel->rel; PruneFreezeResult presult; - int prune_options = 0; + PruneFreezeParams params; Assert(BufferGetBlockNumber(buf) == blkno); + params.relation = rel; + params.buffer = buf; + params.reason = PRUNE_VACUUM_SCAN; + params.cutoffs = &vacrel->cutoffs; + params.vistest = vacrel->vistest; + /* * Prune all HOT-update chains and potentially freeze tuples on this page. * @@ -1970,12 +1976,12 @@ lazy_scan_prune(LVRelState *vacrel, * tuples. Pruning will have determined whether or not the page is * all-visible. */ - prune_options = HEAP_PAGE_PRUNE_FREEZE; + params.options = HEAP_PAGE_PRUNE_FREEZE; if (vacrel->nindexes == 0) - prune_options |= HEAP_PAGE_PRUNE_MARK_UNUSED_NOW; + params.options |= HEAP_PAGE_PRUNE_MARK_UNUSED_NOW; - heap_page_prune_and_freeze(rel, buf, vacrel->vistest, prune_options, - &vacrel->cutoffs, &presult, PRUNE_VACUUM_SCAN, + heap_page_prune_and_freeze(¶ms, + &presult, &vacrel->offnum, &vacrel->NewRelfrozenXid, &vacrel->NewRelminMxid); diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h index e60d34dad25..bc71fef6643 100644 --- a/src/include/access/heapam.h +++ b/src/include/access/heapam.h @@ -221,6 +221,55 @@ typedef struct HeapPageFreeze } HeapPageFreeze; + +/* 'reason' codes for heap_page_prune_and_freeze() */ +typedef enum +{ + PRUNE_ON_ACCESS, /* on-access pruning */ + PRUNE_VACUUM_SCAN, /* VACUUM 1st heap pass */ + PRUNE_VACUUM_CLEANUP, /* VACUUM 2nd heap pass */ +} PruneReason; + +/* + * Input parameters to heap_page_prune_and_freeze() + */ +typedef struct PruneFreezeParams +{ + Relation relation; /* relation containing buffer to be pruned */ + Buffer buffer; /* buffer to be pruned */ + + /* + * The reason pruning was performed. It is used to set the WAL record + * opcode which is used for debugging and analysis purposes. + */ + PruneReason reason; + + /* + * Contains flag bits: + * + * MARK_UNUSED_NOW indicates that dead items can be set LP_UNUSED during + * pruning. + * + * FREEZE indicates that we will also freeze tuples, and will return + * 'all_visible', 'all_frozen' flags to the caller. + */ + int options; + + /* + * vistest is used to distinguish whether tuples are DEAD or RECENTLY_DEAD + * (see heap_prune_satisfies_vacuum). + */ + GlobalVisState *vistest; + + /* + * cutoffs contains the freeze cutoffs, established by VACUUM at the + * beginning of vacuuming the relation. Required if HEAP_PRUNE_FREEZE + * option is set. cutoffs->OldestXmin is also used to determine if dead + * tuples are HEAPTUPLE_RECENTLY_DEAD or HEAPTUPLE_DEAD. + */ + struct VacuumCutoffs *cutoffs; +} PruneFreezeParams; + /* * Per-page state returned by heap_page_prune_and_freeze() */ @@ -264,13 +313,6 @@ typedef struct PruneFreezeResult OffsetNumber deadoffsets[MaxHeapTuplesPerPage]; } PruneFreezeResult; -/* 'reason' codes for heap_page_prune_and_freeze() */ -typedef enum -{ - PRUNE_ON_ACCESS, /* on-access pruning */ - PRUNE_VACUUM_SCAN, /* VACUUM 1st heap pass */ - PRUNE_VACUUM_CLEANUP, /* VACUUM 2nd heap pass */ -} PruneReason; /* ---------------- * function prototypes for heap access method @@ -367,12 +409,8 @@ extern TransactionId heap_index_delete_tuples(Relation rel, /* in heap/pruneheap.c */ extern void heap_page_prune_opt(Relation relation, Buffer buffer); -extern void heap_page_prune_and_freeze(Relation relation, Buffer buffer, - GlobalVisState *vistest, - int options, - struct VacuumCutoffs *cutoffs, +extern void heap_page_prune_and_freeze(PruneFreezeParams *params, PruneFreezeResult *presult, - PruneReason reason, OffsetNumber *off_loc, TransactionId *new_relfrozen_xid, MultiXactId *new_relmin_mxid); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 37f26f6c6b7..8a626d633d5 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2340,6 +2340,7 @@ ProjectionPath PromptInterruptContext ProtocolVersion PrsStorage +PruneFreezeParams PruneFreezeResult PruneReason PruneState -- 2.43.0