| blob | 98ccb98825bc320e33dd1972070c14e9c778f445 |
1 /*-------------------------------------------------------------------------
2 *
3 * vacuumlazy.c
4 * Concurrent ("lazy") vacuuming.
5 *
6 * The major space usage for vacuuming is storage for the array of dead TIDs
7 * that are to be removed from indexes. We want to ensure we can vacuum even
8 * the very largest relations with finite memory space usage. To do that, we
9 * set upper bounds on the number of TIDs we can keep track of at once.
10 *
11 * We are willing to use at most maintenance_work_mem (or perhaps
12 * autovacuum_work_mem) memory space to keep track of dead TIDs. We initially
13 * allocate an array of TIDs of that size, with an upper limit that depends on
14 * table size (this limit ensures we don't allocate a huge area uselessly for
15 * vacuuming small tables). If the array threatens to overflow, we must call
16 * lazy_vacuum to vacuum indexes (and to vacuum the pages that we've pruned).
17 * This frees up the memory space dedicated to storing dead TIDs.
18 *
19 * In practice VACUUM will often complete its initial pass over the target
20 * heap relation without ever running out of space to store TIDs. This means
21 * that there only needs to be one call to lazy_vacuum, after the initial pass
22 * completes.
23 *
24 * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
25 * Portions Copyright (c) 1994, Regents of the University of California
26 *
27 *
28 * IDENTIFICATION
29 * src/backend/access/heap/vacuumlazy.c
30 *
31 *-------------------------------------------------------------------------
32 */
35 #include <math.h>
69 /*
70 * Space/time tradeoff parameters: do these need to be user-tunable?
71 *
72 * To consider truncating the relation, we want there to be at least
73 * REL_TRUNCATE_MINIMUM or (relsize / REL_TRUNCATE_FRACTION) (whichever
74 * is less) potentially-freeable pages.
75 */
76 #define REL_TRUNCATE_MINIMUM 1000
77 #define REL_TRUNCATE_FRACTION 16
79 /*
80 * Timing parameters for truncate locking heuristics.
81 *
82 * These were not exposed as user tunable GUC values because it didn't seem
83 * that the potential for improvement was great enough to merit the cost of
84 * supporting them.
85 */
90 /*
91 * Threshold that controls whether we bypass index vacuuming and heap
92 * vacuuming as an optimization
93 */
96 /*
97 * Perform a failsafe check each time we scan another 4GB of pages.
98 * (Note that this is deliberately kept to a power-of-two, usually 2^19.)
99 */
100 #define FAILSAFE_EVERY_PAGES \
101 ((BlockNumber) (((uint64) 4 * 1024 * 1024 * 1024) / BLCKSZ))
103 /*
104 * When a table has no indexes, vacuum the FSM after every 8GB, approximately
105 * (it won't be exact because we only vacuum FSM after processing a heap page
106 * that has some removable tuples). When there are indexes, this is ignored,
107 * and we vacuum FSM after each index/heap cleaning pass.
108 */
109 #define VACUUM_FSM_EVERY_PAGES \
110 ((BlockNumber) (((uint64) 8 * 1024 * 1024 * 1024) / BLCKSZ))
112 /*
113 * Before we consider skipping a page that's marked as clean in
114 * visibility map, we must've seen at least this many clean pages.
115 */
116 #define SKIP_PAGES_THRESHOLD ((BlockNumber) 32)
118 /*
119 * Size of the prefetch window for lazy vacuum backwards truncation scan.
120 * Needs to be a power of 2.
121 */
122 #define PREFETCH_SIZE ((BlockNumber) 32)
124 /*
125 * Macro to check if we are in a parallel vacuum. If true, we are in the
126 * parallel mode and the DSM segment is initialized.
127 */
128 #define ParallelVacuumIsActive(vacrel) ((vacrel)->pvs != NULL)
130 /* Phases of vacuum during which we report error context. */
132 {
133 VACUUM_ERRCB_PHASE_UNKNOWN,
134 VACUUM_ERRCB_PHASE_SCAN_HEAP,
135 VACUUM_ERRCB_PHASE_VACUUM_INDEX,
136 VACUUM_ERRCB_PHASE_VACUUM_HEAP,
137 VACUUM_ERRCB_PHASE_INDEX_CLEANUP,
138 VACUUM_ERRCB_PHASE_TRUNCATE
142 {
143 /* Target heap relation and its indexes */
144 Relation rel;
148 /* Buffer access strategy and parallel vacuum state */
149 BufferAccessStrategy bstrategy;
152 /* Aggressive VACUUM? (must set relfrozenxid >= FreezeLimit) */
154 /* Use visibility map to skip? (disabled by DISABLE_PAGE_SKIPPING) */
156 /* Wraparound failsafe has been triggered? */
158 /* Consider index vacuuming bypass optimization? */
161 /* Doing index vacuuming, index cleanup, rel truncation? */
166 /* VACUUM operation's cutoffs for freezing and pruning */
169 /* Tracks oldest extant XID/MXID for setting relfrozenxid/relminmxid */
170 TransactionId NewRelfrozenXid;
171 MultiXactId NewRelminMxid;
174 /* Error reporting state */
180 VacErrPhase phase;
183 /*
184 * dead_items stores TIDs whose index tuples are deleted by index
185 * vacuuming. Each TID points to an LP_DEAD line pointer from a heap page
186 * that has been processed by lazy_scan_prune. Also needed by
187 * lazy_vacuum_heap_rel, which marks the same LP_DEAD line pointers as
188 * LP_UNUSED during second heap pass.
189 */
199 /* Statistics output by us, for table */
202 /* Statistics output by index AMs */
205 /* Instrumentation counters */
207 /* Counters that follow are only for scanned_pages */
216 /*
217 * State returned by lazy_scan_prune()
218 */
220 {
224 /*
225 * State describes the proper VM bit states to set for the page following
226 * pruning and freezing. all_visible implies !has_lpdead_items, but don't
227 * trust all_frozen result unless all_visible is also set to true.
228 */
234 /* Struct for saving and restoring vacuum error information. */
236 {
237 BlockNumber blkno;
238 OffsetNumber offnum;
239 VacErrPhase phase;
243 /* non-export function prototypes */
246 BlockNumber next_block,
287 OffsetNumber offnum);
292 /*
293 * heap_vacuum_rel() -- perform VACUUM for one heap relation
294 *
295 * This routine sets things up for and then calls lazy_scan_heap, where
296 * almost all work actually takes place. Finalizes everything after call
297 * returns by managing relation truncation and updating rel's pg_class
298 * entry. (Also updates pg_class entries for any indexes that need it.)
299 *
300 * At entry, we have already established a transaction and opened
301 * and locked the relation.
302 */
303 void
305 BufferAccessStrategy bstrategy)
306 {
309 instrument,
310 skipwithvm,
311 frozenxid_updated,
312 minmulti_updated;
313 BlockNumber orig_rel_pages,
314 new_rel_pages,
315 new_rel_allvisible;
316 PGRUsage ru0;
324 ErrorContextCallback errcallback;
331 {
335 {
338 }
339 }
344 /*
345 * Setup error traceback support for ereport() first. The idea is to set
346 * up an error context callback to display additional information on any
347 * error during a vacuum. During different phases of vacuum, we update
348 * the state so that the error context callback always display current
349 * information.
350 *
351 * Copy the names of heap rel into local memory for error reporting
352 * purposes, too. It isn't always safe to assume that we can get the name
353 * of each rel. It's convenient for code in lazy_scan_heap to always use
354 * these temp copies.
355 */
367 /* Set up high level stuff about rel and its indexes */
373 {
374 /* Copy index names used by instrumentation (not error reporting) */
378 }
380 /*
381 * The index_cleanup param either disables index vacuuming and cleanup or
382 * forces it to go ahead when we would otherwise apply the index bypass
383 * optimization. The default is 'auto', which leaves the final decision
384 * up to lazy_vacuum().
385 *
386 * The truncate param allows user to avoid attempting relation truncation,
387 * though it can't force truncation to happen.
388 */
398 {
399 /* Force disable index vacuuming up-front */
402 }
404 {
405 /* Force index vacuuming. Note that failsafe can still bypass. */
407 }
408 else
409 {
410 /* Default/auto, make all decisions dynamically */
412 }
414 /* Initialize page counters explicitly (be tidy) */
421 /* dead_items_alloc allocates vacrel->dead_items later on */
423 /* Allocate/initialize output statistics state */
429 /* Initialize remaining counters (be tidy) */
438 /*
439 * Get cutoffs that determine which deleted tuples are considered DEAD,
440 * not just RECENTLY_DEAD, and which XIDs/MXIDs to freeze. Then determine
441 * the extent of the blocks that we'll scan in lazy_scan_heap. It has to
442 * happen in this order to ensure that the OldestXmin cutoff field works
443 * as an upper bound on the XIDs stored in the pages we'll actually scan
444 * (NewRelfrozenXid tracking must never be allowed to miss unfrozen XIDs).
445 *
446 * Next acquire vistest, a related cutoff that's used in heap_page_prune.
447 * We expect vistest will always make heap_page_prune remove any deleted
448 * tuple whose xmax is < OldestXmin. lazy_scan_prune must never become
449 * confused about whether a tuple should be frozen or removed. (In the
450 * future we might want to teach lazy_scan_prune to recompute vistest from
451 * time to time, to increase the number of dead tuples it can prune away.)
452 */
456 /* Initialize state used to track oldest extant XID/MXID */
462 {
463 /*
464 * Force aggressive mode, and disable skipping blocks using the
465 * visibility map (even those set all-frozen)
466 */
469 }
474 {
480 else
485 }
487 /*
488 * Allocate dead_items array memory using dead_items_alloc. This handles
489 * parallel VACUUM initialization as part of allocating shared memory
490 * space used for dead_items. (But do a failsafe precheck first, to
491 * ensure that parallel VACUUM won't be attempted at all when relfrozenxid
492 * is already dangerously old.)
493 */
497 /*
498 * Call lazy_scan_heap to perform all required heap pruning, index
499 * vacuuming, and heap vacuuming (plus related processing)
500 */
503 /*
504 * Free resources managed by dead_items_alloc. This ends parallel mode in
505 * passing when necessary.
506 */
510 /*
511 * Update pg_class entries for each of rel's indexes where appropriate.
512 *
513 * Unlike the later update to rel's pg_class entry, this is not critical.
514 * Maintains relpages/reltuples statistics used by the planner only.
515 */
519 /* Done with rel's indexes */
522 /* Optionally truncate rel */
526 /* Pop the error context stack */
529 /* Report that we are now doing final cleanup */
531 PROGRESS_VACUUM_PHASE_FINAL_CLEANUP);
533 /*
534 * Prepare to update rel's pg_class entry.
535 *
536 * Aggressive VACUUMs must always be able to advance relfrozenxid to a
537 * value >= FreezeLimit, and relminmxid to a value >= MultiXactCutoff.
538 * Non-aggressive VACUUMs may advance them by any amount, or not at all.
539 */
549 {
550 /*
551 * Must keep original relfrozenxid in a non-aggressive VACUUM that
552 * chose to skip an all-visible page range. The state that tracks new
553 * values will have missed unfrozen XIDs from the pages we skipped.
554 */
558 }
560 /*
561 * For safety, clamp relallvisible to be not more than what we're setting
562 * pg_class.relpages to
563 */
569 /*
570 * Now actually update rel's pg_class entry.
571 *
572 * In principle new_live_tuples could be -1 indicating that we (still)
573 * don't know the tuple count. In practice that can't happen, since we
574 * scan every page that isn't skipped using the visibility map.
575 */
581 /*
582 * Report results to the cumulative stats system, too.
583 *
584 * Deliberately avoid telling the stats system about LP_DEAD items that
585 * remain in the table due to VACUUM bypassing index and heap vacuuming.
586 * ANALYZE will consider the remaining LP_DEAD items to be dead "tuples".
587 * It seems like a good idea to err on the side of not vacuuming again too
588 * soon in cases where the failsafe prevented significant amounts of heap
589 * vacuuming.
590 */
599 {
605 {
608 WalUsage walusage;
609 StringInfoData buf;
611 int32 diff;
624 {
625 /*
626 * Aggressiveness already reported earlier, in dedicated
627 * VACUUM VERBOSE ereport
628 */
631 }
633 {
634 /*
635 * While it's possible for a VACUUM to be both is_wraparound
636 * and !aggressive, that's just a corner-case -- is_wraparound
637 * implies aggressive. Produce distinct output for the corner
638 * case all the same, just in case.
639 */
641 msgfmt = _("automatic aggressive vacuum to prevent wraparound of table \"%s.%s.%s\": index scans: %d\n");
642 else
644 }
645 else
646 {
649 else
651 }
659 new_rel_pages,
679 {
685 }
687 {
693 }
694 appendStringInfo(&buf, _("frozen: %u pages from table (%.2f%% of total) had %lld tuples frozen\n"),
700 {
703 else
707 }
708 else
709 {
712 else
716 }
723 {
736 }
738 {
744 }
746 {
751 }
769 }
770 }
772 /* Cleanup index statistics and index names */
774 {
780 }
781 }
783 /*
784 * lazy_scan_heap() -- workhorse function for VACUUM
785 *
786 * This routine prunes each page in the heap, and considers the need to
787 * freeze remaining tuples with storage (not including pages that can be
788 * skipped using the visibility map). Also performs related maintenance
789 * of the FSM and visibility map. These steps all take place during an
790 * initial pass over the target heap relation.
791 *
792 * Also invokes lazy_vacuum_all_indexes to vacuum indexes, which largely
793 * consists of deleting index tuples that point to LP_DEAD items left in
794 * heap pages following pruning. Earlier initial pass over the heap will
795 * have collected the TIDs whose index tuples need to be removed.
796 *
797 * Finally, invokes lazy_vacuum_heap_rel to vacuum heap pages, which
798 * largely consists of marking LP_DEAD items (from collected TID array)
799 * as LP_UNUSED. This has to happen in a second, final pass over the
800 * heap, to preserve a basic invariant that all index AMs rely on: no
801 * extant index tuple can ever be allowed to contain a TID that points to
802 * an LP_UNUSED line pointer in the heap. We must disallow premature
803 * recycling of line pointers to avoid index scans that get confused
804 * about which TID points to which tuple immediately after recycling.
805 * (Actually, this isn't a concern when target heap relation happens to
806 * have no indexes, which allows us to safely apply the one-pass strategy
807 * as an optimization).
808 *
809 * In practice we often have enough space to fit all TIDs, and so won't
810 * need to call lazy_vacuum more than once, after our initial pass over
811 * the heap has totally finished. Otherwise things are slightly more
812 * complicated: our "initial pass" over the heap applies only to those
813 * pages that were pruned before we needed to call lazy_vacuum, and our
814 * "final pass" over the heap only vacuums these same heap pages.
815 * However, we process indexes in full every time lazy_vacuum is called,
816 * which makes index processing very inefficient when memory is in short
817 * supply.
818 */
819 static void
821 {
823 blkno,
824 next_unskippable_block,
829 skipping_current_range;
831 PROGRESS_VACUUM_PHASE,
832 PROGRESS_VACUUM_TOTAL_HEAP_BLKS,
833 PROGRESS_VACUUM_MAX_DEAD_TUPLES
834 };
837 /* Report that we're scanning the heap, advertising total # of blocks */
843 /* Set up an initial range of skippable blocks using the visibility map */
848 {
849 Buffer buf;
850 Page page;
852 LVPagePruneState prunestate;
855 {
856 /*
857 * Can't skip this page safely. Must scan the page. But
858 * determine the next skippable range after the page first.
859 */
867 }
868 else
869 {
870 /* Last page always scanned (may need to set nonempty_pages) */
876 /* Current range is too small to skip -- just scan the page */
878 }
882 /* Report as block scanned, update error traceback information */
889 /*
890 * Regularly check if wraparound failsafe should trigger.
891 *
892 * There is a similar check inside lazy_vacuum_all_indexes(), but
893 * relfrozenxid might start to look dangerously old before we reach
894 * that point. This check also provides failsafe coverage for the
895 * one-pass strategy, and the two-pass strategy with the index_cleanup
896 * param set to 'off'.
897 */
901 /*
902 * Consider if we definitely have enough space to process TIDs on page
903 * already. If we are close to overrunning the available space for
904 * dead_items TIDs, pause and do a cycle of vacuuming before we tackle
905 * this page.
906 */
909 {
910 /*
911 * Before beginning index vacuuming, we release any pin we may
912 * hold on the visibility map page. This isn't necessary for
913 * correctness, but we do it anyway to avoid holding the pin
914 * across a lengthy, unrelated operation.
915 */
917 {
920 }
922 /* Perform a round of index and heap vacuuming */
926 /*
927 * Vacuum the Free Space Map to make newly-freed space visible on
928 * upper-level FSM pages. Note we have not yet processed blkno.
929 */
931 blkno);
934 /* Report that we are once again scanning the heap */
936 PROGRESS_VACUUM_PHASE_SCAN_HEAP);
937 }
939 /*
940 * Pin the visibility map page in case we need to mark the page
941 * all-visible. In most cases this will be very cheap, because we'll
942 * already have the correct page pinned anyway.
943 */
946 /* Finished preparatory checks. Actually scan the page. */
951 /*
952 * We need a buffer cleanup lock to prune HOT chains and defragment
953 * the page in lazy_scan_prune. But when it's not possible to acquire
954 * a cleanup lock right away, we may be able to settle for reduced
955 * processing using lazy_scan_noprune.
956 */
958 {
960 recordfreespace;
964 /* Check for new or empty pages before lazy_scan_noprune call */
966 vmbuffer))
967 {
968 /* Processed as new/empty page (lock and pin released) */
970 }
972 /* Collect LP_DEAD items in dead_items array, count tuples */
975 {
978 /*
979 * Processed page successfully (without cleanup lock) -- just
980 * need to perform rel truncation and FSM steps, much like the
981 * lazy_scan_prune case. Don't bother trying to match its
982 * visibility map setting steps, though.
983 */
992 }
994 /*
995 * lazy_scan_noprune could not do all required processing. Wait
996 * for a cleanup lock, and call lazy_scan_prune in the usual way.
997 */
1001 }
1003 /* Check for new or empty pages before lazy_scan_prune call */
1005 {
1006 /* Processed as new/empty page (lock and pin released) */
1008 }
1010 /*
1011 * Prune, freeze, and count tuples.
1012 *
1013 * Accumulates details of remaining LP_DEAD line pointers on page in
1014 * dead_items array. This includes LP_DEAD line pointers that we
1015 * pruned ourselves, as well as existing LP_DEAD line pointers that
1016 * were pruned some time earlier. Also considers freezing XIDs in the
1017 * tuple headers of remaining items with storage.
1018 */
1023 /* Remember the location of the last page with nonremovable tuples */
1028 {
1029 /*
1030 * Consider the need to do page-at-a-time heap vacuuming when
1031 * using the one-pass strategy now.
1032 *
1033 * The one-pass strategy will never call lazy_vacuum(). The steps
1034 * performed here can be thought of as the one-pass equivalent of
1035 * a call to lazy_vacuum().
1036 */
1038 {
1039 Size freespace;
1043 /* Forget the LP_DEAD items that we just vacuumed */
1046 /*
1047 * Periodically perform FSM vacuuming to make newly-freed
1048 * space visible on upper FSM pages. Note we have not yet
1049 * performed FSM processing for blkno.
1050 */
1052 {
1054 blkno);
1056 }
1058 /*
1059 * Now perform FSM processing for blkno, and move on to next
1060 * page.
1061 *
1062 * Our call to lazy_vacuum_heap_page() will have considered if
1063 * it's possible to set all_visible/all_frozen independently
1064 * of lazy_scan_prune(). Note that prunestate was invalidated
1065 * by lazy_vacuum_heap_page() call.
1066 */
1072 }
1074 /*
1075 * There was no call to lazy_vacuum_heap_page() because pruning
1076 * didn't encounter/create any LP_DEAD items that needed to be
1077 * vacuumed. Prune state has not been invalidated, so proceed
1078 * with prunestate-driven visibility map and FSM steps (just like
1079 * the two-pass strategy).
1080 */
1082 }
1084 /*
1085 * Handle setting visibility map bit based on information from the VM
1086 * (as of last lazy_scan_skip() call), and from prunestate
1087 */
1089 {
1095 /*
1096 * It should never be the case that the visibility map page is set
1097 * while the page-level bit is clear, but the reverse is allowed
1098 * (if checksums are not enabled). Regardless, set both bits so
1099 * that we get back in sync.
1100 *
1101 * NB: If the heap page is all-visible but the VM bit is not set,
1102 * we don't need to dirty the heap page. However, if checksums
1103 * are enabled, we do need to make sure that the heap page is
1104 * dirtied before passing it to visibilitymap_set(), because it
1105 * may be logged. Given that this situation should only happen in
1106 * rare cases after a crash, it is not worth optimizing.
1107 */
1112 flags);
1113 }
1115 /*
1116 * As of PostgreSQL 9.2, the visibility map bit should never be set if
1117 * the page-level bit is clear. However, it's possible that the bit
1118 * got cleared after lazy_scan_skip() was called, so we must recheck
1119 * with buffer lock before concluding that the VM is corrupt.
1120 */
1123 {
1124 elog(WARNING, "page is not marked all-visible but visibility map bit is set in relation \"%s\" page %u",
1127 VISIBILITYMAP_VALID_BITS);
1128 }
1130 /*
1131 * It's possible for the value returned by
1132 * GetOldestNonRemovableTransactionId() to move backwards, so it's not
1133 * wrong for us to see tuples that appear to not be visible to
1134 * everyone yet, while PD_ALL_VISIBLE is already set. The real safe
1135 * xmin value never moves backwards, but
1136 * GetOldestNonRemovableTransactionId() is conservative and sometimes
1137 * returns a value that's unnecessarily small, so if we see that
1138 * contradiction it just means that the tuples that we think are not
1139 * visible to everyone yet actually are, and the PD_ALL_VISIBLE flag
1140 * is correct.
1141 *
1142 * There should never be LP_DEAD items on a page with PD_ALL_VISIBLE
1143 * set, however.
1144 */
1146 {
1147 elog(WARNING, "page containing LP_DEAD items is marked as all-visible in relation \"%s\" page %u",
1152 VISIBILITYMAP_VALID_BITS);
1153 }
1155 /*
1156 * If the all-visible page is all-frozen but not marked as such yet,
1157 * mark it as all-frozen. Note that all_frozen is only valid if
1158 * all_visible is true, so we must check both prunestate fields.
1159 */
1163 {
1164 /*
1165 * We can pass InvalidTransactionId as the cutoff XID here,
1166 * because setting the all-frozen bit doesn't cause recovery
1167 * conflicts.
1168 */
1171 VISIBILITYMAP_ALL_FROZEN);
1172 }
1174 /*
1175 * Final steps for block: drop cleanup lock, record free space in the
1176 * FSM
1177 */
1179 {
1180 /*
1181 * Wait until lazy_vacuum_heap_rel() to save free space. This
1182 * doesn't just save us some cycles; it also allows us to record
1183 * any additional free space that lazy_vacuum_heap_page() will
1184 * make available in cases where it's possible to truncate the
1185 * page's line pointer array.
1186 *
1187 * Note: It's not in fact 100% certain that we really will call
1188 * lazy_vacuum_heap_rel() -- lazy_vacuum() might yet opt to skip
1189 * index vacuuming (and so must skip heap vacuuming). This is
1190 * deemed okay because it only happens in emergencies, or when
1191 * there is very little free space anyway. (Besides, we start
1192 * recording free space in the FSM once index vacuuming has been
1193 * abandoned.)
1194 *
1195 * Note: The one-pass (no indexes) case is only supposed to make
1196 * it this far when there were no LP_DEAD items during pruning.
1197 */
1200 }
1201 else
1202 {
1207 }
1208 }
1214 /* report that everything is now scanned */
1217 /* now we can compute the new value for pg_class.reltuples */
1222 /*
1223 * Also compute the total number of surviving heap entries. In the
1224 * (unlikely) scenario that new_live_tuples is -1, take it as zero.
1225 */
1230 /*
1231 * Do index vacuuming (call each index's ambulkdelete routine), then do
1232 * related heap vacuuming
1233 */
1237 /*
1238 * Vacuum the remainder of the Free Space Map. We must do this whether or
1239 * not there were indexes, and whether or not we bypassed index vacuuming.
1240 */
1244 /* report all blocks vacuumed */
1247 /* Do final index cleanup (call each index's amvacuumcleanup routine) */
1250 }
1252 /*
1253 * lazy_scan_skip() -- set up range of skippable blocks using visibility map.
1254 *
1255 * lazy_scan_heap() calls here every time it needs to set up a new range of
1256 * blocks to skip via the visibility map. Caller passes the next block in
1257 * line. We return a next_unskippable_block for this range. When there are
1258 * no skippable blocks we just return caller's next_block. The all-visible
1259 * status of the returned block is set in *next_unskippable_allvis for caller,
1260 * too. Block usually won't be all-visible (since it's unskippable), but it
1261 * can be during aggressive VACUUMs (as well as in certain edge cases).
1262 *
1263 * Sets *skipping_current_range to indicate if caller should skip this range.
1264 * Costs and benefits drive our decision. Very small ranges won't be skipped.
1265 *
1266 * Note: our opinion of which blocks can be skipped can go stale immediately.
1267 * It's okay if caller "misses" a page whose all-visible or all-frozen marking
1268 * was concurrently cleared, though. All that matters is that caller scan all
1269 * pages whose tuples might contain XIDs < OldestXmin, or MXIDs < OldestMxact.
1270 * (Actually, non-aggressive VACUUMs can choose to skip all-visible pages with
1271 * older XIDs/MXIDs. The vacrel->skippedallvis flag will be set here when the
1272 * choice to skip such a range is actually made, making everything safe.)
1273 */
1274 static BlockNumber
1277 {
1285 {
1287 next_unskippable_block,
1288 vmbuffer);
1291 {
1295 }
1297 /*
1298 * Caller must scan the last page to determine whether it has tuples
1299 * (caller must have the opportunity to set vacrel->nonempty_pages).
1300 * This rule avoids having lazy_truncate_heap() take access-exclusive
1301 * lock on rel to attempt a truncation that fails anyway, just because
1302 * there are tuples on the last page (it is likely that there will be
1303 * tuples on other nearby pages as well, but those can be skipped).
1304 *
1305 * Implement this by always treating the last block as unsafe to skip.
1306 */
1310 /* DISABLE_PAGE_SKIPPING makes all skipping unsafe */
1314 /*
1315 * Aggressive VACUUM caller can't skip pages just because they are
1316 * all-visible. They may still skip all-frozen pages, which can't
1317 * contain XIDs < OldestXmin (XIDs that aren't already frozen by now).
1318 */
1320 {
1324 /*
1325 * All-visible block is safe to skip in non-aggressive case. But
1326 * remember that the final range contains such a block for later.
1327 */
1329 }
1332 next_unskippable_block++;
1333 nskippable_blocks++;
1334 }
1336 /*
1337 * We only skip a range with at least SKIP_PAGES_THRESHOLD consecutive
1338 * pages. Since we're reading sequentially, the OS should be doing
1339 * readahead for us, so there's no gain in skipping a page now and then.
1340 * Skipping such a range might even discourage sequential detection.
1341 *
1342 * This test also enables more frequent relfrozenxid advancement during
1343 * non-aggressive VACUUMs. If the range has any all-visible pages then
1344 * skipping makes updating relfrozenxid unsafe, which is a real downside.
1345 */
1348 else
1349 {
1353 }
1356 }
1358 /*
1359 * lazy_scan_new_or_empty() -- lazy_scan_heap() new/empty page handling.
1360 *
1361 * Must call here to handle both new and empty pages before calling
1362 * lazy_scan_prune or lazy_scan_noprune, since they're not prepared to deal
1363 * with new or empty pages.
1364 *
1365 * It's necessary to consider new pages as a special case, since the rules for
1366 * maintaining the visibility map and FSM with empty pages are a little
1367 * different (though new pages can be truncated away during rel truncation).
1368 *
1369 * Empty pages are not really a special case -- they're just heap pages that
1370 * have no allocated tuples (including even LP_UNUSED items). You might
1371 * wonder why we need to handle them here all the same. It's only necessary
1372 * because of a corner-case involving a hard crash during heap relation
1373 * extension. If we ever make relation-extension crash safe, then it should
1374 * no longer be necessary to deal with empty pages here (or new pages, for
1375 * that matter).
1376 *
1377 * Caller must hold at least a shared lock. We might need to escalate the
1378 * lock in that case, so the type of lock caller holds needs to be specified
1379 * using 'sharelock' argument.
1380 *
1381 * Returns false in common case where caller should go on to call
1382 * lazy_scan_prune (or lazy_scan_noprune). Otherwise returns true, indicating
1383 * that lazy_scan_heap is done processing the page, releasing lock on caller's
1384 * behalf.
1385 */
1386 static bool
1389 {
1390 Size freespace;
1393 {
1394 /*
1395 * All-zeroes pages can be left over if either a backend extends the
1396 * relation by a single page, but crashes before the newly initialized
1397 * page has been written out, or when bulk-extending the relation
1398 * (which creates a number of empty pages at the tail end of the
1399 * relation), and then enters them into the FSM.
1400 *
1401 * Note we do not enter the page into the visibilitymap. That has the
1402 * downside that we repeatedly visit this page in subsequent vacuums,
1403 * but otherwise we'll never discover the space on a promoted standby.
1404 * The harm of repeated checking ought to normally not be too bad. The
1405 * space usually should be used at some point, otherwise there
1406 * wouldn't be any regular vacuums.
1407 *
1408 * Make sure these pages are in the FSM, to ensure they can be reused.
1409 * Do that by testing if there's any space recorded for the page. If
1410 * not, enter it. We do so after releasing the lock on the heap page,
1411 * the FSM is approximate, after all.
1412 */
1416 {
1420 }
1423 }
1426 {
1427 /*
1428 * It seems likely that caller will always be able to get a cleanup
1429 * lock on an empty page. But don't take any chances -- escalate to
1430 * an exclusive lock (still don't need a cleanup lock, though).
1431 */
1433 {
1438 {
1439 /* page isn't new or empty -- keep lock and pin for now */
1441 }
1442 }
1443 else
1444 {
1445 /* Already have a full cleanup lock (which is more than enough) */
1446 }
1448 /*
1449 * Unlike new pages, empty pages are always set all-visible and
1450 * all-frozen.
1451 */
1453 {
1456 /* mark buffer dirty before writing a WAL record */
1459 /*
1460 * It's possible that another backend has extended the heap,
1461 * initialized the page, and then failed to WAL-log the page due
1462 * to an ERROR. Since heap extension is not WAL-logged, recovery
1463 * might try to replay our record setting the page all-visible and
1464 * find that the page isn't initialized, which will cause a PANIC.
1465 * To prevent that, check whether the page has been previously
1466 * WAL-logged, and if not, do that now.
1467 */
1477 }
1483 }
1485 /* page isn't new or empty -- keep lock and pin */
1487 }
1489 /*
1490 * lazy_scan_prune() -- lazy_scan_heap() pruning and freezing.
1491 *
1492 * Caller must hold pin and buffer cleanup lock on the buffer.
1493 *
1494 * Prior to PostgreSQL 14 there were very rare cases where heap_page_prune()
1495 * was allowed to disagree with our HeapTupleSatisfiesVacuum() call about
1496 * whether or not a tuple should be considered DEAD. This happened when an
1497 * inserting transaction concurrently aborted (after our heap_page_prune()
1498 * call, before our HeapTupleSatisfiesVacuum() call). There was rather a lot
1499 * of complexity just so we could deal with tuples that were DEAD to VACUUM,
1500 * but nevertheless were left with storage after pruning.
1501 *
1502 * The approach we take now is to restart pruning when the race condition is
1503 * detected. This allows heap_page_prune() to prune the tuples inserted by
1504 * the now-aborted transaction. This is a little crude, but it guarantees
1505 * that any items that make it into the dead_items array are simple LP_DEAD
1506 * line pointers, and that every remaining item with tuple storage is
1507 * considered as a candidate for freezing.
1508 */
1509 static void
1511 Buffer buf,
1512 BlockNumber blkno,
1513 Page page,
1515 {
1517 OffsetNumber offnum,
1518 maxoff;
1519 ItemId itemid;
1520 HeapTupleData tuple;
1521 HTSV_Result res;
1523 tuples_frozen,
1524 lpdead_items,
1525 live_tuples,
1526 recently_dead_tuples;
1528 TransactionId NewRelfrozenXid;
1529 MultiXactId NewRelminMxid;
1535 /*
1536 * maxoff might be reduced following line pointer array truncation in
1537 * heap_page_prune. That's safe for us to ignore, since the reclaimed
1538 * space will continue to look like LP_UNUSED items below.
1539 */
1542 retry:
1544 /* Initialize (or reset) page-level state */
1553 /*
1554 * Prune all HOT-update chains in this page.
1555 *
1556 * We count tuples removed by the pruning step as tuples_deleted. Its
1557 * final value can be thought of as the number of tuples that have been
1558 * deleted from the table. It should not be confused with lpdead_items;
1559 * lpdead_items's final value can be thought of as the number of tuples
1560 * that were deleted from indexes.
1561 */
1566 /*
1567 * Now scan the page to collect LP_DEAD items and check for tuples
1568 * requiring freezing among remaining tuples with storage
1569 */
1579 {
1582 /*
1583 * Set the offset number so that we can display it along with any
1584 * error that occurred while processing this tuple.
1585 */
1592 /* Redirect items mustn't be touched */
1594 {
1597 }
1599 /*
1600 * LP_DEAD items are processed outside of the loop.
1601 *
1602 * Note that we deliberately don't set hastup=true in the case of an
1603 * LP_DEAD item here, which is not how count_nondeletable_pages() does
1604 * it -- it only considers pages empty/truncatable when they have no
1605 * items at all (except LP_UNUSED items).
1606 *
1607 * Our assumption is that any LP_DEAD items we encounter here will
1608 * become LP_UNUSED inside lazy_vacuum_heap_page() before we actually
1609 * call count_nondeletable_pages(). In any case our opinion of
1610 * whether or not a page 'hastup' (which is how our caller sets its
1611 * vacrel->nonempty_pages value) is inherently race-prone. It must be
1612 * treated as advisory/unreliable, so we might as well be slightly
1613 * optimistic.
1614 */
1616 {
1621 }
1630 /*
1631 * DEAD tuples are almost always pruned into LP_DEAD line pointers by
1632 * heap_page_prune(), but it's possible that the tuple state changed
1633 * since heap_page_prune() looked. Handle that here by restarting.
1634 * (See comments at the top of function for a full explanation.)
1635 */
1637 buf);
1642 /*
1643 * The criteria for counting a tuple as live in this block need to
1644 * match what analyze.c's acquire_sample_rows() does, otherwise VACUUM
1645 * and ANALYZE may produce wildly different reltuples values, e.g.
1646 * when there are many recently-dead tuples.
1647 *
1648 * The logic here is a bit simpler than acquire_sample_rows(), as
1649 * VACUUM can't run inside a transaction block, which makes some cases
1650 * impossible (e.g. in-progress insert from the same transaction).
1651 *
1652 * We treat LP_DEAD items (which are the closest thing to DEAD tuples
1653 * that might be seen here) differently, too: we assume that they'll
1654 * become LP_UNUSED before VACUUM finishes. This difference is only
1655 * superficial. VACUUM effectively agrees with ANALYZE about DEAD
1656 * items, in the end. VACUUM won't remember LP_DEAD items, but only
1657 * because they're not supposed to be left behind when it is done.
1658 * (Cases where we bypass index vacuuming will violate this optimistic
1659 * assumption, but the overall impact of that should be negligible.)
1660 */
1662 {
1665 /*
1666 * Count it as live. Not only is this natural, but it's also
1667 * what acquire_sample_rows() does.
1668 */
1669 live_tuples++;
1671 /*
1672 * Is the tuple definitely visible to all transactions?
1673 *
1674 * NB: Like with per-tuple hint bits, we can't set the
1675 * PD_ALL_VISIBLE flag if the inserter committed
1676 * asynchronously. See SetHintBits for more info. Check that
1677 * the tuple is hinted xmin-committed because of that.
1678 */
1680 {
1681 TransactionId xmin;
1684 {
1687 }
1689 /*
1690 * The inserter definitely committed. But is it old enough
1691 * that everyone sees it as committed?
1692 */
1696 {
1699 }
1701 /* Track newest xmin on page. */
1704 }
1708 /*
1709 * If tuple is recently dead then we must not remove it from
1710 * the relation. (We only remove items that are LP_DEAD from
1711 * pruning.)
1712 */
1713 recently_dead_tuples++;
1718 /*
1719 * We do not count these rows as live, because we expect the
1720 * inserting transaction to update the counters at commit, and
1721 * we assume that will happen only after we report our
1722 * results. This assumption is a bit shaky, but it is what
1723 * acquire_sample_rows() does, so be consistent.
1724 */
1728 /* This is an expected case during concurrent vacuum */
1731 /*
1732 * Count such rows as live. As above, we assume the deleting
1733 * transaction will commit and update the counters after we
1734 * report.
1735 */
1736 live_tuples++;
1741 }
1745 /* Tuple with storage -- consider need to freeze */
1749 {
1750 /* Save prepared freeze plan for later */
1752 }
1754 /*
1755 * If tuple is not frozen (and not about to become frozen) then caller
1756 * had better not go on to set this page's VM bit
1757 */
1760 }
1764 /*
1765 * We have now divided every item on the page into either an LP_DEAD item
1766 * that will need to be vacuumed in indexes later, or a LP_NORMAL tuple
1767 * that remains and needs to be considered for freezing now (LP_UNUSED and
1768 * LP_REDIRECT items also remain, but are of no further interest to us).
1769 */
1773 /*
1774 * Consider the need to freeze any items with tuple storage from the page
1775 * first (arbitrary)
1776 */
1778 {
1783 /* Execute all freeze plans for page as a single atomic action */
1787 }
1789 /*
1790 * The second pass over the heap can also set visibility map bits, using
1791 * the same approach. This is important when the table frequently has a
1792 * few old LP_DEAD items on each page by the time we get to it (typically
1793 * because past opportunistic pruning operations freed some non-HOT
1794 * tuples).
1795 *
1796 * VACUUM will call heap_page_is_all_visible() during the second pass over
1797 * the heap to determine all_visible and all_frozen for the page -- this
1798 * is a specialized version of the logic from this function. Now that
1799 * we've finished pruning and freezing, make sure that we're in total
1800 * agreement with heap_page_is_all_visible() using an assertion.
1801 */
1802 #ifdef USE_ASSERT_CHECKING
1803 /* Note that all_frozen value does not matter when !all_visible */
1805 {
1806 TransactionId cutoff;
1815 /*
1816 * It's possible that we froze tuples and made the page's XID cutoff
1817 * (for recovery conflict purposes) FrozenTransactionId. This is okay
1818 * because visibility_cutoff_xid will be logged by our caller in a
1819 * moment.
1820 */
1823 }
1824 #endif
1826 /*
1827 * Now save details of the LP_DEAD items from the page in vacrel
1828 */
1830 {
1832 ItemPointerData tmp;
1842 {
1845 }
1850 }
1852 /* Finally, add page-local counts to whole-VACUUM counts */
1858 }
1860 /*
1861 * lazy_scan_noprune() -- lazy_scan_prune() without pruning or freezing
1862 *
1863 * Caller need only hold a pin and share lock on the buffer, unlike
1864 * lazy_scan_prune, which requires a full cleanup lock. While pruning isn't
1865 * performed here, it's quite possible that an earlier opportunistic pruning
1866 * operation left LP_DEAD items behind. We'll at least collect any such items
1867 * in the dead_items array for removal from indexes.
1868 *
1869 * For aggressive VACUUM callers, we may return false to indicate that a full
1870 * cleanup lock is required for processing by lazy_scan_prune. This is only
1871 * necessary when the aggressive VACUUM needs to freeze some tuple XIDs from
1872 * one or more tuples on the page. We always return true for non-aggressive
1873 * callers.
1874 *
1875 * See lazy_scan_prune for an explanation of hastup return flag.
1876 * recordfreespace flag instructs caller on whether or not it should do
1877 * generic FSM processing for page.
1878 */
1879 static bool
1881 Buffer buf,
1882 BlockNumber blkno,
1883 Page page,
1886 {
1887 OffsetNumber offnum,
1888 maxoff;
1890 live_tuples,
1891 recently_dead_tuples,
1892 missed_dead_tuples;
1893 HeapTupleHeader tupleheader;
1912 {
1913 ItemId itemid;
1914 HeapTupleData tuple;
1923 {
1926 }
1929 {
1930 /*
1931 * Deliberately don't set hastup=true here. See same point in
1932 * lazy_scan_prune for an explanation.
1933 */
1936 }
1942 {
1943 /* Tuple with XID < FreezeLimit (or MXID < MultiXactCutoff) */
1945 {
1946 /*
1947 * Aggressive VACUUMs must always be able to advance rel's
1948 * relfrozenxid to a value >= FreezeLimit (and be able to
1949 * advance rel's relminmxid to a value >= MultiXactCutoff).
1950 * The ongoing aggressive VACUUM won't be able to do that
1951 * unless it can freeze an XID (or MXID) from this tuple now.
1952 *
1953 * The only safe option is to have caller perform processing
1954 * of this page using lazy_scan_prune. Caller might have to
1955 * wait a while for a cleanup lock, but it can't be helped.
1956 */
1959 }
1961 /*
1962 * Non-aggressive VACUUMs are under no obligation to advance
1963 * relfrozenxid (even by one XID). We can be much laxer here.
1964 *
1965 * Currently we always just accept an older final relfrozenxid
1966 * and/or relminmxid value. We never make caller wait or work a
1967 * little harder, even when it likely makes sense to do so.
1968 */
1969 }
1977 buf))
1978 {
1982 /*
1983 * Count both cases as live, just like lazy_scan_prune
1984 */
1985 live_tuples++;
1990 /*
1991 * There is some useful work for pruning to do, that won't be
1992 * done due to failure to get a cleanup lock.
1993 */
1994 missed_dead_tuples++;
1998 /*
1999 * Count in recently_dead_tuples, just like lazy_scan_prune
2000 */
2001 recently_dead_tuples++;
2005 /*
2006 * Do not count these rows as live, just like lazy_scan_prune
2007 */
2012 }
2013 }
2017 /*
2018 * By here we know for sure that caller can put off freezing and pruning
2019 * this particular page until the next VACUUM. Remember its details now.
2020 * (lazy_scan_prune expects a clean slate, so we have to do this last.)
2021 */
2025 /* Save any LP_DEAD items found on the page in dead_items array */
2027 {
2028 /* Using one-pass strategy (since table has no indexes) */
2030 {
2031 /*
2032 * Perfunctory handling for the corner case where a single pass
2033 * strategy VACUUM cannot get a cleanup lock, and it turns out
2034 * that there is one or more LP_DEAD items: just count the LP_DEAD
2035 * items as missed_dead_tuples instead. (This is a bit dishonest,
2036 * but it beats having to maintain specialized heap vacuuming code
2037 * forever, for vanishingly little benefit.)
2038 */
2041 }
2044 }
2046 {
2047 /*
2048 * Won't be vacuuming this page later, so record page's freespace in
2049 * the FSM now
2050 */
2052 }
2053 else
2054 {
2056 ItemPointerData tmp;
2058 /*
2059 * Page has LP_DEAD items, and so any references/TIDs that remain in
2060 * indexes will be deleted during index vacuuming (and then marked
2061 * LP_UNUSED in the heap)
2062 */
2068 {
2071 }
2079 /*
2080 * Assume that we'll go on to vacuum this heap page during final pass
2081 * over the heap. Don't record free space until then.
2082 */
2084 }
2086 /*
2087 * Finally, add relevant page-local counts to whole-VACUUM counts
2088 */
2095 /* Caller won't need to call lazy_scan_prune with same page */
2097 }
2099 /*
2100 * Main entry point for index vacuuming and heap vacuuming.
2101 *
2102 * Removes items collected in dead_items from table's indexes, then marks the
2103 * same items LP_UNUSED in the heap. See the comments above lazy_scan_heap
2104 * for full details.
2105 *
2106 * Also empties dead_items, freeing up space for later TIDs.
2107 *
2108 * We may choose to bypass index vacuuming at this point, though only when the
2109 * ongoing VACUUM operation will definitely only have one index scan/round of
2110 * index vacuuming.
2111 */
2112 static void
2114 {
2117 /* Should not end up here with no indexes */
2122 {
2126 }
2128 /*
2129 * Consider bypassing index vacuuming (and heap vacuuming) entirely.
2130 *
2131 * We currently only do this in cases where the number of LP_DEAD items
2132 * for the entire VACUUM operation is close to zero. This avoids sharp
2133 * discontinuities in the duration and overhead of successive VACUUM
2134 * operations that run against the same table with a fixed workload.
2135 * Ideally, successive VACUUM operations will behave as if there are
2136 * exactly zero LP_DEAD items in cases where there are close to zero.
2137 *
2138 * This is likely to be helpful with a table that is continually affected
2139 * by UPDATEs that can mostly apply the HOT optimization, but occasionally
2140 * have small aberrations that lead to just a few heap pages retaining
2141 * only one or two LP_DEAD items. This is pretty common; even when the
2142 * DBA goes out of their way to make UPDATEs use HOT, it is practically
2143 * impossible to predict whether HOT will be applied in 100% of cases.
2144 * It's far easier to ensure that 99%+ of all UPDATEs against a table use
2145 * HOT through careful tuning.
2146 */
2149 {
2150 BlockNumber threshold;
2157 /*
2158 * This crossover point at which we'll start to do index vacuuming is
2159 * expressed as a percentage of the total number of heap pages in the
2160 * table that are known to have at least one LP_DEAD item. This is
2161 * much more important than the total number of LP_DEAD items, since
2162 * it's a proxy for the number of heap pages whose visibility map bits
2163 * cannot be set on account of bypassing index and heap vacuuming.
2164 *
2165 * We apply one further precautionary test: the space currently used
2166 * to store the TIDs (TIDs that now all point to LP_DEAD items) must
2167 * not exceed 32MB. This limits the risk that we will bypass index
2168 * vacuuming again and again until eventually there is a VACUUM whose
2169 * dead_items space is not CPU cache resident.
2170 *
2171 * We don't take any special steps to remember the LP_DEAD items (such
2172 * as counting them in our final update to the stats system) when the
2173 * optimization is applied. Though the accounting used in analyze.c's
2174 * acquire_sample_rows() will recognize the same LP_DEAD items as dead
2175 * rows in its own stats report, that's okay. The discrepancy should
2176 * be negligible. If this optimization is ever expanded to cover more
2177 * cases then this may need to be reconsidered.
2178 */
2182 }
2185 {
2186 /*
2187 * There are almost zero TIDs. Behave as if there were precisely
2188 * zero: bypass index vacuuming, but do index cleanup.
2189 *
2190 * We expect that the ongoing VACUUM operation will finish very
2191 * quickly, so there is no point in considering speeding up as a
2192 * failsafe against wraparound failure. (Index cleanup is expected to
2193 * finish very quickly in cases where there were no ambulkdelete()
2194 * calls.)
2195 */
2197 }
2199 {
2200 /*
2201 * We successfully completed a round of index vacuuming. Do related
2202 * heap vacuuming now.
2203 */
2205 }
2206 else
2207 {
2208 /*
2209 * Failsafe case.
2210 *
2211 * We attempted index vacuuming, but didn't finish a full round/full
2212 * index scan. This happens when relfrozenxid or relminmxid is too
2213 * far in the past.
2214 *
2215 * From this point on the VACUUM operation will do no further index
2216 * vacuuming or heap vacuuming. This VACUUM operation won't end up
2217 * back here again.
2218 */
2220 }
2222 /*
2223 * Forget the LP_DEAD items that we just vacuumed (or just decided to not
2224 * vacuum)
2225 */
2227 }
2229 /*
2230 * lazy_vacuum_all_indexes() -- Main entry for index vacuuming
2231 *
2232 * Returns true in the common case when all indexes were successfully
2233 * vacuumed. Returns false in rare cases where we determined that the ongoing
2234 * VACUUM operation is at risk of taking too long to finish, leading to
2235 * wraparound failure.
2236 */
2237 static bool
2239 {
2247 /* Precheck for XID wraparound emergencies */
2249 {
2250 /* Wraparound emergency -- don't even start an index scan */
2252 }
2254 /* Report that we are now vacuuming indexes */
2256 PROGRESS_VACUUM_PHASE_VACUUM_INDEX);
2259 {
2261 {
2266 old_live_tuples,
2267 vacrel);
2270 {
2271 /* Wraparound emergency -- end current index scan */
2274 }
2275 }
2276 }
2277 else
2278 {
2279 /* Outsource everything to parallel variant */
2283 /*
2284 * Do a postcheck to consider applying wraparound failsafe now. Note
2285 * that parallel VACUUM only gets the precheck and this postcheck.
2286 */
2289 }
2291 /*
2292 * We delete all LP_DEAD items from the first heap pass in all indexes on
2293 * each call here (except calls where we choose to do the failsafe). This
2294 * makes the next call to lazy_vacuum_heap_rel() safe (except in the event
2295 * of the failsafe triggering, which prevents the next call from taking
2296 * place).
2297 */
2302 /*
2303 * Increase and report the number of index scans.
2304 *
2305 * We deliberately include the case where we started a round of bulk
2306 * deletes that we weren't able to finish due to the failsafe triggering.
2307 */
2313 }
2315 /*
2316 * lazy_vacuum_heap_rel() -- second pass over the heap for two pass strategy
2317 *
2318 * This routine marks LP_DEAD items in vacrel->dead_items array as LP_UNUSED.
2319 * Pages that never had lazy_scan_prune record LP_DEAD items are not visited
2320 * at all.
2321 *
2322 * We may also be able to truncate the line pointer array of the heap pages we
2323 * visit. If there is a contiguous group of LP_UNUSED items at the end of the
2324 * array, it can be reclaimed as free space. These LP_UNUSED items usually
2325 * start out as LP_DEAD items recorded by lazy_scan_prune (we set items from
2326 * each page to LP_UNUSED, and then consider if it's possible to truncate the
2327 * page's line pointer array).
2328 *
2329 * Note: the reason for doing this as a second pass is we cannot remove the
2330 * tuples until we've removed their index entries, and we want to process
2331 * index entry removal in batches as large as possible.
2332 */
2333 static void
2335 {
2337 BlockNumber vacuumed_pages;
2339 LVSavedErrInfo saved_err_info;
2345 /* Report that we are now vacuuming the heap */
2347 PROGRESS_VACUUM_PHASE_VACUUM_HEAP);
2349 /* Update error traceback information */
2351 VACUUM_ERRCB_PHASE_VACUUM_HEAP,
2358 {
2359 BlockNumber tblk;
2360 Buffer buf;
2361 Page page;
2362 Size freespace;
2373 /* Now that we've vacuumed the page, record its available space */
2379 vacuumed_pages++;
2380 }
2382 /* Clear the block number information */
2386 {
2389 }
2391 /*
2392 * We set all LP_DEAD items from the first heap pass to LP_UNUSED during
2393 * the second heap pass. No more, no less.
2394 */
2404 /* Revert to the previous phase information for error traceback */
2406 }
2408 /*
2409 * lazy_vacuum_heap_page() -- free page's LP_DEAD items listed in the
2410 * vacrel->dead_items array.
2411 *
2412 * Caller must have an exclusive buffer lock on the buffer (though a full
2413 * cleanup lock is also acceptable).
2414 *
2415 * index is an offset into the vacrel->dead_items array for the first listed
2416 * LP_DEAD item on the page. The return value is the first index immediately
2417 * after all LP_DEAD items for the same page in the array.
2418 */
2419 static int
2422 {
2427 TransactionId visibility_cutoff_xid;
2429 LVSavedErrInfo saved_err_info;
2435 /* Update error traceback information */
2438 InvalidOffsetNumber);
2443 {
2444 BlockNumber tblk;
2445 OffsetNumber toff;
2446 ItemId itemid;
2457 }
2461 /* Attempt to truncate line pointer array now */
2464 /*
2465 * Mark buffer dirty before we write WAL.
2466 */
2469 /* XLOG stuff */
2471 {
2472 xl_heap_vacuum xlrec;
2473 XLogRecPtr recptr;
2486 }
2488 /*
2489 * End critical section, so we safely can do visibility tests (which
2490 * possibly need to perform IO and allocate memory!). If we crash now the
2491 * page (including the corresponding vm bit) might not be marked all
2492 * visible, but that's fine. A later vacuum will fix that.
2493 */
2496 /*
2497 * Now that we have removed the LD_DEAD items from the page, once again
2498 * check if the page has become all-visible. The page is already marked
2499 * dirty, exclusively locked, and, if needed, a full page image has been
2500 * emitted.
2501 */
2506 /*
2507 * All the changes to the heap page have been done. If the all-visible
2508 * flag is now set, also set the VM all-visible bit (and, if possible, the
2509 * all-frozen bit) unless this has already been done previously.
2510 */
2512 {
2517 /* Set the VM all-frozen bit to flag, if needed */
2527 }
2529 /* Revert to the previous phase information for error traceback */
2532 }
2534 /*
2535 * Trigger the failsafe to avoid wraparound failure when vacrel table has a
2536 * relfrozenxid and/or relminmxid that is dangerously far in the past.
2537 * Triggering the failsafe makes the ongoing VACUUM bypass any further index
2538 * vacuuming and heap vacuuming. Truncating the heap is also bypassed.
2539 *
2540 * Any remaining work (work that VACUUM cannot just bypass) is typically sped
2541 * up when the failsafe triggers. VACUUM stops applying any cost-based delay
2542 * that it started out with.
2543 *
2544 * Returns true when failsafe has been triggered.
2545 */
2546 static bool
2548 {
2549 /* Don't warn more than once per VACUUM */
2554 {
2557 /* Disable index vacuuming, index cleanup, and heap rel truncation */
2563 (errmsg("bypassing nonessential maintenance of table \"%s.%s.%s\" as a failsafe after %d index scans",
2569 errhint("Consider increasing configuration parameter \"maintenance_work_mem\" or \"autovacuum_work_mem\".\n"
2570 "You might also need to consider other ways for VACUUM to keep up with the allocation of transaction IDs.")));
2572 /* Stop applying cost limits from this point on */
2577 }
2580 }
2582 /*
2583 * lazy_cleanup_all_indexes() -- cleanup all indexes of relation.
2584 */
2585 static void
2587 {
2594 /* Report that we are now cleaning up indexes */
2596 PROGRESS_VACUUM_PHASE_INDEX_CLEANUP);
2599 {
2601 {
2608 }
2609 }
2610 else
2611 {
2612 /* Outsource everything to parallel variant */
2615 estimated_count);
2616 }
2617 }
2619 /*
2620 * lazy_vacuum_one_index() -- vacuum index relation.
2621 *
2622 * Delete all the index tuples containing a TID collected in
2623 * vacrel->dead_items array. Also update running statistics.
2624 * Exact details depend on index AM's ambulkdelete routine.
2625 *
2626 * reltuples is the number of heap tuples to be passed to the
2627 * bulkdelete callback. It's always assumed to be estimated.
2628 * See indexam.sgml for more info.
2629 *
2630 * Returns bulk delete stats derived from input stats
2631 */
2635 {
2636 IndexVacuumInfo ivinfo;
2637 LVSavedErrInfo saved_err_info;
2647 /*
2648 * Update error traceback information.
2649 *
2650 * The index name is saved during this phase and restored immediately
2651 * after this phase. See vacuum_error_callback.
2652 */
2656 VACUUM_ERRCB_PHASE_VACUUM_INDEX,
2659 /* Do bulk deletion */
2662 /* Revert to the previous phase information for error traceback */
2668 }
2670 /*
2671 * lazy_cleanup_one_index() -- do post-vacuum cleanup for index relation.
2672 *
2673 * Calls index AM's amvacuumcleanup routine. reltuples is the number
2674 * of heap tuples and estimated_count is true if reltuples is an
2675 * estimated value. See indexam.sgml for more info.
2676 *
2677 * Returns bulk delete stats derived from input stats
2678 */
2683 {
2684 IndexVacuumInfo ivinfo;
2685 LVSavedErrInfo saved_err_info;
2696 /*
2697 * Update error traceback information.
2698 *
2699 * The index name is saved during this phase and restored immediately
2700 * after this phase. See vacuum_error_callback.
2701 */
2705 VACUUM_ERRCB_PHASE_INDEX_CLEANUP,
2710 /* Revert to the previous phase information for error traceback */
2716 }
2718 /*
2719 * should_attempt_truncation - should we attempt to truncate the heap?
2720 *
2721 * Don't even think about it unless we have a shot at releasing a goodly
2722 * number of pages. Otherwise, the time taken isn't worth it, mainly because
2723 * an AccessExclusive lock must be replayed on any hot standby, where it can
2724 * be particularly disruptive.
2725 *
2726 * Also don't attempt it if wraparound failsafe is in effect. The entire
2727 * system might be refusing to allocate new XIDs at this point. The system
2728 * definitely won't return to normal unless and until VACUUM actually advances
2729 * the oldest relfrozenxid -- which hasn't happened for target rel just yet.
2730 * If lazy_truncate_heap attempted to acquire an AccessExclusiveLock to
2731 * truncate the table under these circumstances, an XID exhaustion error might
2732 * make it impossible for VACUUM to fix the underlying XID exhaustion problem.
2733 * There is very little chance of truncation working out when the failsafe is
2734 * in effect in any case. lazy_scan_prune makes the optimistic assumption
2735 * that any LP_DEAD items it encounters will always be LP_UNUSED by the time
2736 * we're called.
2737 *
2738 * Also don't attempt it if we are doing early pruning/vacuuming, because a
2739 * scan which cannot find a truncated heap page cannot determine that the
2740 * snapshot is too old to read that page.
2741 */
2742 static bool
2744 {
2745 BlockNumber possibly_freeable;
2758 }
2760 /*
2761 * lazy_truncate_heap - try to truncate off any empty pages at the end
2762 */
2763 static void
2765 {
2767 BlockNumber new_rel_pages;
2771 /* Report that we are now truncating */
2773 PROGRESS_VACUUM_PHASE_TRUNCATE);
2775 /* Update error traceback information one last time */
2779 /*
2780 * Loop until no more truncating can be done.
2781 */
2782 do
2783 {
2784 /*
2785 * We need full exclusive lock on the relation in order to do
2786 * truncation. If we can't get it, give up rather than waiting --- we
2787 * don't want to block other backends, and we don't want to deadlock
2788 * (which is quite possible considering we already hold a lower-grade
2789 * lock).
2790 */
2794 {
2798 /*
2799 * Check for interrupts while trying to (re-)acquire the exclusive
2800 * lock.
2801 */
2805 VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL))
2806 {
2807 /*
2808 * We failed to establish the lock in the specified number of
2809 * retries. This means we give up truncating.
2810 */
2815 }
2819 VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL,
2820 WAIT_EVENT_VACUUM_TRUNCATE);
2822 }
2824 /*
2825 * Now that we have exclusive lock, look to see if the rel has grown
2826 * whilst we were vacuuming with non-exclusive lock. If so, give up;
2827 * the newly added pages presumably contain non-deletable tuples.
2828 */
2831 {
2832 /*
2833 * Note: we intentionally don't update vacrel->rel_pages with the
2834 * new rel size here. If we did, it would amount to assuming that
2835 * the new pages are empty, which is unlikely. Leaving the numbers
2836 * alone amounts to assuming that the new pages have the same
2837 * tuple density as existing ones, which is less unlikely.
2838 */
2841 }
2843 /*
2844 * Scan backwards from the end to verify that the end pages actually
2845 * contain no tuples. This is *necessary*, not optional, because
2846 * other backends could have added tuples to these pages whilst we
2847 * were vacuuming.
2848 */
2853 {
2854 /* can't do anything after all */
2857 }
2859 /*
2860 * Okay to truncate.
2861 */
2864 /*
2865 * We can release the exclusive lock as soon as we have truncated.
2866 * Other backends can't safely access the relation until they have
2867 * processed the smgr invalidation that smgrtruncate sent out ... but
2868 * that should happen as part of standard invalidation processing once
2869 * they acquire lock on the relation.
2870 */
2873 /*
2874 * Update statistics. Here, it *is* correct to adjust rel_pages
2875 * without also touching reltuples, since the tuple count wasn't
2876 * changed by the truncation.
2877 */
2887 }
2889 /*
2890 * Rescan end pages to verify that they are (still) empty of tuples.
2891 *
2892 * Returns number of nondeletable pages (last nonempty page + 1).
2893 */
2894 static BlockNumber
2896 {
2897 BlockNumber blkno;
2898 BlockNumber prefetchedUntil;
2899 instr_time starttime;
2901 /* Initialize the starttime if we check for conflicting lock requests */
2904 /*
2905 * Start checking blocks at what we believe relation end to be and move
2906 * backwards. (Strange coding of loop control is needed because blkno is
2907 * unsigned.) To make the scan faster, we prefetch a few blocks at a time
2908 * in forward direction, so that OS-level readahead can kick in.
2909 */
2915 {
2916 Buffer buf;
2917 Page page;
2918 OffsetNumber offnum,
2919 maxoff;
2922 /*
2923 * Check if another process requests a lock on our relation. We are
2924 * holding an AccessExclusiveLock here, so they will be waiting. We
2925 * only do this once per VACUUM_TRUNCATE_LOCK_CHECK_INTERVAL, and we
2926 * only check if that interval has elapsed once every 32 blocks to
2927 * keep the number of system calls and actual shared lock table
2928 * lookups to a minimum.
2929 */
2931 {
2932 instr_time currenttime;
2933 instr_time elapsed;
2940 {
2942 {
2949 }
2951 }
2952 }
2954 /*
2955 * We don't insert a vacuum delay point here, because we have an
2956 * exclusive lock on the table which we want to hold for as short a
2957 * time as possible. We still need to check for interrupts however.
2958 */
2961 blkno--;
2963 /* If we haven't prefetched this lot yet, do so now. */
2965 {
2966 BlockNumber prefetchStart;
2967 BlockNumber pblkno;
2971 {
2974 }
2976 }
2981 /* In this phase we only need shared access to the buffer */
2987 {
2990 }
2997 {
2998 ItemId itemid;
3002 /*
3003 * Note: any non-unused item should be taken as a reason to keep
3004 * this page. Even an LP_DEAD item makes truncation unsafe, since
3005 * we must not have cleaned out its index entries.
3006 */
3008 {
3011 }
3016 /* Done scanning if we found a tuple here */
3019 }
3021 /*
3022 * If we fall out of the loop, all the previously-thought-to-be-empty
3023 * pages still are; we need not bother to look at the last known-nonempty
3024 * page.
3025 */
3027 }
3029 /*
3030 * Returns the number of dead TIDs that VACUUM should allocate space to
3031 * store, given a heap rel of size vacrel->rel_pages, and given current
3032 * maintenance_work_mem setting (or current autovacuum_work_mem setting,
3033 * when applicable).
3034 *
3035 * See the comments at the head of this file for rationale.
3036 */
3037 static int
3039 {
3040 int64 max_items;
3046 {
3053 /* curious coding here to ensure the multiplication can't overflow */
3057 /* stay sane if small maintenance_work_mem */
3059 }
3060 else
3061 {
3062 /* One-pass case only stores a single heap page's TIDs at a time */
3064 }
3067 }
3069 /*
3070 * Allocate dead_items (either using palloc, or in dynamic shared memory).
3071 * Sets dead_items in vacrel for caller.
3072 *
3073 * Also handles parallel initialization as part of allocating dead_items in
3074 * DSM when required.
3075 */
3076 static void
3078 {
3085 /*
3086 * Initialize state for a parallel vacuum. As of now, only one worker can
3087 * be used for an index, so we invoke parallelism only if there are at
3088 * least two indexes on a table.
3089 */
3091 {
3092 /*
3093 * Since parallel workers cannot access data in temporary tables, we
3094 * can't perform parallel vacuum on them.
3095 */
3097 {
3098 /*
3099 * Give warning only if the user explicitly tries to perform a
3100 * parallel vacuum on the temporary table.
3101 */
3104 (errmsg("disabling parallel option of vacuum on \"%s\" --- cannot vacuum temporary tables in parallel",
3106 }
3107 else
3110 max_items,
3114 /* If parallel mode started, dead_items space is allocated in DSM */
3116 {
3119 }
3120 }
3122 /* Serial VACUUM case */
3128 }
3130 /*
3131 * Perform cleanup for resources allocated in dead_items_alloc
3132 */
3133 static void
3135 {
3137 {
3138 /* Don't bother with pfree here */
3140 }
3142 /* End parallel mode */
3145 }
3147 /*
3148 * Check if every tuple in the given page is visible to all current and future
3149 * transactions. Also return the visibility_cutoff_xid which is the highest
3150 * xmin amongst the visible tuples. Set *all_frozen to true if every tuple
3151 * on this page is frozen.
3152 *
3153 * This is a stripped down version of lazy_scan_prune(). If you change
3154 * anything here, make sure that everything stays in sync. Note that an
3155 * assertion calls us to verify that everybody still agrees. Be sure to avoid
3156 * introducing new side-effects here.
3157 */
3158 static bool
3162 {
3165 OffsetNumber offnum,
3166 maxoff;
3176 {
3177 ItemId itemid;
3178 HeapTupleData tuple;
3180 /*
3181 * Set the offset number so that we can display it along with any
3182 * error that occurred while processing this tuple.
3183 */
3187 /* Unused or redirect line pointers are of no interest */
3193 /*
3194 * Dead line pointers can have index pointers pointing to them. So
3195 * they can't be treated as visible
3196 */
3198 {
3202 }
3211 buf))
3212 {
3214 {
3215 TransactionId xmin;
3217 /* Check comments in lazy_scan_prune. */
3219 {
3223 }
3225 /*
3226 * The inserter definitely committed. But is it old enough
3227 * that everyone sees it as committed?
3228 */
3232 {
3236 }
3238 /* Track newest xmin on page. */
3242 /* Check whether this tuple is already frozen or not */
3246 }
3253 {
3257 }
3261 }
3264 /* Clear the offset information once we have processed the given page. */
3268 }
3270 /*
3271 * Update index statistics in pg_class if the statistics are accurate.
3272 */
3273 static void
3275 {
3283 {
3290 /* Update index statistics */
3296 InvalidTransactionId,
3297 InvalidMultiXactId,
3299 }
3300 }
3302 /*
3303 * Error context callback for errors occurring during vacuum. The error
3304 * context messages for index phases should match the messages set in parallel
3305 * vacuum. If you change this function for those phases, change
3306 * parallel_vacuum_error_callback() as well.
3307 */
3308 static void
3310 {
3314 {
3317 {
3321 else
3324 }
3325 else
3332 {
3336 else
3339 }
3340 else
3364 * initialized */
3365 }
3366 }
3368 /*
3369 * Updates the information required for vacuum error callback. This also saves
3370 * the current information which can be later restored via restore_vacuum_error_info.
3371 */
3372 static void
3375 {
3377 {
3381 }
3386 }
3388 /*
3389 * Restores the vacuum information saved via a prior call to update_vacuum_error_info.
3390 */
3391 static void
3394 {
3398 }