PostgreSQL Source Code  git master
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
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) &&
1870  !TransactionIdEquals(priorXmax, HeapTupleHeaderGetXmin(htup)))
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(Page page, ItemId itemId)
Definition: bufpage.h:354
static ItemId PageGetItemId(Page page, OffsetNumber offsetNumber)
Definition: bufpage.h:243
static OffsetNumber PageGetMaxOffsetNumber(Page page)
Definition: bufpage.h:372
#define Assert(condition)
Definition: c.h:837
#define MemSet(start, val, len)
Definition: c.h:999
uint32 TransactionId
Definition: c.h:631
HeapTupleHeaderData * HeapTupleHeader
Definition: htup.h:23
#define HeapTupleHeaderIsHeapOnly(tup)
Definition: htup_details.h:499
#define HeapTupleHeaderIndicatesMovedPartitions(tup)
Definition: htup_details.h:444
#define HeapTupleHeaderGetXmin(tup)
Definition: htup_details.h:309
#define MaxHeapTuplesPerPage
Definition: htup_details.h:572
#define HeapTupleHeaderGetUpdateXid(tup)
Definition: htup_details.h:361
#define HeapTupleHeaderIsHotUpdated(tup)
Definition: htup_details.h:482
#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
#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 }
int i
Definition: isn.c:72
#define qsort(a, b, c, d)
Definition: port.h:447
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

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  */
738  Assert(!prstate.pagefrz.freeze_required);
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_FREEZE 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;
854  presult->recently_dead_tuples = prstate.recently_dead_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
892  presult->vm_conflict_horizon = prstate.visibility_cutoff_xid;
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:3724
void MarkBufferDirty(Buffer buffer)
Definition: bufmgr.c:2532
void MarkBufferDirtyHint(Buffer buffer, bool buffer_std)
Definition: bufmgr.c:4988
static Page BufferGetPage(Buffer buffer)
Definition: bufmgr.h:400
PageHeaderData * PageHeader
Definition: bufpage.h:173
Pointer Page
Definition: bufpage.h:81
static void PageClearFull(Page page)
Definition: bufpage.h:423
static bool PageIsFull(Page page)
Definition: bufpage.h:413
#define likely(x)
Definition: c.h:325
#define unlikely(x)
Definition: c.h:326
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:225
void HeapTupleHeaderAdvanceConflictHorizon(HeapTupleHeader tuple, TransactionId *snapshotConflictHorizon)
Definition: heapam.c:7811
void heap_freeze_prepared_tuples(Buffer buffer, HeapTupleFreeze *tuples, int ntuples)
Definition: heapam.c:7220
void heap_pre_freeze_checks(Buffer buffer, HeapTupleFreeze *tuples, int ntuples)
Definition: heapam.c:7167
#define HEAP_PAGE_PRUNE_FREEZE
Definition: heapam.h:43
@ HEAPTUPLE_DEAD
Definition: heapam.h:126
#define HEAP_PAGE_PRUNE_MARK_UNUSED_NOW
Definition: heapam.h:42
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:24
#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:505
#define RelationNeedsWAL(relation)
Definition: rel.h:628
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 recently_dead_tuples
Definition: heapam.h:235
TransactionId vm_conflict_horizon
Definition: heapam.h:250
OffsetNumber deadoffsets[MaxHeapTuplesPerPage]
Definition: heapam.h:264
bool all_visible
Definition: heapam.h:248
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:267
int64 wal_fpi
Definition: instrument.h:54
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:1027

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 = (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  {
1651  Assert(ItemIdIsNormal(lp));
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 */
1677  Assert(ItemIdIsDead(lp) && !ItemIdHasStorage(lp));
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  */
1718  page_verify_redirects(page);
1719  }
1720 }
void PageRepairFragmentation(Page page)
Definition: bufpage.c:688
void PageTruncateLinePointerArray(Page page)
Definition: bufpage.c:824
#define PG_USED_FOR_ASSERTS_ONLY
Definition: c.h:197
#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 */
245  if (!ConditionalLockBufferForCleanup(buffer))
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:5158
bool ConditionalLockBufferForCleanup(Buffer buffer)
Definition: bufmgr.c:5399
#define BUFFER_LOCK_UNLOCK
Definition: bufmgr.h:189
Size PageGetHeapFreeSpace(Page page)
Definition: bufpage.c:980
#define Max(x, y)
Definition: c.h:977
size_t Size
Definition: c.h:584
@ 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:4268
GlobalVisState * GlobalVisTestFor(Relation rel)
Definition: procarray.c:4111
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:378
#define HEAP_DEFAULT_FILLFACTOR
Definition: rel.h:349
bool RecoveryInProgress(void)
Definition: xlog.c:6334

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 heap_prepare_pagescan(), heapam_index_fetch_tuple(), and heapam_scan_bitmap_next_block().

◆ 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 {
1002  TransactionId priorXmax = InvalidTransactionId;
1003  ItemId rootlp;
1004  OffsetNumber offnum;
1005  OffsetNumber chainitems[MaxHeapTuplesPerPage];
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 
1064  Assert(ItemIdIsNormal(lp));
1065 
1066  htup = (HeapTupleHeader) PageGetItem(page, lp);
1067 
1068  /*
1069  * Check the tuple XMIN against prior XMAX, if any
1070  */
1071  if (TransactionIdIsValid(priorXmax) &&
1072  !TransactionIdEquals(HeapTupleHeaderGetXmin(htup), 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 
1153 process_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 
1383  if (!HeapTupleHeaderXminCommitted(htup))
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) &&
1413  TransactionIdIsNormal(xmin))
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:6894
#define HeapTupleHeaderXminCommitted(tup)
Definition: htup_details.h:320
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 
1302  Assert(prstate->nunused < MaxHeapTuplesPerPage);
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 {
920  TransactionId dead_after;
921 
922  res = HeapTupleSatisfiesVacuumHorizon(tup, buffer, &dead_after);
923 
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, res, 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 &&
963  status <= HEAPTUPLE_DELETE_IN_PROGRESS);
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;
2072  OffsetNumber frz_offsets[MaxHeapTuplesPerPage];
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  */
2081  XLogBeginInsert();
2082  XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
2083  if (nfrozen > 0)
2084  {
2085  int nplans;
2086 
2087  xlrec.flags |= XLHP_HAS_FREEZE_PLANS;
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, (char *) &freeze_plans,
2097  offsetof(xlhp_freeze_plans, plans));
2098  XLogRegisterBufData(0, (char *) plans,
2099  sizeof(xlhp_freeze_plan) * nplans);
2100  }
2101  if (nredirected > 0)
2102  {
2103  xlrec.flags |= XLHP_HAS_REDIRECTIONS;
2104 
2105  redirect_items.ntargets = nredirected;
2106  XLogRegisterBufData(0, (char *) &redirect_items,
2107  offsetof(xlhp_prune_items, data));
2108  XLogRegisterBufData(0, (char *) 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, (char *) &dead_items,
2117  offsetof(xlhp_prune_items, data));
2118  XLogRegisterBufData(0, (char *) dead,
2119  sizeof(OffsetNumber) * ndead);
2120  }
2121  if (nunused > 0)
2122  {
2124 
2125  unused_items.ntargets = nunused;
2126  XLogRegisterBufData(0, (char *) &unused_items,
2127  offsetof(xlhp_prune_items, data));
2128  XLogRegisterBufData(0, (char *) unused,
2129  sizeof(OffsetNumber) * nunused);
2130  }
2131  if (nfrozen > 0)
2132  XLogRegisterBufData(0, (char *) frz_offsets,
2133  sizeof(OffsetNumber) * nfrozen);
2134 
2135  /*
2136  * Prepare the main xl_heap_prune record. We already set the XLPH_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  }
2150  XLogRegisterData((char *) &xlrec, SizeOfHeapPrune);
2151  if (TransactionIdIsValid(conflict_xid))
2152  XLogRegisterData((char *) &conflict_xid, sizeof(TransactionId));
2153 
2154  switch (reason)
2155  {
2156  case PRUNE_ON_ACCESS:
2158  break;
2159  case PRUNE_VACUUM_SCAN:
2161  break;
2162  case PRUNE_VACUUM_CLEANUP:
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
unsigned char uint8
Definition: c.h:490
@ PRUNE_VACUUM_CLEANUP
Definition: heapam.h:272
@ PRUNE_VACUUM_SCAN
Definition: heapam.h:271
#define XLHP_HAS_CONFLICT_HORIZON
Definition: heapam_xlog.h:317
#define XLHP_HAS_FREEZE_PLANS
Definition: heapam_xlog.h:323
#define SizeOfHeapPrune
Definition: heapam_xlog.h:296
#define XLHP_HAS_NOW_UNUSED_ITEMS
Definition: heapam_xlog.h:332
#define XLHP_HAS_REDIRECTIONS
Definition: heapam_xlog.h:330
#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:309
#define XLHP_HAS_DEAD_ITEMS
Definition: heapam_xlog.h:331
#define XLOG_HEAP2_PRUNE_VACUUM_CLEANUP
Definition: heapam_xlog.h:62
#define XLHP_IS_CATALOG_REL
Definition: heapam_xlog.h:299
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:684
uint64 XLogRecPtr
Definition: xlogdefs.h:21
void XLogRegisterBufData(uint8 block_id, const char *data, uint32 len)
Definition: xloginsert.c:405
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
Definition: xloginsert.c:474
void XLogRegisterData(const char *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:34

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().