| blob | ad3feb88b3be994507bcdd1c8f69d0aaa5e4b257 |
1 /*-------------------------------------------------------------------------
2 *
3 * vacuumlazy.c
4 * Concurrent ("lazy") vacuuming.
5 *
6 *
7 * The major space usage for LAZY VACUUM is storage for the array of dead tuple
8 * TIDs. We want to ensure we can vacuum even the very largest relations with
9 * finite memory space usage. To do that, we set upper bounds on the number of
10 * tuples we will keep track of at once.
11 *
12 * We are willing to use at most maintenance_work_mem (or perhaps
13 * autovacuum_work_mem) memory space to keep track of dead tuples. We
14 * initially allocate an array of TIDs of that size, with an upper limit that
15 * depends on table size (this limit ensures we don't allocate a huge area
16 * uselessly for vacuuming small tables). If the array threatens to overflow,
17 * we suspend the heap scan phase and perform a pass of index cleanup and page
18 * compaction, then resume the heap scan with an empty TID array.
19 *
20 * If we're processing a table with no indexes, we can just vacuum each page
21 * as we go; there's no need to save up multiple tuples to minimize the number
22 * of index scans performed. So we don't use maintenance_work_mem memory for
23 * the TID array, just enough to hold as many heap tuples as fit on one page.
24 *
25 * Lazy vacuum supports parallel execution with parallel worker processes. In
26 * a parallel vacuum, we perform both index vacuum and index cleanup with
27 * parallel worker processes. Individual indexes are processed by one vacuum
28 * process. At the beginning of a lazy vacuum (at lazy_scan_heap) we prepare
29 * the parallel context and initialize the DSM segment that contains shared
30 * information as well as the memory space for storing dead tuples. When
31 * starting either index vacuum or index cleanup, we launch parallel worker
32 * processes. Once all indexes are processed the parallel worker processes
33 * exit. After that, the leader process re-initializes the parallel context
34 * so that it can use the same DSM for multiple passes of index vacuum and
35 * for performing index cleanup. For updating the index statistics, we need
36 * to update the system table and since updates are not allowed during
37 * parallel mode we update the index statistics after exiting from the
38 * parallel mode.
39 *
40 * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group
41 * Portions Copyright (c) 1994, Regents of the University of California
42 *
43 *
44 * IDENTIFICATION
45 * src/backend/access/heap/vacuumlazy.c
46 *
47 *-------------------------------------------------------------------------
48 */
51 #include <math.h>
85 /*
86 * Space/time tradeoff parameters: do these need to be user-tunable?
87 *
88 * To consider truncating the relation, we want there to be at least
89 * REL_TRUNCATE_MINIMUM or (relsize / REL_TRUNCATE_FRACTION) (whichever
90 * is less) potentially-freeable pages.
91 */
92 #define REL_TRUNCATE_MINIMUM 1000
93 #define REL_TRUNCATE_FRACTION 16
95 /*
96 * Timing parameters for truncate locking heuristics.
97 *
98 * These were not exposed as user tunable GUC values because it didn't seem
99 * that the potential for improvement was great enough to merit the cost of
100 * supporting them.
101 */
106 /*
107 * Threshold that controls whether we bypass index vacuuming and heap
108 * vacuuming as an optimization
109 */
112 /*
113 * Perform a failsafe check every 4GB during the heap scan, approximately
114 */
115 #define FAILSAFE_EVERY_PAGES \
116 ((BlockNumber) (((uint64) 4 * 1024 * 1024 * 1024) / BLCKSZ))
118 /*
119 * When a table has no indexes, vacuum the FSM after every 8GB, approximately
120 * (it won't be exact because we only vacuum FSM after processing a heap page
121 * that has some removable tuples). When there are indexes, this is ignored,
122 * and we vacuum FSM after each index/heap cleaning pass.
123 */
124 #define VACUUM_FSM_EVERY_PAGES \
125 ((BlockNumber) (((uint64) 8 * 1024 * 1024 * 1024) / BLCKSZ))
127 /*
128 * Guesstimation of number of dead tuples per page. This is used to
129 * provide an upper limit to memory allocated when vacuuming small
130 * tables.
131 */
132 #define LAZY_ALLOC_TUPLES MaxHeapTuplesPerPage
134 /*
135 * Before we consider skipping a page that's marked as clean in
136 * visibility map, we must've seen at least this many clean pages.
137 */
138 #define SKIP_PAGES_THRESHOLD ((BlockNumber) 32)
140 /*
141 * Size of the prefetch window for lazy vacuum backwards truncation scan.
142 * Needs to be a power of 2.
143 */
144 #define PREFETCH_SIZE ((BlockNumber) 32)
146 /*
147 * DSM keys for parallel vacuum. Unlike other parallel execution code, since
148 * we don't need to worry about DSM keys conflicting with plan_node_id we can
149 * use small integers.
150 */
151 #define PARALLEL_VACUUM_KEY_SHARED 1
152 #define PARALLEL_VACUUM_KEY_DEAD_TUPLES 2
153 #define PARALLEL_VACUUM_KEY_QUERY_TEXT 3
154 #define PARALLEL_VACUUM_KEY_BUFFER_USAGE 4
155 #define PARALLEL_VACUUM_KEY_WAL_USAGE 5
157 /*
158 * Macro to check if we are in a parallel vacuum. If true, we are in the
159 * parallel mode and the DSM segment is initialized.
160 */
161 #define ParallelVacuumIsActive(vacrel) ((vacrel)->lps != NULL)
163 /* Phases of vacuum during which we report error context. */
165 {
166 VACUUM_ERRCB_PHASE_UNKNOWN,
167 VACUUM_ERRCB_PHASE_SCAN_HEAP,
168 VACUUM_ERRCB_PHASE_VACUUM_INDEX,
169 VACUUM_ERRCB_PHASE_VACUUM_HEAP,
170 VACUUM_ERRCB_PHASE_INDEX_CLEANUP,
171 VACUUM_ERRCB_PHASE_TRUNCATE
174 /*
175 * LVDeadTuples stores the dead tuple TIDs collected during the heap scan.
176 * This is allocated in the DSM segment in parallel mode and in local memory
177 * in non-parallel mode.
178 */
180 {
183 /* List of TIDs of tuples we intend to delete */
184 /* NB: this list is ordered by TID address */
186 * ItemPointerData */
189 /* The dead tuple space consists of LVDeadTuples and dead tuple TIDs */
190 #define SizeOfDeadTuples(cnt) \
191 add_size(offsetof(LVDeadTuples, itemptrs), \
192 mul_size(sizeof(ItemPointerData), cnt))
193 #define MAXDEADTUPLES(max_size) \
194 (((max_size) - offsetof(LVDeadTuples, itemptrs)) / sizeof(ItemPointerData))
196 /*
197 * Shared information among parallel workers. So this is allocated in the DSM
198 * segment.
199 */
201 {
202 /*
203 * Target table relid and log level. These fields are not modified during
204 * the lazy vacuum.
205 */
206 Oid relid;
209 /*
210 * An indication for vacuum workers to perform either index vacuum or
211 * index cleanup. first_time is true only if for_cleanup is true and
212 * bulk-deletion is not performed yet.
213 */
217 /*
218 * Fields for both index vacuum and cleanup.
219 *
220 * reltuples is the total number of input heap tuples. We set either old
221 * live tuples in the index vacuum case or the new live tuples in the
222 * index cleanup case.
223 *
224 * estimated_count is true if reltuples is an estimated value. (Note that
225 * reltuples could be -1 in this case, indicating we have no idea.)
226 */
230 /*
231 * In single process lazy vacuum we could consume more memory during index
232 * vacuuming or cleanup apart from the memory for heap scanning. In
233 * parallel vacuum, since individual vacuum workers can consume memory
234 * equal to maintenance_work_mem, the new maintenance_work_mem for each
235 * worker is set such that the parallel operation doesn't consume more
236 * memory than single process lazy vacuum.
237 */
240 /*
241 * Shared vacuum cost balance. During parallel vacuum,
242 * VacuumSharedCostBalance points to this value and it accumulates the
243 * balance of each parallel vacuum worker.
244 */
245 pg_atomic_uint32 cost_balance;
247 /*
248 * Number of active parallel workers. This is used for computing the
249 * minimum threshold of the vacuum cost balance before a worker sleeps for
250 * cost-based delay.
251 */
252 pg_atomic_uint32 active_nworkers;
254 /*
255 * Variables to control parallel vacuum. We have a bitmap to indicate
256 * which index has stats in shared memory. The set bit in the map
257 * indicates that the particular index supports a parallel vacuum.
258 */
263 /* Shared index statistics data follows at end of struct */
266 #define SizeOfLVShared (offsetof(LVShared, bitmap) + sizeof(bits8))
267 #define GetSharedIndStats(s) \
268 ((LVSharedIndStats *)((char *)(s) + ((LVShared *)(s))->offset))
269 #define IndStatsIsNull(s, i) \
270 (!(((LVShared *)(s))->bitmap[(i) >> 3] & (1 << ((i) & 0x07))))
272 /*
273 * Struct for an index bulk-deletion statistic used for parallel vacuum. This
274 * is allocated in the DSM segment.
275 */
277 {
279 IndexBulkDeleteResult istat;
282 /* Struct for maintaining a parallel vacuum state. */
284 {
287 /* Shared information among parallel vacuum workers */
290 /* Points to buffer usage area in DSM */
293 /* Points to WAL usage area in DSM */
296 /*
297 * The number of indexes that support parallel index bulk-deletion and
298 * parallel index cleanup respectively.
299 */
306 {
307 /* Target heap relation and its indexes */
308 Relation rel;
311 /* Do index vacuuming/cleanup? */
314 /* Wraparound failsafe in effect? (implies !do_index_vacuuming) */
317 /* Buffer access strategy and parallel state */
318 BufferAccessStrategy bstrategy;
321 /* Statistics from pg_class when we start out */
324 /* rel's initial relfrozenxid and relminmxid */
325 TransactionId relfrozenxid;
326 MultiXactId relminmxid;
328 /* VACUUM operation's cutoff for pruning */
329 TransactionId OldestXmin;
330 /* VACUUM operation's cutoff for freezing XIDs and MultiXactIds */
331 TransactionId FreezeLimit;
332 MultiXactId MultiXactCutoff;
334 /* Error reporting state */
340 VacErrPhase phase;
342 /*
343 * State managed by lazy_scan_heap() follows
344 */
356 /* Statistics output by us, for table */
359 /* Statistics output by index AMs */
362 /* Instrumentation counters */
367 * table */
372 /*
373 * State returned by lazy_scan_prune()
374 */
376 {
380 /*
381 * State describes the proper VM bit states to set for the page following
382 * pruning and freezing. all_visible implies !has_lpdead_items, but don't
383 * trust all_frozen result unless all_visible is also set to true.
384 */
390 /* Struct for saving and restoring vacuum error information. */
392 {
393 BlockNumber blkno;
394 OffsetNumber offnum;
395 VacErrPhase phase;
398 /* elevel controls whole VACUUM's verbosity */
402 /* non-export function prototypes */
445 BlockNumber relblocks);
456 BlockNumber nblocks,
465 OffsetNumber offnum);
470 /*
471 * heap_vacuum_rel() -- perform VACUUM for one heap relation
472 *
473 * This routine vacuums a single heap, cleans out its indexes, and
474 * updates its relpages and reltuples statistics.
475 *
476 * At entry, we have already established a transaction and opened
477 * and locked the relation.
478 */
479 void
481 BufferAccessStrategy bstrategy)
482 {
484 PGRUsage ru0;
491 write_rate;
495 TransactionId xidFullScanLimit;
496 MultiXactId mxactFullScanLimit;
497 BlockNumber new_rel_pages;
498 BlockNumber new_rel_allvisible;
500 TransactionId new_frozen_xid;
501 MultiXactId new_min_multi;
502 ErrorContextCallback errcallback;
505 TransactionId OldestXmin;
506 TransactionId FreezeLimit;
507 MultiXactId MultiXactCutoff;
513 /* measure elapsed time iff autovacuum logging requires it */
515 {
519 {
522 }
523 }
527 else
541 /*
542 * We request an aggressive scan if the table's frozen Xid is now older
543 * than or equal to the requested Xid full-table scan limit; or if the
544 * table's minimum MultiXactId is older than or equal to the requested
545 * mxid full-table scan limit; or if DISABLE_PAGE_SKIPPING was specified.
546 */
548 xidFullScanLimit);
550 mxactFullScanLimit);
556 /* Set up high level stuff about rel */
564 {
567 }
574 /* Set cutoffs for entire VACUUM */
584 /* Save index names iff autovacuum logging requires it */
587 {
592 }
594 /*
595 * Setup error traceback support for ereport(). The idea is to set up an
596 * error context callback to display additional information on any error
597 * during a vacuum. During different phases of vacuum (heap scan, heap
598 * vacuum, index vacuum, index clean up, heap truncate), we update the
599 * error context callback to display appropriate information.
600 *
601 * Note that the index vacuum and heap vacuum phases may be called
602 * multiple times in the middle of the heap scan phase. So the old phase
603 * information is restored at the end of those phases.
604 */
610 /* Do the vacuuming */
613 /* Done with indexes */
616 /*
617 * Compute whether we actually scanned the all unfrozen pages. If we did,
618 * we can adjust relfrozenxid and relminmxid.
619 *
620 * NB: We need to check this before truncating the relation, because that
621 * will change ->rel_pages.
622 */
625 {
628 }
629 else
632 /*
633 * Optionally truncate the relation.
634 */
636 {
637 /*
638 * Update error traceback information. This is the last phase during
639 * which we add context information to errors, so we don't need to
640 * revert to the previous phase.
641 */
644 InvalidOffsetNumber);
646 }
648 /* Pop the error context stack */
651 /* Report that we are now doing final cleanup */
653 PROGRESS_VACUUM_PHASE_FINAL_CLEANUP);
655 /*
656 * Update statistics in pg_class.
657 *
658 * In principle new_live_tuples could be -1 indicating that we (still)
659 * don't know the tuple count. In practice that probably can't happen,
660 * since we'd surely have scanned some pages if the table is new and
661 * nonempty.
662 *
663 * For safety, clamp relallvisible to be not more than what we're setting
664 * relpages to.
665 *
666 * Also, don't change relfrozenxid/relminmxid if we skipped any pages,
667 * since then we don't know for certain that all tuples have a newer xmin.
668 */
680 new_rel_pages,
681 new_live_tuples,
682 new_rel_allvisible,
684 new_frozen_xid,
685 new_min_multi,
688 /*
689 * Report results to the stats collector, too.
690 *
691 * Deliberately avoid telling the stats collector about LP_DEAD items that
692 * remain in the table due to VACUUM bypassing index and heap vacuuming.
693 * ANALYZE will consider the remaining LP_DEAD items to be dead tuples. It
694 * seems like a good idea to err on the side of not vacuuming again too
695 * soon in cases where the failsafe prevented significant amounts of heap
696 * vacuuming.
697 */
704 /* and log the action if appropriate */
706 {
712 {
713 StringInfoData buf;
724 {
729 }
731 /*
732 * This is pretty messy, but we split it up so that we can skip
733 * emitting individual parts of the message when not applicable.
734 */
737 {
738 /*
739 * While it's possible for a VACUUM to be both is_wraparound
740 * and !aggressive, that's just a corner-case -- is_wraparound
741 * implies aggressive. Produce distinct output for the corner
742 * case all the same, just in case.
743 */
745 msgfmt = _("automatic aggressive vacuum to prevent wraparound of table \"%s.%s.%s\": index scans: %d\n");
746 else
748 }
749 else
750 {
753 else
755 }
761 appendStringInfo(&buf, _("pages: %u removed, %u remain, %u skipped due to pins, %u skipped frozen\n"),
771 OldestXmin);
778 {
779 BlockNumber orig_rel_pages;
782 {
787 else
789 }
790 else
791 {
796 else
798 }
804 }
806 {
819 }
823 {
832 }
843 }
844 }
846 /* Cleanup index statistics and index names */
848 {
854 }
855 }
857 /*
858 * lazy_scan_heap() -- scan an open heap relation
859 *
860 * This routine prunes each page in the heap, which will among other
861 * things truncate dead tuples to dead line pointers, defragment the
862 * page, and set commit status bits (see heap_page_prune). It also builds
863 * lists of dead tuples and pages with free space, calculates statistics
864 * on the number of live tuples in the heap, and marks pages as
865 * all-visible if appropriate. When done, or when we run low on space
866 * for dead-tuple TIDs, invoke lazy_vacuum to vacuum indexes and vacuum
867 * heap relation during its own second pass over the heap.
868 *
869 * If the table has at least two indexes, we execute both index vacuum
870 * and index cleanup with parallel workers unless parallel vacuum is
871 * disabled. In a parallel vacuum, we enter parallel mode and then
872 * create both the parallel context and the DSM segment before starting
873 * heap scan so that we can record dead tuples to the DSM segment. All
874 * parallel workers are launched at beginning of index vacuuming and
875 * index cleanup and they exit once done with all indexes. At the end of
876 * this function we exit from parallel mode. Index bulk-deletion results
877 * are stored in the DSM segment and we update index statistics for all
878 * the indexes after exiting from parallel mode since writes are not
879 * allowed during parallel mode.
880 *
881 * If there are no indexes then we can reclaim line pointers on the fly;
882 * dead line pointers need only be retained until all index pointers that
883 * reference them have been killed.
884 */
885 static void
887 {
889 BlockNumber nblocks,
890 blkno,
891 next_unskippable_block,
892 next_failsafe_block,
893 next_fsm_block_to_vacuum;
894 PGRUsage ru0;
898 StringInfoData buf;
900 PROGRESS_VACUUM_PHASE,
901 PROGRESS_VACUUM_TOTAL_HEAP_BLKS,
902 PROGRESS_VACUUM_MAX_DEAD_TUPLES
903 };
914 else
934 /* Initialize instrumentation counters */
947 /*
948 * Before beginning scan, check if it's already necessary to apply
949 * failsafe
950 */
953 /*
954 * Allocate the space for dead tuples. Note that this handles parallel
955 * VACUUM initialization as part of allocating shared memory space used
956 * for dead_tuples.
957 */
961 /* Report that we're scanning the heap, advertising total # of blocks */
967 /*
968 * Except when aggressive is set, we want to skip pages that are
969 * all-visible according to the visibility map, but only when we can skip
970 * at least SKIP_PAGES_THRESHOLD consecutive pages. Since we're reading
971 * sequentially, the OS should be doing readahead for us, so there's no
972 * gain in skipping a page now and then; that's likely to disable
973 * readahead and so be counterproductive. Also, skipping even a single
974 * page means that we can't update relfrozenxid, so we only want to do it
975 * if we can skip a goodly number of pages.
976 *
977 * When aggressive is set, we can't skip pages just because they are
978 * all-visible, but we can still skip pages that are all-frozen, since
979 * such pages do not need freezing and do not affect the value that we can
980 * safely set for relfrozenxid or relminmxid.
981 *
982 * Before entering the main loop, establish the invariant that
983 * next_unskippable_block is the next block number >= blkno that we can't
984 * skip based on the visibility map, either all-visible for a regular scan
985 * or all-frozen for an aggressive scan. We set it to nblocks if there's
986 * no such block. We also set up the skipping_blocks flag correctly at
987 * this stage.
988 *
989 * Note: The value returned by visibilitymap_get_status could be slightly
990 * out-of-date, since we make this test before reading the corresponding
991 * heap page or locking the buffer. This is OK. If we mistakenly think
992 * that the page is all-visible or all-frozen when in fact the flag's just
993 * been cleared, we might fail to vacuum the page. It's easy to see that
994 * skipping a page when aggressive is not set is not a very big deal; we
995 * might leave some dead tuples lying around, but the next vacuum will
996 * find them. But even when aggressive *is* set, it's still OK if we miss
997 * a page whose all-frozen marking has just been cleared. Any new XIDs
998 * just added to that page are necessarily newer than the GlobalXmin we
999 * computed, so they'll have no effect on the value to which we can safely
1000 * set relfrozenxid. A similar argument applies for MXIDs and relminmxid.
1001 *
1002 * We will scan the table's last page, at least to the extent of
1003 * determining whether it has tuples or not, even if it should be skipped
1004 * according to the above rules; except when we've already determined that
1005 * it's not worth trying to truncate the table. This avoids having
1006 * lazy_truncate_heap() take access-exclusive lock on the table to attempt
1007 * a truncation that just fails immediately because there are tuples in
1008 * the last page. This is worth avoiding mainly because such a lock must
1009 * be replayed on any hot standby, where it can be disruptive.
1010 */
1012 {
1014 {
1015 uint8 vmstatus;
1018 next_unskippable_block,
1021 {
1024 }
1025 else
1026 {
1029 }
1031 next_unskippable_block++;
1032 }
1033 }
1037 else
1041 {
1042 Buffer buf;
1043 Page page;
1045 LVPagePruneState prunestate;
1047 /*
1048 * Consider need to skip blocks. See note above about forcing
1049 * scanning of last page.
1050 */
1051 #define FORCE_CHECK_PAGE() \
1052 (blkno == nblocks - 1 && should_attempt_truncation(vacrel, params))
1060 {
1061 /* Time to advance next_unskippable_block */
1062 next_unskippable_block++;
1064 {
1066 {
1067 uint8 vmskipflags;
1070 next_unskippable_block,
1073 {
1076 }
1077 else
1078 {
1081 }
1083 next_unskippable_block++;
1084 }
1085 }
1087 /*
1088 * We know we can't skip the current block. But set up
1089 * skipping_blocks to do the right thing at the following blocks.
1090 */
1093 else
1096 /*
1097 * Normally, the fact that we can't skip this block must mean that
1098 * it's not all-visible. But in an aggressive vacuum we know only
1099 * that it's not all-frozen, so it might still be all-visible.
1100 */
1103 }
1104 else
1105 {
1106 /*
1107 * The current block is potentially skippable; if we've seen a
1108 * long enough run of skippable blocks to justify skipping it, and
1109 * we're not forced to check it, then go ahead and skip.
1110 * Otherwise, the page must be at least all-visible if not
1111 * all-frozen, so we can set all_visible_according_to_vm = true.
1112 */
1114 {
1115 /*
1116 * Tricky, tricky. If this is in aggressive vacuum, the page
1117 * must have been all-frozen at the time we checked whether it
1118 * was skippable, but it might not be any more. We must be
1119 * careful to count it as a skipped all-frozen page in that
1120 * case, or else we'll think we can't update relfrozenxid and
1121 * relminmxid. If it's not an aggressive vacuum, we don't
1122 * know whether it was all-frozen, so we have to recheck; but
1123 * in this case an approximate answer is OK.
1124 */
1128 }
1130 }
1134 /*
1135 * Regularly check if wraparound failsafe should trigger.
1136 *
1137 * There is a similar check inside lazy_vacuum_all_indexes(), but
1138 * relfrozenxid might start to look dangerously old before we reach
1139 * that point. This check also provides failsafe coverage for the
1140 * one-pass strategy case.
1141 */
1143 {
1146 }
1148 /*
1149 * Consider if we definitely have enough space to process TIDs on page
1150 * already. If we are close to overrunning the available space for
1151 * dead-tuple TIDs, pause and do a cycle of vacuuming before we tackle
1152 * this page.
1153 */
1156 {
1157 /*
1158 * Before beginning index vacuuming, we release any pin we may
1159 * hold on the visibility map page. This isn't necessary for
1160 * correctness, but we do it anyway to avoid holding the pin
1161 * across a lengthy, unrelated operation.
1162 */
1164 {
1167 }
1169 /* Remove the collected garbage tuples from table and indexes */
1173 /*
1174 * Vacuum the Free Space Map to make newly-freed space visible on
1175 * upper-level FSM pages. Note we have not yet processed blkno.
1176 */
1178 blkno);
1181 /* Report that we are once again scanning the heap */
1183 PROGRESS_VACUUM_PHASE_SCAN_HEAP);
1184 }
1186 /*
1187 * Set up visibility map page as needed.
1188 *
1189 * Pin the visibility map page in case we need to mark the page
1190 * all-visible. In most cases this will be very cheap, because we'll
1191 * already have the correct page pinned anyway. However, it's
1192 * possible that (a) next_unskippable_block is covered by a different
1193 * VM page than the current block or (b) we released our pin and did a
1194 * cycle of index vacuuming.
1195 */
1201 /*
1202 * We need buffer cleanup lock so that we can prune HOT chains and
1203 * defragment the page.
1204 */
1206 {
1209 /*
1210 * If we're not performing an aggressive scan to guard against XID
1211 * wraparound, and we don't want to forcibly check the page, then
1212 * it's OK to skip vacuuming pages we get a lock conflict on. They
1213 * will be dealt with in some future vacuum.
1214 */
1216 {
1220 }
1222 /*
1223 * Read the page with share lock to see if any xids on it need to
1224 * be frozen. If not we just skip the page, after updating our
1225 * scan statistics. If there are some, we wait for cleanup lock.
1226 *
1227 * We could defer the lock request further by remembering the page
1228 * and coming back to it later, or we could even register
1229 * ourselves for multiple buffers and then service whichever one
1230 * is received first. For now, this seems good enough.
1231 *
1232 * If we get here with aggressive false, then we're just forcibly
1233 * checking the page, and so we don't want to insist on getting
1234 * the lock; we only need to know if the page contains tuples, so
1235 * that we can update nonempty_pages correctly. It's convenient
1236 * to use lazy_check_needs_freeze() for both situations, though.
1237 */
1240 {
1247 }
1249 {
1250 /*
1251 * Here, we must not advance scanned_pages; that would amount
1252 * to claiming that the page contains no freezable tuples.
1253 */
1259 }
1262 /* drop through to normal processing */
1263 }
1265 /*
1266 * By here we definitely have enough dead_tuples space for whatever
1267 * LP_DEAD tids are on this page, we have the visibility map page set
1268 * up in case we need to set this page's all_visible/all_frozen bit,
1269 * and we have a super-exclusive lock. Any tuples on this page are
1270 * now sure to be "counted" by this VACUUM.
1271 *
1272 * One last piece of preamble needs to take place before we can prune:
1273 * we need to consider new and empty pages.
1274 */
1281 {
1282 /*
1283 * All-zeroes pages can be left over if either a backend extends
1284 * the relation by a single page, but crashes before the newly
1285 * initialized page has been written out, or when bulk-extending
1286 * the relation (which creates a number of empty pages at the tail
1287 * end of the relation, but enters them into the FSM).
1288 *
1289 * Note we do not enter the page into the visibilitymap. That has
1290 * the downside that we repeatedly visit this page in subsequent
1291 * vacuums, but otherwise we'll never not discover the space on a
1292 * promoted standby. The harm of repeated checking ought to
1293 * normally not be too bad - the space usually should be used at
1294 * some point, otherwise there wouldn't be any regular vacuums.
1295 *
1296 * Make sure these pages are in the FSM, to ensure they can be
1297 * reused. Do that by testing if there's any space recorded for
1298 * the page. If not, enter it. We do so after releasing the lock
1299 * on the heap page, the FSM is approximate, after all.
1300 */
1304 {
1308 }
1310 }
1313 {
1316 /*
1317 * Empty pages are always all-visible and all-frozen (note that
1318 * the same is currently not true for new pages, see above).
1319 */
1321 {
1324 /* mark buffer dirty before writing a WAL record */
1327 /*
1328 * It's possible that another backend has extended the heap,
1329 * initialized the page, and then failed to WAL-log the page
1330 * due to an ERROR. Since heap extension is not WAL-logged,
1331 * recovery might try to replay our record setting the page
1332 * all-visible and find that the page isn't initialized, which
1333 * will cause a PANIC. To prevent that, check whether the
1334 * page has been previously WAL-logged, and if not, do that
1335 * now.
1336 */
1346 }
1351 }
1353 /*
1354 * Prune and freeze tuples.
1355 *
1356 * Accumulates details of remaining LP_DEAD line pointers on page in
1357 * dead tuple list. This includes LP_DEAD line pointers that we
1358 * pruned ourselves, as well as existing LP_DEAD line pointers that
1359 * were pruned some time earlier. Also considers freezing XIDs in the
1360 * tuple headers of remaining items with storage.
1361 */
1366 /* Remember the location of the last page with nonremovable tuples */
1371 {
1372 /*
1373 * Consider the need to do page-at-a-time heap vacuuming when
1374 * using the one-pass strategy now.
1375 *
1376 * The one-pass strategy will never call lazy_vacuum(). The steps
1377 * performed here can be thought of as the one-pass equivalent of
1378 * a call to lazy_vacuum().
1379 */
1381 {
1382 Size freespace;
1386 /* Forget the now-vacuumed tuples */
1389 /*
1390 * Periodically perform FSM vacuuming to make newly-freed
1391 * space visible on upper FSM pages. Note we have not yet
1392 * performed FSM processing for blkno.
1393 */
1395 {
1397 blkno);
1399 }
1401 /*
1402 * Now perform FSM processing for blkno, and move on to next
1403 * page.
1404 *
1405 * Our call to lazy_vacuum_heap_page() will have considered if
1406 * it's possible to set all_visible/all_frozen independently
1407 * of lazy_scan_prune(). Note that prunestate was invalidated
1408 * by lazy_vacuum_heap_page() call.
1409 */
1415 }
1417 /*
1418 * There was no call to lazy_vacuum_heap_page() because pruning
1419 * didn't encounter/create any LP_DEAD items that needed to be
1420 * vacuumed. Prune state has not been invalidated, so proceed
1421 * with prunestate-driven visibility map and FSM steps (just like
1422 * the two-pass strategy).
1423 */
1425 }
1427 /*
1428 * Handle setting visibility map bit based on what the VM said about
1429 * the page before pruning started, and using prunestate
1430 */
1432 {
1438 /*
1439 * It should never be the case that the visibility map page is set
1440 * while the page-level bit is clear, but the reverse is allowed
1441 * (if checksums are not enabled). Regardless, set both bits so
1442 * that we get back in sync.
1443 *
1444 * NB: If the heap page is all-visible but the VM bit is not set,
1445 * we don't need to dirty the heap page. However, if checksums
1446 * are enabled, we do need to make sure that the heap page is
1447 * dirtied before passing it to visibilitymap_set(), because it
1448 * may be logged. Given that this situation should only happen in
1449 * rare cases after a crash, it is not worth optimizing.
1450 */
1455 flags);
1456 }
1458 /*
1459 * As of PostgreSQL 9.2, the visibility map bit should never be set if
1460 * the page-level bit is clear. However, it's possible that the bit
1461 * got cleared after we checked it and before we took the buffer
1462 * content lock, so we must recheck before jumping to the conclusion
1463 * that something bad has happened.
1464 */
1467 {
1468 elog(WARNING, "page is not marked all-visible but visibility map bit is set in relation \"%s\" page %u",
1471 VISIBILITYMAP_VALID_BITS);
1472 }
1474 /*
1475 * It's possible for the value returned by
1476 * GetOldestNonRemovableTransactionId() to move backwards, so it's not
1477 * wrong for us to see tuples that appear to not be visible to
1478 * everyone yet, while PD_ALL_VISIBLE is already set. The real safe
1479 * xmin value never moves backwards, but
1480 * GetOldestNonRemovableTransactionId() is conservative and sometimes
1481 * returns a value that's unnecessarily small, so if we see that
1482 * contradiction it just means that the tuples that we think are not
1483 * visible to everyone yet actually are, and the PD_ALL_VISIBLE flag
1484 * is correct.
1485 *
1486 * There should never be dead tuples on a page with PD_ALL_VISIBLE
1487 * set, however.
1488 */
1490 {
1491 elog(WARNING, "page containing dead tuples is marked as all-visible in relation \"%s\" page %u",
1496 VISIBILITYMAP_VALID_BITS);
1497 }
1499 /*
1500 * If the all-visible page is all-frozen but not marked as such yet,
1501 * mark it as all-frozen. Note that all_frozen is only valid if
1502 * all_visible is true, so we must check both.
1503 */
1507 {
1508 /*
1509 * We can pass InvalidTransactionId as the cutoff XID here,
1510 * because setting the all-frozen bit doesn't cause recovery
1511 * conflicts.
1512 */
1515 VISIBILITYMAP_ALL_FROZEN);
1516 }
1518 /*
1519 * Final steps for block: drop super-exclusive lock, record free space
1520 * in the FSM
1521 */
1523 {
1524 /*
1525 * Wait until lazy_vacuum_heap_rel() to save free space. This
1526 * doesn't just save us some cycles; it also allows us to record
1527 * any additional free space that lazy_vacuum_heap_page() will
1528 * make available in cases where it's possible to truncate the
1529 * page's line pointer array.
1530 *
1531 * Note: It's not in fact 100% certain that we really will call
1532 * lazy_vacuum_heap_rel() -- lazy_vacuum() might yet opt to skip
1533 * index vacuuming (and so must skip heap vacuuming). This is
1534 * deemed okay because it only happens in emergencies, or when
1535 * there is very little free space anyway. (Besides, we start
1536 * recording free space in the FSM once index vacuuming has been
1537 * abandoned.)
1538 *
1539 * Note: The one-pass (no indexes) case is only supposed to make
1540 * it this far when there were no LP_DEAD items during pruning.
1541 */
1544 }
1545 else
1546 {
1551 }
1552 }
1554 /* report that everything is now scanned */
1557 /* Clear the block number information */
1560 /* now we can compute the new value for pg_class.reltuples */
1565 /*
1566 * Also compute the total number of surviving heap entries. In the
1567 * (unlikely) scenario that new_live_tuples is -1, take it as zero.
1568 */
1572 /*
1573 * Release any remaining pin on visibility map page.
1574 */
1576 {
1579 }
1581 /* If any tuples need to be deleted, perform final vacuum cycle */
1585 /*
1586 * Vacuum the remainder of the Free Space Map. We must do this whether or
1587 * not there were indexes, and whether or not we bypassed index vacuuming.
1588 */
1592 /* report all blocks vacuumed */
1595 /* Do post-vacuum cleanup */
1599 /*
1600 * Free resources managed by lazy_space_alloc(). (We must end parallel
1601 * mode/free shared memory before updating index statistics. We cannot
1602 * write while in parallel mode.)
1603 */
1606 /* Update index statistics */
1610 /*
1611 * If table has no indexes and at least one heap pages was vacuumed, make
1612 * log report that lazy_vacuum_heap_rel would've made had there been
1613 * indexes (having indexes implies using the two pass strategy).
1614 *
1615 * We deliberately don't do this in the case where there are indexes but
1616 * index vacuuming was bypassed. We make a similar report at the point
1617 * that index vacuuming is bypassed, but that's actually quite different
1618 * in one important sense: it shows information about work we _haven't_
1619 * done.
1620 *
1621 * log_autovacuum output does things differently; it consistently presents
1622 * information about LP_DEAD items for the VACUUM as a whole. We always
1623 * report on each round of index and heap vacuuming separately, though.
1624 */
1654 nblocks),
1657 }
1659 /*
1660 * lazy_scan_prune() -- lazy_scan_heap() pruning and freezing.
1661 *
1662 * Caller must hold pin and buffer cleanup lock on the buffer.
1663 *
1664 * Prior to PostgreSQL 14 there were very rare cases where heap_page_prune()
1665 * was allowed to disagree with our HeapTupleSatisfiesVacuum() call about
1666 * whether or not a tuple should be considered DEAD. This happened when an
1667 * inserting transaction concurrently aborted (after our heap_page_prune()
1668 * call, before our HeapTupleSatisfiesVacuum() call). There was rather a lot
1669 * of complexity just so we could deal with tuples that were DEAD to VACUUM,
1670 * but nevertheless were left with storage after pruning.
1671 *
1672 * The approach we take now is to restart pruning when the race condition is
1673 * detected. This allows heap_page_prune() to prune the tuples inserted by
1674 * the now-aborted transaction. This is a little crude, but it guarantees
1675 * that any items that make it into the dead_tuples array are simple LP_DEAD
1676 * line pointers, and that every remaining item with tuple storage is
1677 * considered as a candidate for freezing.
1678 */
1679 static void
1681 Buffer buf,
1682 BlockNumber blkno,
1683 Page page,
1686 {
1688 OffsetNumber offnum,
1689 maxoff;
1690 ItemId itemid;
1691 HeapTupleData tuple;
1692 HTSV_Result res;
1694 lpdead_items,
1695 new_dead_tuples,
1696 num_tuples,
1697 live_tuples;
1704 retry:
1706 /* Initialize (or reset) page-level counters */
1713 /*
1714 * Prune all HOT-update chains in this page.
1715 *
1716 * We count tuples removed by the pruning step as tuples_deleted. Its
1717 * final value can be thought of as the number of tuples that have been
1718 * deleted from the table. It should not be confused with lpdead_items;
1719 * lpdead_items's final value can be thought of as the number of tuples
1720 * that were deleted from indexes.
1721 */
1726 /*
1727 * Now scan the page to collect LP_DEAD items and check for tuples
1728 * requiring freezing among remaining tuples with storage
1729 */
1740 {
1743 /*
1744 * Set the offset number so that we can display it along with any
1745 * error that occurred while processing this tuple.
1746 */
1753 /* Redirect items mustn't be touched */
1755 {
1758 }
1760 /*
1761 * LP_DEAD items are processed outside of the loop.
1762 *
1763 * Note that we deliberately don't set hastup=true in the case of an
1764 * LP_DEAD item here, which is not how lazy_check_needs_freeze() or
1765 * count_nondeletable_pages() do it -- they only consider pages empty
1766 * when they only have LP_UNUSED items, which is important for
1767 * correctness.
1768 *
1769 * Our assumption is that any LP_DEAD items we encounter here will
1770 * become LP_UNUSED inside lazy_vacuum_heap_page() before we actually
1771 * call count_nondeletable_pages(). In any case our opinion of
1772 * whether or not a page 'hastup' (which is how our caller sets its
1773 * vacrel->nonempty_pages value) is inherently race-prone. It must be
1774 * treated as advisory/unreliable, so we might as well be slightly
1775 * optimistic.
1776 */
1778 {
1783 }
1792 /*
1793 * DEAD tuples are almost always pruned into LP_DEAD line pointers by
1794 * heap_page_prune(), but it's possible that the tuple state changed
1795 * since heap_page_prune() looked. Handle that here by restarting.
1796 * (See comments at the top of function for a full explanation.)
1797 */
1803 /*
1804 * The criteria for counting a tuple as live in this block need to
1805 * match what analyze.c's acquire_sample_rows() does, otherwise VACUUM
1806 * and ANALYZE may produce wildly different reltuples values, e.g.
1807 * when there are many recently-dead tuples.
1808 *
1809 * The logic here is a bit simpler than acquire_sample_rows(), as
1810 * VACUUM can't run inside a transaction block, which makes some cases
1811 * impossible (e.g. in-progress insert from the same transaction).
1812 *
1813 * We treat LP_DEAD items a little differently, too -- we don't count
1814 * them as dead_tuples at all (we only consider new_dead_tuples). The
1815 * outcome is no different because we assume that any LP_DEAD items we
1816 * encounter here will become LP_UNUSED inside lazy_vacuum_heap_page()
1817 * before we report anything to the stats collector. (Cases where we
1818 * bypass index vacuuming will violate our assumption, but the overall
1819 * impact of that should be negligible.)
1820 */
1822 {
1825 /*
1826 * Count it as live. Not only is this natural, but it's also
1827 * what acquire_sample_rows() does.
1828 */
1829 live_tuples++;
1831 /*
1832 * Is the tuple definitely visible to all transactions?
1833 *
1834 * NB: Like with per-tuple hint bits, we can't set the
1835 * PD_ALL_VISIBLE flag if the inserter committed
1836 * asynchronously. See SetHintBits for more info. Check that
1837 * the tuple is hinted xmin-committed because of that.
1838 */
1840 {
1841 TransactionId xmin;
1844 {
1847 }
1849 /*
1850 * The inserter definitely committed. But is it old enough
1851 * that everyone sees it as committed?
1852 */
1855 {
1858 }
1860 /* Track newest xmin on page. */
1863 }
1867 /*
1868 * If tuple is recently deleted then we must not remove it
1869 * from relation. (We only remove items that are LP_DEAD from
1870 * pruning.)
1871 */
1872 new_dead_tuples++;
1877 /*
1878 * We do not count these rows as live, because we expect the
1879 * inserting transaction to update the counters at commit, and
1880 * we assume that will happen only after we report our
1881 * results. This assumption is a bit shaky, but it is what
1882 * acquire_sample_rows() does, so be consistent.
1883 */
1887 /* This is an expected case during concurrent vacuum */
1890 /*
1891 * Count such rows as live. As above, we assume the deleting
1892 * transaction will commit and update the counters after we
1893 * report.
1894 */
1895 live_tuples++;
1900 }
1902 /*
1903 * Non-removable tuple (i.e. tuple with storage).
1904 *
1905 * Check tuple left behind after pruning to see if needs to be frozen
1906 * now.
1907 */
1908 num_tuples++;
1917 {
1918 /* Will execute freeze below */
1920 }
1922 /*
1923 * If tuple is not frozen (and not about to become frozen) then caller
1924 * had better not go on to set this page's VM bit
1925 */
1928 }
1930 /*
1931 * We have now divided every item on the page into either an LP_DEAD item
1932 * that will need to be vacuumed in indexes later, or a LP_NORMAL tuple
1933 * that remains and needs to be considered for freezing now (LP_UNUSED and
1934 * LP_REDIRECT items also remain, but are of no further interest to us).
1935 */
1938 /*
1939 * Consider the need to freeze any items with tuple storage from the page
1940 * first (arbitrary)
1941 */
1943 {
1946 /*
1947 * At least one tuple with storage needs to be frozen -- execute that
1948 * now.
1949 *
1950 * If we need to freeze any tuples we'll mark the buffer dirty, and
1951 * write a WAL record recording the changes. We must log the changes
1952 * to be crash-safe against future truncation of CLOG.
1953 */
1958 /* execute collected freezes */
1960 {
1961 HeapTupleHeader htup;
1967 }
1969 /* Now WAL-log freezing if necessary */
1971 {
1972 XLogRecPtr recptr;
1977 }
1980 }
1982 /*
1983 * The second pass over the heap can also set visibility map bits, using
1984 * the same approach. This is important when the table frequently has a
1985 * few old LP_DEAD items on each page by the time we get to it (typically
1986 * because past opportunistic pruning operations freed some non-HOT
1987 * tuples).
1988 *
1989 * VACUUM will call heap_page_is_all_visible() during the second pass over
1990 * the heap to determine all_visible and all_frozen for the page -- this
1991 * is a specialized version of the logic from this function. Now that
1992 * we've finished pruning and freezing, make sure that we're in total
1993 * agreement with heap_page_is_all_visible() using an assertion.
1994 */
1995 #ifdef USE_ASSERT_CHECKING
1996 /* Note that all_frozen value does not matter when !all_visible */
1998 {
1999 TransactionId cutoff;
2008 /*
2009 * It's possible that we froze tuples and made the page's XID cutoff
2010 * (for recovery conflict purposes) FrozenTransactionId. This is okay
2011 * because visibility_cutoff_xid will be logged by our caller in a
2012 * moment.
2013 */
2016 }
2017 #endif
2019 /*
2020 * Now save details of the LP_DEAD items from the page in the dead_tuples
2021 * array. Also record that page has dead items in per-page prunestate.
2022 */
2024 {
2026 ItemPointerData tmp;
2036 {
2039 }
2044 }
2046 /* Finally, add page-local counts to whole-VACUUM counts */
2052 }
2054 /*
2055 * Remove the collected garbage tuples from the table and its indexes.
2056 *
2057 * We may choose to bypass index vacuuming at this point, though only when the
2058 * ongoing VACUUM operation will definitely only have one index scan/round of
2059 * index vacuuming. Caller indicates whether or not this is such a VACUUM
2060 * operation using 'onecall' argument.
2061 *
2062 * In rare emergencies, the ongoing VACUUM operation can be made to skip both
2063 * index vacuuming and index cleanup at the point we're called. This avoids
2064 * having the whole system refuse to allocate further XIDs/MultiXactIds due to
2065 * wraparound.
2066 */
2067 static void
2069 {
2072 /* Should not end up here with no indexes */
2078 {
2082 }
2084 /*
2085 * Consider bypassing index vacuuming (and heap vacuuming) entirely.
2086 *
2087 * We currently only do this in cases where the number of LP_DEAD items
2088 * for the entire VACUUM operation is close to zero. This avoids sharp
2089 * discontinuities in the duration and overhead of successive VACUUM
2090 * operations that run against the same table with a fixed workload.
2091 * Ideally, successive VACUUM operations will behave as if there are
2092 * exactly zero LP_DEAD items in cases where there are close to zero.
2093 *
2094 * This is likely to be helpful with a table that is continually affected
2095 * by UPDATEs that can mostly apply the HOT optimization, but occasionally
2096 * have small aberrations that lead to just a few heap pages retaining
2097 * only one or two LP_DEAD items. This is pretty common; even when the
2098 * DBA goes out of their way to make UPDATEs use HOT, it is practically
2099 * impossible to predict whether HOT will be applied in 100% of cases.
2100 * It's far easier to ensure that 99%+ of all UPDATEs against a table use
2101 * HOT through careful tuning.
2102 */
2105 {
2106 BlockNumber threshold;
2113 /*
2114 * This crossover point at which we'll start to do index vacuuming is
2115 * expressed as a percentage of the total number of heap pages in the
2116 * table that are known to have at least one LP_DEAD item. This is
2117 * much more important than the total number of LP_DEAD items, since
2118 * it's a proxy for the number of heap pages whose visibility map bits
2119 * cannot be set on account of bypassing index and heap vacuuming.
2120 *
2121 * We apply one further precautionary test: the space currently used
2122 * to store the TIDs (TIDs that now all point to LP_DEAD items) must
2123 * not exceed 32MB. This limits the risk that we will bypass index
2124 * vacuuming again and again until eventually there is a VACUUM whose
2125 * dead_tuples space is not CPU cache resident.
2126 *
2127 * We don't take any special steps to remember the LP_DEAD items (such
2128 * as counting them in new_dead_tuples report to the stats collector)
2129 * when the optimization is applied. Though the accounting used in
2130 * analyze.c's acquire_sample_rows() will recognize the same LP_DEAD
2131 * items as dead rows in its own stats collector report, that's okay.
2132 * The discrepancy should be negligible. If this optimization is ever
2133 * expanded to cover more cases then this may need to be reconsidered.
2134 */
2136 do_bypass_optimization =
2139 }
2142 {
2143 /*
2144 * There are almost zero TIDs. Behave as if there were precisely
2145 * zero: bypass index vacuuming, but do index cleanup.
2146 *
2147 * We expect that the ongoing VACUUM operation will finish very
2148 * quickly, so there is no point in considering speeding up as a
2149 * failsafe against wraparound failure. (Index cleanup is expected to
2150 * finish very quickly in cases where there were no ambulkdelete()
2151 * calls.)
2152 */
2155 (errmsg("\"%s\": index scan bypassed: %u pages from table (%.2f%% of total) have %lld dead item identifiers",
2159 }
2161 {
2162 /*
2163 * We successfully completed a round of index vacuuming. Do related
2164 * heap vacuuming now.
2165 */
2167 }
2168 else
2169 {
2170 /*
2171 * Failsafe case.
2172 *
2173 * we attempted index vacuuming, but didn't finish a full round/full
2174 * index scan. This happens when relfrozenxid or relminmxid is too
2175 * far in the past.
2176 *
2177 * From this point on the VACUUM operation will do no further index
2178 * vacuuming or heap vacuuming. This VACUUM operation won't end up
2179 * back here again.
2180 */
2182 }
2184 /*
2185 * Forget the LP_DEAD items that we just vacuumed (or just decided to not
2186 * vacuum)
2187 */
2189 }
2191 /*
2192 * lazy_vacuum_all_indexes() -- Main entry for index vacuuming
2193 *
2194 * Returns true in the common case when all indexes were successfully
2195 * vacuumed. Returns false in rare cases where we determined that the ongoing
2196 * VACUUM operation is at risk of taking too long to finish, leading to
2197 * wraparound failure.
2198 */
2199 static bool
2201 {
2211 /* Precheck for XID wraparound emergencies */
2213 {
2214 /* Wraparound emergency -- don't even start an index scan */
2216 }
2218 /* Report that we are now vacuuming indexes */
2220 PROGRESS_VACUUM_PHASE_VACUUM_INDEX);
2223 {
2225 {
2231 vacrel);
2234 {
2235 /* Wraparound emergency -- end current index scan */
2238 }
2239 }
2240 }
2241 else
2242 {
2243 /* Outsource everything to parallel variant */
2246 /*
2247 * Do a postcheck to consider applying wraparound failsafe now. Note
2248 * that parallel VACUUM only gets the precheck and this postcheck.
2249 */
2252 }
2254 /*
2255 * We delete all LP_DEAD items from the first heap pass in all indexes on
2256 * each call here (except calls where we choose to do the failsafe). This
2257 * makes the next call to lazy_vacuum_heap_rel() safe (except in the event
2258 * of the failsafe triggering, which prevents the next call from taking
2259 * place).
2260 */
2265 /*
2266 * Increase and report the number of index scans.
2267 *
2268 * We deliberately include the case where we started a round of bulk
2269 * deletes that we weren't able to finish due to the failsafe triggering.
2270 */
2276 }
2278 /*
2279 * lazy_vacuum_heap_rel() -- second pass over the heap for two pass strategy
2280 *
2281 * This routine marks LP_DEAD items in vacrel->dead_tuples array as LP_UNUSED.
2282 * Pages that never had lazy_scan_prune record LP_DEAD items are not visited
2283 * at all.
2284 *
2285 * We may also be able to truncate the line pointer array of the heap pages we
2286 * visit. If there is a contiguous group of LP_UNUSED items at the end of the
2287 * array, it can be reclaimed as free space. These LP_UNUSED items usually
2288 * start out as LP_DEAD items recorded by lazy_scan_prune (we set items from
2289 * each page to LP_UNUSED, and then consider if it's possible to truncate the
2290 * page's line pointer array).
2291 *
2292 * Note: the reason for doing this as a second pass is we cannot remove the
2293 * tuples until we've removed their index entries, and we want to process
2294 * index entry removal in batches as large as possible.
2295 */
2296 static void
2298 {
2300 BlockNumber vacuumed_pages;
2301 PGRUsage ru0;
2303 LVSavedErrInfo saved_err_info;
2309 /* Report that we are now vacuuming the heap */
2311 PROGRESS_VACUUM_PHASE_VACUUM_HEAP);
2313 /* Update error traceback information */
2315 VACUUM_ERRCB_PHASE_VACUUM_HEAP,
2323 {
2324 BlockNumber tblk;
2325 Buffer buf;
2326 Page page;
2327 Size freespace;
2339 /* Now that we've vacuumed the page, record its available space */
2345 vacuumed_pages++;
2346 }
2348 /* Clear the block number information */
2352 {
2355 }
2357 /*
2358 * We set all LP_DEAD items from the first heap pass to LP_UNUSED during
2359 * the second heap pass. No more, no less.
2360 */
2370 /* Revert to the previous phase information for error traceback */
2372 }
2374 /*
2375 * lazy_vacuum_heap_page() -- free page's LP_DEAD items listed in the
2376 * vacrel->dead_tuples array.
2377 *
2378 * Caller must have an exclusive buffer lock on the buffer (though a
2379 * super-exclusive lock is also acceptable).
2380 *
2381 * tupindex is the index in vacrel->dead_tuples of the first dead tuple for
2382 * this page. We assume the rest follow sequentially. The return value is
2383 * the first tupindex after the tuples of this page.
2384 *
2385 * Prior to PostgreSQL 14 there were rare cases where this routine had to set
2386 * tuples with storage to unused. These days it is strictly responsible for
2387 * marking LP_DEAD stub line pointers as unused. This only happens for those
2388 * LP_DEAD items on the page that were determined to be LP_DEAD items back
2389 * when the same page was visited by lazy_scan_prune() (i.e. those whose TID
2390 * was recorded in the dead_tuples array).
2391 */
2392 static int
2395 {
2400 TransactionId visibility_cutoff_xid;
2402 LVSavedErrInfo saved_err_info;
2408 /* Update error traceback information */
2411 InvalidOffsetNumber);
2416 {
2417 BlockNumber tblk;
2418 OffsetNumber toff;
2419 ItemId itemid;
2430 }
2434 /* Attempt to truncate line pointer array now */
2437 /*
2438 * Mark buffer dirty before we write WAL.
2439 */
2442 /* XLOG stuff */
2444 {
2445 xl_heap_vacuum xlrec;
2446 XLogRecPtr recptr;
2459 }
2461 /*
2462 * End critical section, so we safely can do visibility tests (which
2463 * possibly need to perform IO and allocate memory!). If we crash now the
2464 * page (including the corresponding vm bit) might not be marked all
2465 * visible, but that's fine. A later vacuum will fix that.
2466 */
2469 /*
2470 * Now that we have removed the LD_DEAD items from the page, once again
2471 * check if the page has become all-visible. The page is already marked
2472 * dirty, exclusively locked, and, if needed, a full page image has been
2473 * emitted.
2474 */
2479 /*
2480 * All the changes to the heap page have been done. If the all-visible
2481 * flag is now set, also set the VM all-visible bit (and, if possible, the
2482 * all-frozen bit) unless this has already been done previously.
2483 */
2485 {
2490 /* Set the VM all-frozen bit to flag, if needed */
2500 }
2502 /* Revert to the previous phase information for error traceback */
2505 }
2507 /*
2508 * lazy_check_needs_freeze() -- scan page to see if any tuples
2509 * need to be cleaned to avoid wraparound
2510 *
2511 * Returns true if the page needs to be vacuumed using cleanup lock.
2512 * Also returns a flag indicating whether page contains any tuples at all.
2513 */
2514 static bool
2516 {
2518 OffsetNumber offnum,
2519 maxoff;
2520 HeapTupleHeader tupleheader;
2524 /*
2525 * New and empty pages, obviously, don't contain tuples. We could make
2526 * sure that the page is registered in the FSM, but it doesn't seem worth
2527 * waiting for a cleanup lock just for that, especially because it's
2528 * likely that the pin holder will do so.
2529 */
2537 {
2538 ItemId itemid;
2540 /*
2541 * Set the offset number so that we can display it along with any
2542 * error that occurred while processing this tuple.
2543 */
2547 /* this should match hastup test in count_nondeletable_pages() */
2551 /* dead and redirect items never need freezing */
2562 /* Clear the offset information once we have processed the given page. */
2566 }
2568 /*
2569 * Trigger the failsafe to avoid wraparound failure when vacrel table has a
2570 * relfrozenxid and/or relminmxid that is dangerously far in the past.
2571 * Triggering the failsafe makes the ongoing VACUUM bypass any further index
2572 * vacuuming and heap vacuuming. Truncating the heap is also bypassed.
2573 *
2574 * Any remaining work (work that VACUUM cannot just bypass) is typically sped
2575 * up when the failsafe triggers. VACUUM stops applying any cost-based delay
2576 * that it started out with.
2577 *
2578 * Returns true when failsafe has been triggered.
2579 */
2580 static bool
2582 {
2583 /* Don't warn more than once per VACUUM */
2589 {
2598 (errmsg("bypassing nonessential maintenance of table \"%s.%s.%s\" as a failsafe after %d index scans",
2604 errhint("Consider increasing configuration parameter \"maintenance_work_mem\" or \"autovacuum_work_mem\".\n"
2605 "You might also need to consider other ways for VACUUM to keep up with the allocation of transaction IDs.")));
2607 /* Stop applying cost limits from this point on */
2612 }
2615 }
2617 /*
2618 * Perform lazy_vacuum_all_indexes() steps in parallel
2619 */
2620 static void
2622 {
2623 /* Tell parallel workers to do index vacuuming */
2627 /*
2628 * We can only provide an approximate value of num_heap_tuples in vacuum
2629 * cases.
2630 */
2636 }
2638 /*
2639 * Perform lazy_cleanup_all_indexes() steps in parallel
2640 */
2641 static void
2643 {
2646 /*
2647 * If parallel vacuum is active we perform index cleanup with parallel
2648 * workers.
2649 *
2650 * Tell parallel workers to do index cleanup.
2651 */
2655 /*
2656 * Now we can provide a better estimate of total number of surviving
2657 * tuples (we assume indexes are more interested in that than in the
2658 * number of nominally live tuples).
2659 */
2664 /* Determine the number of parallel workers to launch */
2668 else
2672 }
2674 /*
2675 * Perform index vacuum or index cleanup with parallel workers. This function
2676 * must be used by the parallel vacuum leader process. The caller must set
2677 * lps->lvshared->for_cleanup to indicate whether to perform vacuum or
2678 * cleanup.
2679 */
2680 static void
2682 {
2689 /* The leader process will participate */
2690 nworkers--;
2692 /*
2693 * It is possible that parallel context is initialized with fewer workers
2694 * than the number of indexes that need a separate worker in the current
2695 * phase, so we need to consider it. See compute_parallel_vacuum_workers.
2696 */
2699 /* Setup the shared cost-based vacuum delay and launch workers */
2701 {
2703 {
2704 /* Reset the parallel index processing counter */
2707 /* Reinitialize the parallel context to relaunch parallel workers */
2709 }
2711 /*
2712 * Set up shared cost balance and the number of active workers for
2713 * vacuum delay. We need to do this before launching workers as
2714 * otherwise, they might not see the updated values for these
2715 * parameters.
2716 */
2720 /*
2721 * The number of workers can vary between bulkdelete and cleanup
2722 * phase.
2723 */
2729 {
2730 /*
2731 * Reset the local cost values for leader backend as we have
2732 * already accumulated the remaining balance of heap.
2733 */
2737 /* Enable shared cost balance for leader backend */
2740 }
2748 else
2754 }
2756 /* Process the indexes that can be processed by only leader process */
2759 /*
2760 * Join as a parallel worker. The leader process alone processes all the
2761 * indexes in the case where no workers are launched.
2762 */
2765 /*
2766 * Next, accumulate buffer and WAL usage. (This must wait for the workers
2767 * to finish, or we might get incomplete data.)
2768 */
2770 {
2771 /* Wait for all vacuum workers to finish */
2776 }
2778 /*
2779 * Carry the shared balance value to heap scan and disable shared costing
2780 */
2782 {
2786 }
2787 }
2789 /*
2790 * Index vacuum/cleanup routine used by the leader process and parallel
2791 * vacuum worker processes to process the indexes in parallel.
2792 */
2793 static void
2795 {
2796 /*
2797 * Increment the active worker count if we are able to launch any worker.
2798 */
2802 /* Loop until all indexes are vacuumed */
2804 {
2807 Relation indrel;
2810 /* Get an index number to process */
2813 /* Done for all indexes? */
2817 /* Get the index statistics of this index from DSM */
2820 /* Skip indexes not participating in parallelism */
2826 /*
2827 * Skip processing indexes that are unsafe for workers (these are
2828 * processed in do_serial_processing_for_unsafe_indexes() by leader)
2829 */
2833 /* Do vacuum or cleanup of the index */
2836 lvshared,
2837 shared_istat,
2838 vacrel);
2839 }
2841 /*
2842 * We have completed the index vacuum so decrement the active worker
2843 * count.
2844 */
2847 }
2849 /*
2850 * Vacuum or cleanup indexes that can be processed by only the leader process
2851 * because these indexes don't support parallel operation at that phase.
2852 */
2853 static void
2855 {
2858 /*
2859 * Increment the active worker count if we are able to launch any worker.
2860 */
2865 {
2867 Relation indrel;
2872 /* Skip already-complete indexes */
2878 /*
2879 * We're only here for the unsafe indexes
2880 */
2884 /* Do vacuum or cleanup of the index */
2887 lvshared,
2888 shared_istat,
2889 vacrel);
2890 }
2892 /*
2893 * We have completed the index vacuum so decrement the active worker
2894 * count.
2895 */
2898 }
2900 /*
2901 * Vacuum or cleanup index either by leader process or by one of the worker
2902 * process. After processing the index this function copies the index
2903 * statistics returned from ambulkdelete and amvacuumcleanup to the DSM
2904 * segment.
2905 */
2912 {
2915 /*
2916 * Update the pointer to the corresponding bulk-deletion result if someone
2917 * has already updated it
2918 */
2922 /* Do vacuum or cleanup of the index */
2926 else
2928 vacrel);
2930 /*
2931 * Copy the index bulk-deletion result returned from ambulkdelete and
2932 * amvacuumcleanup to the DSM segment if it's the first cycle because they
2933 * allocate locally and it's possible that an index will be vacuumed by a
2934 * different vacuum process the next cycle. Copying the result normally
2935 * happens only the first time an index is vacuumed. For any additional
2936 * vacuum pass, we directly point to the result on the DSM segment and
2937 * pass it to vacuum index APIs so that workers can update it directly.
2938 *
2939 * Since all vacuum workers write the bulk-deletion result at different
2940 * slots we can write them without locking.
2941 */
2943 {
2947 /* Free the locally-allocated bulk-deletion result */
2950 /* return the pointer to the result from shared memory */
2952 }
2955 }
2957 /*
2958 * lazy_cleanup_all_indexes() -- cleanup all indexes of relation.
2959 */
2960 static void
2962 {
2966 /* Report that we are now cleaning up indexes */
2968 PROGRESS_VACUUM_PHASE_INDEX_CLEANUP);
2971 {
2977 {
2984 }
2985 }
2986 else
2987 {
2988 /* Outsource everything to parallel variant */
2990 }
2991 }
2993 /*
2994 * lazy_vacuum_one_index() -- vacuum index relation.
2995 *
2996 * Delete all the index entries pointing to tuples listed in
2997 * dead_tuples, and update running statistics.
2998 *
2999 * reltuples is the number of heap tuples to be passed to the
3000 * bulkdelete callback. It's always assumed to be estimated.
3001 *
3002 * Returns bulk delete stats derived from input stats
3003 */
3007 {
3008 IndexVacuumInfo ivinfo;
3009 PGRUsage ru0;
3010 LVSavedErrInfo saved_err_info;
3022 /*
3023 * Update error traceback information.
3024 *
3025 * The index name is saved during this phase and restored immediately
3026 * after this phase. See vacuum_error_callback.
3027 */
3031 VACUUM_ERRCB_PHASE_VACUUM_INDEX,
3034 /* Do bulk deletion */
3043 /* Revert to the previous phase information for error traceback */
3049 }
3051 /*
3052 * lazy_cleanup_one_index() -- do post-vacuum cleanup for index relation.
3053 *
3054 * reltuples is the number of heap tuples and estimated_count is true
3055 * if reltuples is an estimated value.
3056 *
3057 * Returns bulk delete stats derived from input stats
3058 */
3063 {
3064 IndexVacuumInfo ivinfo;
3065 PGRUsage ru0;
3066 LVSavedErrInfo saved_err_info;
3079 /*
3080 * Update error traceback information.
3081 *
3082 * The index name is saved during this phase and restored immediately
3083 * after this phase. See vacuum_error_callback.
3084 */
3088 VACUUM_ERRCB_PHASE_INDEX_CLEANUP,
3094 {
3108 }
3110 /* Revert to the previous phase information for error traceback */
3116 }
3118 /*
3119 * should_attempt_truncation - should we attempt to truncate the heap?
3120 *
3121 * Don't even think about it unless we have a shot at releasing a goodly
3122 * number of pages. Otherwise, the time taken isn't worth it.
3123 *
3124 * Also don't attempt it if wraparound failsafe is in effect. It's hard to
3125 * predict how long lazy_truncate_heap will take. Don't take any chances.
3126 * There is very little chance of truncation working out when the failsafe is
3127 * in effect in any case. lazy_scan_prune makes the optimistic assumption
3128 * that any LP_DEAD items it encounters will always be LP_UNUSED by the time
3129 * we're called.
3130 *
3131 * Also don't attempt it if we are doing early pruning/vacuuming, because a
3132 * scan which cannot find a truncated heap page cannot determine that the
3133 * snapshot is too old to read that page.
3134 *
3135 * This is split out so that we can test whether truncation is going to be
3136 * called for before we actually do it. If you change the logic here, be
3137 * careful to depend only on fields that lazy_scan_heap updates on-the-fly.
3138 */
3139 static bool
3141 {
3142 BlockNumber possibly_freeable;
3156 else
3158 }
3160 /*
3161 * lazy_truncate_heap - try to truncate off any empty pages at the end
3162 */
3163 static void
3165 {
3167 BlockNumber new_rel_pages;
3170 /* Report that we are now truncating */
3172 PROGRESS_VACUUM_PHASE_TRUNCATE);
3174 /*
3175 * Loop until no more truncating can be done.
3176 */
3177 do
3178 {
3179 PGRUsage ru0;
3183 /*
3184 * We need full exclusive lock on the relation in order to do
3185 * truncation. If we can't get it, give up rather than waiting --- we
3186 * don't want to block other backends, and we don't want to deadlock
3187 * (which is quite possible considering we already hold a lower-grade
3188 * lock).
3189 */
3193 {
3197 /*
3198 * Check for interrupts while trying to (re-)acquire the exclusive
3199 * lock.
3200 */
3204 VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL))
3205 {
3206 /*
3207 * We failed to establish the lock in the specified number of
3208 * retries. This means we give up truncating.
3209 */
3215 }
3218 }
3220 /*
3221 * Now that we have exclusive lock, look to see if the rel has grown
3222 * whilst we were vacuuming with non-exclusive lock. If so, give up;
3223 * the newly added pages presumably contain non-deletable tuples.
3224 */
3227 {
3228 /*
3229 * Note: we intentionally don't update vacrel->rel_pages with the
3230 * new rel size here. If we did, it would amount to assuming that
3231 * the new pages are empty, which is unlikely. Leaving the numbers
3232 * alone amounts to assuming that the new pages have the same
3233 * tuple density as existing ones, which is less unlikely.
3234 */
3237 }
3239 /*
3240 * Scan backwards from the end to verify that the end pages actually
3241 * contain no tuples. This is *necessary*, not optional, because
3242 * other backends could have added tuples to these pages whilst we
3243 * were vacuuming.
3244 */
3249 {
3250 /* can't do anything after all */
3253 }
3255 /*
3256 * Okay to truncate.
3257 */
3260 /*
3261 * We can release the exclusive lock as soon as we have truncated.
3262 * Other backends can't safely access the relation until they have
3263 * processed the smgr invalidation that smgrtruncate sent out ... but
3264 * that should happen as part of standard invalidation processing once
3265 * they acquire lock on the relation.
3266 */
3269 /*
3270 * Update statistics. Here, it *is* correct to adjust rel_pages
3271 * without also touching reltuples, since the tuple count wasn't
3272 * changed by the truncation.
3273 */
3286 }
3288 /*
3289 * Rescan end pages to verify that they are (still) empty of tuples.
3290 *
3291 * Returns number of nondeletable pages (last nonempty page + 1).
3292 */
3293 static BlockNumber
3295 {
3296 BlockNumber blkno;
3297 BlockNumber prefetchedUntil;
3298 instr_time starttime;
3300 /* Initialize the starttime if we check for conflicting lock requests */
3303 /*
3304 * Start checking blocks at what we believe relation end to be and move
3305 * backwards. (Strange coding of loop control is needed because blkno is
3306 * unsigned.) To make the scan faster, we prefetch a few blocks at a time
3307 * in forward direction, so that OS-level readahead can kick in.
3308 */
3314 {
3315 Buffer buf;
3316 Page page;
3317 OffsetNumber offnum,
3318 maxoff;
3321 /*
3322 * Check if another process requests a lock on our relation. We are
3323 * holding an AccessExclusiveLock here, so they will be waiting. We
3324 * only do this once per VACUUM_TRUNCATE_LOCK_CHECK_INTERVAL, and we
3325 * only check if that interval has elapsed once every 32 blocks to
3326 * keep the number of system calls and actual shared lock table
3327 * lookups to a minimum.
3328 */
3330 {
3331 instr_time currenttime;
3332 instr_time elapsed;
3339 {
3341 {
3348 }
3350 }
3351 }
3353 /*
3354 * We don't insert a vacuum delay point here, because we have an
3355 * exclusive lock on the table which we want to hold for as short a
3356 * time as possible. We still need to check for interrupts however.
3357 */
3360 blkno--;
3362 /* If we haven't prefetched this lot yet, do so now. */
3364 {
3365 BlockNumber prefetchStart;
3366 BlockNumber pblkno;
3370 {
3373 }
3375 }
3380 /* In this phase we only need shared access to the buffer */
3386 {
3389 }
3396 {
3397 ItemId itemid;
3401 /*
3402 * Note: any non-unused item should be taken as a reason to keep
3403 * this page. We formerly thought that DEAD tuples could be
3404 * thrown away, but that's not so, because we'd not have cleaned
3405 * out their index entries.
3406 */
3408 {
3411 }
3416 /* Done scanning if we found a tuple here */
3419 }
3421 /*
3422 * If we fall out of the loop, all the previously-thought-to-be-empty
3423 * pages still are; we need not bother to look at the last known-nonempty
3424 * page.
3425 */
3427 }
3429 /*
3430 * Return the maximum number of dead tuples we can record.
3431 */
3432 static long
3434 {
3441 {
3446 /* curious coding here to ensure the multiplication can't overflow */
3450 /* stay sane if small maintenance_work_mem */
3452 }
3453 else
3457 }
3459 /*
3460 * lazy_space_alloc - space allocation decisions for lazy vacuum
3461 *
3462 * See the comments at the head of this file for rationale.
3463 */
3464 static void
3466 {
3470 /*
3471 * Initialize state for a parallel vacuum. As of now, only one worker can
3472 * be used for an index, so we invoke parallelism only if there are at
3473 * least two indexes on a table.
3474 */
3476 {
3477 /*
3478 * Since parallel workers cannot access data in temporary tables, we
3479 * can't perform parallel vacuum on them.
3480 */
3482 {
3483 /*
3484 * Give warning only if the user explicitly tries to perform a
3485 * parallel vacuum on the temporary table.
3486 */
3489 (errmsg("disabling parallel option of vacuum on \"%s\" --- cannot vacuum temporary tables in parallel",
3491 }
3492 else
3495 /* If parallel mode started, we're done */
3498 }
3507 }
3509 /*
3510 * lazy_space_free - free space allocated in lazy_space_alloc
3511 */
3512 static void
3514 {
3518 /*
3519 * End parallel mode before updating index statistics as we cannot write
3520 * during parallel mode.
3521 */
3523 }
3525 /*
3526 * lazy_tid_reaped() -- is a particular tid deletable?
3527 *
3528 * This has the right signature to be an IndexBulkDeleteCallback.
3529 *
3530 * Assumes dead_tuples array is in sorted order.
3531 */
3532 static bool
3534 {
3536 int64 litem,
3537 ritem,
3538 item;
3539 ItemPointer res;
3545 /*
3546 * Doing a simple bound check before bsearch() is useful to avoid the
3547 * extra cost of bsearch(), especially if dead tuples on the heap are
3548 * concentrated in a certain range. Since this function is called for
3549 * every index tuple, it pays to be really fast.
3550 */
3558 vac_cmp_itemptr);
3561 }
3563 /*
3564 * Comparator routines for use with qsort() and bsearch().
3565 */
3566 static int
3568 {
3569 BlockNumber lblk,
3570 rblk;
3571 OffsetNumber loff,
3572 roff;
3591 }
3593 /*
3594 * Check if every tuple in the given page is visible to all current and future
3595 * transactions. Also return the visibility_cutoff_xid which is the highest
3596 * xmin amongst the visible tuples. Set *all_frozen to true if every tuple
3597 * on this page is frozen.
3598 */
3599 static bool
3603 {
3606 OffsetNumber offnum,
3607 maxoff;
3613 /*
3614 * This is a stripped down version of the line pointer scan in
3615 * lazy_scan_heap(). So if you change anything here, also check that code.
3616 */
3621 {
3622 ItemId itemid;
3623 HeapTupleData tuple;
3625 /*
3626 * Set the offset number so that we can display it along with any
3627 * error that occurred while processing this tuple.
3628 */
3632 /* Unused or redirect line pointers are of no interest */
3638 /*
3639 * Dead line pointers can have index pointers pointing to them. So
3640 * they can't be treated as visible
3641 */
3643 {
3647 }
3656 {
3658 {
3659 TransactionId xmin;
3661 /* Check comments in lazy_scan_heap. */
3663 {
3667 }
3669 /*
3670 * The inserter definitely committed. But is it old enough
3671 * that everyone sees it as committed?
3672 */
3675 {
3679 }
3681 /* Track newest xmin on page. */
3685 /* Check whether this tuple is already frozen or not */
3689 }
3696 {
3700 }
3704 }
3707 /* Clear the offset information once we have processed the given page. */
3711 }
3713 /*
3714 * Compute the number of parallel worker processes to request. Both index
3715 * vacuum and index cleanup can be executed with parallel workers. The index
3716 * is eligible for parallel vacuum iff its size is greater than
3717 * min_parallel_index_scan_size as invoking workers for very small indexes
3718 * can hurt performance.
3719 *
3720 * nrequested is the number of parallel workers that user requested. If
3721 * nrequested is 0, we compute the parallel degree based on nindexes, that is
3722 * the number of indexes that support parallel vacuum. This function also
3723 * sets can_parallel_vacuum to remember indexes that participate in parallel
3724 * vacuum.
3725 */
3726 static int
3729 {
3735 /*
3736 * We don't allow performing parallel operation in standalone backend or
3737 * when parallelism is disabled.
3738 */
3742 /*
3743 * Compute the number of indexes that can participate in parallel vacuum.
3744 */
3746 {
3757 nindexes_parallel_bulkdel++;
3760 nindexes_parallel_cleanup++;
3761 }
3764 nindexes_parallel_cleanup);
3766 /* The leader process takes one index */
3767 nindexes_parallel--;
3769 /* No index supports parallel vacuum */
3773 /* Compute the parallel degree */
3777 /* Cap by max_parallel_maintenance_workers */
3781 }
3783 /*
3784 * Update index statistics in pg_class if the statistics are accurate.
3785 */
3786 static void
3788 {
3796 {
3803 /* Update index statistics */
3809 InvalidTransactionId,
3810 InvalidMultiXactId,
3812 }
3813 }
3815 /*
3816 * This function prepares and returns parallel vacuum state if we can launch
3817 * even one worker. This function is responsible for entering parallel mode,
3818 * create a parallel context, and then initialize the DSM segment.
3819 */
3823 {
3834 Size est_shared;
3835 Size est_deadtuples;
3840 /*
3841 * A parallel vacuum must be requested and there must be indexes on the
3842 * relation
3843 */
3847 /*
3848 * Compute the number of parallel vacuum workers to launch
3849 */
3852 nrequested,
3853 can_parallel_vacuum);
3855 /* Can't perform vacuum in parallel */
3857 {
3860 }
3866 parallel_workers);
3870 /* Estimate size for shared information -- PARALLEL_VACUUM_KEY_SHARED */
3873 {
3877 /*
3878 * Cleanup option should be either disabled, always performing in
3879 * parallel or conditionally performing in parallel.
3880 */
3885 /* Skip indexes that don't participate in parallel vacuum */
3890 nindexes_mwm++;
3894 /*
3895 * Remember the number of indexes that support parallel operation for
3896 * each phase.
3897 */
3904 }
3908 /* Estimate size for dead tuples -- PARALLEL_VACUUM_KEY_DEAD_TUPLES */
3914 /*
3915 * Estimate space for BufferUsage and WalUsage --
3916 * PARALLEL_VACUUM_KEY_BUFFER_USAGE and PARALLEL_VACUUM_KEY_WAL_USAGE.
3917 *
3918 * If there are no extensions loaded that care, we could skip this. We
3919 * have no way of knowing whether anyone's looking at pgBufferUsage or
3920 * pgWalUsage, so do it unconditionally.
3921 */
3929 /* Finally, estimate PARALLEL_VACUUM_KEY_QUERY_TEXT space */
3931 {
3935 }
3936 else
3941 /* Prepare shared information */
3949 maintenance_work_mem;
3956 /*
3957 * Initialize variables for shared index statistics, set NULL bitmap and
3958 * the size of stats for each index.
3959 */
3962 {
3966 /* Set NOT NULL as this index does support parallelism */
3968 }
3973 /* Prepare the dead tuple space */
3981 /*
3982 * Allocate space for each worker's BufferUsage and WalUsage; no need to
3983 * initialize
3984 */
3994 /* Store query string for workers */
3996 {
4004 }
4008 }
4010 /*
4011 * Destroy the parallel context, and end parallel mode.
4012 *
4013 * Since writes are not allowed during parallel mode, copy the
4014 * updated index statistics from DSM into local memory and then later use that
4015 * to update the index statistics. One might think that we can exit from
4016 * parallel mode, update the index statistics and then destroy parallel
4017 * context, but that won't be safe (see ExitParallelMode).
4018 */
4019 static void
4021 {
4028 /* Copy the updated statistics */
4030 {
4035 /*
4036 * Skip unused slot. The statistics of this index are already stored
4037 * in local memory.
4038 */
4043 {
4046 }
4047 else
4049 }
4054 /* Deactivate parallel vacuum */
4057 }
4059 /*
4060 * Return shared memory statistics for index at offset 'getidx', if any
4061 */
4064 {
4072 {
4077 }
4080 }
4082 /*
4083 * Returns false, if the given index can't participate in parallel index
4084 * vacuum or parallel index cleanup
4085 */
4086 static bool
4088 {
4091 /* first_time must be true only if for_cleanup is true */
4095 {
4096 /* Skip, if the index does not support parallel cleanup */
4101 /*
4102 * Skip, if the index supports parallel cleanup conditionally, but we
4103 * have already processed the index (for bulkdelete). See the
4104 * comments for option VACUUM_OPTION_PARALLEL_COND_CLEANUP to know
4105 * when indexes support parallel cleanup conditionally.
4106 */
4110 }
4112 {
4113 /* Skip if the index does not support parallel bulk deletion */
4115 }
4118 }
4120 /*
4121 * Perform work within a launched parallel process.
4122 *
4123 * Since parallel vacuum workers perform only index vacuum or index cleanup,
4124 * we don't need to report progress information.
4125 */
4126 void
4128 {
4129 Relation rel;
4137 LVRelState vacrel;
4138 ErrorContextCallback errcallback;
4146 else
4149 /* Set debug_query_string for individual workers */
4154 /*
4155 * Open table. The lock mode is the same as the leader process. It's
4156 * okay because the lock mode does not conflict among the parallel
4157 * workers.
4158 */
4161 /*
4162 * Open all indexes. indrels are sorted in order by OID, which should be
4163 * matched to the leader's one.
4164 */
4168 /* Set dead tuple space */
4170 PARALLEL_VACUUM_KEY_DEAD_TUPLES,
4173 /* Set cost-based vacuum delay */
4186 /* Each parallel VACUUM worker gets its own access strategy */
4194 /*
4195 * Initialize vacrel for use as error callback arg by parallel worker.
4196 */
4203 /* Setup error traceback support for ereport() */
4209 /* Prepare to track buffer usage during parallel execution */
4212 /* Process indexes to perform vacuum/cleanup */
4215 /* Report buffer/WAL usage during parallel execution */
4221 /* Pop the error context stack */
4228 }
4230 /*
4231 * Error context callback for errors occurring during vacuum.
4232 */
4233 static void
4235 {
4239 {
4242 {
4246 else
4249 }
4250 else
4257 {
4261 else
4264 }
4265 else
4289 * initialized */
4290 }
4291 }
4293 /*
4294 * Updates the information required for vacuum error callback. This also saves
4295 * the current information which can be later restored via restore_vacuum_error_info.
4296 */
4297 static void
4300 {
4302 {
4306 }
4311 }
4313 /*
4314 * Restores the vacuum information saved via a prior call to update_vacuum_error_info.
4315 */
4316 static void
4319 {
4323 }