PostgreSQL Source Code  git master
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 1764 of file pruneheap.c.

1765 {
1766  OffsetNumber offnum,
1767  maxoff;
1768 
1769  MemSet(root_offsets, InvalidOffsetNumber,
1771 
1772  maxoff = PageGetMaxOffsetNumber(page);
1773  for (offnum = FirstOffsetNumber; offnum <= maxoff; offnum = OffsetNumberNext(offnum))
1774  {
1775  ItemId lp = PageGetItemId(page, offnum);
1776  HeapTupleHeader htup;
1777  OffsetNumber nextoffnum;
1778  TransactionId priorXmax;
1779 
1780  /* skip unused and dead items */
1781  if (!ItemIdIsUsed(lp) || ItemIdIsDead(lp))
1782  continue;
1783 
1784  if (ItemIdIsNormal(lp))
1785  {
1786  htup = (HeapTupleHeader) PageGetItem(page, lp);
1787 
1788  /*
1789  * Check if this tuple is part of a HOT-chain rooted at some other
1790  * tuple. If so, skip it for now; we'll process it when we find
1791  * its root.
1792  */
1793  if (HeapTupleHeaderIsHeapOnly(htup))
1794  continue;
1795 
1796  /*
1797  * This is either a plain tuple or the root of a HOT-chain.
1798  * Remember it in the mapping.
1799  */
1800  root_offsets[offnum - 1] = offnum;
1801 
1802  /* If it's not the start of a HOT-chain, we're done with it */
1803  if (!HeapTupleHeaderIsHotUpdated(htup))
1804  continue;
1805 
1806  /* Set up to scan the HOT-chain */
1807  nextoffnum = ItemPointerGetOffsetNumber(&htup->t_ctid);
1808  priorXmax = HeapTupleHeaderGetUpdateXid(htup);
1809  }
1810  else
1811  {
1812  /* Must be a redirect item. We do not set its root_offsets entry */
1814  /* Set up to scan the HOT-chain */
1815  nextoffnum = ItemIdGetRedirect(lp);
1816  priorXmax = InvalidTransactionId;
1817  }
1818 
1819  /*
1820  * Now follow the HOT-chain and collect other tuples in the chain.
1821  *
1822  * Note: Even though this is a nested loop, the complexity of the
1823  * function is O(N) because a tuple in the page should be visited not
1824  * more than twice, once in the outer loop and once in HOT-chain
1825  * chases.
1826  */
1827  for (;;)
1828  {
1829  /* Sanity check (pure paranoia) */
1830  if (offnum < FirstOffsetNumber)
1831  break;
1832 
1833  /*
1834  * An offset past the end of page's line pointer array is possible
1835  * when the array was truncated
1836  */
1837  if (offnum > maxoff)
1838  break;
1839 
1840  lp = PageGetItemId(page, nextoffnum);
1841 
1842  /* Check for broken chains */
1843  if (!ItemIdIsNormal(lp))
1844  break;
1845 
1846  htup = (HeapTupleHeader) PageGetItem(page, lp);
1847 
1848  if (TransactionIdIsValid(priorXmax) &&
1849  !TransactionIdEquals(priorXmax, HeapTupleHeaderGetXmin(htup)))
1850  break;
1851 
1852  /* Remember the root line pointer for this item */
1853  root_offsets[nextoffnum - 1] = offnum;
1854 
1855  /* Advance to next chain member, if any */
1856  if (!HeapTupleHeaderIsHotUpdated(htup))
1857  break;
1858 
1859  /* HOT implies it can't have moved to different partition */
1861 
1862  nextoffnum = ItemPointerGetOffsetNumber(&htup->t_ctid);
1863  priorXmax = HeapTupleHeaderGetUpdateXid(htup);
1864  }
1865  }
1866 }
static Item PageGetItem(Page page, ItemId itemId)
Definition: bufpage.h:351
static ItemId PageGetItemId(Page page, OffsetNumber offsetNumber)
Definition: bufpage.h:240
static OffsetNumber PageGetMaxOffsetNumber(Page page)
Definition: bufpage.h:369
#define Assert(condition)
Definition: c.h:858
#define MemSet(start, val, len)
Definition: c.h:1020
uint32 TransactionId
Definition: c.h:652
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 1891 of file pruneheap.c.

1892 {
1893  HeapTupleFreeze *frz1 = (HeapTupleFreeze *) arg1;
1894  HeapTupleFreeze *frz2 = (HeapTupleFreeze *) arg2;
1895 
1896  if (frz1->xmax < frz2->xmax)
1897  return -1;
1898  else if (frz1->xmax > frz2->xmax)
1899  return 1;
1900 
1901  if (frz1->t_infomask2 < frz2->t_infomask2)
1902  return -1;
1903  else if (frz1->t_infomask2 > frz2->t_infomask2)
1904  return 1;
1905 
1906  if (frz1->t_infomask < frz2->t_infomask)
1907  return -1;
1908  else if (frz1->t_infomask > frz2->t_infomask)
1909  return 1;
1910 
1911  if (frz1->frzflags < frz2->frzflags)
1912  return -1;
1913  else if (frz1->frzflags > frz2->frzflags)
1914  return 1;
1915 
1916  /*
1917  * heap_log_freeze_eq would consider these tuple-wise plans to be equal.
1918  * (So the tuples will share a single canonical freeze plan.)
1919  *
1920  * We tiebreak on page offset number to keep each freeze plan's page
1921  * offset number array individually sorted. (Unnecessary, but be tidy.)
1922  */
1923  if (frz1->offset < frz2->offset)
1924  return -1;
1925  else if (frz1->offset > frz2->offset)
1926  return 1;
1927 
1928  Assert(false);
1929  return 0;
1930 }
uint8 frzflags
Definition: heapam.h:146
uint16 t_infomask2
Definition: heapam.h:144
TransactionId xmax
Definition: heapam.h:143
OffsetNumber offset
Definition: heapam.h:151
uint16 t_infomask
Definition: heapam.h:145

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 1875 of file pruneheap.c.

1876 {
1877  if (plan->xmax == frz->xmax &&
1878  plan->t_infomask2 == frz->t_infomask2 &&
1879  plan->t_infomask == frz->t_infomask &&
1880  plan->frzflags == frz->frzflags)
1881  return true;
1882 
1883  /* Caller must call heap_log_freeze_new_plan again for frz */
1884  return false;
1885 }
#define plan(x)
Definition: pg_regress.c:162

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 1937 of file pruneheap.c.

1938 {
1939  plan->xmax = frz->xmax;
1940  plan->t_infomask2 = frz->t_infomask2;
1941  plan->t_infomask = frz->t_infomask;
1942  plan->frzflags = frz->frzflags;
1943  plan->ntuples = 1; /* for now */
1944 }

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 1957 of file pruneheap.c.

1960 {
1961  int nplans = 0;
1962 
1963  /* Sort tuple-based freeze plans in the order required to deduplicate */
1964  qsort(tuples, ntuples, sizeof(HeapTupleFreeze), heap_log_freeze_cmp);
1965 
1966  for (int i = 0; i < ntuples; i++)
1967  {
1968  HeapTupleFreeze *frz = tuples + i;
1969 
1970  if (i == 0)
1971  {
1972  /* New canonical freeze plan starting with first tup */
1973  heap_log_freeze_new_plan(plans_out, frz);
1974  nplans++;
1975  }
1976  else if (heap_log_freeze_eq(plans_out, frz))
1977  {
1978  /* tup matches open canonical plan -- include tup in it */
1979  Assert(offsets_out[i - 1] < frz->offset);
1980  plans_out->ntuples++;
1981  }
1982  else
1983  {
1984  /* Tup doesn't match current plan -- done with it now */
1985  plans_out++;
1986 
1987  /* New canonical freeze plan starting with this tup */
1988  heap_log_freeze_new_plan(plans_out, frz);
1989  nplans++;
1990  }
1991 
1992  /*
1993  * Save page offset number in dedicated buffer in passing.
1994  *
1995  * REDO routine relies on the record's offset numbers array grouping
1996  * offset numbers by freeze plan. The sort order within each grouping
1997  * is ascending offset number order, just to keep things tidy.
1998  */
1999  offsets_out[i] = frz->offset;
2000  }
2001 
2002  Assert(nplans > 0 && nplans <= ntuples);
2003 
2004  return nplans;
2005 }
int i
Definition: isn.c:73
#define qsort(a, b, c, d)
Definition: port.h:449
static int heap_log_freeze_cmp(const void *arg1, const void *arg2)
Definition: pruneheap.c:1891
static bool heap_log_freeze_eq(xlhp_freeze_plan *plan, HeapTupleFreeze *frz)
Definition: pruneheap.c:1875
static void heap_log_freeze_new_plan(xlhp_freeze_plan *plan, HeapTupleFreeze *frz)
Definition: pruneheap.c:1937

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 348 of file pruneheap.c.

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

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

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:5131
bool ConditionalLockBufferForCleanup(Buffer buffer)
Definition: bufmgr.c:5372
#define BUFFER_LOCK_UNLOCK
Definition: bufmgr.h:193
Size PageGetHeapFreeSpace(Page page)
Definition: bufpage.c:991
#define Max(x, y)
Definition: c.h:998
size_t Size
Definition: c.h:605
@ PRUNE_ON_ACCESS
Definition: heapam.h:269
void pgstat_update_heap_dead_tuples(Relation rel, int delta)
bool GlobalVisTestIsRemovableXid(GlobalVisState *state, TransactionId xid)
Definition: procarray.c:4251
GlobalVisState * GlobalVisTestFor(Relation rel)
Definition: procarray.c:4094
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:348
#define RelationGetTargetPageFreeSpace(relation, defaultff)
Definition: rel.h:378
#define HEAP_DEFAULT_FILLFACTOR
Definition: rel.h:349
bool RecoveryInProgress(void)
Definition: xlog.c:6290

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 978 of file pruneheap.c.

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

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 1225 of file pruneheap.c.

1227 {
1228  Assert(!prstate->processed[offnum]);
1229  prstate->processed[offnum] = true;
1230 
1231  Assert(prstate->ndead < MaxHeapTuplesPerPage);
1232  prstate->nowdead[prstate->ndead] = offnum;
1233  prstate->ndead++;
1234 
1235  /*
1236  * Deliberately delay unsetting all_visible until later during pruning.
1237  * Removable dead tuples shouldn't preclude freezing the page.
1238  */
1239 
1240  /* Record the dead offset for vacuum */
1241  prstate->deadoffsets[prstate->lpdead_items++] = offnum;
1242 
1243  /*
1244  * If the root entry had been a normal tuple, we are deleting it, so count
1245  * it in the result. But changing a redirect (even to DEAD state) doesn't
1246  * count.
1247  */
1248  if (was_normal)
1249  prstate->ndeleted++;
1250 }

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 1259 of file pruneheap.c.

1261 {
1262  /*
1263  * If the caller set mark_unused_now to true, we can remove dead tuples
1264  * during pruning instead of marking their line pointers dead. Set this
1265  * tuple's line pointer LP_UNUSED. We hint that this option is less
1266  * likely.
1267  */
1268  if (unlikely(prstate->mark_unused_now))
1269  heap_prune_record_unused(prstate, offnum, was_normal);
1270  else
1271  heap_prune_record_dead(prstate, offnum, was_normal);
1272 }
static void heap_prune_record_dead(PruneState *prstate, OffsetNumber offnum, bool was_normal)
Definition: pruneheap.c:1225

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 1180 of file pruneheap.c.

1181 {
1182  /*
1183  * This should exactly match the PageSetPrunable macro. We can't store
1184  * directly into the page header yet, so we update working state.
1185  */
1187  if (!TransactionIdIsValid(prstate->new_prune_xid) ||
1188  TransactionIdPrecedes(xid, prstate->new_prune_xid))
1189  prstate->new_prune_xid = xid;
1190 }
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 1194 of file pruneheap.c.

1197 {
1198  Assert(!prstate->processed[offnum]);
1199  prstate->processed[offnum] = true;
1200 
1201  /*
1202  * Do not mark the redirect target here. It needs to be counted
1203  * separately as an unchanged tuple.
1204  */
1205 
1207  prstate->redirected[prstate->nredirected * 2] = offnum;
1208  prstate->redirected[prstate->nredirected * 2 + 1] = rdoffnum;
1209 
1210  prstate->nredirected++;
1211 
1212  /*
1213  * If the root entry had been a normal tuple, we are deleting it, so count
1214  * it in the result. But changing a redirect (even to DEAD state) doesn't
1215  * count.
1216  */
1217  if (was_normal)
1218  prstate->ndeleted++;
1219 
1220  prstate->hastup = true;
1221 }

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 1487 of file pruneheap.c.

1488 {
1489  Assert(!prstate->processed[offnum]);
1490  prstate->processed[offnum] = true;
1491 
1492  /*
1493  * Deliberately don't set hastup for LP_DEAD items. We make the soft
1494  * assumption that any LP_DEAD items encountered here will become
1495  * LP_UNUSED later on, before count_nondeletable_pages is reached. If we
1496  * don't make this assumption then rel truncation will only happen every
1497  * other VACUUM, at most. Besides, VACUUM must treat
1498  * hastup/nonempty_pages as provisional no matter how LP_DEAD items are
1499  * handled (handled here, or handled later on).
1500  *
1501  * Similarly, don't unset all_visible until later, at the end of
1502  * heap_page_prune_and_freeze(). This will allow us to attempt to freeze
1503  * the page after pruning. As long as we unset it before updating the
1504  * visibility map, this will be correct.
1505  */
1506 
1507  /* Record the dead offset for vacuum */
1508  prstate->deadoffsets[prstate->lpdead_items++] = offnum;
1509 }

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 1309 of file pruneheap.c.

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

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 1515 of file pruneheap.c.

1516 {
1517  /*
1518  * A redirect line pointer doesn't count as a live tuple.
1519  *
1520  * If we leave a redirect line pointer in place, there will be another
1521  * tuple on the page that it points to. We will do the bookkeeping for
1522  * that separately. So we have nothing to do here, except remember that
1523  * we processed this item.
1524  */
1525  Assert(!prstate->processed[offnum]);
1526  prstate->processed[offnum] = true;
1527 }

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 1298 of file pruneheap.c.

1299 {
1300  Assert(!prstate->processed[offnum]);
1301  prstate->processed[offnum] = true;
1302 }

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 1276 of file pruneheap.c.

1277 {
1278  Assert(!prstate->processed[offnum]);
1279  prstate->processed[offnum] = true;
1280 
1281  Assert(prstate->nunused < MaxHeapTuplesPerPage);
1282  prstate->nowunused[prstate->nunused] = offnum;
1283  prstate->nunused++;
1284 
1285  /*
1286  * If the root entry had been a normal tuple, we are deleting it, so count
1287  * it in the result. But changing a redirect (even to DEAD state) doesn't
1288  * count.
1289  */
1290  if (was_normal)
1291  prstate->ndeleted++;
1292 }

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 915 of file pruneheap.c.

916 {
918  TransactionId dead_after;
919 
920  res = HeapTupleSatisfiesVacuumHorizon(tup, buffer, &dead_after);
921 
923  return res;
924 
925  if (GlobalVisTestIsRemovableXid(prstate->vistest, dead_after))
927 
928  return res;
929 }
HTSV_Result
Definition: heapam.h:124
HTSV_Result HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer, TransactionId *dead_after)

References GlobalVisTestIsRemovableXid(), HEAPTUPLE_DEAD, HEAPTUPLE_RECENTLY_DEAD, HeapTupleSatisfiesVacuumHorizon(), res, 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 939 of file pruneheap.c.

940 {
941  Assert(status >= HEAPTUPLE_DEAD &&
942  status <= HEAPTUPLE_DELETE_IN_PROGRESS);
943  return (HTSV_Result) status;
944 }

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 2032 of file pruneheap.c.

2040 {
2041  xl_heap_prune xlrec;
2042  XLogRecPtr recptr;
2043  uint8 info;
2044 
2045  /* The following local variables hold data registered in the WAL record: */
2047  xlhp_freeze_plans freeze_plans;
2048  xlhp_prune_items redirect_items;
2049  xlhp_prune_items dead_items;
2050  xlhp_prune_items unused_items;
2051  OffsetNumber frz_offsets[MaxHeapTuplesPerPage];
2052 
2053  xlrec.flags = 0;
2054 
2055  /*
2056  * Prepare data for the buffer. The arrays are not actually in the
2057  * buffer, but we pretend that they are. When XLogInsert stores a full
2058  * page image, the arrays can be omitted.
2059  */
2060  XLogBeginInsert();
2061  XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
2062  if (nfrozen > 0)
2063  {
2064  int nplans;
2065 
2066  xlrec.flags |= XLHP_HAS_FREEZE_PLANS;
2067 
2068  /*
2069  * Prepare deduplicated representation for use in the WAL record. This
2070  * destructively sorts frozen tuples array in-place.
2071  */
2072  nplans = heap_log_freeze_plan(frozen, nfrozen, plans, frz_offsets);
2073 
2074  freeze_plans.nplans = nplans;
2075  XLogRegisterBufData(0, (char *) &freeze_plans,
2076  offsetof(xlhp_freeze_plans, plans));
2077  XLogRegisterBufData(0, (char *) plans,
2078  sizeof(xlhp_freeze_plan) * nplans);
2079  }
2080  if (nredirected > 0)
2081  {
2082  xlrec.flags |= XLHP_HAS_REDIRECTIONS;
2083 
2084  redirect_items.ntargets = nredirected;
2085  XLogRegisterBufData(0, (char *) &redirect_items,
2086  offsetof(xlhp_prune_items, data));
2087  XLogRegisterBufData(0, (char *) redirected,
2088  sizeof(OffsetNumber[2]) * nredirected);
2089  }
2090  if (ndead > 0)
2091  {
2092  xlrec.flags |= XLHP_HAS_DEAD_ITEMS;
2093 
2094  dead_items.ntargets = ndead;
2095  XLogRegisterBufData(0, (char *) &dead_items,
2096  offsetof(xlhp_prune_items, data));
2097  XLogRegisterBufData(0, (char *) dead,
2098  sizeof(OffsetNumber) * ndead);
2099  }
2100  if (nunused > 0)
2101  {
2103 
2104  unused_items.ntargets = nunused;
2105  XLogRegisterBufData(0, (char *) &unused_items,
2106  offsetof(xlhp_prune_items, data));
2107  XLogRegisterBufData(0, (char *) unused,
2108  sizeof(OffsetNumber) * nunused);
2109  }
2110  if (nfrozen > 0)
2111  XLogRegisterBufData(0, (char *) frz_offsets,
2112  sizeof(OffsetNumber) * nfrozen);
2113 
2114  /*
2115  * Prepare the main xl_heap_prune record. We already set the XLPH_HAS_*
2116  * flag above.
2117  */
2119  xlrec.flags |= XLHP_IS_CATALOG_REL;
2120  if (TransactionIdIsValid(conflict_xid))
2122  if (cleanup_lock)
2123  xlrec.flags |= XLHP_CLEANUP_LOCK;
2124  else
2125  {
2126  Assert(nredirected == 0 && ndead == 0);
2127  /* also, any items in 'unused' must've been LP_DEAD previously */
2128  }
2129  XLogRegisterData((char *) &xlrec, SizeOfHeapPrune);
2130  if (TransactionIdIsValid(conflict_xid))
2131  XLogRegisterData((char *) &conflict_xid, sizeof(TransactionId));
2132 
2133  switch (reason)
2134  {
2135  case PRUNE_ON_ACCESS:
2137  break;
2138  case PRUNE_VACUUM_SCAN:
2140  break;
2141  case PRUNE_VACUUM_CLEANUP:
2143  break;
2144  default:
2145  elog(ERROR, "unrecognized prune reason: %d", (int) reason);
2146  break;
2147  }
2148  recptr = XLogInsert(RM_HEAP2_ID, info);
2149 
2150  PageSetLSN(BufferGetPage(buffer), recptr);
2151 }
static void PageSetLSN(Page page, XLogRecPtr lsn)
Definition: bufpage.h:388
unsigned char uint8
Definition: c.h:504
@ PRUNE_VACUUM_CLEANUP
Definition: heapam.h:271
@ PRUNE_VACUUM_SCAN
Definition: heapam.h:270
#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:60
#define XLOG_HEAP2_PRUNE_ON_ACCESS
Definition: heapam_xlog.h:59
#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:61
#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:1957
#define RelationIsAccessibleInLogicalDecoding(relation)
Definition: rel.h:684
uint64 XLogRecPtr
Definition: xlogdefs.h:21
void XLogRegisterData(char *data, uint32 len)
Definition: xloginsert.c:364
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
Definition: xloginsert.c:474
void XLogRegisterBufData(uint8 block_id, char *data, uint32 len)
Definition: xloginsert.c:405
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 1716 of file pruneheap.c.

1717 {
1718 #ifdef USE_ASSERT_CHECKING
1719  OffsetNumber offnum;
1720  OffsetNumber maxoff;
1721 
1722  maxoff = PageGetMaxOffsetNumber(page);
1723  for (offnum = FirstOffsetNumber;
1724  offnum <= maxoff;
1725  offnum = OffsetNumberNext(offnum))
1726  {
1727  ItemId itemid = PageGetItemId(page, offnum);
1728  OffsetNumber targoff;
1729  ItemId targitem;
1730  HeapTupleHeader htup;
1731 
1732  if (!ItemIdIsRedirected(itemid))
1733  continue;
1734 
1735  targoff = ItemIdGetRedirect(itemid);
1736  targitem = PageGetItemId(page, targoff);
1737 
1738  Assert(ItemIdIsUsed(targitem));
1739  Assert(ItemIdIsNormal(targitem));
1740  Assert(ItemIdHasStorage(targitem));
1741  htup = (HeapTupleHeader) PageGetItem(page, targitem);
1743  }
1744 #endif
1745 }

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

Referenced by heap_page_prune_execute().