PostgreSQL Source Code git master
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
pruneheap.c
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2 *
3 * pruneheap.c
4 * heap page pruning and HOT-chain management code
5 *
6 * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * src/backend/access/heap/pruneheap.c
12 *
13 *-------------------------------------------------------------------------
14 */
15#include "postgres.h"
16
17#include "access/heapam.h"
18#include "access/heapam_xlog.h"
19#include "access/htup_details.h"
20#include "access/multixact.h"
21#include "access/transam.h"
22#include "access/xlog.h"
23#include "access/xloginsert.h"
24#include "commands/vacuum.h"
25#include "executor/instrument.h"
26#include "miscadmin.h"
27#include "pgstat.h"
28#include "storage/bufmgr.h"
29#include "utils/rel.h"
30#include "utils/snapmgr.h"
31
32/* Working data for heap_page_prune_and_freeze() and subroutines */
33typedef struct
34{
35 /*-------------------------------------------------------
36 * Arguments passed to heap_page_prune_and_freeze()
37 *-------------------------------------------------------
38 */
39
40 /* tuple visibility test, initialized for the relation */
42 /* whether or not dead items can be set LP_UNUSED during pruning */
44 /* whether to attempt freezing tuples */
45 bool freeze;
47
48 /*-------------------------------------------------------
49 * Fields describing what to do to the page
50 *-------------------------------------------------------
51 */
52 TransactionId new_prune_xid; /* new prune hint value */
54 int nredirected; /* numbers of entries in arrays below */
55 int ndead;
58 /* arrays that accumulate indexes of items to be changed */
63
64 /*-------------------------------------------------------
65 * Working state for HOT chain processing
66 *-------------------------------------------------------
67 */
68
69 /*
70 * 'root_items' contains offsets of all LP_REDIRECT line pointers and
71 * normal non-HOT tuples. They can be stand-alone items or the first item
72 * in a HOT chain. 'heaponly_items' contains heap-only tuples which can
73 * only be removed as part of a HOT chain.
74 */
79
80 /*
81 * processed[offnum] is true if item at offnum has been processed.
82 *
83 * This needs to be MaxHeapTuplesPerPage + 1 long as FirstOffsetNumber is
84 * 1. Otherwise every access would need to subtract 1.
85 */
86 bool processed[MaxHeapTuplesPerPage + 1];
87
88 /*
89 * Tuple visibility is only computed once for each tuple, for correctness
90 * and efficiency reasons; see comment in heap_page_prune_and_freeze() for
91 * details. This is of type int8[], instead of HTSV_Result[], so we can
92 * use -1 to indicate no visibility has been computed, e.g. for LP_DEAD
93 * items.
94 *
95 * This needs to be MaxHeapTuplesPerPage + 1 long as FirstOffsetNumber is
96 * 1. Otherwise every access would need to subtract 1.
97 */
99
100 /*
101 * Freezing-related state.
102 */
104
105 /*-------------------------------------------------------
106 * Information about what was done
107 *
108 * These fields are not used by pruning itself for the most part, but are
109 * used to collect information about what was pruned and what state the
110 * page is in after pruning, for the benefit of the caller. They are
111 * copied to the caller's PruneFreezeResult at the end.
112 * -------------------------------------------------------
113 */
114
115 int ndeleted; /* Number of tuples deleted from the page */
116
117 /* Number of live and recently dead tuples, after pruning */
120
121 /* Whether or not the page makes rel truncation unsafe */
122 bool hastup;
123
124 /*
125 * LP_DEAD items on the page after pruning. Includes existing LP_DEAD
126 * items
127 */
128 int lpdead_items; /* number of items in the array */
129 OffsetNumber *deadoffsets; /* points directly to presult->deadoffsets */
130
131 /*
132 * all_visible and all_frozen indicate if the all-visible and all-frozen
133 * bits in the visibility map can be set for this page after pruning.
134 *
135 * visibility_cutoff_xid is the newest xmin of live tuples on the page.
136 * The caller can use it as the conflict horizon, when setting the VM
137 * bits. It is only valid if we froze some tuples, and all_frozen is
138 * true.
139 *
140 * NOTE: all_visible and all_frozen don't include LP_DEAD items. That's
141 * convenient for heap_page_prune_and_freeze(), to use them to decide
142 * whether to freeze the page or not. The all_visible and all_frozen
143 * values returned to the caller are adjusted to include LP_DEAD items at
144 * the end.
145 *
146 * all_frozen should only be considered valid if all_visible is also set;
147 * we don't bother to clear the all_frozen flag every time we clear the
148 * all_visible flag.
149 */
153} PruneState;
154
155/* Local functions */
157 HeapTuple tup,
158 Buffer buffer);
159static inline HTSV_Result htsv_get_valid_status(int status);
160static void heap_prune_chain(Page page, BlockNumber blockno, OffsetNumber maxoff,
161 OffsetNumber rootoffnum, PruneState *prstate);
162static void heap_prune_record_prunable(PruneState *prstate, TransactionId xid);
163static void heap_prune_record_redirect(PruneState *prstate,
164 OffsetNumber offnum, OffsetNumber rdoffnum,
165 bool was_normal);
166static void heap_prune_record_dead(PruneState *prstate, OffsetNumber offnum,
167 bool was_normal);
168static void heap_prune_record_dead_or_unused(PruneState *prstate, OffsetNumber offnum,
169 bool was_normal);
170static void heap_prune_record_unused(PruneState *prstate, OffsetNumber offnum, bool was_normal);
171
172static void heap_prune_record_unchanged_lp_unused(Page page, PruneState *prstate, OffsetNumber offnum);
173static void heap_prune_record_unchanged_lp_normal(Page page, PruneState *prstate, OffsetNumber offnum);
174static void heap_prune_record_unchanged_lp_dead(Page page, PruneState *prstate, OffsetNumber offnum);
176
177static void page_verify_redirects(Page page);
178
179
180/*
181 * Optionally prune and repair fragmentation in the specified page.
182 *
183 * This is an opportunistic function. It will perform housekeeping
184 * only if the page heuristically looks like a candidate for pruning and we
185 * can acquire buffer cleanup lock without blocking.
186 *
187 * Note: this is called quite often. It's important that it fall out quickly
188 * if there's not any use in pruning.
189 *
190 * Caller must have pin on the buffer, and must *not* have a lock on it.
191 */
192void
194{
195 Page page = BufferGetPage(buffer);
196 TransactionId prune_xid;
197 GlobalVisState *vistest;
198 Size minfree;
199
200 /*
201 * We can't write WAL in recovery mode, so there's no point trying to
202 * clean the page. The primary will likely issue a cleaning WAL record
203 * soon anyway, so this is no particular loss.
204 */
205 if (RecoveryInProgress())
206 return;
207
208 /*
209 * First check whether there's any chance there's something to prune,
210 * determining the appropriate horizon is a waste if there's no prune_xid
211 * (i.e. no updates/deletes left potentially dead tuples around).
212 */
213 prune_xid = ((PageHeader) page)->pd_prune_xid;
214 if (!TransactionIdIsValid(prune_xid))
215 return;
216
217 /*
218 * Check whether prune_xid indicates that there may be dead rows that can
219 * be cleaned up.
220 */
221 vistest = GlobalVisTestFor(relation);
222
223 if (!GlobalVisTestIsRemovableXid(vistest, prune_xid))
224 return;
225
226 /*
227 * We prune when a previous UPDATE failed to find enough space on the page
228 * for a new tuple version, or when free space falls below the relation's
229 * fill-factor target (but not less than 10%).
230 *
231 * Checking free space here is questionable since we aren't holding any
232 * lock on the buffer; in the worst case we could get a bogus answer. It's
233 * unlikely to be *seriously* wrong, though, since reading either pd_lower
234 * or pd_upper is probably atomic. Avoiding taking a lock seems more
235 * important than sometimes getting a wrong answer in what is after all
236 * just a heuristic estimate.
237 */
238 minfree = RelationGetTargetPageFreeSpace(relation,
240 minfree = Max(minfree, BLCKSZ / 10);
241
242 if (PageIsFull(page) || PageGetHeapFreeSpace(page) < minfree)
243 {
244 /* OK, try to get exclusive buffer lock */
246 return;
247
248 /*
249 * Now that we have buffer lock, get accurate information about the
250 * page's free space, and recheck the heuristic about whether to
251 * prune.
252 */
253 if (PageIsFull(page) || PageGetHeapFreeSpace(page) < minfree)
254 {
255 OffsetNumber dummy_off_loc;
256 PruneFreezeResult presult;
257
258 /*
259 * For now, pass mark_unused_now as false regardless of whether or
260 * not the relation has indexes, since we cannot safely determine
261 * that during on-access pruning with the current implementation.
262 */
263 heap_page_prune_and_freeze(relation, buffer, vistest, 0,
264 NULL, &presult, PRUNE_ON_ACCESS, &dummy_off_loc, NULL, NULL);
265
266 /*
267 * Report the number of tuples reclaimed to pgstats. This is
268 * presult.ndeleted minus the number of newly-LP_DEAD-set items.
269 *
270 * We derive the number of dead tuples like this to avoid totally
271 * forgetting about items that were set to LP_DEAD, since they
272 * still need to be cleaned up by VACUUM. We only want to count
273 * heap-only tuples that just became LP_UNUSED in our report,
274 * which don't.
275 *
276 * VACUUM doesn't have to compensate in the same way when it
277 * tracks ndeleted, since it will set the same LP_DEAD items to
278 * LP_UNUSED separately.
279 */
280 if (presult.ndeleted > presult.nnewlpdead)
282 presult.ndeleted - presult.nnewlpdead);
283 }
284
285 /* And release buffer lock */
287
288 /*
289 * We avoid reuse of any free space created on the page by unrelated
290 * UPDATEs/INSERTs by opting to not update the FSM at this point. The
291 * free space should be reused by UPDATEs to *this* page.
292 */
293 }
294}
295
296
297/*
298 * Prune and repair fragmentation and potentially freeze tuples on the
299 * specified page.
300 *
301 * Caller must have pin and buffer cleanup lock on the page. Note that we
302 * don't update the FSM information for page on caller's behalf. Caller might
303 * also need to account for a reduction in the length of the line pointer
304 * array following array truncation by us.
305 *
306 * If the HEAP_PRUNE_FREEZE option is set, we will also freeze tuples if it's
307 * required in order to advance relfrozenxid / relminmxid, or if it's
308 * considered advantageous for overall system performance to do so now. The
309 * 'cutoffs', 'presult', 'new_relfrozen_xid' and 'new_relmin_mxid' arguments
310 * are required when freezing. When HEAP_PRUNE_FREEZE option is set, we also
311 * set presult->all_visible and presult->all_frozen on exit, to indicate if
312 * the VM bits can be set. They are always set to false when the
313 * HEAP_PRUNE_FREEZE option is not set, because at the moment only callers
314 * that also freeze need that information.
315 *
316 * vistest is used to distinguish whether tuples are DEAD or RECENTLY_DEAD
317 * (see heap_prune_satisfies_vacuum).
318 *
319 * options:
320 * MARK_UNUSED_NOW indicates that dead items can be set LP_UNUSED during
321 * pruning.
322 *
323 * FREEZE indicates that we will also freeze tuples, and will return
324 * 'all_visible', 'all_frozen' flags to the caller.
325 *
326 * cutoffs contains the freeze cutoffs, established by VACUUM at the beginning
327 * of vacuuming the relation. Required if HEAP_PRUNE_FREEZE option is set.
328 * cutoffs->OldestXmin is also used to determine if dead tuples are
329 * HEAPTUPLE_RECENTLY_DEAD or HEAPTUPLE_DEAD.
330 *
331 * presult contains output parameters needed by callers, such as the number of
332 * tuples removed and the offsets of dead items on the page after pruning.
333 * heap_page_prune_and_freeze() is responsible for initializing it. Required
334 * by all callers.
335 *
336 * reason indicates why the pruning is performed. It is included in the WAL
337 * record for debugging and analysis purposes, but otherwise has no effect.
338 *
339 * off_loc is the offset location required by the caller to use in error
340 * callback.
341 *
342 * new_relfrozen_xid and new_relmin_mxid must provided by the caller if the
343 * HEAP_PRUNE_FREEZE option is set. On entry, they contain the oldest XID and
344 * multi-XID seen on the relation so far. They will be updated with oldest
345 * values present on the page after pruning. After processing the whole
346 * relation, VACUUM can use these values as the new relfrozenxid/relminmxid
347 * for the relation.
348 */
349void
351 GlobalVisState *vistest,
352 int options,
353 struct VacuumCutoffs *cutoffs,
354 PruneFreezeResult *presult,
355 PruneReason reason,
356 OffsetNumber *off_loc,
357 TransactionId *new_relfrozen_xid,
358 MultiXactId *new_relmin_mxid)
359{
360 Page page = BufferGetPage(buffer);
361 BlockNumber blockno = BufferGetBlockNumber(buffer);
362 OffsetNumber offnum,
363 maxoff;
364 PruneState prstate;
365 HeapTupleData tup;
366 bool do_freeze;
367 bool do_prune;
368 bool do_hint;
369 bool hint_bit_fpi;
370 int64 fpi_before = pgWalUsage.wal_fpi;
371
372 /* Copy parameters to prstate */
373 prstate.vistest = vistest;
375 prstate.freeze = (options & HEAP_PAGE_PRUNE_FREEZE) != 0;
376 prstate.cutoffs = cutoffs;
377
378 /*
379 * Our strategy is to scan the page and make lists of items to change,
380 * then apply the changes within a critical section. This keeps as much
381 * logic as possible out of the critical section, and also ensures that
382 * WAL replay will work the same as the normal case.
383 *
384 * First, initialize the new pd_prune_xid value to zero (indicating no
385 * prunable tuples). If we find any tuples which may soon become
386 * prunable, we will save the lowest relevant XID in new_prune_xid. Also
387 * initialize the rest of our working state.
388 */
391 prstate.nredirected = prstate.ndead = prstate.nunused = prstate.nfrozen = 0;
392 prstate.nroot_items = 0;
393 prstate.nheaponly_items = 0;
394
395 /* initialize page freezing working state */
396 prstate.pagefrz.freeze_required = false;
397 if (prstate.freeze)
398 {
399 Assert(new_relfrozen_xid && new_relmin_mxid);
400 prstate.pagefrz.FreezePageRelfrozenXid = *new_relfrozen_xid;
401 prstate.pagefrz.NoFreezePageRelfrozenXid = *new_relfrozen_xid;
402 prstate.pagefrz.FreezePageRelminMxid = *new_relmin_mxid;
403 prstate.pagefrz.NoFreezePageRelminMxid = *new_relmin_mxid;
404 }
405 else
406 {
407 Assert(new_relfrozen_xid == NULL && new_relmin_mxid == NULL);
412 }
413
414 prstate.ndeleted = 0;
415 prstate.live_tuples = 0;
416 prstate.recently_dead_tuples = 0;
417 prstate.hastup = false;
418 prstate.lpdead_items = 0;
419 prstate.deadoffsets = presult->deadoffsets;
420
421 /*
422 * Caller may update the VM after we're done. We can keep track of
423 * whether the page will be all-visible and all-frozen after pruning and
424 * freezing to help the caller to do that.
425 *
426 * Currently, only VACUUM sets the VM bits. To save the effort, only do
427 * the bookkeeping if the caller needs it. Currently, that's tied to
428 * HEAP_PAGE_PRUNE_FREEZE, but it could be a separate flag if you wanted
429 * to update the VM bits without also freezing or freeze without also
430 * setting the VM bits.
431 *
432 * In addition to telling the caller whether it can set the VM bit, we
433 * also use 'all_visible' and 'all_frozen' for our own decision-making. If
434 * the whole page would become frozen, we consider opportunistically
435 * freezing tuples. We will not be able to freeze the whole page if there
436 * are tuples present that are not visible to everyone or if there are
437 * dead tuples which are not yet removable. However, dead tuples which
438 * will be removed by the end of vacuuming should not preclude us from
439 * opportunistically freezing. Because of that, we do not clear
440 * all_visible when we see LP_DEAD items. We fix that at the end of the
441 * function, when we return the value to the caller, so that the caller
442 * doesn't set the VM bit incorrectly.
443 */
444 if (prstate.freeze)
445 {
446 prstate.all_visible = true;
447 prstate.all_frozen = true;
448 }
449 else
450 {
451 /*
452 * Initializing to false allows skipping the work to update them in
453 * heap_prune_record_unchanged_lp_normal().
454 */
455 prstate.all_visible = false;
456 prstate.all_frozen = false;
457 }
458
459 /*
460 * The visibility cutoff xid is the newest xmin of live tuples on the
461 * page. In the common case, this will be set as the conflict horizon the
462 * caller can use for updating the VM. If, at the end of freezing and
463 * pruning, the page is all-frozen, there is no possibility that any
464 * running transaction on the standby does not see tuples on the page as
465 * all-visible, so the conflict horizon remains InvalidTransactionId.
466 */
468
469 maxoff = PageGetMaxOffsetNumber(page);
470 tup.t_tableOid = RelationGetRelid(relation);
471
472 /*
473 * Determine HTSV for all tuples, and queue them up for processing as HOT
474 * chain roots or as heap-only items.
475 *
476 * Determining HTSV only once for each tuple is required for correctness,
477 * to deal with cases where running HTSV twice could result in different
478 * results. For example, RECENTLY_DEAD can turn to DEAD if another
479 * checked item causes GlobalVisTestIsRemovableFullXid() to update the
480 * horizon, or INSERT_IN_PROGRESS can change to DEAD if the inserting
481 * transaction aborts.
482 *
483 * It's also good for performance. Most commonly tuples within a page are
484 * stored at decreasing offsets (while the items are stored at increasing
485 * offsets). When processing all tuples on a page this leads to reading
486 * memory at decreasing offsets within a page, with a variable stride.
487 * That's hard for CPU prefetchers to deal with. Processing the items in
488 * reverse order (and thus the tuples in increasing order) increases
489 * prefetching efficiency significantly / decreases the number of cache
490 * misses.
491 */
492 for (offnum = maxoff;
493 offnum >= FirstOffsetNumber;
494 offnum = OffsetNumberPrev(offnum))
495 {
496 ItemId itemid = PageGetItemId(page, offnum);
497 HeapTupleHeader htup;
498
499 /*
500 * Set the offset number so that we can display it along with any
501 * error that occurred while processing this tuple.
502 */
503 *off_loc = offnum;
504
505 prstate.processed[offnum] = false;
506 prstate.htsv[offnum] = -1;
507
508 /* Nothing to do if slot doesn't contain a tuple */
509 if (!ItemIdIsUsed(itemid))
510 {
511 heap_prune_record_unchanged_lp_unused(page, &prstate, offnum);
512 continue;
513 }
514
515 if (ItemIdIsDead(itemid))
516 {
517 /*
518 * If the caller set mark_unused_now true, we can set dead line
519 * pointers LP_UNUSED now.
520 */
521 if (unlikely(prstate.mark_unused_now))
522 heap_prune_record_unused(&prstate, offnum, false);
523 else
524 heap_prune_record_unchanged_lp_dead(page, &prstate, offnum);
525 continue;
526 }
527
528 if (ItemIdIsRedirected(itemid))
529 {
530 /* This is the start of a HOT chain */
531 prstate.root_items[prstate.nroot_items++] = offnum;
532 continue;
533 }
534
535 Assert(ItemIdIsNormal(itemid));
536
537 /*
538 * Get the tuple's visibility status and queue it up for processing.
539 */
540 htup = (HeapTupleHeader) PageGetItem(page, itemid);
541 tup.t_data = htup;
542 tup.t_len = ItemIdGetLength(itemid);
543 ItemPointerSet(&tup.t_self, blockno, offnum);
544
545 prstate.htsv[offnum] = heap_prune_satisfies_vacuum(&prstate, &tup,
546 buffer);
547
548 if (!HeapTupleHeaderIsHeapOnly(htup))
549 prstate.root_items[prstate.nroot_items++] = offnum;
550 else
551 prstate.heaponly_items[prstate.nheaponly_items++] = offnum;
552 }
553
554 /*
555 * If checksums are enabled, heap_prune_satisfies_vacuum() may have caused
556 * an FPI to be emitted.
557 */
558 hint_bit_fpi = fpi_before != pgWalUsage.wal_fpi;
559
560 /*
561 * Process HOT chains.
562 *
563 * We added the items to the array starting from 'maxoff', so by
564 * processing the array in reverse order, we process the items in
565 * ascending offset number order. The order doesn't matter for
566 * correctness, but some quick micro-benchmarking suggests that this is
567 * faster. (Earlier PostgreSQL versions, which scanned all the items on
568 * the page instead of using the root_items array, also did it in
569 * ascending offset number order.)
570 */
571 for (int i = prstate.nroot_items - 1; i >= 0; i--)
572 {
573 offnum = prstate.root_items[i];
574
575 /* Ignore items already processed as part of an earlier chain */
576 if (prstate.processed[offnum])
577 continue;
578
579 /* see preceding loop */
580 *off_loc = offnum;
581
582 /* Process this item or chain of items */
583 heap_prune_chain(page, blockno, maxoff, offnum, &prstate);
584 }
585
586 /*
587 * Process any heap-only tuples that were not already processed as part of
588 * a HOT chain.
589 */
590 for (int i = prstate.nheaponly_items - 1; i >= 0; i--)
591 {
592 offnum = prstate.heaponly_items[i];
593
594 if (prstate.processed[offnum])
595 continue;
596
597 /* see preceding loop */
598 *off_loc = offnum;
599
600 /*
601 * If the tuple is DEAD and doesn't chain to anything else, mark it
602 * unused. (If it does chain, we can only remove it as part of
603 * pruning its chain.)
604 *
605 * We need this primarily to handle aborted HOT updates, that is,
606 * XMIN_INVALID heap-only tuples. Those might not be linked to by any
607 * chain, since the parent tuple might be re-updated before any
608 * pruning occurs. So we have to be able to reap them separately from
609 * chain-pruning. (Note that HeapTupleHeaderIsHotUpdated will never
610 * return true for an XMIN_INVALID tuple, so this code will work even
611 * when there were sequential updates within the aborted transaction.)
612 */
613 if (prstate.htsv[offnum] == HEAPTUPLE_DEAD)
614 {
615 ItemId itemid = PageGetItemId(page, offnum);
616 HeapTupleHeader htup = (HeapTupleHeader) PageGetItem(page, itemid);
617
619 {
621 &prstate.latest_xid_removed);
622 heap_prune_record_unused(&prstate, offnum, true);
623 }
624 else
625 {
626 /*
627 * This tuple should've been processed and removed as part of
628 * a HOT chain, so something's wrong. To preserve evidence,
629 * we don't dare to remove it. We cannot leave behind a DEAD
630 * tuple either, because that will cause VACUUM to error out.
631 * Throwing an error with a distinct error message seems like
632 * the least bad option.
633 */
634 elog(ERROR, "dead heap-only tuple (%u, %d) is not linked to from any HOT chain",
635 blockno, offnum);
636 }
637 }
638 else
639 heap_prune_record_unchanged_lp_normal(page, &prstate, offnum);
640 }
641
642 /* We should now have processed every tuple exactly once */
643#ifdef USE_ASSERT_CHECKING
644 for (offnum = FirstOffsetNumber;
645 offnum <= maxoff;
646 offnum = OffsetNumberNext(offnum))
647 {
648 *off_loc = offnum;
649
650 Assert(prstate.processed[offnum]);
651 }
652#endif
653
654 /* Clear the offset information once we have processed the given page. */
655 *off_loc = InvalidOffsetNumber;
656
657 do_prune = prstate.nredirected > 0 ||
658 prstate.ndead > 0 ||
659 prstate.nunused > 0;
660
661 /*
662 * Even if we don't prune anything, if we found a new value for the
663 * pd_prune_xid field or the page was marked full, we will update the hint
664 * bit.
665 */
666 do_hint = ((PageHeader) page)->pd_prune_xid != prstate.new_prune_xid ||
667 PageIsFull(page);
668
669 /*
670 * Decide if we want to go ahead with freezing according to the freeze
671 * plans we prepared, or not.
672 */
673 do_freeze = false;
674 if (prstate.freeze)
675 {
676 if (prstate.pagefrz.freeze_required)
677 {
678 /*
679 * heap_prepare_freeze_tuple indicated that at least one XID/MXID
680 * from before FreezeLimit/MultiXactCutoff is present. Must
681 * freeze to advance relfrozenxid/relminmxid.
682 */
683 do_freeze = true;
684 }
685 else
686 {
687 /*
688 * Opportunistically freeze the page if we are generating an FPI
689 * anyway and if doing so means that we can set the page
690 * all-frozen afterwards (might not happen until VACUUM's final
691 * heap pass).
692 *
693 * XXX: Previously, we knew if pruning emitted an FPI by checking
694 * pgWalUsage.wal_fpi before and after pruning. Once the freeze
695 * and prune records were combined, this heuristic couldn't be
696 * used anymore. The opportunistic freeze heuristic must be
697 * improved; however, for now, try to approximate the old logic.
698 */
699 if (prstate.all_visible && prstate.all_frozen && prstate.nfrozen > 0)
700 {
701 /*
702 * Freezing would make the page all-frozen. Have already
703 * emitted an FPI or will do so anyway?
704 */
705 if (RelationNeedsWAL(relation))
706 {
707 if (hint_bit_fpi)
708 do_freeze = true;
709 else if (do_prune)
710 {
711 if (XLogCheckBufferNeedsBackup(buffer))
712 do_freeze = true;
713 }
714 else if (do_hint)
715 {
717 do_freeze = true;
718 }
719 }
720 }
721 }
722 }
723
724 if (do_freeze)
725 {
726 /*
727 * Validate the tuples we will be freezing before entering the
728 * critical section.
729 */
730 heap_pre_freeze_checks(buffer, prstate.frozen, prstate.nfrozen);
731 }
732 else if (prstate.nfrozen > 0)
733 {
734 /*
735 * The page contained some tuples that were not already frozen, and we
736 * chose not to freeze them now. The page won't be all-frozen then.
737 */
739
740 prstate.all_frozen = false;
741 prstate.nfrozen = 0; /* avoid miscounts in instrumentation */
742 }
743 else
744 {
745 /*
746 * We have no freeze plans to execute. The page might already be
747 * all-frozen (perhaps only following pruning), though. Such pages
748 * can be marked all-frozen in the VM by our caller, even though none
749 * of its tuples were newly frozen here.
750 */
751 }
752
753 /* Any error while applying the changes is critical */
755
756 if (do_hint)
757 {
758 /*
759 * Update the page's pd_prune_xid field to either zero, or the lowest
760 * XID of any soon-prunable tuple.
761 */
762 ((PageHeader) page)->pd_prune_xid = prstate.new_prune_xid;
763
764 /*
765 * Also clear the "page is full" flag, since there's no point in
766 * repeating the prune/defrag process until something else happens to
767 * the page.
768 */
769 PageClearFull(page);
770
771 /*
772 * If that's all we had to do to the page, this is a non-WAL-logged
773 * hint. If we are going to freeze or prune the page, we will mark
774 * the buffer dirty below.
775 */
776 if (!do_freeze && !do_prune)
777 MarkBufferDirtyHint(buffer, true);
778 }
779
780 if (do_prune || do_freeze)
781 {
782 /* Apply the planned item changes and repair page fragmentation. */
783 if (do_prune)
784 {
785 heap_page_prune_execute(buffer, false,
786 prstate.redirected, prstate.nredirected,
787 prstate.nowdead, prstate.ndead,
788 prstate.nowunused, prstate.nunused);
789 }
790
791 if (do_freeze)
792 heap_freeze_prepared_tuples(buffer, prstate.frozen, prstate.nfrozen);
793
794 MarkBufferDirty(buffer);
795
796 /*
797 * Emit a WAL XLOG_HEAP2_PRUNE_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;
855
856 /*
857 * It was convenient to ignore LP_DEAD items in all_visible earlier on to
858 * make the choice of whether or not to freeze the page unaffected by the
859 * short-term presence of LP_DEAD items. These LP_DEAD items were
860 * effectively assumed to be LP_UNUSED items in the making. It doesn't
861 * matter which vacuum heap pass (initial pass or final pass) ends up
862 * setting the page all-frozen, as long as the ongoing VACUUM does it.
863 *
864 * Now that freezing has been finalized, unset all_visible if there are
865 * any LP_DEAD items on the page. It needs to reflect the present state
866 * of the page, as expected by our caller.
867 */
868 if (prstate.all_visible && prstate.lpdead_items == 0)
869 {
870 presult->all_visible = prstate.all_visible;
871 presult->all_frozen = prstate.all_frozen;
872 }
873 else
874 {
875 presult->all_visible = false;
876 presult->all_frozen = false;
877 }
878
879 presult->hastup = prstate.hastup;
880
881 /*
882 * For callers planning to update the visibility map, the conflict horizon
883 * for that record must be the newest xmin on the page. However, if the
884 * page is completely frozen, there can be no conflict and the
885 * vm_conflict_horizon should remain InvalidTransactionId. This includes
886 * the case that we just froze all the tuples; the prune-freeze record
887 * included the conflict XID already so the caller doesn't need it.
888 */
889 if (presult->all_frozen)
891 else
893
894 presult->lpdead_items = prstate.lpdead_items;
895 /* the presult->deadoffsets array was already filled in */
896
897 if (prstate.freeze)
898 {
899 if (presult->nfrozen > 0)
900 {
901 *new_relfrozen_xid = prstate.pagefrz.FreezePageRelfrozenXid;
902 *new_relmin_mxid = prstate.pagefrz.FreezePageRelminMxid;
903 }
904 else
905 {
906 *new_relfrozen_xid = prstate.pagefrz.NoFreezePageRelfrozenXid;
907 *new_relmin_mxid = prstate.pagefrz.NoFreezePageRelminMxid;
908 }
909 }
910}
911
912
913/*
914 * Perform visibility checks for heap pruning.
915 */
916static HTSV_Result
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}
951
952
953/*
954 * Pruning calculates tuple visibility once and saves the results in an array
955 * of int8. See PruneState.htsv for details. This helper function is meant
956 * to guard against examining visibility status array members which have not
957 * yet been computed.
958 */
959static inline HTSV_Result
961{
962 Assert(status >= HEAPTUPLE_DEAD &&
964 return (HTSV_Result) status;
965}
966
967/*
968 * Prune specified line pointer or a HOT chain originating at line pointer.
969 *
970 * Tuple visibility information is provided in prstate->htsv.
971 *
972 * If the item is an index-referenced tuple (i.e. not a heap-only tuple),
973 * the HOT chain is pruned by removing all DEAD tuples at the start of the HOT
974 * chain. We also prune any RECENTLY_DEAD tuples preceding a DEAD tuple.
975 * This is OK because a RECENTLY_DEAD tuple preceding a DEAD tuple is really
976 * DEAD, our visibility test is just too coarse to detect it.
977 *
978 * Pruning must never leave behind a DEAD tuple that still has tuple storage.
979 * VACUUM isn't prepared to deal with that case.
980 *
981 * The root line pointer is redirected to the tuple immediately after the
982 * latest DEAD tuple. If all tuples in the chain are DEAD, the root line
983 * pointer is marked LP_DEAD. (This includes the case of a DEAD simple
984 * tuple, which we treat as a chain of length 1.)
985 *
986 * We don't actually change the page here. We just add entries to the arrays in
987 * prstate showing the changes to be made. Items to be redirected are added
988 * to the redirected[] array (two entries per redirection); items to be set to
989 * LP_DEAD state are added to nowdead[]; and items to be set to LP_UNUSED
990 * state are added to nowunused[]. We perform bookkeeping of live tuples,
991 * visibility etc. based on what the page will look like after the changes
992 * applied. All that bookkeeping is performed in the heap_prune_record_*()
993 * subroutines. The division of labor is that heap_prune_chain() decides the
994 * fate of each tuple, ie. whether it's going to be removed, redirected or
995 * left unchanged, and the heap_prune_record_*() subroutines update PruneState
996 * based on that outcome.
997 */
998static void
1000 OffsetNumber rootoffnum, PruneState *prstate)
1001{
1003 ItemId rootlp;
1004 OffsetNumber offnum;
1006
1007 /*
1008 * After traversing the HOT chain, ndeadchain is the index in chainitems
1009 * of the first live successor after the last dead item.
1010 */
1011 int ndeadchain = 0,
1012 nchain = 0;
1013
1014 rootlp = PageGetItemId(page, rootoffnum);
1015
1016 /* Start from the root tuple */
1017 offnum = rootoffnum;
1018
1019 /* while not end of the chain */
1020 for (;;)
1021 {
1022 HeapTupleHeader htup;
1023 ItemId lp;
1024
1025 /* Sanity check (pure paranoia) */
1026 if (offnum < FirstOffsetNumber)
1027 break;
1028
1029 /*
1030 * An offset past the end of page's line pointer array is possible
1031 * when the array was truncated (original item must have been unused)
1032 */
1033 if (offnum > maxoff)
1034 break;
1035
1036 /* If item is already processed, stop --- it must not be same chain */
1037 if (prstate->processed[offnum])
1038 break;
1039
1040 lp = PageGetItemId(page, offnum);
1041
1042 /*
1043 * Unused item obviously isn't part of the chain. Likewise, a dead
1044 * line pointer can't be part of the chain. Both of those cases were
1045 * already marked as processed.
1046 */
1047 Assert(ItemIdIsUsed(lp));
1048 Assert(!ItemIdIsDead(lp));
1049
1050 /*
1051 * If we are looking at the redirected root line pointer, jump to the
1052 * first normal tuple in the chain. If we find a redirect somewhere
1053 * else, stop --- it must not be same chain.
1054 */
1055 if (ItemIdIsRedirected(lp))
1056 {
1057 if (nchain > 0)
1058 break; /* not at start of chain */
1059 chainitems[nchain++] = offnum;
1060 offnum = ItemIdGetRedirect(rootlp);
1061 continue;
1062 }
1063
1065
1066 htup = (HeapTupleHeader) PageGetItem(page, lp);
1067
1068 /*
1069 * Check the tuple XMIN against prior XMAX, if any
1070 */
1071 if (TransactionIdIsValid(priorXmax) &&
1073 break;
1074
1075 /*
1076 * OK, this tuple is indeed a member of the chain.
1077 */
1078 chainitems[nchain++] = offnum;
1079
1080 switch (htsv_get_valid_status(prstate->htsv[offnum]))
1081 {
1082 case HEAPTUPLE_DEAD:
1083
1084 /* Remember the last DEAD tuple seen */
1085 ndeadchain = nchain;
1087 &prstate->latest_xid_removed);
1088 /* Advance to next chain member */
1089 break;
1090
1092
1093 /*
1094 * We don't need to advance the conflict horizon for
1095 * RECENTLY_DEAD tuples, even if we are removing them. This
1096 * is because we only remove RECENTLY_DEAD tuples if they
1097 * precede a DEAD tuple, and the DEAD tuple must have been
1098 * inserted by a newer transaction than the RECENTLY_DEAD
1099 * tuple by virtue of being later in the chain. We will have
1100 * advanced the conflict horizon for the DEAD tuple.
1101 */
1102
1103 /*
1104 * Advance past RECENTLY_DEAD tuples just in case there's a
1105 * DEAD one after them. We have to make sure that we don't
1106 * miss any DEAD tuples, since DEAD tuples that still have
1107 * tuple storage after pruning will confuse VACUUM.
1108 */
1109 break;
1110
1112 case HEAPTUPLE_LIVE:
1114 goto process_chain;
1115
1116 default:
1117 elog(ERROR, "unexpected HeapTupleSatisfiesVacuum result");
1118 goto process_chain;
1119 }
1120
1121 /*
1122 * If the tuple is not HOT-updated, then we are at the end of this
1123 * HOT-update chain.
1124 */
1125 if (!HeapTupleHeaderIsHotUpdated(htup))
1126 goto process_chain;
1127
1128 /* HOT implies it can't have moved to different partition */
1130
1131 /*
1132 * Advance to next chain member.
1133 */
1134 Assert(ItemPointerGetBlockNumber(&htup->t_ctid) == blockno);
1135 offnum = ItemPointerGetOffsetNumber(&htup->t_ctid);
1136 priorXmax = HeapTupleHeaderGetUpdateXid(htup);
1137 }
1138
1139 if (ItemIdIsRedirected(rootlp) && nchain < 2)
1140 {
1141 /*
1142 * We found a redirect item that doesn't point to a valid follow-on
1143 * item. This can happen if the loop in heap_page_prune_and_freeze()
1144 * caused us to visit the dead successor of a redirect item before
1145 * visiting the redirect item. We can clean up by setting the
1146 * redirect item to LP_DEAD state or LP_UNUSED if the caller
1147 * indicated.
1148 */
1149 heap_prune_record_dead_or_unused(prstate, rootoffnum, false);
1150 return;
1151 }
1152
1153process_chain:
1154
1155 if (ndeadchain == 0)
1156 {
1157 /*
1158 * No DEAD tuple was found, so the chain is entirely composed of
1159 * normal, unchanged tuples. Leave it alone.
1160 */
1161 int i = 0;
1162
1163 if (ItemIdIsRedirected(rootlp))
1164 {
1165 heap_prune_record_unchanged_lp_redirect(prstate, rootoffnum);
1166 i++;
1167 }
1168 for (; i < nchain; i++)
1169 heap_prune_record_unchanged_lp_normal(page, prstate, chainitems[i]);
1170 }
1171 else if (ndeadchain == nchain)
1172 {
1173 /*
1174 * The entire chain is dead. Mark the root line pointer LP_DEAD, and
1175 * fully remove the other tuples in the chain.
1176 */
1177 heap_prune_record_dead_or_unused(prstate, rootoffnum, ItemIdIsNormal(rootlp));
1178 for (int i = 1; i < nchain; i++)
1179 heap_prune_record_unused(prstate, chainitems[i], true);
1180 }
1181 else
1182 {
1183 /*
1184 * We found a DEAD tuple in the chain. Redirect the root line pointer
1185 * to the first non-DEAD tuple, and mark as unused each intermediate
1186 * item that we are able to remove from the chain.
1187 */
1188 heap_prune_record_redirect(prstate, rootoffnum, chainitems[ndeadchain],
1189 ItemIdIsNormal(rootlp));
1190 for (int i = 1; i < ndeadchain; i++)
1191 heap_prune_record_unused(prstate, chainitems[i], true);
1192
1193 /* the rest of tuples in the chain are normal, unchanged tuples */
1194 for (int i = ndeadchain; i < nchain; i++)
1195 heap_prune_record_unchanged_lp_normal(page, prstate, chainitems[i]);
1196 }
1197}
1198
1199/* Record lowest soon-prunable XID */
1200static void
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}
1212
1213/* Record line pointer to be redirected */
1214static void
1216 OffsetNumber offnum, OffsetNumber rdoffnum,
1217 bool was_normal)
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}
1243
1244/* Record line pointer to be marked dead */
1245static void
1247 bool was_normal)
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}
1272
1273/*
1274 * Depending on whether or not the caller set mark_unused_now to true, record that a
1275 * line pointer should be marked LP_DEAD or LP_UNUSED. There are other cases in
1276 * which we will mark line pointers LP_UNUSED, but we will not mark line
1277 * pointers LP_DEAD if mark_unused_now is true.
1278 */
1279static void
1281 bool was_normal)
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}
1294
1295/* Record line pointer to be marked unused */
1296static void
1297heap_prune_record_unused(PruneState *prstate, OffsetNumber offnum, bool was_normal)
1298{
1299 Assert(!prstate->processed[offnum]);
1300 prstate->processed[offnum] = true;
1301
1303 prstate->nowunused[prstate->nunused] = offnum;
1304 prstate->nunused++;
1305
1306 /*
1307 * If the root entry had been a normal tuple, we are deleting it, so count
1308 * it in the result. But changing a redirect (even to DEAD state) doesn't
1309 * count.
1310 */
1311 if (was_normal)
1312 prstate->ndeleted++;
1313}
1314
1315/*
1316 * Record an unused line pointer that is left unchanged.
1317 */
1318static void
1320{
1321 Assert(!prstate->processed[offnum]);
1322 prstate->processed[offnum] = true;
1323}
1324
1325/*
1326 * Record line pointer that is left unchanged. We consider freezing it, and
1327 * update bookkeeping of tuple counts and page visibility.
1328 */
1329static void
1331{
1332 HeapTupleHeader htup;
1333
1334 Assert(!prstate->processed[offnum]);
1335 prstate->processed[offnum] = true;
1336
1337 prstate->hastup = true; /* the page is not empty */
1338
1339 /*
1340 * The criteria for counting a tuple as live in this block need to match
1341 * what analyze.c's acquire_sample_rows() does, otherwise VACUUM and
1342 * ANALYZE may produce wildly different reltuples values, e.g. when there
1343 * are many recently-dead tuples.
1344 *
1345 * The logic here is a bit simpler than acquire_sample_rows(), as VACUUM
1346 * can't run inside a transaction block, which makes some cases impossible
1347 * (e.g. in-progress insert from the same transaction).
1348 *
1349 * HEAPTUPLE_DEAD are handled by the other heap_prune_record_*()
1350 * subroutines. They don't count dead items like acquire_sample_rows()
1351 * does, because we assume that all dead items will become LP_UNUSED
1352 * before VACUUM finishes. This difference is only superficial. VACUUM
1353 * effectively agrees with ANALYZE about DEAD items, in the end. VACUUM
1354 * won't remember LP_DEAD items, but only because they're not supposed to
1355 * be left behind when it is done. (Cases where we bypass index vacuuming
1356 * will violate this optimistic assumption, but the overall impact of that
1357 * should be negligible.)
1358 */
1359 htup = (HeapTupleHeader) PageGetItem(page, PageGetItemId(page, offnum));
1360
1361 switch (prstate->htsv[offnum])
1362 {
1363 case HEAPTUPLE_LIVE:
1364
1365 /*
1366 * Count it as live. Not only is this natural, but it's also what
1367 * acquire_sample_rows() does.
1368 */
1369 prstate->live_tuples++;
1370
1371 /*
1372 * Is the tuple definitely visible to all transactions?
1373 *
1374 * NB: Like with per-tuple hint bits, we can't set the
1375 * PD_ALL_VISIBLE flag if the inserter committed asynchronously.
1376 * See SetHintBits for more info. Check that the tuple is hinted
1377 * xmin-committed because of that.
1378 */
1379 if (prstate->all_visible)
1380 {
1381 TransactionId xmin;
1382
1384 {
1385 prstate->all_visible = false;
1386 break;
1387 }
1388
1389 /*
1390 * The inserter definitely committed. But is it old enough
1391 * that everyone sees it as committed? A FrozenTransactionId
1392 * is seen as committed to everyone. Otherwise, we check if
1393 * there is a snapshot that considers this xid to still be
1394 * running, and if so, we don't consider the page all-visible.
1395 */
1396 xmin = HeapTupleHeaderGetXmin(htup);
1397
1398 /*
1399 * For now always use prstate->cutoffs for this test, because
1400 * we only update 'all_visible' when freezing is requested. We
1401 * could use GlobalVisTestIsRemovableXid instead, if a
1402 * non-freezing caller wanted to set the VM bit.
1403 */
1404 Assert(prstate->cutoffs);
1405 if (!TransactionIdPrecedes(xmin, prstate->cutoffs->OldestXmin))
1406 {
1407 prstate->all_visible = false;
1408 break;
1409 }
1410
1411 /* Track newest xmin on page. */
1412 if (TransactionIdFollows(xmin, prstate->visibility_cutoff_xid) &&
1414 prstate->visibility_cutoff_xid = xmin;
1415 }
1416 break;
1417
1419 prstate->recently_dead_tuples++;
1420 prstate->all_visible = false;
1421
1422 /*
1423 * This tuple will soon become DEAD. Update the hint field so
1424 * that the page is reconsidered for pruning in future.
1425 */
1428 break;
1429
1431
1432 /*
1433 * We do not count these rows as live, because we expect the
1434 * inserting transaction to update the counters at commit, and we
1435 * assume that will happen only after we report our results. This
1436 * assumption is a bit shaky, but it is what acquire_sample_rows()
1437 * does, so be consistent.
1438 */
1439 prstate->all_visible = false;
1440
1441 /*
1442 * If we wanted to optimize for aborts, we might consider marking
1443 * the page prunable when we see INSERT_IN_PROGRESS. But we
1444 * don't. See related decisions about when to mark the page
1445 * prunable in heapam.c.
1446 */
1447 break;
1448
1450
1451 /*
1452 * This an expected case during concurrent vacuum. Count such
1453 * rows as live. As above, we assume the deleting transaction
1454 * will commit and update the counters after we report.
1455 */
1456 prstate->live_tuples++;
1457 prstate->all_visible = false;
1458
1459 /*
1460 * This tuple may soon become DEAD. Update the hint field so that
1461 * the page is reconsidered for pruning in future.
1462 */
1465 break;
1466
1467 default:
1468
1469 /*
1470 * DEAD tuples should've been passed to heap_prune_record_dead()
1471 * or heap_prune_record_unused() instead.
1472 */
1473 elog(ERROR, "unexpected HeapTupleSatisfiesVacuum result %d",
1474 prstate->htsv[offnum]);
1475 break;
1476 }
1477
1478 /* Consider freezing any normal tuples which will not be removed */
1479 if (prstate->freeze)
1480 {
1481 bool totally_frozen;
1482
1483 if ((heap_prepare_freeze_tuple(htup,
1484 prstate->cutoffs,
1485 &prstate->pagefrz,
1486 &prstate->frozen[prstate->nfrozen],
1487 &totally_frozen)))
1488 {
1489 /* Save prepared freeze plan for later */
1490 prstate->frozen[prstate->nfrozen++].offset = offnum;
1491 }
1492
1493 /*
1494 * If any tuple isn't either totally frozen already or eligible to
1495 * become totally frozen (according to its freeze plan), then the page
1496 * definitely cannot be set all-frozen in the visibility map later on.
1497 */
1498 if (!totally_frozen)
1499 prstate->all_frozen = false;
1500 }
1501}
1502
1503
1504/*
1505 * Record line pointer that was already LP_DEAD and is left unchanged.
1506 */
1507static void
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}
1531
1532/*
1533 * Record LP_REDIRECT that is left unchanged.
1534 */
1535static void
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}
1549
1550/*
1551 * Perform the actual page changes needed by heap_page_prune_and_freeze().
1552 *
1553 * If 'lp_truncate_only' is set, we are merely marking LP_DEAD line pointers
1554 * as unused, not redirecting or removing anything else. The
1555 * PageRepairFragmentation() call is skipped in that case.
1556 *
1557 * If 'lp_truncate_only' is not set, the caller must hold a cleanup lock on
1558 * the buffer. If it is set, an ordinary exclusive lock suffices.
1559 */
1560void
1561heap_page_prune_execute(Buffer buffer, bool lp_truncate_only,
1562 OffsetNumber *redirected, int nredirected,
1563 OffsetNumber *nowdead, int ndead,
1564 OffsetNumber *nowunused, int nunused)
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 {
1652 htup = (HeapTupleHeader) PageGetItem(page, lp);
1654 }
1655 else
1656 {
1657 /* Whole HOT chain becomes dead */
1659 }
1660#endif
1661
1662 ItemIdSetDead(lp);
1663 }
1664
1665 /* Update all now-unused line pointers */
1666 offnum = nowunused;
1667 for (int i = 0; i < nunused; i++)
1668 {
1669 OffsetNumber off = *offnum++;
1670 ItemId lp = PageGetItemId(page, off);
1671
1672#ifdef USE_ASSERT_CHECKING
1673
1674 if (lp_truncate_only)
1675 {
1676 /* Setting LP_DEAD to LP_UNUSED in vacuum's second pass */
1678 }
1679 else
1680 {
1681 /*
1682 * When heap_page_prune_and_freeze() was called, mark_unused_now
1683 * may have been passed as true, which allows would-be LP_DEAD
1684 * items to be made LP_UNUSED instead. This is only possible if
1685 * the relation has no indexes. If there are any dead items, then
1686 * mark_unused_now was not true and every item being marked
1687 * LP_UNUSED must refer to a heap-only tuple.
1688 */
1689 if (ndead > 0)
1690 {
1692 htup = (HeapTupleHeader) PageGetItem(page, lp);
1694 }
1695 else
1696 Assert(ItemIdIsUsed(lp));
1697 }
1698
1699#endif
1700
1701 ItemIdSetUnused(lp);
1702 }
1703
1704 if (lp_truncate_only)
1706 else
1707 {
1708 /*
1709 * Finally, repair any fragmentation, and update the page's hint bit
1710 * about whether it has free pointers.
1711 */
1713
1714 /*
1715 * Now that the page has been modified, assert that redirect items
1716 * still point to valid targets.
1717 */
1719 }
1720}
1721
1722
1723/*
1724 * If built with assertions, verify that all LP_REDIRECT items point to a
1725 * valid item.
1726 *
1727 * One way that bugs related to HOT pruning show is redirect items pointing to
1728 * removed tuples. It's not trivial to reliably check that marking an item
1729 * unused will not orphan a redirect item during heap_prune_chain() /
1730 * heap_page_prune_execute(), so we additionally check the whole page after
1731 * pruning. Without this check such bugs would typically only cause asserts
1732 * later, potentially well after the corruption has been introduced.
1733 *
1734 * Also check comments in heap_page_prune_execute()'s redirection loop.
1735 */
1736static void
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}
1767
1768
1769/*
1770 * For all items in this page, find their respective root line pointers.
1771 * If item k is part of a HOT-chain with root at item j, then we set
1772 * root_offsets[k - 1] = j.
1773 *
1774 * The passed-in root_offsets array must have MaxHeapTuplesPerPage entries.
1775 * Unused entries are filled with InvalidOffsetNumber (zero).
1776 *
1777 * The function must be called with at least share lock on the buffer, to
1778 * prevent concurrent prune operations.
1779 *
1780 * Note: The information collected here is valid only as long as the caller
1781 * holds a pin on the buffer. Once pin is released, a tuple might be pruned
1782 * and reused by a completely unrelated tuple.
1783 */
1784void
1786{
1787 OffsetNumber offnum,
1788 maxoff;
1789
1790 MemSet(root_offsets, InvalidOffsetNumber,
1792
1793 maxoff = PageGetMaxOffsetNumber(page);
1794 for (offnum = FirstOffsetNumber; offnum <= maxoff; offnum = OffsetNumberNext(offnum))
1795 {
1796 ItemId lp = PageGetItemId(page, offnum);
1797 HeapTupleHeader htup;
1798 OffsetNumber nextoffnum;
1799 TransactionId priorXmax;
1800
1801 /* skip unused and dead items */
1802 if (!ItemIdIsUsed(lp) || ItemIdIsDead(lp))
1803 continue;
1804
1805 if (ItemIdIsNormal(lp))
1806 {
1807 htup = (HeapTupleHeader) PageGetItem(page, lp);
1808
1809 /*
1810 * Check if this tuple is part of a HOT-chain rooted at some other
1811 * tuple. If so, skip it for now; we'll process it when we find
1812 * its root.
1813 */
1814 if (HeapTupleHeaderIsHeapOnly(htup))
1815 continue;
1816
1817 /*
1818 * This is either a plain tuple or the root of a HOT-chain.
1819 * Remember it in the mapping.
1820 */
1821 root_offsets[offnum - 1] = offnum;
1822
1823 /* If it's not the start of a HOT-chain, we're done with it */
1824 if (!HeapTupleHeaderIsHotUpdated(htup))
1825 continue;
1826
1827 /* Set up to scan the HOT-chain */
1828 nextoffnum = ItemPointerGetOffsetNumber(&htup->t_ctid);
1829 priorXmax = HeapTupleHeaderGetUpdateXid(htup);
1830 }
1831 else
1832 {
1833 /* Must be a redirect item. We do not set its root_offsets entry */
1835 /* Set up to scan the HOT-chain */
1836 nextoffnum = ItemIdGetRedirect(lp);
1837 priorXmax = InvalidTransactionId;
1838 }
1839
1840 /*
1841 * Now follow the HOT-chain and collect other tuples in the chain.
1842 *
1843 * Note: Even though this is a nested loop, the complexity of the
1844 * function is O(N) because a tuple in the page should be visited not
1845 * more than twice, once in the outer loop and once in HOT-chain
1846 * chases.
1847 */
1848 for (;;)
1849 {
1850 /* Sanity check (pure paranoia) */
1851 if (offnum < FirstOffsetNumber)
1852 break;
1853
1854 /*
1855 * An offset past the end of page's line pointer array is possible
1856 * when the array was truncated
1857 */
1858 if (offnum > maxoff)
1859 break;
1860
1861 lp = PageGetItemId(page, nextoffnum);
1862
1863 /* Check for broken chains */
1864 if (!ItemIdIsNormal(lp))
1865 break;
1866
1867 htup = (HeapTupleHeader) PageGetItem(page, lp);
1868
1869 if (TransactionIdIsValid(priorXmax) &&
1871 break;
1872
1873 /* Remember the root line pointer for this item */
1874 root_offsets[nextoffnum - 1] = offnum;
1875
1876 /* Advance to next chain member, if any */
1877 if (!HeapTupleHeaderIsHotUpdated(htup))
1878 break;
1879
1880 /* HOT implies it can't have moved to different partition */
1882
1883 nextoffnum = ItemPointerGetOffsetNumber(&htup->t_ctid);
1884 priorXmax = HeapTupleHeaderGetUpdateXid(htup);
1885 }
1886 }
1887}
1888
1889
1890/*
1891 * Compare fields that describe actions required to freeze tuple with caller's
1892 * open plan. If everything matches then the frz tuple plan is equivalent to
1893 * caller's plan.
1894 */
1895static inline bool
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}
1907
1908/*
1909 * Comparator used to deduplicate the freeze plans used in WAL records.
1910 */
1911static int
1912heap_log_freeze_cmp(const void *arg1, const void *arg2)
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}
1952
1953/*
1954 * Start new plan initialized using tuple-level actions. At least one tuple
1955 * will have steps required to freeze described by caller's plan during REDO.
1956 */
1957static inline void
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}
1966
1967/*
1968 * Deduplicate tuple-based freeze plans so that each distinct set of
1969 * processing steps is only stored once in the WAL record.
1970 * Called during original execution of freezing (for logged relations).
1971 *
1972 * Return value is number of plans set in *plans_out for caller. Also writes
1973 * an array of offset numbers into *offsets_out output argument for caller
1974 * (actually there is one array per freeze plan, but that's not of immediate
1975 * concern to our caller).
1976 */
1977static int
1979 xlhp_freeze_plan *plans_out,
1980 OffsetNumber *offsets_out)
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}
2027
2028/*
2029 * Write an XLOG_HEAP2_PRUNE_FREEZE WAL record
2030 *
2031 * This is used for several different page maintenance operations:
2032 *
2033 * - Page pruning, in VACUUM's 1st pass or on access: Some items are
2034 * redirected, some marked dead, and some removed altogether.
2035 *
2036 * - Freezing: Items are marked as 'frozen'.
2037 *
2038 * - Vacuum, 2nd pass: Items that are already LP_DEAD are marked as unused.
2039 *
2040 * They have enough commonalities that we use a single WAL record for them
2041 * all.
2042 *
2043 * If replaying the record requires a cleanup lock, pass cleanup_lock = true.
2044 * Replaying 'redirected' or 'dead' items always requires a cleanup lock, but
2045 * replaying 'unused' items depends on whether they were all previously marked
2046 * as dead.
2047 *
2048 * Note: This function scribbles on the 'frozen' array.
2049 *
2050 * Note: This is called in a critical section, so careful what you do here.
2051 */
2052void
2054 TransactionId conflict_xid,
2055 bool cleanup_lock,
2056 PruneReason reason,
2057 HeapTupleFreeze *frozen, int nfrozen,
2058 OffsetNumber *redirected, int nredirected,
2059 OffsetNumber *dead, int ndead,
2060 OffsetNumber *unused, int nunused)
2061{
2062 xl_heap_prune xlrec;
2063 XLogRecPtr recptr;
2064 uint8 info;
2065
2066 /* The following local variables hold data registered in the WAL record: */
2068 xlhp_freeze_plans freeze_plans;
2069 xlhp_prune_items redirect_items;
2070 xlhp_prune_items dead_items;
2071 xlhp_prune_items unused_items;
2073
2074 xlrec.flags = 0;
2075
2076 /*
2077 * Prepare data for the buffer. The arrays are not actually in the
2078 * buffer, but we pretend that they are. When XLogInsert stores a full
2079 * page image, the arrays can be omitted.
2080 */
2083 if (nfrozen > 0)
2084 {
2085 int nplans;
2086
2088
2089 /*
2090 * Prepare deduplicated representation for use in the WAL record. This
2091 * destructively sorts frozen tuples array in-place.
2092 */
2093 nplans = heap_log_freeze_plan(frozen, nfrozen, plans, frz_offsets);
2094
2095 freeze_plans.nplans = nplans;
2096 XLogRegisterBufData(0, (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 {
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;
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}
uint32 BlockNumber
Definition: block.h:31
int Buffer
Definition: buf.h:23
BlockNumber BufferGetBlockNumber(Buffer buffer)
Definition: bufmgr.c:3724
void MarkBufferDirty(Buffer buffer)
Definition: bufmgr.c:2532
void LockBuffer(Buffer buffer, int mode)
Definition: bufmgr.c:5158
void MarkBufferDirtyHint(Buffer buffer, bool buffer_std)
Definition: bufmgr.c:4988
bool ConditionalLockBufferForCleanup(Buffer buffer)
Definition: bufmgr.c:5399
#define BUFFER_LOCK_UNLOCK
Definition: bufmgr.h:189
static Page BufferGetPage(Buffer buffer)
Definition: bufmgr.h:400
Size PageGetHeapFreeSpace(Page page)
Definition: bufpage.c:980
void PageRepairFragmentation(Page page)
Definition: bufpage.c:688
void PageTruncateLinePointerArray(Page page)
Definition: bufpage.c:824
PageHeaderData * PageHeader
Definition: bufpage.h:173
Pointer Page
Definition: bufpage.h:81
static Item PageGetItem(Page page, ItemId itemId)
Definition: bufpage.h:354
static void PageClearFull(Page page)
Definition: bufpage.h:423
static ItemId PageGetItemId(Page page, OffsetNumber offsetNumber)
Definition: bufpage.h:243
static void PageSetLSN(Page page, XLogRecPtr lsn)
Definition: bufpage.h:391
static bool PageIsFull(Page page)
Definition: bufpage.h:413
static OffsetNumber PageGetMaxOffsetNumber(Page page)
Definition: bufpage.h:372
#define likely(x)
Definition: c.h:329
uint8_t uint8
Definition: c.h:483
#define PG_USED_FOR_ASSERTS_ONLY
Definition: c.h:201
#define Max(x, y)
Definition: c.h:952
#define Assert(condition)
Definition: c.h:812
int64_t int64
Definition: c.h:482
TransactionId MultiXactId
Definition: c.h:616
int8_t int8
Definition: c.h:479
#define unlikely(x)
Definition: c.h:330
#define MemSet(start, val, len)
Definition: c.h:974
uint32 TransactionId
Definition: c.h:606
size_t Size
Definition: c.h:559
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:225
void HeapTupleHeaderAdvanceConflictHorizon(HeapTupleHeader tuple, TransactionId *snapshotConflictHorizon)
Definition: heapam.c:7814
void heap_freeze_prepared_tuples(Buffer buffer, HeapTupleFreeze *tuples, int ntuples)
Definition: heapam.c:7223
bool heap_prepare_freeze_tuple(HeapTupleHeader tuple, const struct VacuumCutoffs *cutoffs, HeapPageFreeze *pagefrz, HeapTupleFreeze *frz, bool *totally_frozen)
Definition: heapam.c:6897
void heap_pre_freeze_checks(Buffer buffer, HeapTupleFreeze *tuples, int ntuples)
Definition: heapam.c:7170
#define HEAP_PAGE_PRUNE_FREEZE
Definition: heapam.h:43
HTSV_Result
Definition: heapam.h:125
@ 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
@ HEAPTUPLE_DEAD
Definition: heapam.h:126
PruneReason
Definition: heapam.h:269
@ PRUNE_VACUUM_CLEANUP
Definition: heapam.h:272
@ PRUNE_ON_ACCESS
Definition: heapam.h:270
@ PRUNE_VACUUM_SCAN
Definition: heapam.h:271
#define HEAP_PAGE_PRUNE_MARK_UNUSED_NOW
Definition: heapam.h:42
HTSV_Result HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer, TransactionId *dead_after)
#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
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 HeapTupleHeaderXminCommitted(tup)
Definition: htup_details.h:320
#define MaxHeapTuplesPerPage
Definition: htup_details.h:572
#define HeapTupleHeaderGetUpdateXid(tup)
Definition: htup_details.h:361
#define HeapTupleHeaderIsHotUpdated(tup)
Definition: htup_details.h:482
WalUsage pgWalUsage
Definition: instrument.c:22
int i
Definition: isn.c:72
#define ItemIdGetLength(itemId)
Definition: itemid.h:59
#define ItemIdSetRedirect(itemId, link)
Definition: itemid.h:152
#define ItemIdIsNormal(itemId)
Definition: itemid.h:99
#define ItemIdGetRedirect(itemId)
Definition: itemid.h:78
#define ItemIdIsDead(itemId)
Definition: itemid.h:113
#define ItemIdSetDead(itemId)
Definition: itemid.h:164
#define ItemIdIsUsed(itemId)
Definition: itemid.h:92
#define ItemIdSetUnused(itemId)
Definition: itemid.h:128
#define ItemIdIsRedirected(itemId)
Definition: itemid.h:106
#define ItemIdHasStorage(itemId)
Definition: itemid.h:120
static void ItemPointerSet(ItemPointerData *pointer, BlockNumber blockNumber, OffsetNumber offNum)
Definition: itemptr.h:135
static OffsetNumber ItemPointerGetOffsetNumber(const ItemPointerData *pointer)
Definition: itemptr.h:124
static BlockNumber ItemPointerGetBlockNumber(const ItemPointerData *pointer)
Definition: itemptr.h:103
#define START_CRIT_SECTION()
Definition: miscadmin.h:149
#define END_CRIT_SECTION()
Definition: miscadmin.h:151
#define InvalidMultiXactId
Definition: multixact.h:24
#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
#define OffsetNumberPrev(offsetNumber)
Definition: off.h:54
const void * data
#define plan(x)
Definition: pg_regress.c:161
void pgstat_update_heap_dead_tuples(Relation rel, int delta)
#define qsort(a, b, c, d)
Definition: port.h:447
bool GlobalVisTestIsRemovableXid(GlobalVisState *state, TransactionId xid)
Definition: procarray.c:4264
GlobalVisState * GlobalVisTestFor(Relation rel)
Definition: procarray.c:4107
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
void heap_get_root_tuples(Page page, OffsetNumber *root_offsets)
Definition: pruneheap.c:1785
void heap_page_prune_opt(Relation relation, Buffer buffer)
Definition: pruneheap.c:193
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
static HTSV_Result htsv_get_valid_status(int status)
Definition: pruneheap.c:960
static int heap_log_freeze_plan(HeapTupleFreeze *tuples, int ntuples, xlhp_freeze_plan *plans_out, OffsetNumber *offsets_out)
Definition: pruneheap.c:1978
static void page_verify_redirects(Page page)
Definition: pruneheap.c:1737
static void heap_prune_record_unused(PruneState *prstate, OffsetNumber offnum, bool was_normal)
Definition: pruneheap.c:1297
static void heap_prune_record_redirect(PruneState *prstate, OffsetNumber offnum, OffsetNumber rdoffnum, bool was_normal)
Definition: pruneheap.c:1215
static void heap_prune_record_unchanged_lp_normal(Page page, PruneState *prstate, OffsetNumber offnum)
Definition: pruneheap.c:1330
static int heap_log_freeze_cmp(const void *arg1, const void *arg2)
Definition: pruneheap.c:1912
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_dead(PruneState *prstate, OffsetNumber offnum, bool was_normal)
Definition: pruneheap.c:1246
static bool heap_log_freeze_eq(xlhp_freeze_plan *plan, HeapTupleFreeze *frz)
Definition: pruneheap.c:1896
static void heap_prune_record_prunable(PruneState *prstate, TransactionId xid)
Definition: pruneheap.c:1201
static void heap_prune_record_unchanged_lp_unused(Page page, PruneState *prstate, OffsetNumber offnum)
Definition: pruneheap.c:1319
static void heap_log_freeze_new_plan(xlhp_freeze_plan *plan, HeapTupleFreeze *frz)
Definition: pruneheap.c:1958
static HTSV_Result heap_prune_satisfies_vacuum(PruneState *prstate, HeapTuple tup, Buffer buffer)
Definition: pruneheap.c:917
static void heap_prune_record_dead_or_unused(PruneState *prstate, OffsetNumber offnum, bool was_normal)
Definition: pruneheap.c:1280
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
static void heap_prune_record_unchanged_lp_redirect(PruneState *prstate, OffsetNumber offnum)
Definition: pruneheap.c:1536
#define RelationGetRelid(relation)
Definition: rel.h:505
#define RelationGetTargetPageFreeSpace(relation, defaultff)
Definition: rel.h:378
#define RelationIsAccessibleInLogicalDecoding(relation)
Definition: rel.h:684
#define RelationNeedsWAL(relation)
Definition: rel.h:628
#define HEAP_DEFAULT_FILLFACTOR
Definition: rel.h:349
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
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
ItemPointerData t_ctid
Definition: htup_details.h:161
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 TransactionIdPrecedes(TransactionId id1, TransactionId id2)
Definition: transam.c:280
bool TransactionIdFollows(TransactionId id1, TransactionId id2)
Definition: transam.c:314
#define TransactionIdRetreat(dest)
Definition: transam.h:141
#define InvalidTransactionId
Definition: transam.h:31
#define TransactionIdEquals(id1, id2)
Definition: transam.h:43
#define NormalTransactionIdPrecedes(id1, id2)
Definition: transam.h:147
#define TransactionIdIsValid(xid)
Definition: transam.h:41
#define TransactionIdIsNormal(xid)
Definition: transam.h:42
bool RecoveryInProgress(void)
Definition: xlog.c:6334
#define XLogHintBitIsNeeded()
Definition: xlog.h:120
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
bool XLogCheckBufferNeedsBackup(Buffer buffer)
Definition: xloginsert.c:1027
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