PostgreSQL Source Code git master
Data Structures | Functions
pruneheap.c File Reference
#include "postgres.h"
#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"
#include "commands/vacuum.h"
#include "executor/instrument.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "storage/bufmgr.h"
#include "utils/rel.h"
#include "utils/snapmgr.h"
Include dependency graph for pruneheap.c:

Go to the source code of this file.

Data Structures

struct   PruneState
 

Functions

static HTSV_Result  heap_prune_satisfies_vacuum (PruneState *prstate, HeapTuple tup, Buffer buffer)
 
static HTSV_Result  htsv_get_valid_status (int status)
 
static void  heap_prune_chain (Page page, BlockNumber blockno, OffsetNumber maxoff, OffsetNumber rootoffnum, PruneState *prstate)
 
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)
 
static void  heap_prune_record_dead (PruneState *prstate, OffsetNumber offnum, bool was_normal)
 
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_lp_unused (Page page, PruneState *prstate, OffsetNumber offnum)
 
static void  heap_prune_record_unchanged_lp_normal (Page page, PruneState *prstate, OffsetNumber offnum)
 
static void  heap_prune_record_unchanged_lp_dead (Page page, PruneState *prstate, OffsetNumber offnum)
 
static void  heap_prune_record_unchanged_lp_redirect (PruneState *prstate, OffsetNumber offnum)
 
static void  page_verify_redirects (Page page)
 
void  heap_page_prune_opt (Relation relation, Buffer buffer)
 
void  heap_page_prune_and_freeze (Relation relation, Buffer buffer, GlobalVisState *vistest, int options, struct VacuumCutoffs *cutoffs, PruneFreezeResult *presult, PruneReason reason, OffsetNumber *off_loc, TransactionId *new_relfrozen_xid, MultiXactId *new_relmin_mxid)
 
void  heap_page_prune_execute (Buffer buffer, bool lp_truncate_only, OffsetNumber *redirected, int nredirected, OffsetNumber *nowdead, int ndead, OffsetNumber *nowunused, int nunused)
 
void  heap_get_root_tuples (Page page, OffsetNumber *root_offsets)
 
static bool  heap_log_freeze_eq (xlhp_freeze_plan *plan, HeapTupleFreeze *frz)
 
static int  heap_log_freeze_cmp (const void *arg1, const void *arg2)
 
static void  heap_log_freeze_new_plan (xlhp_freeze_plan *plan, HeapTupleFreeze *frz)
 
static int  heap_log_freeze_plan (HeapTupleFreeze *tuples, int ntuples, xlhp_freeze_plan *plans_out, OffsetNumber *offsets_out)
 
void  log_heap_prune_and_freeze (Relation relation, Buffer buffer, TransactionId conflict_xid, bool cleanup_lock, PruneReason reason, HeapTupleFreeze *frozen, int nfrozen, OffsetNumber *redirected, int nredirected, OffsetNumber *dead, int ndead, OffsetNumber *unused, int nunused)
 

Function Documentation

◆ heap_get_root_tuples()

void heap_get_root_tuples ( Page  page,
OffsetNumber *  root_offsets 
)

Definition at line 1785 of file pruneheap.c.

1786{
1787 OffsetNumber offnum,
1788 maxoff;
1789
1790 MemSet(root_offsets, InvalidOffsetNumber,
1792
1793 maxoff = PageGetMaxOffsetNumber(page);
1794 for (offnum = FirstOffsetNumber; offnum <= maxoff; offnum = OffsetNumberNext(offnum))
1795 {
1796 ItemId lp = PageGetItemId(page, offnum);
1797 HeapTupleHeader htup;
1798 OffsetNumber nextoffnum;
1799 TransactionId priorXmax;
1800
1801 /* skip unused and dead items */
1802 if (!ItemIdIsUsed(lp) || ItemIdIsDead(lp))
1803 continue;
1804
1805 if (ItemIdIsNormal(lp))
1806 {
1807 htup = (HeapTupleHeader) PageGetItem(page, lp);
1808
1809 /*
1810 * Check if this tuple is part of a HOT-chain rooted at some other
1811 * tuple. If so, skip it for now; we'll process it when we find
1812 * its root.
1813 */
1814 if (HeapTupleHeaderIsHeapOnly(htup))
1815 continue;
1816
1817 /*
1818 * This is either a plain tuple or the root of a HOT-chain.
1819 * Remember it in the mapping.
1820 */
1821 root_offsets[offnum - 1] = offnum;
1822
1823 /* If it's not the start of a HOT-chain, we're done with it */
1824 if (!HeapTupleHeaderIsHotUpdated(htup))
1825 continue;
1826
1827 /* Set up to scan the HOT-chain */
1828 nextoffnum = ItemPointerGetOffsetNumber(&htup->t_ctid);
1829 priorXmax = HeapTupleHeaderGetUpdateXid(htup);
1830 }
1831 else
1832 {
1833 /* Must be a redirect item. We do not set its root_offsets entry */
1835 /* Set up to scan the HOT-chain */
1836 nextoffnum = ItemIdGetRedirect(lp);
1837 priorXmax = InvalidTransactionId;
1838 }
1839
1840 /*
1841 * Now follow the HOT-chain and collect other tuples in the chain.
1842 *
1843 * Note: Even though this is a nested loop, the complexity of the
1844 * function is O(N) because a tuple in the page should be visited not
1845 * more than twice, once in the outer loop and once in HOT-chain
1846 * chases.
1847 */
1848 for (;;)
1849 {
1850 /* Sanity check (pure paranoia) */
1851 if (offnum < FirstOffsetNumber)
1852 break;
1853
1854 /*
1855 * An offset past the end of page's line pointer array is possible
1856 * when the array was truncated
1857 */
1858 if (offnum > maxoff)
1859 break;
1860
1861 lp = PageGetItemId(page, nextoffnum);
1862
1863 /* Check for broken chains */
1864 if (!ItemIdIsNormal(lp))
1865 break;
1866
1867 htup = (HeapTupleHeader) PageGetItem(page, lp);
1868
1869 if (TransactionIdIsValid(priorXmax) &&
1871 break;
1872
1873 /* Remember the root line pointer for this item */
1874 root_offsets[nextoffnum - 1] = offnum;
1875
1876 /* Advance to next chain member, if any */
1877 if (!HeapTupleHeaderIsHotUpdated(htup))
1878 break;
1879
1880 /* HOT implies it can't have moved to different partition */
1882
1883 nextoffnum = ItemPointerGetOffsetNumber(&htup->t_ctid);
1884 priorXmax = HeapTupleHeaderGetUpdateXid(htup);
1885 }
1886 }
1887}
static Item PageGetItem(const PageData *page, const ItemIdData *itemId)
Definition: bufpage.h:354
static ItemId PageGetItemId(Page page, OffsetNumber offsetNumber)
Definition: bufpage.h:244
static OffsetNumber PageGetMaxOffsetNumber(const PageData *page)
Definition: bufpage.h:372
#define MemSet(start, val, len)
Definition: c.h:1019
uint32 TransactionId
Definition: c.h:657
Assert(PointerIsAligned(start, uint64))
HeapTupleHeaderData * HeapTupleHeader
Definition: htup.h:23
static bool HeapTupleHeaderIsHeapOnly(const HeapTupleHeaderData *tup)
Definition: htup_details.h:555
static TransactionId HeapTupleHeaderGetXmin(const HeapTupleHeaderData *tup)
Definition: htup_details.h:324
static bool HeapTupleHeaderIndicatesMovedPartitions(const HeapTupleHeaderData *tup)
Definition: htup_details.h:480
static bool HeapTupleHeaderIsHotUpdated(const HeapTupleHeaderData *tup)
Definition: htup_details.h:534
static TransactionId HeapTupleHeaderGetUpdateXid(const HeapTupleHeaderData *tup)
Definition: htup_details.h:397
#define MaxHeapTuplesPerPage
Definition: htup_details.h:624
#define ItemIdIsNormal(itemId)
Definition: itemid.h:99
#define ItemIdGetRedirect(itemId)
Definition: itemid.h:78
#define ItemIdIsDead(itemId)
Definition: itemid.h:113
#define ItemIdIsUsed(itemId)
Definition: itemid.h:92
#define ItemIdIsRedirected(itemId)
Definition: itemid.h:106
static OffsetNumber ItemPointerGetOffsetNumber(const ItemPointerData *pointer)
Definition: itemptr.h:124
#define InvalidOffsetNumber
Definition: off.h:26
#define OffsetNumberNext(offsetNumber)
Definition: off.h:52
uint16 OffsetNumber
Definition: off.h:24
#define FirstOffsetNumber
Definition: off.h:27
ItemPointerData t_ctid
Definition: htup_details.h:161
Definition: itemid.h:26
#define InvalidTransactionId
Definition: transam.h:31
#define TransactionIdEquals(id1, id2)
Definition: transam.h:43
#define TransactionIdIsValid(xid)
Definition: transam.h:41

References Assert(), FirstOffsetNumber, HeapTupleHeaderGetUpdateXid(), HeapTupleHeaderGetXmin(), HeapTupleHeaderIndicatesMovedPartitions(), HeapTupleHeaderIsHeapOnly(), HeapTupleHeaderIsHotUpdated(), InvalidOffsetNumber, InvalidTransactionId, ItemIdGetRedirect, ItemIdIsDead, ItemIdIsNormal, ItemIdIsRedirected, ItemIdIsUsed, ItemPointerGetOffsetNumber(), MaxHeapTuplesPerPage, MemSet, OffsetNumberNext, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), HeapTupleHeaderData::t_ctid, TransactionIdEquals, and TransactionIdIsValid.

Referenced by heapam_index_build_range_scan(), and heapam_index_validate_scan().

◆ heap_log_freeze_cmp()

static int heap_log_freeze_cmp ( const void *  arg1,
const void *  arg2 
)
static

Definition at line 1912 of file pruneheap.c.

1913{
1914 HeapTupleFreeze *frz1 = (HeapTupleFreeze *) arg1;
1915 HeapTupleFreeze *frz2 = (HeapTupleFreeze *) arg2;
1916
1917 if (frz1->xmax < frz2->xmax)
1918 return -1;
1919 else if (frz1->xmax > frz2->xmax)
1920 return 1;
1921
1922 if (frz1->t_infomask2 < frz2->t_infomask2)
1923 return -1;
1924 else if (frz1->t_infomask2 > frz2->t_infomask2)
1925 return 1;
1926
1927 if (frz1->t_infomask < frz2->t_infomask)
1928 return -1;
1929 else if (frz1->t_infomask > frz2->t_infomask)
1930 return 1;
1931
1932 if (frz1->frzflags < frz2->frzflags)
1933 return -1;
1934 else if (frz1->frzflags > frz2->frzflags)
1935 return 1;
1936
1937 /*
1938 * heap_log_freeze_eq would consider these tuple-wise plans to be equal.
1939 * (So the tuples will share a single canonical freeze plan.)
1940 *
1941 * We tiebreak on page offset number to keep each freeze plan's page
1942 * offset number array individually sorted. (Unnecessary, but be tidy.)
1943 */
1944 if (frz1->offset < frz2->offset)
1945 return -1;
1946 else if (frz1->offset > frz2->offset)
1947 return 1;
1948
1949 Assert(false);
1950 return 0;
1951}
uint8 frzflags
Definition: heapam.h:147
uint16 t_infomask2
Definition: heapam.h:145
TransactionId xmax
Definition: heapam.h:144
OffsetNumber offset
Definition: heapam.h:152
uint16 t_infomask
Definition: heapam.h:146

References Assert(), HeapTupleFreeze::frzflags, HeapTupleFreeze::offset, HeapTupleFreeze::t_infomask, HeapTupleFreeze::t_infomask2, and HeapTupleFreeze::xmax.

Referenced by heap_log_freeze_plan().

◆ heap_log_freeze_eq()

static bool heap_log_freeze_eq ( xlhp_freeze_plan *  plan,
HeapTupleFreeze *  frz 
)
inlinestatic

Definition at line 1896 of file pruneheap.c.

1897{
1898 if (plan->xmax == frz->xmax &&
1899 plan->t_infomask2 == frz->t_infomask2 &&
1900 plan->t_infomask == frz->t_infomask &&
1901 plan->frzflags == frz->frzflags)
1902 return true;
1903
1904 /* Caller must call heap_log_freeze_new_plan again for frz */
1905 return false;
1906}
#define plan(x)
Definition: pg_regress.c:161

References HeapTupleFreeze::frzflags, plan, HeapTupleFreeze::t_infomask, HeapTupleFreeze::t_infomask2, and HeapTupleFreeze::xmax.

Referenced by heap_log_freeze_plan().

◆ heap_log_freeze_new_plan()

static void heap_log_freeze_new_plan ( xlhp_freeze_plan *  plan,
HeapTupleFreeze *  frz 
)
inlinestatic

Definition at line 1958 of file pruneheap.c.

1959{
1960 plan->xmax = frz->xmax;
1961 plan->t_infomask2 = frz->t_infomask2;
1962 plan->t_infomask = frz->t_infomask;
1963 plan->frzflags = frz->frzflags;
1964 plan->ntuples = 1; /* for now */
1965}

References HeapTupleFreeze::frzflags, plan, HeapTupleFreeze::t_infomask, HeapTupleFreeze::t_infomask2, and HeapTupleFreeze::xmax.

Referenced by heap_log_freeze_plan().

◆ heap_log_freeze_plan()

static int heap_log_freeze_plan ( HeapTupleFreeze *  tuples,
int  ntuples,
xlhp_freeze_plan *  plans_out,
OffsetNumber *  offsets_out 
)
static

Definition at line 1978 of file pruneheap.c.

1981{
1982 int nplans = 0;
1983
1984 /* Sort tuple-based freeze plans in the order required to deduplicate */
1985 qsort(tuples, ntuples, sizeof(HeapTupleFreeze), heap_log_freeze_cmp);
1986
1987 for (int i = 0; i < ntuples; i++)
1988 {
1989 HeapTupleFreeze *frz = tuples + i;
1990
1991 if (i == 0)
1992 {
1993 /* New canonical freeze plan starting with first tup */
1994 heap_log_freeze_new_plan(plans_out, frz);
1995 nplans++;
1996 }
1997 else if (heap_log_freeze_eq(plans_out, frz))
1998 {
1999 /* tup matches open canonical plan -- include tup in it */
2000 Assert(offsets_out[i - 1] < frz->offset);
2001 plans_out->ntuples++;
2002 }
2003 else
2004 {
2005 /* Tup doesn't match current plan -- done with it now */
2006 plans_out++;
2007
2008 /* New canonical freeze plan starting with this tup */
2009 heap_log_freeze_new_plan(plans_out, frz);
2010 nplans++;
2011 }
2012
2013 /*
2014 * Save page offset number in dedicated buffer in passing.
2015 *
2016 * REDO routine relies on the record's offset numbers array grouping
2017 * offset numbers by freeze plan. The sort order within each grouping
2018 * is ascending offset number order, just to keep things tidy.
2019 */
2020 offsets_out[i] = frz->offset;
2021 }
2022
2023 Assert(nplans > 0 && nplans <= ntuples);
2024
2025 return nplans;
2026}
i
int i
Definition: isn.c:77
#define qsort(a, b, c, d)
Definition: port.h:479
static int heap_log_freeze_cmp(const void *arg1, const void *arg2)
Definition: pruneheap.c:1912
static bool heap_log_freeze_eq(xlhp_freeze_plan *plan, HeapTupleFreeze *frz)
Definition: pruneheap.c:1896
static void heap_log_freeze_new_plan(xlhp_freeze_plan *plan, HeapTupleFreeze *frz)
Definition: pruneheap.c:1958
uint16 ntuples
Definition: heapam_xlog.h:349

References Assert(), heap_log_freeze_cmp(), heap_log_freeze_eq(), heap_log_freeze_new_plan(), i, xlhp_freeze_plan::ntuples, HeapTupleFreeze::offset, and qsort.

Referenced by log_heap_prune_and_freeze().

◆ heap_page_prune_and_freeze()

void heap_page_prune_and_freeze ( Relation  relation,
Buffer  buffer,
GlobalVisState *  vistest,
int  options,
struct VacuumCutoffs *  cutoffs,
PruneFreezeResult *  presult,
PruneReason  reason,
OffsetNumber *  off_loc,
TransactionId *  new_relfrozen_xid,
MultiXactId *  new_relmin_mxid 
)

Definition at line 350 of file pruneheap.c.

359{
360 Page page = BufferGetPage(buffer);
361 BlockNumber blockno = BufferGetBlockNumber(buffer);
362 OffsetNumber offnum,
363 maxoff;
364 PruneState prstate;
365 HeapTupleData tup;
366 bool do_freeze;
367 bool do_prune;
368 bool do_hint;
369 bool hint_bit_fpi;
370 int64 fpi_before = pgWalUsage.wal_fpi;
371
372 /* Copy parameters to prstate */
373 prstate.vistest = vistest;
375 prstate.freeze = (options & HEAP_PAGE_PRUNE_FREEZE) != 0;
376 prstate.cutoffs = cutoffs;
377
378 /*
379 * Our strategy is to scan the page and make lists of items to change,
380 * then apply the changes within a critical section. This keeps as much
381 * logic as possible out of the critical section, and also ensures that
382 * WAL replay will work the same as the normal case.
383 *
384 * First, initialize the new pd_prune_xid value to zero (indicating no
385 * prunable tuples). If we find any tuples which may soon become
386 * prunable, we will save the lowest relevant XID in new_prune_xid. Also
387 * initialize the rest of our working state.
388 */
391 prstate.nredirected = prstate.ndead = prstate.nunused = prstate.nfrozen = 0;
392 prstate.nroot_items = 0;
393 prstate.nheaponly_items = 0;
394
395 /* initialize page freezing working state */
396 prstate.pagefrz.freeze_required = false;
397 if (prstate.freeze)
398 {
399 Assert(new_relfrozen_xid && new_relmin_mxid);
400 prstate.pagefrz.FreezePageRelfrozenXid = *new_relfrozen_xid;
401 prstate.pagefrz.NoFreezePageRelfrozenXid = *new_relfrozen_xid;
402 prstate.pagefrz.FreezePageRelminMxid = *new_relmin_mxid;
403 prstate.pagefrz.NoFreezePageRelminMxid = *new_relmin_mxid;
404 }
405 else
406 {
407 Assert(new_relfrozen_xid == NULL && new_relmin_mxid == NULL);
412 }
413
414 prstate.ndeleted = 0;
415 prstate.live_tuples = 0;
416 prstate.recently_dead_tuples = 0;
417 prstate.hastup = false;
418 prstate.lpdead_items = 0;
419 prstate.deadoffsets = presult->deadoffsets;
420
421 /*
422 * Caller may update the VM after we're done. We can keep track of
423 * whether the page will be all-visible and all-frozen after pruning and
424 * freezing to help the caller to do that.
425 *
426 * Currently, only VACUUM sets the VM bits. To save the effort, only do
427 * the bookkeeping if the caller needs it. Currently, that's tied to
428 * HEAP_PAGE_PRUNE_FREEZE, but it could be a separate flag if you wanted
429 * to update the VM bits without also freezing or freeze without also
430 * setting the VM bits.
431 *
432 * In addition to telling the caller whether it can set the VM bit, we
433 * also use 'all_visible' and 'all_frozen' for our own decision-making. If
434 * the whole page would become frozen, we consider opportunistically
435 * freezing tuples. We will not be able to freeze the whole page if there
436 * are tuples present that are not visible to everyone or if there are
437 * dead tuples which are not yet removable. However, dead tuples which
438 * will be removed by the end of vacuuming should not preclude us from
439 * opportunistically freezing. Because of that, we do not clear
440 * all_visible when we see LP_DEAD items. We fix that at the end of the
441 * function, when we return the value to the caller, so that the caller
442 * doesn't set the VM bit incorrectly.
443 */
444 if (prstate.freeze)
445 {
446 prstate.all_visible = true;
447 prstate.all_frozen = true;
448 }
449 else
450 {
451 /*
452 * Initializing to false allows skipping the work to update them in
453 * heap_prune_record_unchanged_lp_normal().
454 */
455 prstate.all_visible = false;
456 prstate.all_frozen = false;
457 }
458
459 /*
460 * The visibility cutoff xid is the newest xmin of live tuples on the
461 * page. In the common case, this will be set as the conflict horizon the
462 * caller can use for updating the VM. If, at the end of freezing and
463 * pruning, the page is all-frozen, there is no possibility that any
464 * running transaction on the standby does not see tuples on the page as
465 * all-visible, so the conflict horizon remains InvalidTransactionId.
466 */
468
469 maxoff = PageGetMaxOffsetNumber(page);
470 tup.t_tableOid = RelationGetRelid(relation);
471
472 /*
473 * Determine HTSV for all tuples, and queue them up for processing as HOT
474 * chain roots or as heap-only items.
475 *
476 * Determining HTSV only once for each tuple is required for correctness,
477 * to deal with cases where running HTSV twice could result in different
478 * results. For example, RECENTLY_DEAD can turn to DEAD if another
479 * checked item causes GlobalVisTestIsRemovableFullXid() to update the
480 * horizon, or INSERT_IN_PROGRESS can change to DEAD if the inserting
481 * transaction aborts.
482 *
483 * It's also good for performance. Most commonly tuples within a page are
484 * stored at decreasing offsets (while the items are stored at increasing
485 * offsets). When processing all tuples on a page this leads to reading
486 * memory at decreasing offsets within a page, with a variable stride.
487 * That's hard for CPU prefetchers to deal with. Processing the items in
488 * reverse order (and thus the tuples in increasing order) increases
489 * prefetching efficiency significantly / decreases the number of cache
490 * misses.
491 */
492 for (offnum = maxoff;
493 offnum >= FirstOffsetNumber;
494 offnum = OffsetNumberPrev(offnum))
495 {
496 ItemId itemid = PageGetItemId(page, offnum);
497 HeapTupleHeader htup;
498
499 /*
500 * Set the offset number so that we can display it along with any
501 * error that occurred while processing this tuple.
502 */
503 *off_loc = offnum;
504
505 prstate.processed[offnum] = false;
506 prstate.htsv[offnum] = -1;
507
508 /* Nothing to do if slot doesn't contain a tuple */
509 if (!ItemIdIsUsed(itemid))
510 {
511 heap_prune_record_unchanged_lp_unused(page, &prstate, offnum);
512 continue;
513 }
514
515 if (ItemIdIsDead(itemid))
516 {
517 /*
518 * If the caller set mark_unused_now true, we can set dead line
519 * pointers LP_UNUSED now.
520 */
521 if (unlikely(prstate.mark_unused_now))
522 heap_prune_record_unused(&prstate, offnum, false);
523 else
524 heap_prune_record_unchanged_lp_dead(page, &prstate, offnum);
525 continue;
526 }
527
528 if (ItemIdIsRedirected(itemid))
529 {
530 /* This is the start of a HOT chain */
531 prstate.root_items[prstate.nroot_items++] = offnum;
532 continue;
533 }
534
535 Assert(ItemIdIsNormal(itemid));
536
537 /*
538 * Get the tuple's visibility status and queue it up for processing.
539 */
540 htup = (HeapTupleHeader) PageGetItem(page, itemid);
541 tup.t_data = htup;
542 tup.t_len = ItemIdGetLength(itemid);
543 ItemPointerSet(&tup.t_self, blockno, offnum);
544
545 prstate.htsv[offnum] = heap_prune_satisfies_vacuum(&prstate, &tup,
546 buffer);
547
548 if (!HeapTupleHeaderIsHeapOnly(htup))
549 prstate.root_items[prstate.nroot_items++] = offnum;
550 else
551 prstate.heaponly_items[prstate.nheaponly_items++] = offnum;
552 }
553
554 /*
555 * If checksums are enabled, heap_prune_satisfies_vacuum() may have caused
556 * an FPI to be emitted.
557 */
558 hint_bit_fpi = fpi_before != pgWalUsage.wal_fpi;
559
560 /*
561 * Process HOT chains.
562 *
563 * We added the items to the array starting from 'maxoff', so by
564 * processing the array in reverse order, we process the items in
565 * ascending offset number order. The order doesn't matter for
566 * correctness, but some quick micro-benchmarking suggests that this is
567 * faster. (Earlier PostgreSQL versions, which scanned all the items on
568 * the page instead of using the root_items array, also did it in
569 * ascending offset number order.)
570 */
571 for (int i = prstate.nroot_items - 1; i >= 0; i--)
572 {
573 offnum = prstate.root_items[i];
574
575 /* Ignore items already processed as part of an earlier chain */
576 if (prstate.processed[offnum])
577 continue;
578
579 /* see preceding loop */
580 *off_loc = offnum;
581
582 /* Process this item or chain of items */
583 heap_prune_chain(page, blockno, maxoff, offnum, &prstate);
584 }
585
586 /*
587 * Process any heap-only tuples that were not already processed as part of
588 * a HOT chain.
589 */
590 for (int i = prstate.nheaponly_items - 1; i >= 0; i--)
591 {
592 offnum = prstate.heaponly_items[i];
593
594 if (prstate.processed[offnum])
595 continue;
596
597 /* see preceding loop */
598 *off_loc = offnum;
599
600 /*
601 * If the tuple is DEAD and doesn't chain to anything else, mark it
602 * unused. (If it does chain, we can only remove it as part of
603 * pruning its chain.)
604 *
605 * We need this primarily to handle aborted HOT updates, that is,
606 * XMIN_INVALID heap-only tuples. Those might not be linked to by any
607 * chain, since the parent tuple might be re-updated before any
608 * pruning occurs. So we have to be able to reap them separately from
609 * chain-pruning. (Note that HeapTupleHeaderIsHotUpdated will never
610 * return true for an XMIN_INVALID tuple, so this code will work even
611 * when there were sequential updates within the aborted transaction.)
612 */
613 if (prstate.htsv[offnum] == HEAPTUPLE_DEAD)
614 {
615 ItemId itemid = PageGetItemId(page, offnum);
616 HeapTupleHeader htup = (HeapTupleHeader) PageGetItem(page, itemid);
617
619 {
621 &prstate.latest_xid_removed);
622 heap_prune_record_unused(&prstate, offnum, true);
623 }
624 else
625 {
626 /*
627 * This tuple should've been processed and removed as part of
628 * a HOT chain, so something's wrong. To preserve evidence,
629 * we don't dare to remove it. We cannot leave behind a DEAD
630 * tuple either, because that will cause VACUUM to error out.
631 * Throwing an error with a distinct error message seems like
632 * the least bad option.
633 */
634 elog(ERROR, "dead heap-only tuple (%u, %d) is not linked to from any HOT chain",
635 blockno, offnum);
636 }
637 }
638 else
639 heap_prune_record_unchanged_lp_normal(page, &prstate, offnum);
640 }
641
642 /* We should now have processed every tuple exactly once */
643#ifdef USE_ASSERT_CHECKING
644 for (offnum = FirstOffsetNumber;
645 offnum <= maxoff;
646 offnum = OffsetNumberNext(offnum))
647 {
648 *off_loc = offnum;
649
650 Assert(prstate.processed[offnum]);
651 }
652#endif
653
654 /* Clear the offset information once we have processed the given page. */
655 *off_loc = InvalidOffsetNumber;
656
657 do_prune = prstate.nredirected > 0 ||
658 prstate.ndead > 0 ||
659 prstate.nunused > 0;
660
661 /*
662 * Even if we don't prune anything, if we found a new value for the
663 * pd_prune_xid field or the page was marked full, we will update the hint
664 * bit.
665 */
666 do_hint = ((PageHeader) page)->pd_prune_xid != prstate.new_prune_xid ||
667 PageIsFull(page);
668
669 /*
670 * Decide if we want to go ahead with freezing according to the freeze
671 * plans we prepared, or not.
672 */
673 do_freeze = false;
674 if (prstate.freeze)
675 {
676 if (prstate.pagefrz.freeze_required)
677 {
678 /*
679 * heap_prepare_freeze_tuple indicated that at least one XID/MXID
680 * from before FreezeLimit/MultiXactCutoff is present. Must
681 * freeze to advance relfrozenxid/relminmxid.
682 */
683 do_freeze = true;
684 }
685 else
686 {
687 /*
688 * Opportunistically freeze the page if we are generating an FPI
689 * anyway and if doing so means that we can set the page
690 * all-frozen afterwards (might not happen until VACUUM's final
691 * heap pass).
692 *
693 * XXX: Previously, we knew if pruning emitted an FPI by checking
694 * pgWalUsage.wal_fpi before and after pruning. Once the freeze
695 * and prune records were combined, this heuristic couldn't be
696 * used anymore. The opportunistic freeze heuristic must be
697 * improved; however, for now, try to approximate the old logic.
698 */
699 if (prstate.all_visible && prstate.all_frozen && prstate.nfrozen > 0)
700 {
701 /*
702 * Freezing would make the page all-frozen. Have already
703 * emitted an FPI or will do so anyway?
704 */
705 if (RelationNeedsWAL(relation))
706 {
707 if (hint_bit_fpi)
708 do_freeze = true;
709 else if (do_prune)
710 {
711 if (XLogCheckBufferNeedsBackup(buffer))
712 do_freeze = true;
713 }
714 else if (do_hint)
715 {
717 do_freeze = true;
718 }
719 }
720 }
721 }
722 }
723
724 if (do_freeze)
725 {
726 /*
727 * Validate the tuples we will be freezing before entering the
728 * critical section.
729 */
730 heap_pre_freeze_checks(buffer, prstate.frozen, prstate.nfrozen);
731 }
732 else if (prstate.nfrozen > 0)
733 {
734 /*
735 * The page contained some tuples that were not already frozen, and we
736 * chose not to freeze them now. The page won't be all-frozen then.
737 */
739
740 prstate.all_frozen = false;
741 prstate.nfrozen = 0; /* avoid miscounts in instrumentation */
742 }
743 else
744 {
745 /*
746 * We have no freeze plans to execute. The page might already be
747 * all-frozen (perhaps only following pruning), though. Such pages
748 * can be marked all-frozen in the VM by our caller, even though none
749 * of its tuples were newly frozen here.
750 */
751 }
752
753 /* Any error while applying the changes is critical */
755
756 if (do_hint)
757 {
758 /*
759 * Update the page's pd_prune_xid field to either zero, or the lowest
760 * XID of any soon-prunable tuple.
761 */
762 ((PageHeader) page)->pd_prune_xid = prstate.new_prune_xid;
763
764 /*
765 * Also clear the "page is full" flag, since there's no point in
766 * repeating the prune/defrag process until something else happens to
767 * the page.
768 */
769 PageClearFull(page);
770
771 /*
772 * If that's all we had to do to the page, this is a non-WAL-logged
773 * hint. If we are going to freeze or prune the page, we will mark
774 * the buffer dirty below.
775 */
776 if (!do_freeze && !do_prune)
777 MarkBufferDirtyHint(buffer, true);
778 }
779
780 if (do_prune || do_freeze)
781 {
782 /* Apply the planned item changes and repair page fragmentation. */
783 if (do_prune)
784 {
785 heap_page_prune_execute(buffer, false,
786 prstate.redirected, prstate.nredirected,
787 prstate.nowdead, prstate.ndead,
788 prstate.nowunused, prstate.nunused);
789 }
790
791 if (do_freeze)
792 heap_freeze_prepared_tuples(buffer, prstate.frozen, prstate.nfrozen);
793
794 MarkBufferDirty(buffer);
795
796 /*
797 * Emit a WAL XLOG_HEAP2_PRUNE* record showing what we did
798 */
799 if (RelationNeedsWAL(relation))
800 {
801 /*
802 * The snapshotConflictHorizon for the whole record should be the
803 * most conservative of all the horizons calculated for any of the
804 * possible modifications. If this record will prune tuples, any
805 * transactions on the standby older than the youngest xmax of the
806 * most recently removed tuple this record will prune will
807 * conflict. If this record will freeze tuples, any transactions
808 * on the standby with xids older than the youngest tuple this
809 * record will freeze will conflict.
810 */
811 TransactionId frz_conflict_horizon = InvalidTransactionId;
812 TransactionId conflict_xid;
813
814 /*
815 * We can use the visibility_cutoff_xid as our cutoff for
816 * conflicts when the whole page is eligible to become all-frozen
817 * in the VM once we're done with it. Otherwise we generate a
818 * conservative cutoff by stepping back from OldestXmin.
819 */
820 if (do_freeze)
821 {
822 if (prstate.all_visible && prstate.all_frozen)
823 frz_conflict_horizon = prstate.visibility_cutoff_xid;
824 else
825 {
826 /* Avoids false conflicts when hot_standby_feedback in use */
827 frz_conflict_horizon = prstate.cutoffs->OldestXmin;
828 TransactionIdRetreat(frz_conflict_horizon);
829 }
830 }
831
832 if (TransactionIdFollows(frz_conflict_horizon, prstate.latest_xid_removed))
833 conflict_xid = frz_conflict_horizon;
834 else
835 conflict_xid = prstate.latest_xid_removed;
836
837 log_heap_prune_and_freeze(relation, buffer,
838 conflict_xid,
839 true, reason,
840 prstate.frozen, prstate.nfrozen,
841 prstate.redirected, prstate.nredirected,
842 prstate.nowdead, prstate.ndead,
843 prstate.nowunused, prstate.nunused);
844 }
845 }
846
848
849 /* Copy information back for caller */
850 presult->ndeleted = prstate.ndeleted;
851 presult->nnewlpdead = prstate.ndead;
852 presult->nfrozen = prstate.nfrozen;
853 presult->live_tuples = prstate.live_tuples;
855
856 /*
857 * It was convenient to ignore LP_DEAD items in all_visible earlier on to
858 * make the choice of whether or not to freeze the page unaffected by the
859 * short-term presence of LP_DEAD items. These LP_DEAD items were
860 * effectively assumed to be LP_UNUSED items in the making. It doesn't
861 * matter which vacuum heap pass (initial pass or final pass) ends up
862 * setting the page all-frozen, as long as the ongoing VACUUM does it.
863 *
864 * Now that freezing has been finalized, unset all_visible if there are
865 * any LP_DEAD items on the page. It needs to reflect the present state
866 * of the page, as expected by our caller.
867 */
868 if (prstate.all_visible && prstate.lpdead_items == 0)
869 {
870 presult->all_visible = prstate.all_visible;
871 presult->all_frozen = prstate.all_frozen;
872 }
873 else
874 {
875 presult->all_visible = false;
876 presult->all_frozen = false;
877 }
878
879 presult->hastup = prstate.hastup;
880
881 /*
882 * For callers planning to update the visibility map, the conflict horizon
883 * for that record must be the newest xmin on the page. However, if the
884 * page is completely frozen, there can be no conflict and the
885 * vm_conflict_horizon should remain InvalidTransactionId. This includes
886 * the case that we just froze all the tuples; the prune-freeze record
887 * included the conflict XID already so the caller doesn't need it.
888 */
889 if (presult->all_frozen)
891 else
893
894 presult->lpdead_items = prstate.lpdead_items;
895 /* the presult->deadoffsets array was already filled in */
896
897 if (prstate.freeze)
898 {
899 if (presult->nfrozen > 0)
900 {
901 *new_relfrozen_xid = prstate.pagefrz.FreezePageRelfrozenXid;
902 *new_relmin_mxid = prstate.pagefrz.FreezePageRelminMxid;
903 }
904 else
905 {
906 *new_relfrozen_xid = prstate.pagefrz.NoFreezePageRelfrozenXid;
907 *new_relmin_mxid = prstate.pagefrz.NoFreezePageRelminMxid;
908 }
909 }
910}
uint32 BlockNumber
Definition: block.h:31
BlockNumber BufferGetBlockNumber(Buffer buffer)
Definition: bufmgr.c:4198
void MarkBufferDirty(Buffer buffer)
Definition: bufmgr.c:2921
void MarkBufferDirtyHint(Buffer buffer, bool buffer_std)
Definition: bufmgr.c:5402
static Page BufferGetPage(Buffer buffer)
Definition: bufmgr.h:417
PageHeaderData * PageHeader
Definition: bufpage.h:174
static void PageClearFull(Page page)
Definition: bufpage.h:423
PageData * Page
Definition: bufpage.h:82
static bool PageIsFull(const PageData *page)
Definition: bufpage.h:413
#define likely(x)
Definition: c.h:401
int64_t int64
Definition: c.h:535
#define unlikely(x)
Definition: c.h:402
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:226
void HeapTupleHeaderAdvanceConflictHorizon(HeapTupleHeader tuple, TransactionId *snapshotConflictHorizon)
Definition: heapam.c:7973
void heap_freeze_prepared_tuples(Buffer buffer, HeapTupleFreeze *tuples, int ntuples)
Definition: heapam.c:7380
void heap_pre_freeze_checks(Buffer buffer, HeapTupleFreeze *tuples, int ntuples)
Definition: heapam.c:7327
#define HEAP_PAGE_PRUNE_FREEZE
Definition: heapam.h:44
@ HEAPTUPLE_DEAD
Definition: heapam.h:126
#define HEAP_PAGE_PRUNE_MARK_UNUSED_NOW
Definition: heapam.h:43
WalUsage pgWalUsage
Definition: instrument.c:22
#define ItemIdGetLength(itemId)
Definition: itemid.h:59
static void ItemPointerSet(ItemPointerData *pointer, BlockNumber blockNumber, OffsetNumber offNum)
Definition: itemptr.h:135
#define START_CRIT_SECTION()
Definition: miscadmin.h:149
#define END_CRIT_SECTION()
Definition: miscadmin.h:151
#define InvalidMultiXactId
Definition: multixact.h:25
#define OffsetNumberPrev(offsetNumber)
Definition: off.h:54
static void heap_prune_chain(Page page, BlockNumber blockno, OffsetNumber maxoff, OffsetNumber rootoffnum, PruneState *prstate)
Definition: pruneheap.c:999
static void heap_prune_record_unchanged_lp_dead(Page page, PruneState *prstate, OffsetNumber offnum)
Definition: pruneheap.c:1508
static void heap_prune_record_unused(PruneState *prstate, OffsetNumber offnum, bool was_normal)
Definition: pruneheap.c:1297
static void heap_prune_record_unchanged_lp_normal(Page page, PruneState *prstate, OffsetNumber offnum)
Definition: pruneheap.c:1330
void log_heap_prune_and_freeze(Relation relation, Buffer buffer, TransactionId conflict_xid, bool cleanup_lock, PruneReason reason, HeapTupleFreeze *frozen, int nfrozen, OffsetNumber *redirected, int nredirected, OffsetNumber *dead, int ndead, OffsetNumber *unused, int nunused)
Definition: pruneheap.c:2053
static void heap_prune_record_unchanged_lp_unused(Page page, PruneState *prstate, OffsetNumber offnum)
Definition: pruneheap.c:1319
static HTSV_Result heap_prune_satisfies_vacuum(PruneState *prstate, HeapTuple tup, Buffer buffer)
Definition: pruneheap.c:917
void heap_page_prune_execute(Buffer buffer, bool lp_truncate_only, OffsetNumber *redirected, int nredirected, OffsetNumber *nowdead, int ndead, OffsetNumber *nowunused, int nunused)
Definition: pruneheap.c:1561
#define RelationGetRelid(relation)
Definition: rel.h:514
#define RelationNeedsWAL(relation)
Definition: rel.h:637
MultiXactId NoFreezePageRelminMxid
Definition: heapam.h:220
TransactionId FreezePageRelfrozenXid
Definition: heapam.h:208
bool freeze_required
Definition: heapam.h:182
MultiXactId FreezePageRelminMxid
Definition: heapam.h:209
TransactionId NoFreezePageRelfrozenXid
Definition: heapam.h:219
ItemPointerData t_self
Definition: htup.h:65
uint32 t_len
Definition: htup.h:64
HeapTupleHeader t_data
Definition: htup.h:68
Oid t_tableOid
Definition: htup.h:66
int lpdead_items
Definition: heapam.h:263
int recently_dead_tuples
Definition: heapam.h:235
int ndeleted
Definition: heapam.h:229
int nnewlpdead
Definition: heapam.h:230
TransactionId vm_conflict_horizon
Definition: heapam.h:250
bool all_frozen
Definition: heapam.h:249
int live_tuples
Definition: heapam.h:234
OffsetNumber deadoffsets[MaxHeapTuplesPerPage]
Definition: heapam.h:264
bool all_visible
Definition: heapam.h:248
bool hastup
Definition: heapam.h:257
HeapPageFreeze pagefrz
Definition: pruneheap.c:103
bool all_visible
Definition: pruneheap.c:150
int ndead
Definition: pruneheap.c:55
bool processed[MaxHeapTuplesPerPage+1]
Definition: pruneheap.c:86
OffsetNumber heaponly_items[MaxHeapTuplesPerPage]
Definition: pruneheap.c:78
TransactionId new_prune_xid
Definition: pruneheap.c:52
bool hastup
Definition: pruneheap.c:122
int recently_dead_tuples
Definition: pruneheap.c:119
OffsetNumber nowdead[MaxHeapTuplesPerPage]
Definition: pruneheap.c:60
int nroot_items
Definition: pruneheap.c:75
OffsetNumber nowunused[MaxHeapTuplesPerPage]
Definition: pruneheap.c:61
int nheaponly_items
Definition: pruneheap.c:77
bool mark_unused_now
Definition: pruneheap.c:43
int live_tuples
Definition: pruneheap.c:118
TransactionId visibility_cutoff_xid
Definition: pruneheap.c:152
bool all_frozen
Definition: pruneheap.c:151
GlobalVisState * vistest
Definition: pruneheap.c:41
struct VacuumCutoffs * cutoffs
Definition: pruneheap.c:46
HeapTupleFreeze frozen[MaxHeapTuplesPerPage]
Definition: pruneheap.c:62
int lpdead_items
Definition: pruneheap.c:128
int nfrozen
Definition: pruneheap.c:57
OffsetNumber redirected[MaxHeapTuplesPerPage *2]
Definition: pruneheap.c:59
int ndeleted
Definition: pruneheap.c:115
bool freeze
Definition: pruneheap.c:45
int nredirected
Definition: pruneheap.c:54
int8 htsv[MaxHeapTuplesPerPage+1]
Definition: pruneheap.c:98
TransactionId latest_xid_removed
Definition: pruneheap.c:53
int nunused
Definition: pruneheap.c:56
OffsetNumber root_items[MaxHeapTuplesPerPage]
Definition: pruneheap.c:76
OffsetNumber * deadoffsets
Definition: pruneheap.c:129
TransactionId OldestXmin
Definition: vacuum.h:274
int64 wal_fpi
Definition: instrument.h:54
Definition: oid2name.c:30
bool TransactionIdFollows(TransactionId id1, TransactionId id2)
Definition: transam.c:314
#define TransactionIdRetreat(dest)
Definition: transam.h:141
#define XLogHintBitIsNeeded()
Definition: xlog.h:120
bool XLogCheckBufferNeedsBackup(Buffer buffer)
Definition: xloginsert.c:1039

References PruneState::all_frozen, PruneFreezeResult::all_frozen, PruneState::all_visible, PruneFreezeResult::all_visible, Assert(), BufferGetBlockNumber(), BufferGetPage(), PruneState::cutoffs, PruneState::deadoffsets, PruneFreezeResult::deadoffsets, elog, END_CRIT_SECTION, ERROR, FirstOffsetNumber, PruneState::freeze, HeapPageFreeze::freeze_required, HeapPageFreeze::FreezePageRelfrozenXid, HeapPageFreeze::FreezePageRelminMxid, PruneState::frozen, PruneState::hastup, PruneFreezeResult::hastup, heap_freeze_prepared_tuples(), heap_page_prune_execute(), HEAP_PAGE_PRUNE_FREEZE, HEAP_PAGE_PRUNE_MARK_UNUSED_NOW, heap_pre_freeze_checks(), heap_prune_chain(), heap_prune_record_unchanged_lp_dead(), heap_prune_record_unchanged_lp_normal(), heap_prune_record_unchanged_lp_unused(), heap_prune_record_unused(), heap_prune_satisfies_vacuum(), PruneState::heaponly_items, HEAPTUPLE_DEAD, HeapTupleHeaderAdvanceConflictHorizon(), HeapTupleHeaderIsHeapOnly(), HeapTupleHeaderIsHotUpdated(), PruneState::htsv, i, InvalidMultiXactId, InvalidOffsetNumber, InvalidTransactionId, ItemIdGetLength, ItemIdIsDead, ItemIdIsNormal, ItemIdIsRedirected, ItemIdIsUsed, ItemPointerSet(), PruneState::latest_xid_removed, likely, PruneState::live_tuples, PruneFreezeResult::live_tuples, log_heap_prune_and_freeze(), PruneState::lpdead_items, PruneFreezeResult::lpdead_items, PruneState::mark_unused_now, MarkBufferDirty(), MarkBufferDirtyHint(), PruneState::ndead, PruneState::ndeleted, PruneFreezeResult::ndeleted, PruneState::new_prune_xid, PruneState::nfrozen, PruneFreezeResult::nfrozen, PruneState::nheaponly_items, PruneFreezeResult::nnewlpdead, HeapPageFreeze::NoFreezePageRelfrozenXid, HeapPageFreeze::NoFreezePageRelminMxid, PruneState::nowdead, PruneState::nowunused, PruneState::nredirected, PruneState::nroot_items, PruneState::nunused, OffsetNumberNext, OffsetNumberPrev, VacuumCutoffs::OldestXmin, PageClearFull(), PruneState::pagefrz, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), PageIsFull(), pgWalUsage, PruneState::processed, PruneState::recently_dead_tuples, PruneFreezeResult::recently_dead_tuples, PruneState::redirected, RelationGetRelid, RelationNeedsWAL, PruneState::root_items, START_CRIT_SECTION, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TransactionIdFollows(), TransactionIdRetreat, unlikely, PruneState::visibility_cutoff_xid, PruneState::vistest, PruneFreezeResult::vm_conflict_horizon, WalUsage::wal_fpi, XLogCheckBufferNeedsBackup(), and XLogHintBitIsNeeded.

Referenced by heap_page_prune_opt(), and lazy_scan_prune().

◆ heap_page_prune_execute()

void heap_page_prune_execute ( Buffer  buffer,
bool  lp_truncate_only,
OffsetNumber *  redirected,
int  nredirected,
OffsetNumber *  nowdead,
int  ndead,
OffsetNumber *  nowunused,
int  nunused 
)

Definition at line 1561 of file pruneheap.c.

1565{
1566 Page page = BufferGetPage(buffer);
1567 OffsetNumber *offnum;
1569
1570 /* Shouldn't be called unless there's something to do */
1571 Assert(nredirected > 0 || ndead > 0 || nunused > 0);
1572
1573 /* If 'lp_truncate_only', we can only remove already-dead line pointers */
1574 Assert(!lp_truncate_only || (nredirected == 0 && ndead == 0));
1575
1576 /* Update all redirected line pointers */
1577 offnum = redirected;
1578 for (int i = 0; i < nredirected; i++)
1579 {
1580 OffsetNumber fromoff = *offnum++;
1581 OffsetNumber tooff = *offnum++;
1582 ItemId fromlp = PageGetItemId(page, fromoff);
1584
1585#ifdef USE_ASSERT_CHECKING
1586
1587 /*
1588 * Any existing item that we set as an LP_REDIRECT (any 'from' item)
1589 * must be the first item from a HOT chain. If the item has tuple
1590 * storage then it can't be a heap-only tuple. Otherwise we are just
1591 * maintaining an existing LP_REDIRECT from an existing HOT chain that
1592 * has been pruned at least once before now.
1593 */
1594 if (!ItemIdIsRedirected(fromlp))
1595 {
1596 Assert(ItemIdHasStorage(fromlp) && ItemIdIsNormal(fromlp));
1597
1598 htup = (HeapTupleHeader) PageGetItem(page, fromlp);
1600 }
1601 else
1602 {
1603 /* We shouldn't need to redundantly set the redirect */
1604 Assert(ItemIdGetRedirect(fromlp) != tooff);
1605 }
1606
1607 /*
1608 * The item that we're about to set as an LP_REDIRECT (the 'from'
1609 * item) will point to an existing item (the 'to' item) that is
1610 * already a heap-only tuple. There can be at most one LP_REDIRECT
1611 * item per HOT chain.
1612 *
1613 * We need to keep around an LP_REDIRECT item (after original
1614 * non-heap-only root tuple gets pruned away) so that it's always
1615 * possible for VACUUM to easily figure out what TID to delete from
1616 * indexes when an entire HOT chain becomes dead. A heap-only tuple
1617 * can never become LP_DEAD; an LP_REDIRECT item or a regular heap
1618 * tuple can.
1619 *
1620 * This check may miss problems, e.g. the target of a redirect could
1621 * be marked as unused subsequently. The page_verify_redirects() check
1622 * below will catch such problems.
1623 */
1624 tolp = PageGetItemId(page, tooff);
1625 Assert(ItemIdHasStorage(tolp) && ItemIdIsNormal(tolp));
1626 htup = (HeapTupleHeader) PageGetItem(page, tolp);
1628#endif
1629
1630 ItemIdSetRedirect(fromlp, tooff);
1631 }
1632
1633 /* Update all now-dead line pointers */
1634 offnum = nowdead;
1635 for (int i = 0; i < ndead; i++)
1636 {
1637 OffsetNumber off = *offnum++;
1638 ItemId lp = PageGetItemId(page, off);
1639
1640#ifdef USE_ASSERT_CHECKING
1641
1642 /*
1643 * An LP_DEAD line pointer must be left behind when the original item
1644 * (which is dead to everybody) could still be referenced by a TID in
1645 * an index. This should never be necessary with any individual
1646 * heap-only tuple item, though. (It's not clear how much of a problem
1647 * that would be, but there is no reason to allow it.)
1648 */
1649 if (ItemIdHasStorage(lp))
1650 {
1652 htup = (HeapTupleHeader) PageGetItem(page, lp);
1654 }
1655 else
1656 {
1657 /* Whole HOT chain becomes dead */
1659 }
1660#endif
1661
1662 ItemIdSetDead(lp);
1663 }
1664
1665 /* Update all now-unused line pointers */
1666 offnum = nowunused;
1667 for (int i = 0; i < nunused; i++)
1668 {
1669 OffsetNumber off = *offnum++;
1670 ItemId lp = PageGetItemId(page, off);
1671
1672#ifdef USE_ASSERT_CHECKING
1673
1674 if (lp_truncate_only)
1675 {
1676 /* Setting LP_DEAD to LP_UNUSED in vacuum's second pass */
1678 }
1679 else
1680 {
1681 /*
1682 * When heap_page_prune_and_freeze() was called, mark_unused_now
1683 * may have been passed as true, which allows would-be LP_DEAD
1684 * items to be made LP_UNUSED instead. This is only possible if
1685 * the relation has no indexes. If there are any dead items, then
1686 * mark_unused_now was not true and every item being marked
1687 * LP_UNUSED must refer to a heap-only tuple.
1688 */
1689 if (ndead > 0)
1690 {
1692 htup = (HeapTupleHeader) PageGetItem(page, lp);
1694 }
1695 else
1696 Assert(ItemIdIsUsed(lp));
1697 }
1698
1699#endif
1700
1701 ItemIdSetUnused(lp);
1702 }
1703
1704 if (lp_truncate_only)
1706 else
1707 {
1708 /*
1709 * Finally, repair any fragmentation, and update the page's hint bit
1710 * about whether it has free pointers.
1711 */
1713
1714 /*
1715 * Now that the page has been modified, assert that redirect items
1716 * still point to valid targets.
1717 */
1719 }
1720}
void PageRepairFragmentation(Page page)
Definition: bufpage.c:698
void PageTruncateLinePointerArray(Page page)
Definition: bufpage.c:834
#define PG_USED_FOR_ASSERTS_ONLY
Definition: c.h:223
#define ItemIdSetRedirect(itemId, link)
Definition: itemid.h:152
#define ItemIdSetDead(itemId)
Definition: itemid.h:164
#define ItemIdSetUnused(itemId)
Definition: itemid.h:128
#define ItemIdHasStorage(itemId)
Definition: itemid.h:120
static void page_verify_redirects(Page page)
Definition: pruneheap.c:1737

References Assert(), BufferGetPage(), HeapTupleHeaderIsHeapOnly(), i, ItemIdGetRedirect, ItemIdHasStorage, ItemIdIsDead, ItemIdIsNormal, ItemIdIsRedirected, ItemIdIsUsed, ItemIdSetDead, ItemIdSetRedirect, ItemIdSetUnused, page_verify_redirects(), PageGetItem(), PageGetItemId(), PageRepairFragmentation(), PageTruncateLinePointerArray(), and PG_USED_FOR_ASSERTS_ONLY.

Referenced by heap_page_prune_and_freeze(), and heap_xlog_prune_freeze().

◆ heap_page_prune_opt()

void heap_page_prune_opt ( Relation  relation,
Buffer  buffer 
)

Definition at line 193 of file pruneheap.c.

194{
195 Page page = BufferGetPage(buffer);
196 TransactionId prune_xid;
197 GlobalVisState *vistest;
198 Size minfree;
199
200 /*
201 * We can't write WAL in recovery mode, so there's no point trying to
202 * clean the page. The primary will likely issue a cleaning WAL record
203 * soon anyway, so this is no particular loss.
204 */
205 if (RecoveryInProgress())
206 return;
207
208 /*
209 * First check whether there's any chance there's something to prune,
210 * determining the appropriate horizon is a waste if there's no prune_xid
211 * (i.e. no updates/deletes left potentially dead tuples around).
212 */
213 prune_xid = ((PageHeader) page)->pd_prune_xid;
214 if (!TransactionIdIsValid(prune_xid))
215 return;
216
217 /*
218 * Check whether prune_xid indicates that there may be dead rows that can
219 * be cleaned up.
220 */
221 vistest = GlobalVisTestFor(relation);
222
223 if (!GlobalVisTestIsRemovableXid(vistest, prune_xid))
224 return;
225
226 /*
227 * We prune when a previous UPDATE failed to find enough space on the page
228 * for a new tuple version, or when free space falls below the relation's
229 * fill-factor target (but not less than 10%).
230 *
231 * Checking free space here is questionable since we aren't holding any
232 * lock on the buffer; in the worst case we could get a bogus answer. It's
233 * unlikely to be *seriously* wrong, though, since reading either pd_lower
234 * or pd_upper is probably atomic. Avoiding taking a lock seems more
235 * important than sometimes getting a wrong answer in what is after all
236 * just a heuristic estimate.
237 */
238 minfree = RelationGetTargetPageFreeSpace(relation,
240 minfree = Max(minfree, BLCKSZ / 10);
241
242 if (PageIsFull(page) || PageGetHeapFreeSpace(page) < minfree)
243 {
244 /* OK, try to get exclusive buffer lock */
246 return;
247
248 /*
249 * Now that we have buffer lock, get accurate information about the
250 * page's free space, and recheck the heuristic about whether to
251 * prune.
252 */
253 if (PageIsFull(page) || PageGetHeapFreeSpace(page) < minfree)
254 {
255 OffsetNumber dummy_off_loc;
256 PruneFreezeResult presult;
257
258 /*
259 * For now, pass mark_unused_now as false regardless of whether or
260 * not the relation has indexes, since we cannot safely determine
261 * that during on-access pruning with the current implementation.
262 */
263 heap_page_prune_and_freeze(relation, buffer, vistest, 0,
264 NULL, &presult, PRUNE_ON_ACCESS, &dummy_off_loc, NULL, NULL);
265
266 /*
267 * Report the number of tuples reclaimed to pgstats. This is
268 * presult.ndeleted minus the number of newly-LP_DEAD-set items.
269 *
270 * We derive the number of dead tuples like this to avoid totally
271 * forgetting about items that were set to LP_DEAD, since they
272 * still need to be cleaned up by VACUUM. We only want to count
273 * heap-only tuples that just became LP_UNUSED in our report,
274 * which don't.
275 *
276 * VACUUM doesn't have to compensate in the same way when it
277 * tracks ndeleted, since it will set the same LP_DEAD items to
278 * LP_UNUSED separately.
279 */
280 if (presult.ndeleted > presult.nnewlpdead)
282 presult.ndeleted - presult.nnewlpdead);
283 }
284
285 /* And release buffer lock */
287
288 /*
289 * We avoid reuse of any free space created on the page by unrelated
290 * UPDATEs/INSERTs by opting to not update the FSM at this point. The
291 * free space should be reused by UPDATEs to *this* page.
292 */
293 }
294}
void LockBuffer(Buffer buffer, int mode)
Definition: bufmgr.c:5572
bool ConditionalLockBufferForCleanup(Buffer buffer)
Definition: bufmgr.c:5820
#define BUFFER_LOCK_UNLOCK
Definition: bufmgr.h:196
Size PageGetHeapFreeSpace(const PageData *page)
Definition: bufpage.c:990
#define Max(x, y)
Definition: c.h:997
size_t Size
Definition: c.h:610
@ PRUNE_ON_ACCESS
Definition: heapam.h:270
void pgstat_update_heap_dead_tuples(Relation rel, int delta)
bool GlobalVisTestIsRemovableXid(GlobalVisState *state, TransactionId xid)
Definition: procarray.c:4226
GlobalVisState * GlobalVisTestFor(Relation rel)
Definition: procarray.c:4069
void heap_page_prune_and_freeze(Relation relation, Buffer buffer, GlobalVisState *vistest, int options, struct VacuumCutoffs *cutoffs, PruneFreezeResult *presult, PruneReason reason, OffsetNumber *off_loc, TransactionId *new_relfrozen_xid, MultiXactId *new_relmin_mxid)
Definition: pruneheap.c:350
#define RelationGetTargetPageFreeSpace(relation, defaultff)
Definition: rel.h:389
#define HEAP_DEFAULT_FILLFACTOR
Definition: rel.h:360
bool RecoveryInProgress(void)
Definition: xlog.c:6386

References BUFFER_LOCK_UNLOCK, BufferGetPage(), ConditionalLockBufferForCleanup(), GlobalVisTestFor(), GlobalVisTestIsRemovableXid(), HEAP_DEFAULT_FILLFACTOR, heap_page_prune_and_freeze(), LockBuffer(), Max, PruneFreezeResult::ndeleted, PruneFreezeResult::nnewlpdead, PageGetHeapFreeSpace(), PageIsFull(), pgstat_update_heap_dead_tuples(), PRUNE_ON_ACCESS, RecoveryInProgress(), RelationGetTargetPageFreeSpace, and TransactionIdIsValid.

Referenced by BitmapHeapScanNextBlock(), heap_prepare_pagescan(), and heapam_index_fetch_tuple().

◆ heap_prune_chain()

static void heap_prune_chain ( Page  page,
BlockNumber  blockno,
OffsetNumber  maxoff,
OffsetNumber  rootoffnum,
PruneState *  prstate 
)
static

Definition at line 999 of file pruneheap.c.

1001{
1003 ItemId rootlp;
1004 OffsetNumber offnum;
1006
1007 /*
1008 * After traversing the HOT chain, ndeadchain is the index in chainitems
1009 * of the first live successor after the last dead item.
1010 */
1011 int ndeadchain = 0,
1012 nchain = 0;
1013
1014 rootlp = PageGetItemId(page, rootoffnum);
1015
1016 /* Start from the root tuple */
1017 offnum = rootoffnum;
1018
1019 /* while not end of the chain */
1020 for (;;)
1021 {
1022 HeapTupleHeader htup;
1023 ItemId lp;
1024
1025 /* Sanity check (pure paranoia) */
1026 if (offnum < FirstOffsetNumber)
1027 break;
1028
1029 /*
1030 * An offset past the end of page's line pointer array is possible
1031 * when the array was truncated (original item must have been unused)
1032 */
1033 if (offnum > maxoff)
1034 break;
1035
1036 /* If item is already processed, stop --- it must not be same chain */
1037 if (prstate->processed[offnum])
1038 break;
1039
1040 lp = PageGetItemId(page, offnum);
1041
1042 /*
1043 * Unused item obviously isn't part of the chain. Likewise, a dead
1044 * line pointer can't be part of the chain. Both of those cases were
1045 * already marked as processed.
1046 */
1047 Assert(ItemIdIsUsed(lp));
1048 Assert(!ItemIdIsDead(lp));
1049
1050 /*
1051 * If we are looking at the redirected root line pointer, jump to the
1052 * first normal tuple in the chain. If we find a redirect somewhere
1053 * else, stop --- it must not be same chain.
1054 */
1055 if (ItemIdIsRedirected(lp))
1056 {
1057 if (nchain > 0)
1058 break; /* not at start of chain */
1059 chainitems[nchain++] = offnum;
1060 offnum = ItemIdGetRedirect(rootlp);
1061 continue;
1062 }
1063
1065
1066 htup = (HeapTupleHeader) PageGetItem(page, lp);
1067
1068 /*
1069 * Check the tuple XMIN against prior XMAX, if any
1070 */
1071 if (TransactionIdIsValid(priorXmax) &&
1073 break;
1074
1075 /*
1076 * OK, this tuple is indeed a member of the chain.
1077 */
1078 chainitems[nchain++] = offnum;
1079
1080 switch (htsv_get_valid_status(prstate->htsv[offnum]))
1081 {
1082 case HEAPTUPLE_DEAD:
1083
1084 /* Remember the last DEAD tuple seen */
1085 ndeadchain = nchain;
1087 &prstate->latest_xid_removed);
1088 /* Advance to next chain member */
1089 break;
1090
1092
1093 /*
1094 * We don't need to advance the conflict horizon for
1095 * RECENTLY_DEAD tuples, even if we are removing them. This
1096 * is because we only remove RECENTLY_DEAD tuples if they
1097 * precede a DEAD tuple, and the DEAD tuple must have been
1098 * inserted by a newer transaction than the RECENTLY_DEAD
1099 * tuple by virtue of being later in the chain. We will have
1100 * advanced the conflict horizon for the DEAD tuple.
1101 */
1102
1103 /*
1104 * Advance past RECENTLY_DEAD tuples just in case there's a
1105 * DEAD one after them. We have to make sure that we don't
1106 * miss any DEAD tuples, since DEAD tuples that still have
1107 * tuple storage after pruning will confuse VACUUM.
1108 */
1109 break;
1110
1112 case HEAPTUPLE_LIVE:
1114 goto process_chain;
1115
1116 default:
1117 elog(ERROR, "unexpected HeapTupleSatisfiesVacuum result");
1118 goto process_chain;
1119 }
1120
1121 /*
1122 * If the tuple is not HOT-updated, then we are at the end of this
1123 * HOT-update chain.
1124 */
1125 if (!HeapTupleHeaderIsHotUpdated(htup))
1126 goto process_chain;
1127
1128 /* HOT implies it can't have moved to different partition */
1130
1131 /*
1132 * Advance to next chain member.
1133 */
1134 Assert(ItemPointerGetBlockNumber(&htup->t_ctid) == blockno);
1135 offnum = ItemPointerGetOffsetNumber(&htup->t_ctid);
1136 priorXmax = HeapTupleHeaderGetUpdateXid(htup);
1137 }
1138
1139 if (ItemIdIsRedirected(rootlp) && nchain < 2)
1140 {
1141 /*
1142 * We found a redirect item that doesn't point to a valid follow-on
1143 * item. This can happen if the loop in heap_page_prune_and_freeze()
1144 * caused us to visit the dead successor of a redirect item before
1145 * visiting the redirect item. We can clean up by setting the
1146 * redirect item to LP_DEAD state or LP_UNUSED if the caller
1147 * indicated.
1148 */
1149 heap_prune_record_dead_or_unused(prstate, rootoffnum, false);
1150 return;
1151 }
1152
1153process_chain:
1154
1155 if (ndeadchain == 0)
1156 {
1157 /*
1158 * No DEAD tuple was found, so the chain is entirely composed of
1159 * normal, unchanged tuples. Leave it alone.
1160 */
1161 int i = 0;
1162
1163 if (ItemIdIsRedirected(rootlp))
1164 {
1165 heap_prune_record_unchanged_lp_redirect(prstate, rootoffnum);
1166 i++;
1167 }
1168 for (; i < nchain; i++)
1169 heap_prune_record_unchanged_lp_normal(page, prstate, chainitems[i]);
1170 }
1171 else if (ndeadchain == nchain)
1172 {
1173 /*
1174 * The entire chain is dead. Mark the root line pointer LP_DEAD, and
1175 * fully remove the other tuples in the chain.
1176 */
1177 heap_prune_record_dead_or_unused(prstate, rootoffnum, ItemIdIsNormal(rootlp));
1178 for (int i = 1; i < nchain; i++)
1179 heap_prune_record_unused(prstate, chainitems[i], true);
1180 }
1181 else
1182 {
1183 /*
1184 * We found a DEAD tuple in the chain. Redirect the root line pointer
1185 * to the first non-DEAD tuple, and mark as unused each intermediate
1186 * item that we are able to remove from the chain.
1187 */
1188 heap_prune_record_redirect(prstate, rootoffnum, chainitems[ndeadchain],
1189 ItemIdIsNormal(rootlp));
1190 for (int i = 1; i < ndeadchain; i++)
1191 heap_prune_record_unused(prstate, chainitems[i], true);
1192
1193 /* the rest of tuples in the chain are normal, unchanged tuples */
1194 for (int i = ndeadchain; i < nchain; i++)
1195 heap_prune_record_unchanged_lp_normal(page, prstate, chainitems[i]);
1196 }
1197}
@ HEAPTUPLE_RECENTLY_DEAD
Definition: heapam.h:128
@ HEAPTUPLE_INSERT_IN_PROGRESS
Definition: heapam.h:129
@ HEAPTUPLE_LIVE
Definition: heapam.h:127
@ HEAPTUPLE_DELETE_IN_PROGRESS
Definition: heapam.h:130
static BlockNumber ItemPointerGetBlockNumber(const ItemPointerData *pointer)
Definition: itemptr.h:103
static HTSV_Result htsv_get_valid_status(int status)
Definition: pruneheap.c:960
static void heap_prune_record_redirect(PruneState *prstate, OffsetNumber offnum, OffsetNumber rdoffnum, bool was_normal)
Definition: pruneheap.c:1215
static void heap_prune_record_dead_or_unused(PruneState *prstate, OffsetNumber offnum, bool was_normal)
Definition: pruneheap.c:1280
static void heap_prune_record_unchanged_lp_redirect(PruneState *prstate, OffsetNumber offnum)
Definition: pruneheap.c:1536

References Assert(), elog, ERROR, FirstOffsetNumber, heap_prune_record_dead_or_unused(), heap_prune_record_redirect(), heap_prune_record_unchanged_lp_normal(), heap_prune_record_unchanged_lp_redirect(), heap_prune_record_unused(), HEAPTUPLE_DEAD, HEAPTUPLE_DELETE_IN_PROGRESS, HEAPTUPLE_INSERT_IN_PROGRESS, HEAPTUPLE_LIVE, HEAPTUPLE_RECENTLY_DEAD, HeapTupleHeaderAdvanceConflictHorizon(), HeapTupleHeaderGetUpdateXid(), HeapTupleHeaderGetXmin(), HeapTupleHeaderIndicatesMovedPartitions(), HeapTupleHeaderIsHotUpdated(), PruneState::htsv, htsv_get_valid_status(), i, InvalidTransactionId, ItemIdGetRedirect, ItemIdIsDead, ItemIdIsNormal, ItemIdIsRedirected, ItemIdIsUsed, ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), PruneState::latest_xid_removed, MaxHeapTuplesPerPage, PageGetItem(), PageGetItemId(), PruneState::processed, HeapTupleHeaderData::t_ctid, TransactionIdEquals, and TransactionIdIsValid.

Referenced by heap_page_prune_and_freeze().

◆ heap_prune_record_dead()

static void heap_prune_record_dead ( PruneState *  prstate,
OffsetNumber  offnum,
bool  was_normal 
)
static

Definition at line 1246 of file pruneheap.c.

1248{
1249 Assert(!prstate->processed[offnum]);
1250 prstate->processed[offnum] = true;
1251
1252 Assert(prstate->ndead < MaxHeapTuplesPerPage);
1253 prstate->nowdead[prstate->ndead] = offnum;
1254 prstate->ndead++;
1255
1256 /*
1257 * Deliberately delay unsetting all_visible until later during pruning.
1258 * Removable dead tuples shouldn't preclude freezing the page.
1259 */
1260
1261 /* Record the dead offset for vacuum */
1262 prstate->deadoffsets[prstate->lpdead_items++] = offnum;
1263
1264 /*
1265 * If the root entry had been a normal tuple, we are deleting it, so count
1266 * it in the result. But changing a redirect (even to DEAD state) doesn't
1267 * count.
1268 */
1269 if (was_normal)
1270 prstate->ndeleted++;
1271}

References Assert(), PruneState::deadoffsets, PruneState::lpdead_items, MaxHeapTuplesPerPage, PruneState::ndead, PruneState::ndeleted, PruneState::nowdead, and PruneState::processed.

Referenced by heap_prune_record_dead_or_unused().

◆ heap_prune_record_dead_or_unused()

static void heap_prune_record_dead_or_unused ( PruneState *  prstate,
OffsetNumber  offnum,
bool  was_normal 
)
static

Definition at line 1280 of file pruneheap.c.

1282{
1283 /*
1284 * If the caller set mark_unused_now to true, we can remove dead tuples
1285 * during pruning instead of marking their line pointers dead. Set this
1286 * tuple's line pointer LP_UNUSED. We hint that this option is less
1287 * likely.
1288 */
1289 if (unlikely(prstate->mark_unused_now))
1290 heap_prune_record_unused(prstate, offnum, was_normal);
1291 else
1292 heap_prune_record_dead(prstate, offnum, was_normal);
1293}
static void heap_prune_record_dead(PruneState *prstate, OffsetNumber offnum, bool was_normal)
Definition: pruneheap.c:1246

References heap_prune_record_dead(), heap_prune_record_unused(), PruneState::mark_unused_now, and unlikely.

Referenced by heap_prune_chain().

◆ heap_prune_record_prunable()

static void heap_prune_record_prunable ( PruneState *  prstate,
TransactionId  xid 
)
static

Definition at line 1201 of file pruneheap.c.

1202{
1203 /*
1204 * This should exactly match the PageSetPrunable macro. We can't store
1205 * directly into the page header yet, so we update working state.
1206 */
1208 if (!TransactionIdIsValid(prstate->new_prune_xid) ||
1209 TransactionIdPrecedes(xid, prstate->new_prune_xid))
1210 prstate->new_prune_xid = xid;
1211}
bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
Definition: transam.c:280
#define TransactionIdIsNormal(xid)
Definition: transam.h:42

References Assert(), PruneState::new_prune_xid, TransactionIdIsNormal, TransactionIdIsValid, and TransactionIdPrecedes().

Referenced by heap_prune_record_unchanged_lp_normal().

◆ heap_prune_record_redirect()

static void heap_prune_record_redirect ( PruneState *  prstate,
OffsetNumber  offnum,
OffsetNumber  rdoffnum,
bool  was_normal 
)
static

Definition at line 1215 of file pruneheap.c.

1218{
1219 Assert(!prstate->processed[offnum]);
1220 prstate->processed[offnum] = true;
1221
1222 /*
1223 * Do not mark the redirect target here. It needs to be counted
1224 * separately as an unchanged tuple.
1225 */
1226
1228 prstate->redirected[prstate->nredirected * 2] = offnum;
1229 prstate->redirected[prstate->nredirected * 2 + 1] = rdoffnum;
1230
1231 prstate->nredirected++;
1232
1233 /*
1234 * If the root entry had been a normal tuple, we are deleting it, so count
1235 * it in the result. But changing a redirect (even to DEAD state) doesn't
1236 * count.
1237 */
1238 if (was_normal)
1239 prstate->ndeleted++;
1240
1241 prstate->hastup = true;
1242}

References Assert(), PruneState::hastup, MaxHeapTuplesPerPage, PruneState::ndeleted, PruneState::nredirected, PruneState::processed, and PruneState::redirected.

Referenced by heap_prune_chain().

◆ heap_prune_record_unchanged_lp_dead()

static void heap_prune_record_unchanged_lp_dead ( Page  page,
PruneState *  prstate,
OffsetNumber  offnum 
)
static

Definition at line 1508 of file pruneheap.c.

1509{
1510 Assert(!prstate->processed[offnum]);
1511 prstate->processed[offnum] = true;
1512
1513 /*
1514 * Deliberately don't set hastup for LP_DEAD items. We make the soft
1515 * assumption that any LP_DEAD items encountered here will become
1516 * LP_UNUSED later on, before count_nondeletable_pages is reached. If we
1517 * don't make this assumption then rel truncation will only happen every
1518 * other VACUUM, at most. Besides, VACUUM must treat
1519 * hastup/nonempty_pages as provisional no matter how LP_DEAD items are
1520 * handled (handled here, or handled later on).
1521 *
1522 * Similarly, don't unset all_visible until later, at the end of
1523 * heap_page_prune_and_freeze(). This will allow us to attempt to freeze
1524 * the page after pruning. As long as we unset it before updating the
1525 * visibility map, this will be correct.
1526 */
1527
1528 /* Record the dead offset for vacuum */
1529 prstate->deadoffsets[prstate->lpdead_items++] = offnum;
1530}

References Assert(), PruneState::deadoffsets, PruneState::lpdead_items, and PruneState::processed.

Referenced by heap_page_prune_and_freeze().

◆ heap_prune_record_unchanged_lp_normal()

static void heap_prune_record_unchanged_lp_normal ( Page  page,
PruneState *  prstate,
OffsetNumber  offnum 
)
static

Definition at line 1330 of file pruneheap.c.

1331{
1332 HeapTupleHeader htup;
1333
1334 Assert(!prstate->processed[offnum]);
1335 prstate->processed[offnum] = true;
1336
1337 prstate->hastup = true; /* the page is not empty */
1338
1339 /*
1340 * The criteria for counting a tuple as live in this block need to match
1341 * what analyze.c's acquire_sample_rows() does, otherwise VACUUM and
1342 * ANALYZE may produce wildly different reltuples values, e.g. when there
1343 * are many recently-dead tuples.
1344 *
1345 * The logic here is a bit simpler than acquire_sample_rows(), as VACUUM
1346 * can't run inside a transaction block, which makes some cases impossible
1347 * (e.g. in-progress insert from the same transaction).
1348 *
1349 * HEAPTUPLE_DEAD are handled by the other heap_prune_record_*()
1350 * subroutines. They don't count dead items like acquire_sample_rows()
1351 * does, because we assume that all dead items will become LP_UNUSED
1352 * before VACUUM finishes. This difference is only superficial. VACUUM
1353 * effectively agrees with ANALYZE about DEAD items, in the end. VACUUM
1354 * won't remember LP_DEAD items, but only because they're not supposed to
1355 * be left behind when it is done. (Cases where we bypass index vacuuming
1356 * will violate this optimistic assumption, but the overall impact of that
1357 * should be negligible.)
1358 */
1359 htup = (HeapTupleHeader) PageGetItem(page, PageGetItemId(page, offnum));
1360
1361 switch (prstate->htsv[offnum])
1362 {
1363 case HEAPTUPLE_LIVE:
1364
1365 /*
1366 * Count it as live. Not only is this natural, but it's also what
1367 * acquire_sample_rows() does.
1368 */
1369 prstate->live_tuples++;
1370
1371 /*
1372 * Is the tuple definitely visible to all transactions?
1373 *
1374 * NB: Like with per-tuple hint bits, we can't set the
1375 * PD_ALL_VISIBLE flag if the inserter committed asynchronously.
1376 * See SetHintBits for more info. Check that the tuple is hinted
1377 * xmin-committed because of that.
1378 */
1379 if (prstate->all_visible)
1380 {
1381 TransactionId xmin;
1382
1384 {
1385 prstate->all_visible = false;
1386 break;
1387 }
1388
1389 /*
1390 * The inserter definitely committed. But is it old enough
1391 * that everyone sees it as committed? A FrozenTransactionId
1392 * is seen as committed to everyone. Otherwise, we check if
1393 * there is a snapshot that considers this xid to still be
1394 * running, and if so, we don't consider the page all-visible.
1395 */
1396 xmin = HeapTupleHeaderGetXmin(htup);
1397
1398 /*
1399 * For now always use prstate->cutoffs for this test, because
1400 * we only update 'all_visible' when freezing is requested. We
1401 * could use GlobalVisTestIsRemovableXid instead, if a
1402 * non-freezing caller wanted to set the VM bit.
1403 */
1404 Assert(prstate->cutoffs);
1405 if (!TransactionIdPrecedes(xmin, prstate->cutoffs->OldestXmin))
1406 {
1407 prstate->all_visible = false;
1408 break;
1409 }
1410
1411 /* Track newest xmin on page. */
1412 if (TransactionIdFollows(xmin, prstate->visibility_cutoff_xid) &&
1414 prstate->visibility_cutoff_xid = xmin;
1415 }
1416 break;
1417
1419 prstate->recently_dead_tuples++;
1420 prstate->all_visible = false;
1421
1422 /*
1423 * This tuple will soon become DEAD. Update the hint field so
1424 * that the page is reconsidered for pruning in future.
1425 */
1428 break;
1429
1431
1432 /*
1433 * We do not count these rows as live, because we expect the
1434 * inserting transaction to update the counters at commit, and we
1435 * assume that will happen only after we report our results. This
1436 * assumption is a bit shaky, but it is what acquire_sample_rows()
1437 * does, so be consistent.
1438 */
1439 prstate->all_visible = false;
1440
1441 /*
1442 * If we wanted to optimize for aborts, we might consider marking
1443 * the page prunable when we see INSERT_IN_PROGRESS. But we
1444 * don't. See related decisions about when to mark the page
1445 * prunable in heapam.c.
1446 */
1447 break;
1448
1450
1451 /*
1452 * This an expected case during concurrent vacuum. Count such
1453 * rows as live. As above, we assume the deleting transaction
1454 * will commit and update the counters after we report.
1455 */
1456 prstate->live_tuples++;
1457 prstate->all_visible = false;
1458
1459 /*
1460 * This tuple may soon become DEAD. Update the hint field so that
1461 * the page is reconsidered for pruning in future.
1462 */
1465 break;
1466
1467 default:
1468
1469 /*
1470 * DEAD tuples should've been passed to heap_prune_record_dead()
1471 * or heap_prune_record_unused() instead.
1472 */
1473 elog(ERROR, "unexpected HeapTupleSatisfiesVacuum result %d",
1474 prstate->htsv[offnum]);
1475 break;
1476 }
1477
1478 /* Consider freezing any normal tuples which will not be removed */
1479 if (prstate->freeze)
1480 {
1481 bool totally_frozen;
1482
1483 if ((heap_prepare_freeze_tuple(htup,
1484 prstate->cutoffs,
1485 &prstate->pagefrz,
1486 &prstate->frozen[prstate->nfrozen],
1487 &totally_frozen)))
1488 {
1489 /* Save prepared freeze plan for later */
1490 prstate->frozen[prstate->nfrozen++].offset = offnum;
1491 }
1492
1493 /*
1494 * If any tuple isn't either totally frozen already or eligible to
1495 * become totally frozen (according to its freeze plan), then the page
1496 * definitely cannot be set all-frozen in the visibility map later on.
1497 */
1498 if (!totally_frozen)
1499 prstate->all_frozen = false;
1500 }
1501}
bool heap_prepare_freeze_tuple(HeapTupleHeader tuple, const struct VacuumCutoffs *cutoffs, HeapPageFreeze *pagefrz, HeapTupleFreeze *frz, bool *totally_frozen)
Definition: heapam.c:7054
static bool HeapTupleHeaderXminCommitted(const HeapTupleHeaderData *tup)
Definition: htup_details.h:337
static void heap_prune_record_prunable(PruneState *prstate, TransactionId xid)
Definition: pruneheap.c:1201

References PruneState::all_frozen, PruneState::all_visible, Assert(), PruneState::cutoffs, elog, ERROR, PruneState::freeze, PruneState::frozen, PruneState::hastup, heap_prepare_freeze_tuple(), heap_prune_record_prunable(), HEAPTUPLE_DELETE_IN_PROGRESS, HEAPTUPLE_INSERT_IN_PROGRESS, HEAPTUPLE_LIVE, HEAPTUPLE_RECENTLY_DEAD, HeapTupleHeaderGetUpdateXid(), HeapTupleHeaderGetXmin(), HeapTupleHeaderXminCommitted(), PruneState::htsv, PruneState::live_tuples, PruneState::nfrozen, HeapTupleFreeze::offset, VacuumCutoffs::OldestXmin, PruneState::pagefrz, PageGetItem(), PageGetItemId(), PruneState::processed, PruneState::recently_dead_tuples, TransactionIdFollows(), TransactionIdIsNormal, TransactionIdPrecedes(), and PruneState::visibility_cutoff_xid.

Referenced by heap_page_prune_and_freeze(), and heap_prune_chain().

◆ heap_prune_record_unchanged_lp_redirect()

static void heap_prune_record_unchanged_lp_redirect ( PruneState *  prstate,
OffsetNumber  offnum 
)
static

Definition at line 1536 of file pruneheap.c.

1537{
1538 /*
1539 * A redirect line pointer doesn't count as a live tuple.
1540 *
1541 * If we leave a redirect line pointer in place, there will be another
1542 * tuple on the page that it points to. We will do the bookkeeping for
1543 * that separately. So we have nothing to do here, except remember that
1544 * we processed this item.
1545 */
1546 Assert(!prstate->processed[offnum]);
1547 prstate->processed[offnum] = true;
1548}

References Assert(), and PruneState::processed.

Referenced by heap_prune_chain().

◆ heap_prune_record_unchanged_lp_unused()

static void heap_prune_record_unchanged_lp_unused ( Page  page,
PruneState *  prstate,
OffsetNumber  offnum 
)
static

Definition at line 1319 of file pruneheap.c.

1320{
1321 Assert(!prstate->processed[offnum]);
1322 prstate->processed[offnum] = true;
1323}

References Assert(), and PruneState::processed.

Referenced by heap_page_prune_and_freeze().

◆ heap_prune_record_unused()

static void heap_prune_record_unused ( PruneState *  prstate,
OffsetNumber  offnum,
bool  was_normal 
)
static

Definition at line 1297 of file pruneheap.c.

1298{
1299 Assert(!prstate->processed[offnum]);
1300 prstate->processed[offnum] = true;
1301
1303 prstate->nowunused[prstate->nunused] = offnum;
1304 prstate->nunused++;
1305
1306 /*
1307 * If the root entry had been a normal tuple, we are deleting it, so count
1308 * it in the result. But changing a redirect (even to DEAD state) doesn't
1309 * count.
1310 */
1311 if (was_normal)
1312 prstate->ndeleted++;
1313}

References Assert(), MaxHeapTuplesPerPage, PruneState::ndeleted, PruneState::nowunused, PruneState::nunused, and PruneState::processed.

Referenced by heap_page_prune_and_freeze(), heap_prune_chain(), and heap_prune_record_dead_or_unused().

◆ heap_prune_satisfies_vacuum()

static HTSV_Result heap_prune_satisfies_vacuum ( PruneState *  prstate,
HeapTuple  tup,
Buffer  buffer 
)
static

Definition at line 917 of file pruneheap.c.

918{
919 HTSV_Result res;
920 TransactionId dead_after;
921
922 res = HeapTupleSatisfiesVacuumHorizon(tup, buffer, &dead_after);
923
924 if (res != HEAPTUPLE_RECENTLY_DEAD)
925 return res;
926
927 /*
928 * For VACUUM, we must be sure to prune tuples with xmax older than
929 * OldestXmin -- a visibility cutoff determined at the beginning of
930 * vacuuming the relation. OldestXmin is used for freezing determination
931 * and we cannot freeze dead tuples' xmaxes.
932 */
933 if (prstate->cutoffs &&
935 NormalTransactionIdPrecedes(dead_after, prstate->cutoffs->OldestXmin))
936 return HEAPTUPLE_DEAD;
937
938 /*
939 * Determine whether or not the tuple is considered dead when compared
940 * with the provided GlobalVisState. On-access pruning does not provide
941 * VacuumCutoffs. And for vacuum, even if the tuple's xmax is not older
942 * than OldestXmin, GlobalVisTestIsRemovableXid() could find the row dead
943 * if the GlobalVisState has been updated since the beginning of vacuuming
944 * the relation.
945 */
946 if (GlobalVisTestIsRemovableXid(prstate->vistest, dead_after))
947 return HEAPTUPLE_DEAD;
948
949 return res;
950}
HTSV_Result
Definition: heapam.h:125
HTSV_Result HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer, TransactionId *dead_after)
#define NormalTransactionIdPrecedes(id1, id2)
Definition: transam.h:147

References PruneState::cutoffs, GlobalVisTestIsRemovableXid(), HEAPTUPLE_DEAD, HEAPTUPLE_RECENTLY_DEAD, HeapTupleSatisfiesVacuumHorizon(), NormalTransactionIdPrecedes, VacuumCutoffs::OldestXmin, TransactionIdIsValid, and PruneState::vistest.

Referenced by heap_page_prune_and_freeze().

◆ htsv_get_valid_status()

static HTSV_Result htsv_get_valid_status ( int  status )
inlinestatic

Definition at line 960 of file pruneheap.c.

961{
962 Assert(status >= HEAPTUPLE_DEAD &&
964 return (HTSV_Result) status;
965}

References Assert(), HEAPTUPLE_DEAD, and HEAPTUPLE_DELETE_IN_PROGRESS.

Referenced by heap_prune_chain().

◆ log_heap_prune_and_freeze()

void log_heap_prune_and_freeze ( Relation  relation,
Buffer  buffer,
TransactionId  conflict_xid,
bool  cleanup_lock,
PruneReason  reason,
HeapTupleFreeze *  frozen,
int  nfrozen,
OffsetNumber *  redirected,
int  nredirected,
OffsetNumber *  dead,
int  ndead,
OffsetNumber *  unused,
int  nunused 
)

Definition at line 2053 of file pruneheap.c.

2061{
2062 xl_heap_prune xlrec;
2063 XLogRecPtr recptr;
2064 uint8 info;
2065
2066 /* The following local variables hold data registered in the WAL record: */
2068 xlhp_freeze_plans freeze_plans;
2069 xlhp_prune_items redirect_items;
2070 xlhp_prune_items dead_items;
2071 xlhp_prune_items unused_items;
2073
2074 xlrec.flags = 0;
2075
2076 /*
2077 * Prepare data for the buffer. The arrays are not actually in the
2078 * buffer, but we pretend that they are. When XLogInsert stores a full
2079 * page image, the arrays can be omitted.
2080 */
2083 if (nfrozen > 0)
2084 {
2085 int nplans;
2086
2088
2089 /*
2090 * Prepare deduplicated representation for use in the WAL record. This
2091 * destructively sorts frozen tuples array in-place.
2092 */
2093 nplans = heap_log_freeze_plan(frozen, nfrozen, plans, frz_offsets);
2094
2095 freeze_plans.nplans = nplans;
2096 XLogRegisterBufData(0, &freeze_plans,
2097 offsetof(xlhp_freeze_plans, plans));
2098 XLogRegisterBufData(0, plans,
2099 sizeof(xlhp_freeze_plan) * nplans);
2100 }
2101 if (nredirected > 0)
2102 {
2104
2105 redirect_items.ntargets = nredirected;
2106 XLogRegisterBufData(0, &redirect_items,
2107 offsetof(xlhp_prune_items, data));
2108 XLogRegisterBufData(0, redirected,
2109 sizeof(OffsetNumber[2]) * nredirected);
2110 }
2111 if (ndead > 0)
2112 {
2113 xlrec.flags |= XLHP_HAS_DEAD_ITEMS;
2114
2115 dead_items.ntargets = ndead;
2116 XLogRegisterBufData(0, &dead_items,
2117 offsetof(xlhp_prune_items, data));
2118 XLogRegisterBufData(0, dead,
2119 sizeof(OffsetNumber) * ndead);
2120 }
2121 if (nunused > 0)
2122 {
2124
2125 unused_items.ntargets = nunused;
2126 XLogRegisterBufData(0, &unused_items,
2127 offsetof(xlhp_prune_items, data));
2128 XLogRegisterBufData(0, unused,
2129 sizeof(OffsetNumber) * nunused);
2130 }
2131 if (nfrozen > 0)
2132 XLogRegisterBufData(0, frz_offsets,
2133 sizeof(OffsetNumber) * nfrozen);
2134
2135 /*
2136 * Prepare the main xl_heap_prune record. We already set the XLHP_HAS_*
2137 * flag above.
2138 */
2140 xlrec.flags |= XLHP_IS_CATALOG_REL;
2141 if (TransactionIdIsValid(conflict_xid))
2143 if (cleanup_lock)
2144 xlrec.flags |= XLHP_CLEANUP_LOCK;
2145 else
2146 {
2147 Assert(nredirected == 0 && ndead == 0);
2148 /* also, any items in 'unused' must've been LP_DEAD previously */
2149 }
2151 if (TransactionIdIsValid(conflict_xid))
2152 XLogRegisterData(&conflict_xid, sizeof(TransactionId));
2153
2154 switch (reason)
2155 {
2156 case PRUNE_ON_ACCESS:
2158 break;
2159 case PRUNE_VACUUM_SCAN:
2161 break;
2164 break;
2165 default:
2166 elog(ERROR, "unrecognized prune reason: %d", (int) reason);
2167 break;
2168 }
2169 recptr = XLogInsert(RM_HEAP2_ID, info);
2170
2171 PageSetLSN(BufferGetPage(buffer), recptr);
2172}
static void PageSetLSN(Page page, XLogRecPtr lsn)
Definition: bufpage.h:391
uint8_t uint8
Definition: c.h:536
@ PRUNE_VACUUM_CLEANUP
Definition: heapam.h:272
@ PRUNE_VACUUM_SCAN
Definition: heapam.h:271
#define XLHP_HAS_CONFLICT_HORIZON
Definition: heapam_xlog.h:316
#define XLHP_HAS_FREEZE_PLANS
Definition: heapam_xlog.h:322
#define SizeOfHeapPrune
Definition: heapam_xlog.h:295
#define XLHP_HAS_NOW_UNUSED_ITEMS
Definition: heapam_xlog.h:331
#define XLHP_HAS_REDIRECTIONS
Definition: heapam_xlog.h:329
#define XLOG_HEAP2_PRUNE_VACUUM_SCAN
Definition: heapam_xlog.h:61
#define XLOG_HEAP2_PRUNE_ON_ACCESS
Definition: heapam_xlog.h:60
#define XLHP_CLEANUP_LOCK
Definition: heapam_xlog.h:308
#define XLHP_HAS_DEAD_ITEMS
Definition: heapam_xlog.h:330
#define XLOG_HEAP2_PRUNE_VACUUM_CLEANUP
Definition: heapam_xlog.h:62
#define XLHP_IS_CATALOG_REL
Definition: heapam_xlog.h:298
const void * data
static int heap_log_freeze_plan(HeapTupleFreeze *tuples, int ntuples, xlhp_freeze_plan *plans_out, OffsetNumber *offsets_out)
Definition: pruneheap.c:1978
#define RelationIsAccessibleInLogicalDecoding(relation)
Definition: rel.h:693
Definition: heapam_xlog.h:286
uint8 flags
Definition: heapam_xlog.h:287
Definition: heapam_xlog.h:342
Definition: heapam_xlog.h:365
uint16 nplans
Definition: heapam_xlog.h:366
Definition: heapam_xlog.h:378
uint16 ntargets
Definition: heapam_xlog.h:379
uint64 XLogRecPtr
Definition: xlogdefs.h:21
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
Definition: xloginsert.c:474
void XLogRegisterBufData(uint8 block_id, const void *data, uint32 len)
Definition: xloginsert.c:405
void XLogRegisterData(const void *data, uint32 len)
Definition: xloginsert.c:364
void XLogRegisterBuffer(uint8 block_id, Buffer buffer, uint8 flags)
Definition: xloginsert.c:242
void XLogBeginInsert(void)
Definition: xloginsert.c:149
#define REGBUF_STANDARD
Definition: xloginsert.h:35

References Assert(), BufferGetPage(), data, elog, ERROR, xl_heap_prune::flags, heap_log_freeze_plan(), MaxHeapTuplesPerPage, xlhp_freeze_plans::nplans, xlhp_prune_items::ntargets, PageSetLSN(), PRUNE_ON_ACCESS, PRUNE_VACUUM_CLEANUP, PRUNE_VACUUM_SCAN, REGBUF_STANDARD, RelationIsAccessibleInLogicalDecoding, SizeOfHeapPrune, TransactionIdIsValid, XLHP_CLEANUP_LOCK, XLHP_HAS_CONFLICT_HORIZON, XLHP_HAS_DEAD_ITEMS, XLHP_HAS_FREEZE_PLANS, XLHP_HAS_NOW_UNUSED_ITEMS, XLHP_HAS_REDIRECTIONS, XLHP_IS_CATALOG_REL, XLOG_HEAP2_PRUNE_ON_ACCESS, XLOG_HEAP2_PRUNE_VACUUM_CLEANUP, XLOG_HEAP2_PRUNE_VACUUM_SCAN, XLogBeginInsert(), XLogInsert(), XLogRegisterBufData(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by heap_page_prune_and_freeze(), and lazy_vacuum_heap_page().

◆ page_verify_redirects()

static void page_verify_redirects ( Page  page )
static

Definition at line 1737 of file pruneheap.c.

1738{
1739#ifdef USE_ASSERT_CHECKING
1740 OffsetNumber offnum;
1741 OffsetNumber maxoff;
1742
1743 maxoff = PageGetMaxOffsetNumber(page);
1744 for (offnum = FirstOffsetNumber;
1745 offnum <= maxoff;
1746 offnum = OffsetNumberNext(offnum))
1747 {
1748 ItemId itemid = PageGetItemId(page, offnum);
1749 OffsetNumber targoff;
1750 ItemId targitem;
1751 HeapTupleHeader htup;
1752
1753 if (!ItemIdIsRedirected(itemid))
1754 continue;
1755
1756 targoff = ItemIdGetRedirect(itemid);
1757 targitem = PageGetItemId(page, targoff);
1758
1759 Assert(ItemIdIsUsed(targitem));
1760 Assert(ItemIdIsNormal(targitem));
1761 Assert(ItemIdHasStorage(targitem));
1762 htup = (HeapTupleHeader) PageGetItem(page, targitem);
1764 }
1765#endif
1766}

References Assert(), FirstOffsetNumber, HeapTupleHeaderIsHeapOnly(), ItemIdGetRedirect, ItemIdHasStorage, ItemIdIsNormal, ItemIdIsRedirected, ItemIdIsUsed, OffsetNumberNext, PageGetItem(), PageGetItemId(), and PageGetMaxOffsetNumber().

Referenced by heap_page_prune_execute().

AltStyle によって変換されたページ (->オリジナル) /